From 00db08bfc973c7c817349d4303b4820d974179df Mon Sep 17 00:00:00 2001 From: Fabio Zadrozny Date: Thu, 31 Aug 2023 10:01:13 -0300 Subject: [PATCH] wip --- .github/workflows/linting.yml | 1 + .../.settings/org.python.pydev.analysis.yaml | 5 - robocorp-code/.settings/org.python.pydev.yaml | 3 +- robocorp-code/bin/create_env/conda.yaml | 3 +- .../create_env/conda_vscode_darwin_amd64.yaml | 3 +- .../create_env/conda_vscode_linux_amd64.yaml | 3 +- .../conda_vscode_windows_amd64.yaml | 3 +- .../src/robocorp_code/deps/_conda_deps.py | 17 +- .../src/robocorp_code/deps/_deps_protocols.py | 70 +- .../src/robocorp_code/deps/analyzer.py | 8 + .../src/robocorp_code/deps/conda_cloud.py | 634 ++ .../deps/conda_impl/conda_match_spec.py | 1 + .../deps/conda_impl/conda_url.py | 1 + robocorp-code/src/robocorp_code/hover.py | 214 +- .../robocorp_code/robocorp_language_server.py | 44 +- robocorp-code/src/setup.py | 6 +- .../.conda_indexes/index_0001/linux-64.db | Bin 0 -> 86016 bytes .../.conda_indexes/index_0001/noarch.db | Bin 0 -> 28672 bytes .../.conda_indexes/index_0001/osx-64.db | Bin 0 -> 77824 bytes .../.conda_indexes/index_0001/win-64.db | Bin 0 -> 57344 bytes .../.conda_indexes/latest_index_info.json | 1 + .../_resources/conda-forge cache/README.txt | 2 + .../deps/test_conda_cloud.py | 170 + .../test_conda_cloud/noarch-testdata.json | 9567 +++++++++++++++++ .../test_conda_cloud_index.yml | 14 + .../robocorp_code_tests/deps/test_deps.py | 21 +- .../test_hover_conda_yaml_rpaframework.yml | 35 +- .../tests/robocorp_code_tests/fixtures.py | 49 + .../test_language_server_directly.py | 9 +- .../test_vscode_integration.py | 57 +- ..._conda_yaml_conda_forge_numpy_versions.yml | 62 + ..._hover_conda_yaml_conda_forge_versions.yml | 24 + ...> test_hover_conda_yaml_pypi_versions.yml} | 35 +- ..._hover_conda_yaml_versions_no_releases.yml | 18 +- robocorp-code/vscode-client/src/rcc.ts | 6 +- .../org.eclipse.core.resources.prefs | 1 + 36 files changed, 10989 insertions(+), 98 deletions(-) delete mode 100644 robocorp-code/.settings/org.python.pydev.analysis.yaml create mode 100644 robocorp-code/src/robocorp_code/deps/conda_cloud.py create mode 100644 robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/.conda_indexes/index_0001/linux-64.db create mode 100644 robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/.conda_indexes/index_0001/noarch.db create mode 100644 robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/.conda_indexes/index_0001/osx-64.db create mode 100644 robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/.conda_indexes/index_0001/win-64.db create mode 100644 robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/.conda_indexes/latest_index_info.json create mode 100644 robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/README.txt create mode 100644 robocorp-code/tests/robocorp_code_tests/deps/test_conda_cloud.py create mode 100644 robocorp-code/tests/robocorp_code_tests/deps/test_conda_cloud/noarch-testdata.json create mode 100644 robocorp-code/tests/robocorp_code_tests/deps/test_conda_cloud/test_conda_cloud_index.yml create mode 100644 robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_conda_forge_numpy_versions.yml create mode 100644 robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_conda_forge_versions.yml rename robocorp-code/tests/robocorp_code_tests/test_vscode_integration/{test_hover_conda_yaml_versions.yml => test_hover_conda_yaml_pypi_versions.yml} (95%) diff --git a/.github/workflows/linting.yml b/.github/workflows/linting.yml index 0d97b7ed15..df07cf04b9 100644 --- a/.github/workflows/linting.yml +++ b/.github/workflows/linting.yml @@ -66,6 +66,7 @@ jobs: python -m pip install -r robocorp-code/tests/test_requirements.txt python -m pip install -r robocorp-code/dev_requirements.txt + python -m pip install msgspec python -m pip install robotframework python -m pip install robotframework-output-stream diff --git a/robocorp-code/.settings/org.python.pydev.analysis.yaml b/robocorp-code/.settings/org.python.pydev.analysis.yaml deleted file mode 100644 index 0d4cb1776a..0000000000 --- a/robocorp-code/.settings/org.python.pydev.analysis.yaml +++ /dev/null @@ -1,5 +0,0 @@ -MYPY_USE_CONSOLE: false -SEARCH_MYPY_LOCATION: SEARCH -USE_MYPY: true -MYPY_ADD_PROJECT_FOLDERS_TO_MYPYPATH: true -MYPY_FILE_LOCATION: '' \ No newline at end of file diff --git a/robocorp-code/.settings/org.python.pydev.yaml b/robocorp-code/.settings/org.python.pydev.yaml index b4e6434d78..ff65eda1ff 100644 --- a/robocorp-code/.settings/org.python.pydev.yaml +++ b/robocorp-code/.settings/org.python.pydev.yaml @@ -30,8 +30,7 @@ MYPY_ARGS: --follow-imports=silent --show-column-numbers --namespace-packages -- MYPY_FILE_LOCATION: '' MYPY_USE_CONSOLE: true PYDEV_TEST_RUNNER: '2' -PYDEV_TEST_RUNNER_DEFAULT_PARAMETERS: --capture=no -W ignore::DeprecationWarning -n - 0 --tb=native -vv --force-regen --assert=plain +PYDEV_TEST_RUNNER_DEFAULT_PARAMETERS: --capture=no -W ignore::DeprecationWarning -n 0 --tb=native -vv --force-regen --assert=plain PYDEV_USE_PYUNIT_VIEW: true RUFF_ARGS: '' RUFF_FILE_LOCATION: '' diff --git a/robocorp-code/bin/create_env/conda.yaml b/robocorp-code/bin/create_env/conda.yaml index 40b4181c47..f1f30999c0 100644 --- a/robocorp-code/bin/create_env/conda.yaml +++ b/robocorp-code/bin/create_env/conda.yaml @@ -7,6 +7,7 @@ dependencies: - python=3.9.13 # https://pyreadiness.org/3.9/ - pip=22.1.2 # https://pip.pypa.io/en/stable/news/ - pyyaml=6.0 + - msgspec=0.18.2 - pip: - - robocorp-inspector==0.10.1 # https://github.com/robocorp/inspector/blob/master/CHANGELOG.md + - robocorp-inspector==0.10.2 # https://github.com/robocorp/inspector/blob/master/CHANGELOG.md - robotframework==5.0.1 # https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-5.0.1.rst diff --git a/robocorp-code/bin/create_env/conda_vscode_darwin_amd64.yaml b/robocorp-code/bin/create_env/conda_vscode_darwin_amd64.yaml index e65a773442..2887ca50f3 100644 --- a/robocorp-code/bin/create_env/conda_vscode_darwin_amd64.yaml +++ b/robocorp-code/bin/create_env/conda_vscode_darwin_amd64.yaml @@ -8,6 +8,7 @@ dependencies: - pip=22.1.2 # https://pip.pypa.io/en/stable/news/ - python.app=1.3 # https://anaconda.org/conda-forge/python.app/files - pyyaml=6.0 + - msgspec=0.18.2 - pip: - - robocorp-inspector==0.10.1 # https://github.com/robocorp/inspector/blob/master/CHANGELOG.md + - robocorp-inspector==0.10.2 # https://github.com/robocorp/inspector/blob/master/CHANGELOG.md - robotframework==5.0.1 # https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-5.0.1.rst diff --git a/robocorp-code/bin/create_env/conda_vscode_linux_amd64.yaml b/robocorp-code/bin/create_env/conda_vscode_linux_amd64.yaml index e9ee7490b1..6ce6ce6145 100644 --- a/robocorp-code/bin/create_env/conda_vscode_linux_amd64.yaml +++ b/robocorp-code/bin/create_env/conda_vscode_linux_amd64.yaml @@ -9,6 +9,7 @@ dependencies: - pyside2=5.15.4 # https://wiki.qt.io/Qt_for_Python - qtpy=2.3.0 # https://github.com/spyder-ide/qtpy/blob/master/CHANGELOG.md - pyyaml=6.0 + - msgspec=0.18.2 - pip: - - robocorp-inspector==0.10.1 # https://github.com/robocorp/inspector/blob/master/CHANGELOG.md + - robocorp-inspector==0.10.2 # https://github.com/robocorp/inspector/blob/master/CHANGELOG.md - robotframework==5.0.1 # https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-5.0.1.rst diff --git a/robocorp-code/bin/create_env/conda_vscode_windows_amd64.yaml b/robocorp-code/bin/create_env/conda_vscode_windows_amd64.yaml index 0551b94fc6..c854bf93ba 100644 --- a/robocorp-code/bin/create_env/conda_vscode_windows_amd64.yaml +++ b/robocorp-code/bin/create_env/conda_vscode_windows_amd64.yaml @@ -8,6 +8,7 @@ dependencies: - pip=22.1.2 # https://pip.pypa.io/en/stable/news/ - pywin32=303 # https://github.com/mhammond/pywin32/blob/main/CHANGES.txt - pyyaml=6.0 + - msgspec=0.18.2 - pip: - - robocorp-inspector==0.10.1 # https://github.com/robocorp/inspector/blob/master/CHANGELOG.md + - robocorp-inspector==0.10.2 # https://github.com/robocorp/inspector/blob/master/CHANGELOG.md - robotframework==5.0.1 # https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-5.0.1.rst diff --git a/robocorp-code/src/robocorp_code/deps/_conda_deps.py b/robocorp-code/src/robocorp_code/deps/_conda_deps.py index 790e62f204..d9bebf129d 100644 --- a/robocorp-code/src/robocorp_code/deps/_conda_deps.py +++ b/robocorp-code/src/robocorp_code/deps/_conda_deps.py @@ -1,12 +1,12 @@ from dataclasses import dataclass -from typing import Dict, Optional +from typing import Dict, Iterator, Optional -from .analyzer import _RangeTypedDict +from ._deps_protocols import _RangeTypedDict from .conda_impl import conda_match_spec, conda_version @dataclass -class _CondaDepInfo: +class CondaDepInfo: name: str # The name of the dep (i.e.: python) value: str # The full value of the dep (i.e.: python=3.7) version: str # The version of the dep (as seen by conda: '3.7.*') @@ -15,7 +15,7 @@ class _CondaDepInfo: class CondaDeps: def __init__(self): - self._deps: Dict[str, _CondaDepInfo] = {} + self._deps: Dict[str, CondaDepInfo] = {} def add_dep(self, value: str, dep_range: _RangeTypedDict): """ @@ -25,14 +25,16 @@ def add_dep(self, value: str, dep_range: _RangeTypedDict): """ try: spec = conda_match_spec.parse_spec_str(value) - version = spec["version"] + + # It may not have a version if it wasn't specified. + version = spec.get("version", "*") if version.endswith("*"): version = version[:-1] name = spec["name"] except Exception: pass else: - self._deps[name] = _CondaDepInfo(name, value, version, dep_range) + self._deps[name] = CondaDepInfo(name, value, version, dep_range) def get_dep_vspec(self, spec_name: str) -> Optional[conda_version.VersionSpec]: conda_dep_info = self._deps.get(spec_name) @@ -43,3 +45,6 @@ def get_dep_vspec(self, spec_name: str) -> Optional[conda_version.VersionSpec]: def get_dep_range(self, spec_name: str) -> _RangeTypedDict: return self._deps[spec_name].dep_range + + def iter_conda_dep_infos(self) -> Iterator[CondaDepInfo]: + yield from self._deps.values() diff --git a/robocorp-code/src/robocorp_code/deps/_deps_protocols.py b/robocorp-code/src/robocorp_code/deps/_deps_protocols.py index 6e2d9eee30..8939ca4a8a 100644 --- a/robocorp-code/src/robocorp_code/deps/_deps_protocols.py +++ b/robocorp-code/src/robocorp_code/deps/_deps_protocols.py @@ -1,8 +1,10 @@ # Versions = Union[LegacyVersion, Version] import datetime import sys +import typing +from contextlib import contextmanager from dataclasses import dataclass -from typing import Any, Dict, Iterator, List, Optional, Union +from typing import Any, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Union # Hack so that we don't break the runtime on versions prior to Python 3.8. if sys.version_info[:2] < (3, 8): @@ -106,6 +108,72 @@ def get_versions_newer_than( """ +SubdirToBuildAndDependsJsonBytesType = Dict[str, List[Tuple[str, bytes]]] + + +@dataclass(unsafe_hash=True) +class CondaVersionInfo: + package_name: str + version: str + timestamp: int # Max is given + subdir_to_build_and_depends_json_bytes: SubdirToBuildAndDependsJsonBytesType + + +if typing.TYPE_CHECKING: + # No need for sqlite3 until it's actually used. + from sqlite3 import Cursor +else: + Cursor = object + + +class LatestIndexInfoTypedDict(TypedDict): + # The place where the index info is saved. + index_dir: str + timestamp: datetime.datetime + + +class ISqliteQueries(Protocol): + @contextmanager + def db_cursors( + self, db_cursor: Optional[Sequence[Cursor]] = None + ) -> Iterator[Sequence[Cursor]]: + pass + + def query_names(self, db_cursors: Optional[Sequence[Cursor]] = None) -> Set[str]: + pass + + def query_versions( + self, package_name, db_cursors: Optional[Sequence[Cursor]] = None + ) -> Set[str]: + pass + + def query_version_info( + self, + package_name: str, + version: str, + db_cursors: Optional[Sequence[Cursor]] = None, + ) -> CondaVersionInfo: + pass + + +class IOnFinished(Protocol): + def __call__(self): + pass + + +class ICondaCloud(Protocol): + def is_information_cached(self) -> bool: + pass + + def sqlite_queries(self) -> Optional[ISqliteQueries]: + pass + + def schedule_update( + self, on_finished: Optional[IOnFinished] = None, wait=False, force=False + ) -> None: + pass + + class _DiagnosticSeverity(object): Error = 1 Warning = 2 diff --git a/robocorp-code/src/robocorp_code/deps/analyzer.py b/robocorp-code/src/robocorp_code/deps/analyzer.py index a40a99434a..d5a83df269 100644 --- a/robocorp-code/src/robocorp_code/deps/analyzer.py +++ b/robocorp-code/src/robocorp_code/deps/analyzer.py @@ -7,6 +7,7 @@ from typing import Any, Iterator, List, Optional, Tuple import yaml +from robocorp_code.deps._conda_deps import CondaDepInfo from robocorp_code.deps._deps_protocols import ( _DiagnosticSeverity, _DiagnosticsTypedDict, @@ -270,6 +271,13 @@ def find_pip_dep_at(self, line, col) -> Optional[PipDepInfo]: return dep_info return None + def find_conda_dep_at(self, line, col) -> Optional[CondaDepInfo]: + self.load_conda_yaml() + for dep_info in self._conda_deps.iter_conda_dep_infos(): + if is_inside(dep_info.dep_range, line, col): + return dep_info + return None + def is_inside(range_dct: _RangeTypedDict, line: int, col: int) -> bool: from robocorp_ls_core.lsp import Position diff --git a/robocorp-code/src/robocorp_code/deps/conda_cloud.py b/robocorp-code/src/robocorp_code/deps/conda_cloud.py new file mode 100644 index 0000000000..97b623c589 --- /dev/null +++ b/robocorp-code/src/robocorp_code/deps/conda_cloud.py @@ -0,0 +1,634 @@ +import datetime +import enum +import itertools +import json +import os +import shutil +import threading +import time +import typing +from concurrent.futures import Future +from contextlib import contextmanager +from functools import partial +from pathlib import Path +from typing import Dict, Iterator, List, Optional, Sequence, Set, Tuple, Union + +from robocorp_ls_core.robotframework_log import get_logger + +from ._deps_protocols import ( + CondaVersionInfo, + IOnFinished, + LatestIndexInfoTypedDict, + SubdirToBuildAndDependsJsonBytesType, +) + +if typing.TYPE_CHECKING: + # No need for sqlite3 until it's actually used. + from sqlite3 import Cursor +else: + Cursor = object + +log = get_logger(__name__) + +TABLE_PACKAGES_SQL = """ + CREATE TABLE Packages ( + package_id INTEGER PRIMARY KEY, + package_name TEXT UNIQUE + ); +""" + +TABLE_VERSIONS_SQL = """ + CREATE TABLE Versions ( + version_id INTEGER PRIMARY KEY, + package_id INTEGER, + depends TEXT, + timestamp INTEGER, + version TEXT, + subdir TEXT, + build TEXT, + FOREIGN KEY (package_id) REFERENCES Packages(package_id) + ); +""" + +CREATE_INDEXES_SQL = [ + """ +CREATE UNIQUE INDEX package_name_index +ON Packages(package_name); +""", + """ +CREATE INDEX package_id_on_versions_index +ON Versions(package_id); +""", + """ +CREATE INDEX version_index +ON Versions(version); +""", +] + + +class State(enum.Enum): + initial = 1 + downloading = 2 + done = 3 + + +def timestamp_to_datetime(timestamp_milliseconds: float) -> datetime.datetime: + timestamp_seconds = timestamp_milliseconds / 1000 # Convert to seconds + return datetime.datetime.fromtimestamp(timestamp_seconds) + + +class SqliteQueries: + def __init__(self, sqlite_file: Union[Path, Sequence[Path]]): + sqlite_files: Sequence[Path] + if isinstance(sqlite_file, Path): + sqlite_files = [sqlite_file] + else: + sqlite_files = sqlite_file + self.sqlite_files: Sequence[Path] = sqlite_files + + @contextmanager + def db_cursors( + self, db_cursor: Optional[Sequence[Cursor]] = None + ) -> Iterator[Sequence[Cursor]]: + if db_cursor is not None: + yield db_cursor + return + + import sqlite3 + + db_cursors: List[Cursor] = [] + db_connections: list = [] + for path in self.sqlite_files: + db_connections.append(sqlite3.connect(path)) + db_cursors.append(db_connections[-1].cursor()) + try: + yield db_cursors + finally: + for cursor in db_cursors: + try: + cursor.close() + except Exception: + log.exception("Error closing sqlite cursor.") + + for db_connection in db_connections: + try: + db_connection.close() + except Exception: + log.exception("Error closing sqlite connection.") + + def query_names(self, db_cursors: Optional[Sequence[Cursor]] = None) -> Set[str]: + with self.db_cursors(db_cursors) as db_cursors: + package_names: Set[str] = set() + for db_cursor in db_cursors: + db_cursor.execute("SELECT package_name FROM packages") + rows = db_cursor.fetchall() + + package_names.update(row[0] for row in rows) + return package_names + + def query_versions( + self, package_name, db_cursors: Optional[Sequence[Cursor]] = None + ) -> Set[str]: + with self.db_cursors(db_cursors) as db_cursors: + versions: Set[str] = set() + for db_cursor in db_cursors: + db_cursor.execute( + """ +SELECT Versions.version +FROM Packages +INNER JOIN Versions ON Packages.package_id = Versions.package_id +WHERE Packages.package_name = ? +""", + (package_name,), + ) + rows = db_cursor.fetchall() + + # Note that we exclude release candidates and development versions. + versions.update( + row[0] + for row in rows + if "_rc" not in row[0] and "_dev" not in row[0] + ) + + return versions + + def query_version_info( + self, + package_name: str, + version: str, + db_cursors: Optional[Sequence[Cursor]] = None, + ) -> CondaVersionInfo: + """ + Note that the same package/version may have multiple infos + because of build ids (but in this API this isn't given, + so, if the same depends are available then they're shown + only as one). + """ + with self.db_cursors(db_cursors) as db_cursors: + subdir_to_build_and_depends: SubdirToBuildAndDependsJsonBytesType = {} + max_timestamp = 0 + + for db_cursor in db_cursors: + db_cursor.execute( + """ +SELECT Versions.depends, Versions.timestamp, Versions.subdir, Versions.build +FROM Packages +INNER JOIN Versions ON Packages.package_id = Versions.package_id +WHERE Packages.package_name = ? and Versions.version = ? +""", + (package_name, version), + ) + + for row in db_cursor.fetchall(): + depends, timestamp, subdir, build = row + try: + lst = subdir_to_build_and_depends[subdir] + except KeyError: + lst = subdir_to_build_and_depends[subdir] = [] + + lst.append((build, depends)) + + max_timestamp = max(max_timestamp, timestamp) + + return CondaVersionInfo( + package_name, version, max_timestamp, subdir_to_build_and_depends + ) + + +# Can be used in tests to index just a few libraries. +INDEX_FOR_LIBRARIES: Optional[Set[str]] = None + + +def index_conda_info(json_file: Path, target_sqlite_file: Path): + import sqlite3 + + # Using msgspec cuts the time in half (from 1 second to 0.5 seconds + # for the full process in one use case). + # Not only the decoding is faster (from 0.44 to 0.28), but accessing + # things from the structure it provides is faster than accessing from + # python structures (dict/list). + import msgspec + + # Use Struct types to define the JSON schema. For efficiency we only define + # the fields we actually need. + class Package(msgspec.Struct): + name: str + depends: Optional[List[str]] = [] + version: Optional[str] = "" + subdir: Optional[str] = "" + timestamp: Optional[int] = 0 + build: Optional[str] = "" + + class Info(msgspec.Struct): + subdir: str = "" + + class RepoData(msgspec.Struct): + info: Info + packages: Optional[Dict[str, Package]] + packages_conda: Optional[Dict[str, Package]] = msgspec.field( + name="packages.conda", + default=None, + ) + + # Decode the data as a `RepoData` type + with open(json_file, "rb") as stream: + bytes_read = stream.read() + data = msgspec.json.decode(bytes_read, type=RepoData) + + # This is actually the arch. + default_subdir = data.info.subdir + + # Step 3: Create SQLite database and table + db_connection = sqlite3.connect(target_sqlite_file) + try: + db_cursor = db_connection.cursor() + try: + + db_cursor.execute(TABLE_PACKAGES_SQL) + + db_cursor.execute(TABLE_VERSIONS_SQL) + + for sql in CREATE_INDEXES_SQL: + db_cursor.execute(sql) + + package_name_to_id: Dict[str, int] = {} + rows = [] + # Step 4: Insert package information into the database + for package_filename, package_info in itertools.chain( + (data.packages or {}).items(), (data.packages_conda or {}).items() + ): + # "2dfatmic-1.0-hbb7d975_1.tar.bz2": { + # "build": "hbb7d975_1", + # "build": 1, + # "depends": [ + # "libgfortran 5.*", + # "libgfortran5 >=9.3.0" + # ], + # "license": "Public Domain", + # "license_family": "OTHER", + # "md5": "0abb38856a2c0a45595bbf3888405507", + # "name": "2dfatmic", + # "sha256": "54d7427b37a4984e97c0529f94c927f9bccfbc9e5b57d0fb52030e4be92ce38a", + # "size": 173360, + # "subdir": "osx-64", + # "timestamp": 1602245771778, + # "version": "1.0" + # }, + name = package_info.name + if not name: + continue + if INDEX_FOR_LIBRARIES: + if name not in INDEX_FOR_LIBRARIES: + continue + + try: + package_id = package_name_to_id[name] + except KeyError: + db_cursor.execute( + """INSERT INTO Packages (package_name) VALUES (?);""", (name,) + ) + package_id = package_name_to_id[name] = db_cursor.lastrowid + + depends = package_info.depends + depends = msgspec.json.encode(depends) + version = package_info.version + timestamp = package_info.timestamp # 0 means unknown + build = package_info.build # '' means unknown + subdir = package_info.subdir or default_subdir + + if not version: + log.info( + f"Unable to get version for package_filename: {package_filename}. Subdir: {subdir}" + ) + continue + rows.append((package_id, depends, timestamp, version, subdir, build)) + + db_cursor.executemany( + "INSERT INTO Versions (package_id, depends, timestamp, version, subdir, build) VALUES (?, ?, ?, ?, ?, ?);", + rows, + ) + finally: + db_cursor.close() + + db_connection.commit() + finally: + db_connection.close() + + +Arch = str + + +class _AfterDownloadMakeSqlite: + def __init__( + self, available_arch: List[Arch], cache_dir: Path, index_cache_dir: Path + ): + from robocorp_ls_core.callbacks import Callback + + self._available_arch = available_arch + self._lock = threading.Lock() + self._count = 0 + self._call_on_finished = Callback() + self._finished = False + self._arch_to_sqlite: Dict[str, Path] = {} + self._index_cache_dir = index_cache_dir + self._cache_dir = cache_dir + + def _convert_to_sqlite(self, json_file: Path, arch: Arch) -> Path: + target_sqlite_file = self._index_cache_dir / f"{arch}.db" + index_conda_info(json_file, target_sqlite_file) + return target_sqlite_file + + def __call__(self, download_future: "Future[Tuple[Path, Arch]]"): + json_file = None + try: + json_file, arch = download_future.result() + self._arch_to_sqlite[arch] = self._convert_to_sqlite(json_file, arch) + except BaseException: + # Handle all exceptions (because the on_finished calls + # must always be called). + log.exception() + + try: + if json_file is not None: + # After we convert to sqlite, there's no need to keep the + # (big) json file around anymore. + os.remove(json_file) + except Exception: + log.exception(f"Error removing: {json_file}.") + + with self._lock: + self._count += 1 + last = self._count == len(self._available_arch) + if last: + self._finished = True + # If we're the last, change the information on the + # cache dir to use. + latest_path = self._cache_dir / "latest_index_info.json" + latest_path.write_text( + json.dumps( + { + # Note: save relative to the cache dir. + "index_dir": os.path.basename(str(self._index_cache_dir)), + "timestamp": datetime.datetime.now().isoformat(), + } + ), + encoding="utf-8", + ) + + self._call_on_finished() + + def register_on_finished(self, on_finished: IOnFinished): + with self._lock: + if self._finished: + on_finished() + else: + self._call_on_finished.register(on_finished) + + +def _extract_dir_number(dirname) -> int: + try: + _n, number = dirname.split("_") + return int(number) + except Exception: + # Return zero if not what we expected. + return 0 + + +class CondaCloud: + """ + Manages information from conda. + + The cache_dir is where we hold information on disk. + + The basic structure is: + /cache_dir + /cache_dir/tmp_0001 <-- used to download information and build the sqlite db. + /cache_dir/tmp_0001/noarch.json <-- actually removed after the sqlite db is built. + /cache_dir/tmp_0001/win-64.json + /cache_dir/index_0001/noarch.db <-- sqlite db we actually use + /cache_dir/index_0001/win-64.db + /cache_dir/latest_index_info.json <-- will be used to point to index_0001 + """ + + def __init__(self, cache_dir: Path, reindex_if_old: bool = True) -> None: + self._base_url = "https://conda.anaconda.org/conda-forge" + self._available_arch = [ + "noarch", + "win-64", + "linux-64", + "osx-64", + ] + + self._json_name = "current_repodata.json" + + self._cache_dir = cache_dir + cache_dir.mkdir(parents=True, exist_ok=True) + + self._lock = threading.Lock() + self._state: State = State.initial + self._call_on_finished: List[IOnFinished] = [] + + if self.is_information_cached(): + if reindex_if_old: + # When a new CondaCloud is created, set it as done already if + # 4 hours haven't elapsed from the last time it was requested. + latest_index_info = self.load_latest_index_info() + if latest_index_info is not None: + diff = datetime.datetime.now() - latest_index_info["timestamp"] + eight_hours = datetime.timedelta(hours=4) + if diff < eight_hours: + self._state = State.done + else: + self._state = State.done + + def _download(self, url: str, target_json: Path, arch: str) -> Tuple[Path, Arch]: + import requests + + CHUNK_SIZE = 32768 + + with target_json.open("wb") as stream: + with requests.get(url, stream=True) as response: + response.raise_for_status() + for chunk in response.iter_content(CHUNK_SIZE): + if chunk: # Filter out keep-alive new chunks + stream.write(chunk) + return target_json, arch + + def _call_on_finished_callbacks(self): + for on_finished in self._call_on_finished: + try: + on_finished() + except Exception: + log.exception("Unexpected exception.") + del self._call_on_finished[:] + + def schedule_update( + self, on_finished: Optional[IOnFinished] = None, wait=False, force=False + ) -> None: + """ + This can be called at any time (in any thread). It schedules the download + of the information we need. + + If it's currently downloading already it'll not do a new request and if it + was already downloaded it'll only redownload if force == True. + """ + import random + + with self._lock: + if on_finished is not None: + self._call_on_finished.append(on_finished) + + if self._state == State.initial: + # Keep on going... + pass + + elif self._state == State.downloading: + # Ok, already downloading, nothing to do besides registering + # the on_finished if given (already done) + return + + elif self._state == State.done: + if force: + # Forcing: go back to the initial state + self._state = State.initial + else: + # Already finished, just call the registered callback now. + self._call_on_finished_callbacks() + return + + assert self._state in (State.initial, State.done) + + # We need to compute the target for the files + dir_entries = os.listdir(self._cache_dir) + + stale_dirs: List[Path] = [] + max_tries = 3 + for i in range(max_tries): + max_number: int = 0 + for dir_name in dir_entries: + if dir_name.startswith("tmp_") or dir_name.startswith("index_"): + max_number = max(max_number, _extract_dir_number(dir_name)) + + for dir_name in dir_entries: + if dir_name.startswith("tmp_") or dir_name.startswith("index_"): + i = _extract_dir_number(dir_name) + if i < max_number: + stale_dirs.append(self._cache_dir / dir_name) + + max_number += 1 + + tmp_cache_dir = self._cache_dir / ("tmp_%04d" % (max_number,)) + index_cache_dir = self._cache_dir / ("index_%04d" % (max_number,)) + try: + # If we failed to create the dir, + tmp_cache_dir.mkdir(parents=True, exist_ok=False) + index_cache_dir.mkdir(parents=True, exist_ok=False) + except: + if i == max_tries - 1: + raise + # Sleep a bit and retry, we could be running in parallel + # with another process (so, we may compute a new max_number). + time.sleep(random.random()) + else: + break + + # Just change the state when we have the directory structure in place. + # (but still inside the self._lock session). + self._state = State.downloading + + on_done = _AfterDownloadMakeSqlite( + self._available_arch, self._cache_dir, index_cache_dir + ) + + def mark_as_done(*args, **kwargs): + with self._lock: + self._state = State.done + + # Now, remove stale dirs. + for directory in stale_dirs: + try: + shutil.rmtree(directory, ignore_errors=False) + except Exception: + log.exception( + f"Error removing old conda cloud dirs from: {directory}" + ) + + self._call_on_finished_callbacks() + + on_done.register_on_finished(mark_as_done) + + if on_finished: + self._call_on_finished.append(on_finished) + + from concurrent.futures.thread import ThreadPoolExecutor + + executor = ThreadPoolExecutor(max_workers=4) + + for arch in self._available_arch: + name = tmp_cache_dir / f"{arch}.json" + # Something as: + # https://conda.anaconda.org/conda-forge/linux-64/current_repodata.json + url = f"{self._base_url}/{arch}/{self._json_name}" + future = executor.submit(partial(self._download, url, name, arch)) + future.add_done_callback(on_done) + executor.shutdown(wait=wait) + + def load_latest_index_info(self) -> Optional[LatestIndexInfoTypedDict]: + try: + latest_dir_info = self._cache_dir / "latest_index_info.json" + with latest_dir_info.open("rb") as stream: + info = json.load(stream) + + # index_dir is relative to the .json. + index_dir_info: LatestIndexInfoTypedDict = { + "index_dir": str(self._cache_dir / info["index_dir"]), + "timestamp": datetime.datetime.fromisoformat(info["timestamp"]), + } + return index_dir_info + except Exception: + return None + + def _load_latest_index_dir_location(self) -> Optional[Path]: + latest_dir_info = self.load_latest_index_info() + if not latest_dir_info: + return None + + try: + index_dir_location = latest_dir_info["index_dir"] + except Exception: + return None + + index_dir_path = Path(index_dir_location) + return index_dir_path + + def _iter_index_files(self) -> Iterator[Path]: + """ + Returns: + An iterator which provides the paths to the sqlite files + which contain the indexed conda informations (one for each arch). + """ + index_dir_path = self._load_latest_index_dir_location() + if not index_dir_path or not index_dir_path.exists(): + return + + for arch in self._available_arch: + f = index_dir_path / f"{arch}.db" + if f.exists(): + yield f + + def is_information_cached(self) -> bool: + index_dir_path = self._load_latest_index_dir_location() + if not index_dir_path or not index_dir_path.exists(): + return False + + for arch in self._available_arch: + if not (index_dir_path / f"{arch}.db").exists(): + return False + + return True + + def sqlite_queries(self) -> Optional[SqliteQueries]: + index_dir_files = tuple(self._iter_index_files()) + if not index_dir_files: + return None + return SqliteQueries(index_dir_files) diff --git a/robocorp-code/src/robocorp_code/deps/conda_impl/conda_match_spec.py b/robocorp-code/src/robocorp_code/deps/conda_impl/conda_match_spec.py index f440c7d3e2..a460056e5d 100644 --- a/robocorp-code/src/robocorp_code/deps/conda_impl/conda_match_spec.py +++ b/robocorp-code/src/robocorp_code/deps/conda_impl/conda_match_spec.py @@ -1,3 +1,4 @@ +# Based on: https://github.com/conda/conda/blob/main/conda/models/match_spec.py """ Original license: BSD 3-Clause License diff --git a/robocorp-code/src/robocorp_code/deps/conda_impl/conda_url.py b/robocorp-code/src/robocorp_code/deps/conda_impl/conda_url.py index e16d12462f..89c266f09b 100644 --- a/robocorp-code/src/robocorp_code/deps/conda_impl/conda_url.py +++ b/robocorp-code/src/robocorp_code/deps/conda_impl/conda_url.py @@ -11,6 +11,7 @@ from os.path import abspath, expanduser from typing import Tuple from urllib.parse import quote_plus # noqa: F401 +from urllib.parse import unquote # noqa (add to public API). from urllib.parse import ParseResult from urllib.parse import urlparse as _urlparse from urllib.parse import urlunparse as _urlunparse # noqa: F401 diff --git a/robocorp-code/src/robocorp_code/hover.py b/robocorp-code/src/robocorp_code/hover.py index 84dfe37f6f..430164e3ab 100644 --- a/robocorp-code/src/robocorp_code/hover.py +++ b/robocorp-code/src/robocorp_code/hover.py @@ -1,9 +1,18 @@ import datetime -from typing import Optional +import sys +from typing import Dict, List, Optional, Set +from robocorp_ls_core.lsp import HoverTypedDict, MarkupContent, MarkupKind from robocorp_ls_core.protocols import IDocument -from robocorp_code.deps._deps_protocols import IPyPiCloud, ReleaseData +from robocorp_code.deps._conda_deps import CondaDepInfo +from robocorp_code.deps._deps_protocols import ( + CondaVersionInfo, + ICondaCloud, + IPyPiCloud, + ReleaseData, +) +from robocorp_code.deps._pip_deps import PipDepInfo # Can be used in tests to force a date. FORCE_DATETIME_NOW: Optional[datetime.datetime] = None @@ -14,9 +23,9 @@ def hover_on_conda_yaml( line: int, col: int, pypi_cloud: IPyPiCloud, -): + conda_cloud: ICondaCloud, +) -> Optional[HoverTypedDict]: - from robocorp_ls_core.lsp import MarkupContent, MarkupKind from robocorp_ls_core.protocols import IDocumentSelection from robocorp_code.deps.analyzer import Analyzer @@ -24,9 +33,185 @@ def hover_on_conda_yaml( sel: IDocumentSelection = doc.selection(line, col) analyzer = Analyzer(doc.source, doc.path, pypi_cloud) pip_dep = analyzer.find_pip_dep_at(sel.line, sel.col) - if pip_dep is None: - return None + if pip_dep is not None: + return _hover_handle_pip_dep(pypi_cloud, pip_dep) + conda_dep: Optional[CondaDepInfo] = analyzer.find_conda_dep_at(sel.line, sel.col) + if conda_dep is not None: + return _hover_handle_conda_dep(conda_cloud, conda_dep) + return None + + +def _create_conda_requirements_desc_parts( + version_info: CondaVersionInfo, +) -> List[str]: + """ + Args: + versions_info: Note that we get multiple versions because conda + has multiple builds for a single version. + """ + import msgspec + + from robocorp_code.deps.conda_impl.conda_match_spec import parse_spec_str + + desc_parts = [] + sub_to_dep_names: Dict[str, Set] = {} + + for ( + subdir, + build_and_depends, + ) in version_info.subdir_to_build_and_depends_json_bytes.items(): + for _build, depends in build_and_depends: + decoded_deps = msgspec.json.decode(depends) + for dep in decoded_deps: + dep_info = parse_spec_str(dep) + try: + dep_names = sub_to_dep_names[subdir] + except KeyError: + dep_names = sub_to_dep_names[subdir] = set() + dep_names.add(dep_info["name"]) + + plat = "" + if sys.platform == "win32": + plat = "win-64" + elif sys.platform == "darwin": + plat = "osx-64" + elif "linux" in sys.platform: + plat = "linux-64" + + # Try to use noarch as the basis. + base_deps = sub_to_dep_names.pop("noarch", None) + if base_deps: + base_subdir = "noarch" + desc_parts.append(f"## Requirements (noarch):") + desc_parts.extend([f"- {x}" for x in sorted(base_deps)]) + + if not base_deps: + # noarch wasn't there, let's try to use the current platform as + # the basis. + base_deps = sub_to_dep_names.pop(plat, None) + if base_deps: + base_subdir = plat + desc_parts.append(f"## Requirements ({plat}):") + desc_parts.extend([f"- {x}" for x in sorted(base_deps)]) + + if not base_deps: + desc_parts.append("## Requirements not found for the current platform!") + for sub, plat_deps in sorted(sub_to_dep_names.items()): + desc_parts.append(f"## Requirements ({sub}):") + desc_parts.extend([f"- {x}" for x in plat_deps]) + else: + # Ok, we have a basis, let's show the information for the other platforms + # as a delta. + base_as_set = set(base_deps) + for sub, new_deps in sorted(sub_to_dep_names.items()): + new_as_set = set(new_deps) + + added_deps = [item for item in new_deps if item not in base_as_set] + removed_deps = [item for item in base_deps if item not in new_as_set] + + if added_deps or removed_deps: + desc_parts.append( + f"## Requirements difference in {sub} (compared with {base_subdir}):" + ) + if added_deps: + desc_parts.extend([f"- Added: {x}" for x in sorted(added_deps)]) + if removed_deps: + desc_parts.extend([f"- Removed: {x}" for x in sorted(removed_deps)]) + + return desc_parts + + +def _hover_handle_conda_dep( + conda_cloud: ICondaCloud, conda_dep: CondaDepInfo +) -> Optional[HoverTypedDict]: + from robocorp_code.deps.conda_cloud import timestamp_to_datetime + + if not conda_cloud.is_information_cached(): + return { + "contents": MarkupContent( + MarkupKind.Markdown, + "Hover unavailable (conda-forge information is still not loaded, please retry later).", + ).to_dict(), + "range": conda_dep.dep_range, + } + + sqlite_queries = conda_cloud.sqlite_queries() + if not sqlite_queries: + return { + "contents": MarkupContent( + MarkupKind.Markdown, + "Hover unavailable (internal error: sqlite queries not available).", + ).to_dict(), + "range": conda_dep.dep_range, + } + + with sqlite_queries.db_cursors() as db_cursors: + versions = sqlite_queries.query_versions(conda_dep.name, db_cursors) + if not versions: + return { + "contents": MarkupContent( + MarkupKind.Markdown, + f"Unable to find {conda_dep.name} in conda-forge.", + ).to_dict(), + "range": conda_dep.dep_range, + } + + current_datetime = ( + FORCE_DATETIME_NOW + if FORCE_DATETIME_NOW is not None + else datetime.datetime.now() + ) + + desc_parts = [f"# {conda_dep.name}"] + last_year = current_datetime - datetime.timedelta(days=365) + last_year_version_infos: List[CondaVersionInfo] = [] + all_version_infos: List[CondaVersionInfo] = [] + + for version in versions: + version_info = sqlite_queries.query_version_info( + conda_dep.name, version, db_cursors + ) + all_version_infos.append(version_info) + if ( + version_info.timestamp > 0 + and timestamp_to_datetime(version_info.timestamp) > last_year + ): + last_year_version_infos.append(version_info) + + all_version_infos = list(sorted(all_version_infos, key=lambda a: a.timestamp)) + if all_version_infos: + desc_parts.append("Conda-forge information:") + last_version_info: Optional[CondaVersionInfo] = all_version_infos[-1] + if last_version_info: + desc_parts.append( + f"\nLast release version: `{last_version_info.version}` done at: " + f"`{format_date(timestamp_to_datetime(last_version_info.timestamp))}`." + ) + + desc_parts.extend( + _create_conda_requirements_desc_parts(last_version_info) + ) + + last_year_version_infos = list( + sorted(last_year_version_infos, key=lambda v: v.timestamp) + ) + if last_year_version_infos: + desc_parts.append("\nVersions released in the last 12 months:") + releases = "`, `".join(x.version for x in reversed(last_year_version_infos)) + desc_parts.append(f"`{releases}`") + else: + desc_parts.append("\nNote: no releases in the last 12 months.") + + return { + "contents": MarkupContent(MarkupKind.Markdown, "\n".join(desc_parts)).to_dict(), + "range": conda_dep.dep_range, + } + + +def _hover_handle_pip_dep( + pypi_cloud: IPyPiCloud, pip_dep: PipDepInfo +) -> HoverTypedDict: package_data = pypi_cloud.get_package_data(pip_dep.name) if package_data is None: return { @@ -65,13 +250,13 @@ def hover_on_conda_yaml( ] = package_data.get_release_data(local_version) if specified_release_data is not None: desc_parts.append( - f"Version `{local_version}` was released at: `{specified_release_data.upload_time}`" + f"Version `{local_version}` was released at: `{format_date_from_pypi(specified_release_data.upload_time)}`" ) last_release_data: Optional[ReleaseData] = package_data.get_last_release_data() if last_release_data: desc_parts.append( - f"\nLast release version: `{last_release_data.version_str}` done at: `{last_release_data.upload_time}`." + f"\nLast release version: `{last_release_data.version_str}` done at: `{format_date_from_pypi(last_release_data.upload_time)}`." ) if releases_data: @@ -115,3 +300,16 @@ def hover_on_conda_yaml( "contents": MarkupContent(kind, "\n".join(desc_parts)).to_dict(), "range": pip_dep.dep_range, } + + +def format_date(d: datetime.datetime) -> str: + return f"{d.year:02}-{d.month:02}-{d.day:02}" + + +def format_date_from_pypi(d: Optional[str]) -> str: + if not d: + return "" + try: + return d.split("T", 1)[0] + except Exception: + return d diff --git a/robocorp-code/src/robocorp_code/robocorp_language_server.py b/robocorp-code/src/robocorp_code/robocorp_language_server.py index 6a2d92fe37..b4e3bbe81e 100644 --- a/robocorp-code/src/robocorp_code/robocorp_language_server.py +++ b/robocorp-code/src/robocorp_code/robocorp_language_server.py @@ -5,20 +5,21 @@ from base64 import b64encode from functools import partial from pathlib import Path -from typing import Any, Dict, Iterator, List, Optional, Sequence +from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple from robocorp_ls_core import watchdog_wrapper from robocorp_ls_core.basic import overrides from robocorp_ls_core.cache import CachedFileInfo from robocorp_ls_core.command_dispatcher import _CommandDispatcher from robocorp_ls_core.jsonrpc.endpoint import require_monitor +from robocorp_ls_core.lsp import HoverTypedDict from robocorp_ls_core.protocols import IConfig, IMonitor, LibraryVersionInfoDict from robocorp_ls_core.python_ls import BaseLintManager, PythonLanguageServer from robocorp_ls_core.robotframework_log import get_logger from robocorp_ls_core.watchdog_wrapper import IFSObserver from robocorp_code import commands -from robocorp_code.deps._deps_protocols import IPyPiCloud +from robocorp_code.deps._deps_protocols import ICondaCloud, IPyPiCloud from robocorp_code.protocols import ( ActionResultDict, ActionResultDictLocalRobotMetadata, @@ -85,7 +86,7 @@ class RobocorpLanguageServer(PythonLanguageServer): CLOUD_LIST_WORKSPACE_CACHE_KEY = "CLOUD_LIST_WORKSPACE_CACHE_V3" PACKAGE_ACCESS_LRU_CACHE_KEY = "PACKAGE_ACCESS_LRU_CACHE" - def __init__(self, read_stream, write_stream): + def __init__(self, read_stream, write_stream) -> None: from queue import Queue from robocorp_ls_core.cache import DirCache @@ -146,7 +147,7 @@ def __init__(self, read_stream, write_stream): f"Env vars info: {env_vars_info}\n" ) - self._fs_observer = None + self._fs_observer: Optional[IFSObserver] = None self._dir_cache = DirCache(cache_dir) self._rcc = Rcc(self) @@ -196,12 +197,13 @@ def clear_caches_on_login_change(): ) from robocorp_code.plugins.resolve_interpreter import register_plugins - self._prefix_to_last_run_number_and_time = {} - - self._pypi_cloud = PyPiCloud(weakref.WeakMethod(self._get_pypi_base_urls)) + self._prefix_to_last_run_number_and_time: Dict[str, Tuple[int, float]] = {} + self._pypi_cloud = PyPiCloud(weakref.WeakMethod(self._get_pypi_base_urls)) # type: ignore + self._cache_dir = cache_dir self._paths_remover = None - self._paths_remover_queue = Queue() + self.__conda_cloud: Optional[ICondaCloud] = None + self._paths_remover_queue: "Queue[Path]" = Queue() register_plugins(self._pm) self._playwright = _Playwright( @@ -211,6 +213,22 @@ def clear_caches_on_login_change(): lsp_messages=self._lsp_messages, ) + @property + def _conda_cloud(self) -> ICondaCloud: # Create it on demand + if self.__conda_cloud is None: + conda_cloud = self.__conda_cloud = self._create_conda_cloud(self._cache_dir) + conda_cloud.schedule_update() + return self.__conda_cloud + + def _create_conda_cloud(self, cache_dir: str) -> ICondaCloud: + """ + Note: monkey-patched in tests (so that we don't reindex + and specify the conda-indexes to use). + """ + from robocorp_code.deps.conda_cloud import CondaCloud + + return CondaCloud(Path(cache_dir) / ".conda_indexes") + def _get_pypi_base_urls(self) -> Sequence[str]: return self._profile.get_pypi_base_urls() @@ -488,7 +506,7 @@ def _cloud_list_workspaces( return result.as_dict() workspaces = result.result - for ws in workspaces: + for ws in workspaces or []: packages: List[PackageInfoDict] = [] activity_package: IRccRobotMetadata @@ -503,7 +521,7 @@ def _cloud_list_workspaces( continue workspace_activities = activities_result.result - for activity_package in workspace_activities: + for activity_package in workspace_activities or []: key = (ws.workspace_id, activity_package.robot_id) sort_key = "%05d%s" % ( ws_id_and_pack_id_to_lru_index.get(key, DEFAULT_SORT_KEY), @@ -546,7 +564,7 @@ def _create_robot(self, params: CreateRobotParamsDict) -> ActionResultDict: template = params["template"] name = params.get("name", "").strip() - force = params.get("force", False) + force: bool = bool(params.get("force", False)) if name: # If the name is given we join it to the directory, otherwise # we use the directory directly. @@ -1125,7 +1143,7 @@ def m_text_document__hover(self, **kwargs) -> Any: def _hover_on_conda_yaml( self, doc_uri, line, col, monitor: IMonitor - ) -> Optional[dict]: + ) -> Optional[HoverTypedDict]: from robocorp_ls_core.protocols import IDocument from robocorp_code.hover import hover_on_conda_yaml @@ -1138,7 +1156,7 @@ def _hover_on_conda_yaml( if doc is None: return None - return hover_on_conda_yaml(doc, line, col, self._pypi_cloud) + return hover_on_conda_yaml(doc, line, col, self._pypi_cloud, self._conda_cloud) def _hover_on_locators_json( self, doc_uri, line, col, monitor: IMonitor diff --git a/robocorp-code/src/setup.py b/robocorp-code/src/setup.py index 0251eecc91..9ed5c6d834 100644 --- a/robocorp-code/src/setup.py +++ b/robocorp-code/src/setup.py @@ -1,7 +1,8 @@ -from setuptools.dist import Distribution -from setuptools import find_packages, setup import os +from setuptools import find_packages, setup +from setuptools.dist import Distribution + _dirname = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) _readme_filename = os.path.join(_dirname, "README.md") if not os.path.exists(_readme_filename): @@ -33,6 +34,7 @@ def is_pure(self): # requirements files see: # https://packaging.python.org/en/latest/requirements.html install_requires=[ + "msgspec", "rpaframework-core", "rpaframework-recognition", "numpy<1.25,>=1.20", diff --git a/robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/.conda_indexes/index_0001/linux-64.db b/robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/.conda_indexes/index_0001/linux-64.db new file mode 100644 index 0000000000000000000000000000000000000000..4ee23b434e5170bc4139886cf7d3a53bb83a7456 GIT binary patch literal 86016 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 Ij9I4oKQw11xBvhE literal 0 HcmV?d00001 diff --git a/robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/.conda_indexes/index_0001/win-64.db b/robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/.conda_indexes/index_0001/win-64.db new file mode 100644 index 0000000000000000000000000000000000000000..77b3b4fc125cf0ba11bd84a5d3dacdb0dfd3ed86 GIT binary patch literal 57344 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 H{rZ0aN=1(J literal 0 HcmV?d00001 diff --git a/robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/.conda_indexes/latest_index_info.json b/robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/.conda_indexes/latest_index_info.json new file mode 100644 index 0000000000..cb3f6796bf --- /dev/null +++ b/robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/.conda_indexes/latest_index_info.json @@ -0,0 +1 @@ +{"index_dir": "index_0001", "timestamp": "2023-08-30T15:44:44.616027"} \ No newline at end of file diff --git a/robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/README.txt b/robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/README.txt new file mode 100644 index 0000000000..87a8b347d3 --- /dev/null +++ b/robocorp-code/tests/robocorp_code_tests/_resources/conda-forge cache/README.txt @@ -0,0 +1,2 @@ +When running tests the patch_conda_forge_cloud_setup fixture will +create the indexes related to conda forge in this directory. \ No newline at end of file diff --git a/robocorp-code/tests/robocorp_code_tests/deps/test_conda_cloud.py b/robocorp-code/tests/robocorp_code_tests/deps/test_conda_cloud.py new file mode 100644 index 0000000000..664cff87a7 --- /dev/null +++ b/robocorp-code/tests/robocorp_code_tests/deps/test_conda_cloud.py @@ -0,0 +1,170 @@ +import os +import threading +from dataclasses import asdict +from pathlib import Path + + +def test_conda_cloud_index(datadir, data_regression): + from robocorp_code.deps.conda_cloud import SqliteQueries, index_conda_info + + target_sqlite = datadir / "sqlite.db" + index_conda_info(datadir / "noarch-testdata.json", target_sqlite) + sqlite_helper = SqliteQueries(target_sqlite) + names = sqlite_helper.query_names() + assert len(names) == 292 + + # This one has 0.1.5 with multiple build ids. + versions = sqlite_helper.query_versions("arn") + assert versions == {"0.1.5"} + + versions = sqlite_helper.query_versions("aadict") + assert versions == {"0.2.3", "0.2.5"} + + with sqlite_helper.db_cursors() as db_cursors: + name = "aadict" + # We can also reuse the cursor (it's a bit faster when doing multiple queries). + versions = sqlite_helper.query_versions(name, db_cursors=db_cursors) + assert versions == {"0.2.3", "0.2.5"} + infos = [] + for version in sorted(versions): + version_info = sqlite_helper.query_version_info( + name, version, db_cursors=db_cursors + ) + dct = asdict(version_info) + + # Convert the bytes from for the depends to a str. + new_subdir_to_build_and_depends = {} + for subdir, build_and_depends in list( + dct["subdir_to_build_and_depends_json_bytes"].items() + ): + new_lst = sorted( + [(x[0], x[1].decode("utf-8")) for x in build_and_depends] + ) + new_subdir_to_build_and_depends[subdir] = new_lst + dct[ + "subdir_to_build_and_depends_json_bytes" + ] = new_subdir_to_build_and_depends + infos.append(dct) + + data_regression.check(infos) + os.remove(target_sqlite) + + +def _test_check_manual(): + # Manual performance tests with a downloaded file. + from robocorp_code.deps.conda_cloud import SqliteQueries, index_conda_info + + p = Path(r"C:\temp\conda_check\linux-64.db") + import os + + if p.exists(): + os.remove(p) + + index_conda_info(Path(r"C:\temp\conda_check\linux-64.json"), p) + sqlite_queries = SqliteQueries(p) + with sqlite_queries.db_cursors() as db_cursors: + names = sqlite_queries.query_names(db_cursors=db_cursors) + print(len(names)) + name = "numpy" + # for name in sorted(names)[:100]: + versions = sqlite_queries.query_versions(name, db_cursors=db_cursors) + print("---") + for version in versions: + print(name, version) + version_info = sqlite_queries.query_version_info( + name, version, db_cursors=db_cursors + ) + print(version_info) + + +def test_conda_cloud(datadir): + from robocorp_code.deps.conda_cloud import CondaCloud, State + from robocorp_ls_core.basic import wait_for_condition + + cache_dir = datadir / "cache" + conda_cloud = CondaCloud(cache_dir, reindex_if_old=True) + assert not conda_cloud.is_information_cached() + + original_download = conda_cloud._download + + def create_mock_download(): + # Just download once. Get from cache afterwards. + download_cache: dict = {} + + def mock_download(url: str, target_json: Path, arch: str): + try: + contents = download_cache[url] + except KeyError: + target_json, arch = original_download(url, target_json, arch) + + # Save in the cache. + with target_json.open("rb") as stream: + download_cache[url] = stream.read() + + else: + # Write cache contents to file. + with target_json.open("wb") as stream: + stream.write(contents) + + return target_json, arch + + return mock_download + + conda_cloud._download = create_mock_download() + + event = threading.Event() + + def on_finished(*args, **kwargs): + event.set() + + conda_cloud.schedule_update(on_finished, wait=True) + assert event.wait(10) + + assert conda_cloud.is_information_cached() + + sqlite_queries = conda_cloud.sqlite_queries() + assert sqlite_queries + with sqlite_queries.db_cursors() as db_cursors: + names = sqlite_queries.query_names(db_cursors=db_cursors) + assert len(names) > 1000 + found_deps = False + for name in sorted(names)[:50]: + versions = sqlite_queries.query_versions(name, db_cursors=db_cursors) + assert len(versions) >= 1 + for version in versions: + version_info = sqlite_queries.query_version_info( + name, version, db_cursors=db_cursors + ) + assert len(version_info.subdir_to_build_and_depends_json_bytes) >= 1 + found_deps = ( + found_deps + or len(version_info.subdir_to_build_and_depends_json_bytes) >= 1 + ) + # i.e.: at least one of the 50 packages we've queried must have + # dependencies/subdir. + assert found_deps + + location1 = conda_cloud._load_latest_index_dir_location() + assert conda_cloud._state == State.done + assert location1 + assert location1.name.endswith("index_0001") + + conda_cloud.schedule_update(wait=True, force=True) + location2 = conda_cloud._load_latest_index_dir_location() + assert location2 + assert location2.name.endswith("index_0002") + + conda_cloud.schedule_update(wait=True, force=True) + assert conda_cloud._state == State.done + location3 = conda_cloud._load_latest_index_dir_location() + assert location3 + assert location3.name.endswith("index_0003") + + # We always keep 1 as buffer and remove the previous ones. + wait_for_condition(lambda: not location1.exists()) + assert location2.exists() + + # Ok, now, let's see that creating a new one does say that it + # was downloaded already. + conda_cloud = CondaCloud(cache_dir, reindex_if_old=True) + assert conda_cloud._state == State.done diff --git a/robocorp-code/tests/robocorp_code_tests/deps/test_conda_cloud/noarch-testdata.json b/robocorp-code/tests/robocorp_code_tests/deps/test_conda_cloud/noarch-testdata.json new file mode 100644 index 0000000000..e927309148 --- /dev/null +++ b/robocorp-code/tests/robocorp_code_tests/deps/test_conda_cloud/noarch-testdata.json @@ -0,0 +1,9567 @@ +{ + "info": { + "subdir": "noarch" + }, + "packages": { + "_current_repodata_hack_gcc_linux_64_75-0.0.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "gcc_linux-64 7.5.*" + ], + "license": "LicenseRef-OTHER", + "md5": "6f29ba77e8b03b191c9d667f331bf2a0", + "name": "_current_repodata_hack_gcc_linux_64_75", + "noarch": "generic", + "sha256": "ecde63af23e0d49c0ece19ec539d873ea408a6f966d3126994c6d33ae1b9d3f7", + "size": 3357, + "subdir": "noarch", + "timestamp": 1599854591823, + "version": "0.0.1" + }, + "_current_repodata_hack_gcc_linux_64_84-0.0.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "gcc_linux-64 8.4.*" + ], + "license": "LicenseRef-OTHER", + "md5": "e7d3afa400b27989a4381d58cfec740a", + "name": "_current_repodata_hack_gcc_linux_64_84", + "noarch": "generic", + "sha256": "5fb50ad4ab4615559987b9ec3a9e387de6f26a5ea9f69a769d7b6d980b4f987a", + "size": 3351, + "subdir": "noarch", + "timestamp": 1599854615753, + "version": "0.0.1" + }, + "_current_repodata_hack_gcc_linux_aarch64_75-0.0.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "gcc_linux-aarch64 7.5.*" + ], + "license": "LicenseRef-OTHER", + "md5": "a02e93fbfdad3347b95e9ea4f64a2248", + "name": "_current_repodata_hack_gcc_linux_aarch64_75", + "noarch": "generic", + "sha256": "ee0c2fbf22dd6353605d6f68df056d6b41ce02bd9adfc138545d4c6a4e95ce67", + "size": 3427, + "subdir": "noarch", + "timestamp": 1599854683958, + "version": "0.0.1" + }, + "_current_repodata_hack_gcc_linux_aarch64_84-0.0.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "gcc_linux-aarch64 8.4.*" + ], + "license": "LicenseRef-OTHER", + "md5": "37f4d678daab62eed5cecb188bef4f99", + "name": "_current_repodata_hack_gcc_linux_aarch64_84", + "noarch": "generic", + "sha256": "2f635d68a29c0c0ff4f6f57f32265ae2acd5a62fc52188a8b4a3dbbf99e4a749", + "size": 3439, + "subdir": "noarch", + "timestamp": 1599854759478, + "version": "0.0.1" + }, + "_current_repodata_hack_gcc_linux_ppc64le_75-0.0.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "gcc_linux-ppc64le 7.5.*" + ], + "license": "LicenseRef-OTHER", + "md5": "4ec64f48695247547d4cac078561475e", + "name": "_current_repodata_hack_gcc_linux_ppc64le_75", + "noarch": "generic", + "sha256": "fd062eb0b7f3544408cd6180adf6365060adf43d6b4e4bee4bc4cc8d91342415", + "size": 3425, + "subdir": "noarch", + "timestamp": 1599854831497, + "version": "0.0.1" + }, + "_current_repodata_hack_gcc_linux_ppc64le_84-0.0.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [ + "gcc_linux-ppc64le 8.4.*" + ], + "license": "LicenseRef-OTHER", + "md5": "137d5828171c8ccb307fd2d2c5114c2c", + "name": "_current_repodata_hack_gcc_linux_ppc64le_84", + "noarch": "generic", + "sha256": "5777454451a7e8c9147817c64fbf98748b8d5c230f9fe4ceabb6e83b3fc5b736", + "size": 3428, + "subdir": "noarch", + "timestamp": 1599854903488, + "version": "0.0.1" + }, + "_dvc-azure-1.9.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "_dvc 1.9.0 py37hc8dfbb8_1", + "azure-storage-blob >=12.0", + "knack" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e066807ea8ffb89bdbcc543aae68a181", + "name": "_dvc-azure", + "noarch": "generic", + "sha256": "7d86b52596fa0347c02cd03fc4f36ce9aa56b98695567b600a4221847d981104", + "size": 9525, + "subdir": "noarch", + "timestamp": 1603745544340, + "version": "1.9.0" + }, + "_dvc-gdrive-1.9.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "_dvc 1.9.0 py37hc8dfbb8_1", + "pydrive2 >=1.6.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4c216a855152ba388802340d61ed6239", + "name": "_dvc-gdrive", + "noarch": "generic", + "sha256": "9fcd30b5935e62fd95241f5ce71fee5a72d0f8a2d432e8e39bdc5647b7107c3c", + "size": 9535, + "subdir": "noarch", + "timestamp": 1603745545766, + "version": "1.9.0" + }, + "_dvc-gs-1.9.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "_dvc 1.9.0 py37hc8dfbb8_1", + "google-cloud-storage 1.19.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c12a622adfe839b9d43f46b04dcabd32", + "name": "_dvc-gs", + "noarch": "generic", + "sha256": "fbfcb86fee7a7e6d24debfa1445f1532271e8e183c812891dec5c63a4de3aa82", + "size": 9542, + "subdir": "noarch", + "timestamp": 1603745547217, + "version": "1.9.0" + }, + "_dvc-hdfs-1.9.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "_dvc 1.9.0 py37hc8dfbb8_1", + "pyarrow >=0.17.1" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ad6422fb7d1e3c81997b6a782f47ca04", + "name": "_dvc-hdfs", + "noarch": "generic", + "sha256": "a43efd9aeebddc1adbb012b291bdc51ab39f149f07207e57a26a4a717998c7f4", + "size": 9532, + "subdir": "noarch", + "timestamp": 1603745548651, + "version": "1.9.0" + }, + "_dvc-oss-1.9.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "_dvc 1.9.0 py37hc8dfbb8_1", + "oss2 >=2.11.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "09214d2d0a2ec77b0837f1b83a243c25", + "name": "_dvc-oss", + "noarch": "generic", + "sha256": "575c87514c458da890084381c42712e725bbe82307c49e83c342e489b0749446", + "size": 9542, + "subdir": "noarch", + "timestamp": 1603745550060, + "version": "1.9.0" + }, + "_dvc-s3-1.9.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "_dvc 1.9.0 py37hc8dfbb8_1", + "boto3 >=1.9.201" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ff0dd29a55630bfa4641e02a3af167f8", + "name": "_dvc-s3", + "noarch": "generic", + "sha256": "1ca4da200d815f66e67e87ef1287a827e8e99698ec00a13584f06eb8191928df", + "size": 9527, + "subdir": "noarch", + "timestamp": 1603745551511, + "version": "1.9.0" + }, + "_dvc-ssh-1.9.0-1.tar.bz2": { + "build": "1", + "build_number": 1, + "depends": [ + "_dvc 1.9.0 py37hc8dfbb8_1", + "invoke >=1.3", + "paramiko >=2.7.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "198e7982c1d42fb7cea9342cb841fd81", + "name": "_dvc-ssh", + "noarch": "generic", + "sha256": "a92e99a9c791fb2b7314f0a84025f3b37bb71c0566df57a721908c8bfbc3c247", + "size": 9521, + "subdir": "noarch", + "timestamp": 1603745552987, + "version": "1.9.0" + }, + "_r-mutex-1.0.1-anacondar_1.tar.bz2": { + "build": "anacondar_1", + "build_number": 1, + "depends": [], + "license": "BSD", + "md5": "19f9db5f4f1b7f5ef5f6d67207f25f38", + "name": "_r-mutex", + "noarch": "generic", + "sha256": "e58f9eeb416b92b550e824bcb1b9fb1958dee69abfe3089dfd1a9173e3a0528a", + "size": 3566, + "subdir": "noarch", + "timestamp": 1562343890778, + "version": "1.0.1" + }, + "_sysroot_linux-64_curr_repodata_hack-3-h5bd9786_11.tar.bz2": { + "build": "h5bd9786_11", + "build_number": 11, + "depends": [], + "license": "LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0", + "license_family": "GPL", + "md5": "1a31b3a31da207ebdb802ddb1b123241", + "name": "_sysroot_linux-64_curr_repodata_hack", + "noarch": "generic", + "sha256": "6c819a357f816fb54fa743a59f106a3fa3cf18a5a55fc9b7f866e03a01344766", + "size": 13839, + "subdir": "noarch", + "timestamp": 1626505489635, + "version": "3" + }, + "_sysroot_linux-64_curr_repodata_hack-3-h5bd9786_12.tar.bz2": { + "build": "h5bd9786_12", + "build_number": 12, + "depends": [], + "license": "LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0", + "license_family": "GPL", + "md5": "b17f80d3410b4129e2dabf7e21a75c1b", + "name": "_sysroot_linux-64_curr_repodata_hack", + "noarch": "generic", + "sha256": "099dc9bd78910fea303c7b5aff2311cdee3e072e51c1f64a88ec5ca6480eae41", + "size": 14055, + "subdir": "noarch", + "timestamp": 1626616468127, + "version": "3" + }, + "_sysroot_linux-64_curr_repodata_hack-3-h5bd9786_13.tar.bz2": { + "build": "h5bd9786_13", + "build_number": 13, + "depends": [], + "license": "LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0", + "license_family": "GPL", + "md5": "a581b4a89191b6c1d6a16488a9cffbfc", + "name": "_sysroot_linux-64_curr_repodata_hack", + "noarch": "generic", + "sha256": "695e67ae4bc22f9e0be5f54b1948a8f2b678f4da920fa2082a249dd5a88f440e", + "size": 14588, + "subdir": "noarch", + "timestamp": 1635519333217, + "version": "3" + }, + "_sysroot_linux-64_curr_repodata_hack-3-ha9d2b57_10.tar.bz2": { + "build": "ha9d2b57_10", + "build_number": 10, + "depends": [], + "license": "LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0", + "license_family": "GPL", + "md5": "3245b4721f4b6f6efd90d3f827ee90b6", + "name": "_sysroot_linux-64_curr_repodata_hack", + "noarch": "generic", + "sha256": "a43606c28a37e2c4dd4e95db159b75db54c8885da722158cc30abb5ce119d61d", + "size": 12855, + "subdir": "noarch", + "timestamp": 1596297786339, + "version": "3" + }, + "_sysroot_linux-64_curr_repodata_hack-3-ha9d2b57_9.tar.bz2": { + "build": "ha9d2b57_9", + "build_number": 9, + "depends": [], + "license": "LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later", + "license_family": "GPL", + "md5": "ab5523646e615755160390034107212f", + "name": "_sysroot_linux-64_curr_repodata_hack", + "noarch": "generic", + "sha256": "f44ee275f01b3049e2702ce0350e3bfe246525e625c257a58e573404c28c7673", + "size": 5716, + "subdir": "noarch", + "timestamp": 1595697296932, + "version": "3" + }, + "_sysroot_linux-64_curr_repodata_hack-4-h5bd9786_14.tar.bz2": { + "build": "h5bd9786_14", + "build_number": 14, + "depends": [ + "kernel-headers_linux-64 2.6.32.*", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0", + "license_family": "GPL", + "md5": "b6af27980692c6885ba3b335f5b83c66", + "name": "_sysroot_linux-64_curr_repodata_hack", + "noarch": "generic", + "sha256": "84b7430470074c892775e1860f138ed3d1bd53be9421bbbc50a1f297de99b417", + "size": 13076, + "subdir": "noarch", + "timestamp": 1626618661248, + "version": "4" + }, + "_sysroot_linux-64_curr_repodata_hack-4-h5bd9786_15.tar.bz2": { + "build": "h5bd9786_15", + "build_number": 15, + "depends": [ + "kernel-headers_linux-64 2.6.32.*", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0", + "license_family": "GPL", + "md5": "21e4a0f72ae5f0a6221874259d7d314a", + "name": "_sysroot_linux-64_curr_repodata_hack", + "noarch": "generic", + "sha256": "8aa933d40f7d4e7dc53f0aadca80eac099a9a848ec085978902ed44b252abcf7", + "size": 13522, + "subdir": "noarch", + "timestamp": 1635519387811, + "version": "4" + }, + "_sysroot_linux-64_curr_repodata_hack-4-ha9d2b57_12.tar.bz2": { + "build": "ha9d2b57_12", + "build_number": 12, + "depends": [ + "kernel-headers_linux-64 2.6.32.*", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later", + "license_family": "GPL", + "md5": "3fd29e1090e6cb23be12c5103d3c13e3", + "name": "_sysroot_linux-64_curr_repodata_hack", + "noarch": "generic", + "sha256": "736af191ed7b6cee7cdc6e7365154b03507b559e103d88d5ab6c4d8719b36008", + "size": 5867, + "subdir": "noarch", + "timestamp": 1595697316940, + "version": "4" + }, + "_sysroot_linux-64_curr_repodata_hack-4-ha9d2b57_13.tar.bz2": { + "build": "ha9d2b57_13", + "build_number": 13, + "depends": [ + "kernel-headers_linux-64 2.6.32.*", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0", + "license_family": "GPL", + "md5": "bfaa9419eb45d8211bc550b31929a402", + "name": "_sysroot_linux-64_curr_repodata_hack", + "noarch": "generic", + "sha256": "d79f23c31dca075ca90d8527919db05f55c81f19b2fccc6ebe6a15fc5cfeab63", + "size": 12999, + "subdir": "noarch", + "timestamp": 1596296712118, + "version": "4" + }, + "aadict-0.2.3-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "python", + "six >=1.6.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "2aec7db01c5532cc66538de775800c01", + "name": "aadict", + "noarch": "python", + "sha256": "43e3e090dde8469e2514e1526ea446b9338a2204ffe94e51b51ac404d376447e", + "size": 20967, + "subdir": "noarch", + "timestamp": 1602526568722, + "version": "0.2.3" + }, + "aadict-0.2.5-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "python", + "six >=1.6.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "2aec7db01c5532cc66538de775800c01", + "name": "aadict", + "noarch": "python", + "sha256": "43e3e090dde8469e2514e1526ea446b9338a2204ffe94e51b51ac404d376447e", + "size": 20967, + "subdir": "noarch", + "timestamp": 1602526578722, + "version": "0.2.5" + }, + "abc-classroom-0.1.9-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "github3.py", + "jinja2", + "nbclean", + "nbformat", + "python >=3", + "ruamel.yaml" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "791d10d0e611bd4323deef3348459695", + "name": "abc-classroom", + "noarch": "python", + "sha256": "bc8dbd67caaa0b0692f52373ed613853d8247c81b8d74f30b77c052c1c9873f1", + "size": 34117, + "subdir": "noarch", + "timestamp": 1612972269114, + "version": "0.1.9" + }, + "abinit-data-0.0.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "6513f11de33a0b7b874cf5d7d28948ed", + "name": "abinit-data", + "noarch": "generic", + "sha256": "541db5e75e7b1cf0e4564a3405614cbd1af43527eb7119a0c0cc22521aa186ca", + "size": 27553287, + "subdir": "noarch", + "timestamp": 1591883684078, + "version": "0.0.1" + }, + "absl-py-0.10.0-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "depends": [ + "python >=3", + "six" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "5d9d02500a08209ab2402097ce4b7194", + "name": "absl-py", + "noarch": "python", + "sha256": "07de2a4458c10f31e94782c8623fd39772c4be477aeba718f806ac3f775b9404", + "size": 97284, + "subdir": "noarch", + "timestamp": 1606234831210, + "version": "0.10.0" + }, + "absolufy-imports-0.3.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6cfab7bc82c2a20549163c93c890e9d6", + "name": "absolufy-imports", + "noarch": "python", + "sha256": "c3734dc0b657bfc31ef190a785343cd15c600b19180dd5f3244bd001a92f6b3e", + "size": 8915, + "subdir": "noarch", + "timestamp": 1650889223986, + "version": "0.3.1" + }, + "absolv-0.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "ambertools", + "openff-toolkit-base >=0.9.2", + "openff-utilities", + "openmm >=7.6", + "openmmtools >=0.20.3", + "packmol", + "pydantic", + "pymbar", + "python >=3.8", + "rdkit", + "tqdm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b7be797eb26dbb59d5eb28d3c7ff608c", + "name": "absolv", + "noarch": "python", + "sha256": "41ad9e85b2b8438655d1c747fcc9543b1dae4ff5654180079630f50b9f6d00e5", + "size": 42413, + "subdir": "noarch", + "timestamp": 1640283463721, + "version": "0.0.1" + }, + "absolv-0.0.1-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "depends": [ + "absolv-base 0.0.1 pyhd8ed1ab_1", + "ambertools", + "python >=3.8", + "rdkit" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1cad2b404ae62486d66eb5616fd187b1", + "name": "absolv", + "noarch": "python", + "sha256": "7169d4146f9b31c10529689da883c9614a1b5b74871379cef196aa5e4cb03320", + "size": 4505, + "subdir": "noarch", + "timestamp": 1650727791519, + "version": "0.0.1" + }, + "absolv-base-0.0.1-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "depends": [ + "openff-toolkit-base >=0.9.2", + "openff-utilities", + "openmm >=7.6", + "openmmtools >=0.20.3", + "packmol", + "pydantic", + "pymbar", + "python >=3.8", + "tqdm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a16dc7525fcdcf43a81ab7516828e152", + "name": "absolv-base", + "noarch": "python", + "sha256": "040f362bb3740d69a6ac0239296570ca467f137bf170da1162e1c7c472bdce22", + "size": 42531, + "subdir": "noarch", + "timestamp": 1650727779967, + "version": "0.0.1" + }, + "abydos-0.5.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "deprecation", + "numpy", + "python >=3.5" + ], + "license": "GNU General Public v3 or later (GPLv3+)", + "license_family": "GPL3", + "md5": "d000039e1b5332ec7d2b0126356263c0", + "name": "abydos", + "noarch": "python", + "sha256": "ab6941eb4f93f295e72ea99dd3c91214554d5f9a06b46305d1e16887fa33a43d", + "size": 352575, + "subdir": "noarch", + "timestamp": 1579201612301, + "version": "0.5.0" + }, + "academic-0.8.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "bibtexparser", + "python >=3.6", + "requests", + "ruamel.yaml", + "toml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "692a0d8dbdcea7fd111f728ba5d6e2b3", + "name": "academic", + "noarch": "python", + "sha256": "b13b3e760d5ef1ae6f5a803d1817d477228595b068ed759754e356de6d1c60e0", + "size": 15652, + "subdir": "noarch", + "timestamp": 1638252930145, + "version": "0.8.1" + }, + "access-1.1.8-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "geopandas", + "numpy >=1.3", + "pandas >=0.23.4", + "python >=3.6", + "requests >=2" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d2317e302dbce55bbf3374bdeab49143", + "name": "access", + "noarch": "python", + "sha256": "5ae3e241ab57a597dbe887f5748e442518e3f3791f94831cd934ae5aa7c58734", + "size": 23865, + "subdir": "noarch", + "timestamp": 1659357797704, + "version": "1.1.8" + }, + "acme-tiny-5.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dbeb638a5890c2ce1ae346f531986e07", + "name": "acme-tiny", + "noarch": "python", + "sha256": "3911a18c3e2e98adca0c88957307b80f10d8f5b00b877978a07b1dd95864466b", + "size": 10529, + "subdir": "noarch", + "timestamp": 1633360955907, + "version": "5.0.1" + }, + "acorns-3.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "numpy", + "pycparser", + "python >=3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "724c04db4796d4b1643c72ece0dd727b", + "name": "acorns", + "noarch": "python", + "sha256": "f05a3100d776bd1f21804fec9a93a7bd54221121729da01de4bb05294189457d", + "size": 16898, + "subdir": "noarch", + "timestamp": 1610998214952, + "version": "3.0" + }, + "acpype-2022.7.21-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "ambertools", + "matplotlib-base", + "numpy", + "openbabel", + "parmed", + "python >=3", + "scipy" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "e6f54fb5bdd6890b87822ca74dc2d4ca", + "name": "acpype", + "noarch": "python", + "sha256": "7d6363e0bd74ab4672d4cc6b908d37a4c7dd4e674daa7f0d921afa05d2fe5cdb", + "size": 5153603, + "subdir": "noarch", + "timestamp": 1658419986710, + "version": "2022.7.21" + }, + "acrv_datasets-0.9.3-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "colorama", + "python >=3.6", + "pyyaml", + "requests", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4907237ef9e00d202856b18a75acb69d", + "name": "acrv_datasets", + "noarch": "python", + "sha256": "a8b9fbebcb2cf21fe990b935d90d5264ce0135df69f8be4085b1b892f02a6c80", + "size": 15236, + "subdir": "noarch", + "timestamp": 1622599129161, + "version": "0.9.3" + }, + "acsconv-0.1.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "fire", + "matplotlib-base", + "numpy", + "pandas", + "python >=3.6", + "pytorch", + "scikit-image", + "scikit-learn", + "scipy", + "tensorboardx", + "torchvision", + "tqdm" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2d9a8b72d5f8819832d8d9d6d4b96385", + "name": "acsconv", + "noarch": "python", + "sha256": "bfe80cc7a8328e1b97d1d9f57c12fc63647f57431f10a9d35cfdee9c0424275c", + "size": 25386, + "subdir": "noarch", + "timestamp": 1653067081606, + "version": "0.1.1" + }, + "adagio-0.2.4-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "triad" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a3aac791912add08df7a9e749216c76f", + "name": "adagio", + "noarch": "python", + "sha256": "f9b88b3cf97ad828c542ceae658994f98deb2042aa5bcf2920939b47451ae142", + "size": 27484, + "subdir": "noarch", + "timestamp": 1658241961621, + "version": "0.2.4" + }, + "adal-1.2.7-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "cryptography >=1.1.0", + "pyjwt >=1.0.0", + "python >=3.6", + "python-dateutil >=2.1.0", + "requests >=2.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a0f134d22bad81e93f1e130b35afb35", + "name": "adal", + "noarch": "python", + "sha256": "3631c3713355d8fa81a77489dbc803b5004ea3be7e02b4ac9c16391f67dc57d5", + "size": 36420, + "subdir": "noarch", + "timestamp": 1617781742370, + "version": "1.2.7" + }, + "adb-1.3.0-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "depends": [ + "libusb1 >=1.0.16", + "python >=3.6", + "rsa" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e60327a7105ed83b2d234c4119dbb786", + "name": "adb", + "noarch": "python", + "sha256": "6a3d4a45ffd677aa655cc050b6d857398af6df95cbfb960cde31e8b735460654", + "size": 32129, + "subdir": "noarch", + "timestamp": 1633614859336, + "version": "1.3.0" + }, + "adb-shell-0.4.3-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "cryptography", + "pyasn1", + "python >=3.6", + "rsa" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "21546049cd60e0c61a6a31505c27f5e0", + "name": "adb-shell", + "noarch": "python", + "sha256": "0b446002ad726047b4d1ef00d7811834fe5814bb96e197f8efce07db655fba53", + "size": 37875, + "subdir": "noarch", + "timestamp": 1654620878039, + "version": "0.4.3" + }, + "addict-2.4.0-pyhd8ed1ab_2.tar.bz2": { + "build": "pyhd8ed1ab_2", + "build_number": 2, + "depends": [ + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1bbe615df222cd4c84bfe0d546f915dc", + "name": "addict", + "noarch": "python", + "sha256": "2455b6afceebb4456b19f2a18da401c69362866bde65aab1b5872f755d9abf4a", + "size": 7748, + "subdir": "noarch", + "timestamp": 1636818220993, + "version": "2.4.0" + }, + "addicty-2022.2.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.7", + "pyyaml", + "yamllint" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e8533edcb3deab7c41d39cef03d2fdc7", + "name": "addicty", + "noarch": "python", + "sha256": "9f6aa0c2cab66050a89775e17dfb7c7a78f49ccced5c13dc06e84af6cd102a83", + "size": 11077, + "subdir": "noarch", + "timestamp": 1645648018235, + "version": "2022.2.1" + }, + "adf2dms-0.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "crccheck", + "python >=3.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e7985946874df6c4418dd8db825fb076", + "name": "adf2dms", + "noarch": "python", + "sha256": "50e1dbbf3dc74668861c0a06c00e6166cf89b4fec8849fa39d94dea3d265459c", + "size": 11581, + "subdir": "noarch", + "timestamp": 1658845703231, + "version": "0.0.1" + }, + "adjusttext-0.7.3.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c73bc5e36b287d8dbf10d8de9b8bbf59", + "name": "adjusttext", + "noarch": "python", + "sha256": "4e20b2eb02cc7b966892961f5190b6a88b0a418801faa5c78e25ac7d4f128435", + "size": 10731, + "subdir": "noarch", + "timestamp": 1551462639832, + "version": "0.7.3.1" + }, + "adjusttext-0.7.3.1-py_1.tar.bz2": { + "build": "py_1", + "build_number": 1, + "depends": [ + "matplotlib-base", + "numpy", + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1e4a4438639a2e3e762f0cd4b43c984e", + "name": "adjusttext", + "noarch": "python", + "sha256": "a4d471f2154d4955fd63f27eb8373f89895eddbb9397c4420a5370291610a267", + "size": 10956, + "subdir": "noarch", + "timestamp": 1582809995880, + "version": "0.7.3.1" + }, + "adl2pydm-0.0.4-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.7" + ], + "license": "BSD-4-Clause", + "md5": "875d718271739318c26deda19550b3df", + "name": "adl2pydm", + "noarch": "python", + "sha256": "7133d8ca2a5111e9fb33d6aba079e726439a9bac5d60539baa120c6ce4588bb4", + "size": 37796, + "subdir": "noarch", + "timestamp": 1660861321459, + "version": "0.0.4" + }, + "adlfs-2021.9.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiohttp", + "azure-core >=1.7.0", + "azure-datalake-store >=0.0.46,<0.1", + "azure-identity", + "azure-storage-blob >=12.5.0", + "fsspec >=2021.6.1", + "python >3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6849e52ad5f9028fb04c3dac3d1a0efa", + "name": "adlfs", + "noarch": "python", + "sha256": "f9534f4182bdc8774b81995debeee70d1eca1fda1f45b598c80d1bbce9222783", + "size": 22507, + "subdir": "noarch", + "timestamp": 1631313924749, + "version": "2021.9.1" + }, + "ads-0.12.3-py_2.tar.bz2": { + "arch": null, + "build": "py_2", + "build_number": 2, + "depends": [ + "mock", + "python", + "requests", + "six", + "werkzeug" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c3f9e178e9665fad6cee5a1f1caca5ce", + "name": "ads", + "noarch": "python", + "platform": null, + "sha256": "9e0c1b294168a344d0961ab1068b7504895098008876ae6dd7fe439b58ac6a43", + "size": 31403, + "subdir": "noarch", + "timestamp": 1531136292436, + "version": "0.12.3" + }, + "ads2inspire-0.3.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "bibtexparser", + "click >=6.0", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "45d3ffcd3283f34939e7f9f3d8da1142", + "name": "ads2inspire", + "noarch": "python", + "sha256": "2c74cf68c524a6419b57c4b0c9bec0baeb894787bd45ed7fde2355852d7aa899", + "size": 12424, + "subdir": "noarch", + "timestamp": 1607110789615, + "version": "0.3.1" + }, + "adtk-0.6.2-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "matplotlib-base >=3.0", + "numpy >=1.15", + "packaging >=17.0", + "pandas >=0.23", + "python >=3.5", + "scikit-learn >=0.20", + "statsmodels <0.11,>=0.9", + "tabulate >=0.8" + ], + "license": "MPL-2.0", + "license_family": "MOZILLA", + "md5": "e7f7df307932e82966f0c6887b276b17", + "name": "adtk", + "noarch": "python", + "sha256": "d520628dfd5b665622caa4164d9ab4c0fba6b78605298acd708eb70893ab8294", + "size": 50087, + "subdir": "noarch", + "timestamp": 1587411927004, + "version": "0.6.2" + }, + "advbumpversion-1.2.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fb1111deeaafb427a923a998a2b7842c", + "name": "advbumpversion", + "noarch": "python", + "sha256": "4e3a0e53b0f81f07f4ac3045b9103a34d821ce774d95ac74dc83a68d253b67bf", + "size": 19783, + "subdir": "noarch", + "timestamp": 1532100821313, + "version": "1.2.0" + }, + "aenum-2.2.6-pyhd3deb0d_0.tar.bz2": { + "build": "pyhd3deb0d_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "543d7385280a84c838a4313fcbe18f2a", + "name": "aenum", + "noarch": "python", + "sha256": "35cc87694bc81df6af039b2867a07c0f8a4f0bd81c94384e6fdad7e3b6dd8342", + "size": 87277, + "subdir": "noarch", + "timestamp": 1607492858438, + "version": "2.2.6" + }, + "aesara-theano-fallback-0.1.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "51de8babc0380778a61d9315537086d6", + "name": "aesara-theano-fallback", + "noarch": "python", + "sha256": "61eceffd1a53138e7d3f00226de673d8bf03ba4adeebf1e07e45e798e752cd8b", + "size": 8556, + "subdir": "noarch", + "timestamp": 1641869904678, + "version": "0.1.0" + }, + "afar-0.6.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "distributed >=2021.9.1", + "innerscope", + "python >=3.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6a4aef528f3b16dc8f5d4da317c029e0", + "name": "afar", + "noarch": "python", + "sha256": "d49ce0243e4a75f77f82bc75b2d156d5f5b8391eb93b8665a5fca2ac058f5fb7", + "size": 20205, + "subdir": "noarch", + "timestamp": 1633046717643, + "version": "0.6.1" + }, + "aflow-0.0.11-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "ase", + "beautifulsoup4", + "jinja2", + "numpy", + "python", + "six", + "termcolor" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "44435f3b88db535f2d85a141a3ee499b", + "name": "aflow", + "noarch": "python", + "sha256": "f8292bb6e1bcb091e3352e5db9e5ad94660324ad0e1c126ba5825bdba6eaffd7", + "size": 26908, + "subdir": "noarch", + "timestamp": 1582955419364, + "version": "0.0.11" + }, + "afwizard-library-0.0.10-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d98f08bcd86b3d1fc468ddc57d96d592", + "name": "afwizard-library", + "noarch": "python", + "sha256": "bbc0840f3162754602325a67696687ba27c395743a3ec3fe54fb8fa388f11879", + "size": 7543, + "subdir": "noarch", + "timestamp": 1667406856832, + "version": "0.0.10" + }, + "ag-grid-18.0.1-0.tar.bz2": { + "arch": null, + "build": "0", + "build_number": 0, + "depends": [], + "license": "MIT", + "license_family": "MIT", + "md5": "370af27e4827749564c56da587c07f6a", + "name": "ag-grid", + "noarch": "generic", + "platform": null, + "sha256": "94c73748ba6a8ef9b08dbe9f5a74bad0c5bb57041259f39a8cf1a175dec1cc8e", + "size": 1312314, + "subdir": "noarch", + "timestamp": 1528827662858, + "version": "18.0.1" + }, + "agate-1.6.3-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "babel >=2.0", + "future", + "isodate >=0.5.4", + "leather >=0.3.2", + "parsedatetime !=2.5,!=2.6,>=2.1", + "pyicu", + "python >=3.6", + "python-slugify >=1.2.1", + "pytimeparse >=1.1.5", + "six >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "df30dcb550fc75692377cc71672af4f2", + "name": "agate", + "noarch": "python", + "sha256": "015cecf949cf5eee88c99b71df90c3e69153a0b299c77c817051a14fc1cba308", + "size": 57574, + "subdir": "noarch", + "timestamp": 1626421559114, + "version": "1.6.3" + }, + "agate-dbf-0.2.2-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "dbfread >=2.0.5", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a07dfe4b3ddfdb7fd3536d902f3396f8", + "name": "agate-dbf", + "noarch": "python", + "sha256": "80ed45b5670024194280e3c8631a4989fde4119a9223bc0acccf7ebab4608018", + "size": 7213, + "subdir": "noarch", + "timestamp": 1622404803230, + "version": "0.2.2" + }, + "agate-excel-0.2.3-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "openpyxl >=2.3.0", + "python", + "xlrd >=0.9.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26a3416153f17addfdab82a183665a98", + "name": "agate-excel", + "noarch": "python", + "sha256": "f33c0d10fb2b13385c6fa5cca6ccbfb0b2a425c8bb2d57a786907a7b1b92350d", + "size": 8306, + "subdir": "noarch", + "timestamp": 1552826424504, + "version": "0.2.3" + }, + "agate-remote-0.2.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "agate >=1.5.0", + "python >=3.6", + "requests >=2.9.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4b3a25a3a4aae660fd06e13cccfa7555", + "name": "agate-remote", + "noarch": "python", + "sha256": "acdf2eef94dadb154addde590686efafd32e8c0d6309468a0a30752db82675b6", + "size": 7672, + "subdir": "noarch", + "timestamp": 1626204651117, + "version": "0.2.1" + }, + "aghast-0.2.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "numpy", + "python", + "python-flatbuffers >=1.8.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b7b4c7c1d66d0a8844bfc587772360b0", + "name": "aghast", + "noarch": "python", + "sha256": "b4698c9573bb1baec79fff3a89407b5dc9708cc864335dcfdfd869f51f8439c9", + "size": 99658, + "subdir": "noarch", + "timestamp": 1555134846616, + "version": "0.2.1" + }, + "ago-0.0.93-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "Public Domain", + "license_family": "OTHER", + "md5": "43d25d43507c7ba249600ac8542885a0", + "name": "ago", + "noarch": "python", + "sha256": "51f2c85a970d98b5ab393ed897efa044a842a348c2ec51825c70a9cc8efce6c5", + "size": 6037, + "subdir": "noarch", + "timestamp": 1549168983592, + "version": "0.0.93" + }, + "ai2thor-4.2.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aws-requests-auth", + "botocore", + "flask", + "msgpack-python", + "numpy", + "opencv", + "pillow", + "progressbar2", + "python >=3.6", + "python-xlib", + "requests", + "werkzeug >=0.15.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "2bd019166170e0164a269e45984edb2a", + "name": "ai2thor", + "noarch": "python", + "sha256": "03d47a89d8b2e358791999c94304bc99dff6cfde076afa4c334f9a2939e8a6b0", + "size": 56833, + "subdir": "noarch", + "timestamp": 1644892555269, + "version": "4.2.0" + }, + "aif360-0.5.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "numpy >=1.16", + "pandas >=0.24.0", + "python >=3.6,<3.9", + "scikit-learn >=0.22.1", + "scipy >=1.2.0,<1.6.0", + "tempeh" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "a636d7750b1bf5fd5f4dca43630911bf", + "name": "aif360", + "noarch": "python", + "sha256": "f3d226251921c1966a10a6d8e4a7053665672ff03d8446092dbfbdec08b23fbb", + "size": 135487, + "subdir": "noarch", + "timestamp": 1662299913403, + "version": "0.5.0" + }, + "aiida-bigdft-0.2.6-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiida-core >=1.1.1,<2.0.0", + "python >=3.7", + "six", + "voluptuous" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3a92ec790d00a24518ad321d00651d9a", + "name": "aiida-bigdft", + "noarch": "python", + "sha256": "22a5e2af05afc42bf280210581827906d61154362f2fc1a0df7fd3fa08b44684", + "size": 163414, + "subdir": "noarch", + "timestamp": 1657550232023, + "version": "0.2.6" + }, + "aiida-castep-2.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiida-core >=2.0,<3.0.0", + "ase >=3.0,<4.0", + "castepinput 0.1.6", + "castepxbin >=0.2.0,<0.3.0", + "click", + "deepdiff", + "matplotlib-base", + "python >=3.6", + "seekpath >=1.9.3,<1.10.0", + "six >=1.0,<2.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c613a5d9b6487c54c88d14317ac1c8d3", + "name": "aiida-castep", + "noarch": "python", + "sha256": "a5afbafbba71a6d6890e19181124c5f421f65f35ea4b5571a8a13dfc0699d5ce", + "size": 116401, + "subdir": "noarch", + "timestamp": 1658511766840, + "version": "2.0.1" + }, + "aiida-core-1.6.8-pyh6c4a22f_0.tar.bz2": { + "build": "pyh6c4a22f_0", + "build_number": 0, + "constrains": [ + "aiida-core.services ==1.6.8" + ], + "depends": [ + "aio-pika ~=6.6", + "aldjemy ~=0.9.1", + "alembic ~=1.2", + "archive-path ~=0.2.1", + "circus ~=0.17.1", + "click ~=7.1", + "click-completion ~=0.5.1", + "click-config-file ~=0.6.0", + "click-spinner ~=0.1.8", + "django ~=2.2", + "ete3 ~=3.1", + "ipython ~=7.20", + "jinja2 ~=2.10", + "jsonschema ~=3.0", + "kiwipy ~=0.7.4", + "markupsafe <2.1", + "numpy ~=1.17", + "pamqp ~=2.3", + "paramiko ~=2.7,>=2.7.2", + "pgsu ~=0.2.0", + "plumpy ~=0.20.0", + "psutil ~=5.6", + "psycopg2-binary ~=2.8.3", + "python ~=3.7", + "python-dateutil ~=2.8", + "python-graphviz ~=0.13", + "pytz ~=2019.3", + "pyyaml ~=5.4", + "reentry ~=1.3", + "simplejson ~=3.16", + "sqlalchemy ~=1.3.10", + "sqlalchemy-utils ~=0.36.0", + "tabulate ~=0.8.5", + "tqdm ~=4.45", + "tzlocal ~=2.0", + "upf_to_json ~=0.9.2", + "wrapt ~=1.11.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1652b2dca37446ae9d222dcf1b785e2f", + "name": "aiida-core", + "noarch": "python", + "sha256": "02cd0ea713e163eaf3a08e1a04c1686caf74348d91bf9c573e7baf9bba0e1080", + "size": 718424, + "subdir": "noarch", + "timestamp": 1648225042046, + "version": "1.6.8" + }, + "aiida-core-1.6.8-pyh6c4a22f_1.tar.bz2": { + "build": "pyh6c4a22f_1", + "build_number": 1, + "constrains": [ + "aiida-core.services 1.6.8 1" + ], + "depends": [ + "aio-pika ~=6.6", + "aldjemy ~=0.9.1", + "alembic ~=1.2", + "archive-path ~=0.2.1", + "circus ~=0.17.1", + "click ~=7.1", + "click-completion ~=0.5.1", + "click-config-file ~=0.6.0", + "click-spinner ~=0.1.8", + "django ~=2.2", + "ete3 ~=3.1", + "ipython ~=7.20", + "jinja2 ~=2.10", + "jsonschema ~=3.0", + "kiwipy ~=0.7.4", + "markupsafe <2.1", + "numpy ~=1.17", + "pamqp ~=2.3", + "paramiko ~=2.7,>=2.7.2", + "pgsu ~=0.2.0", + "plumpy ~=0.20.0", + "psutil ~=5.6", + "psycopg2-binary ~=2.8.3", + "python ~=3.7", + "python-dateutil ~=2.8", + "python-graphviz ~=0.13", + "pytz ~=2019.3", + "pyyaml ~=5.4", + "reentry ~=1.3", + "simplejson ~=3.16", + "sqlalchemy ~=1.3.10", + "sqlalchemy-utils ~=0.36.0", + "tabulate ~=0.8.5", + "tqdm ~=4.45", + "tzlocal ~=2.0", + "upf_to_json ~=0.9.2", + "wrapt ~=1.11.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d901f97f1a1310cc1ac9e1e9d98fcc70", + "name": "aiida-core", + "noarch": "python", + "sha256": "3645ccc6826c22ccd0be6fa9fa5518dadf3b57a6fd25134ae167c6e6bd91734f", + "size": 719674, + "subdir": "noarch", + "timestamp": 1657567327663, + "version": "1.6.8" + }, + "aiida-core-1.6.8-pyh6c4a22f_2.tar.bz2": { + "build": "pyh6c4a22f_2", + "build_number": 2, + "constrains": [ + "aiida-core.services 1.6.8 2" + ], + "depends": [ + "aio-pika ~=6.6", + "aldjemy ~=0.9.1", + "alembic ~=1.2", + "archive-path ~=0.2.1", + "circus ~=0.17.1", + "click ~=7.1", + "click-completion ~=0.5.1", + "click-config-file ~=0.6.0", + "click-spinner ~=0.1.8", + "django ~=2.2", + "ete3 ~=3.1", + "ipython ~=7.20", + "jinja2 ~=2.10", + "jsonschema ~=3.0", + "kiwipy ~=0.7.4", + "markupsafe <2.1", + "numpy ~=1.17", + "pamqp ~=2.3", + "paramiko ~=2.7,>=2.7.2", + "pgsu ~=0.2.0", + "plumpy ~=0.20.0", + "psutil ~=5.6", + "psycopg2-binary ~=2.8.3", + "python ~=3.7", + "python-dateutil ~=2.8", + "python-graphviz ~=0.13", + "pytz ~=2019.3", + "pyyaml ~=5.4", + "reentry ~=1.3", + "simplejson ~=3.16", + "sqlalchemy ~=1.3.10", + "sqlalchemy-utils ~=0.36.0", + "tabulate ~=0.8.5", + "tqdm ~=4.45", + "tzlocal ~=2.0", + "upf_to_json ~=0.9.2", + "wrapt ~=1.11.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af58ba7c95a188e8c7ae7bcdec8fcc66", + "name": "aiida-core", + "noarch": "python", + "sha256": "71c586c6fb1a16bcfd2d035e75a15172f47d048899781d46ad042544aca54027", + "size": 719772, + "subdir": "noarch", + "timestamp": 1658457033313, + "version": "1.6.8" + }, + "aiida-core.atomic_tools-1.6.8-hd8ed1ab_1.tar.bz2": { + "build": "hd8ed1ab_1", + "build_number": 1, + "depends": [ + "aiida-core 1.6.8 pyh6c4a22f_1", + "ase ~=3.18", + "matplotlib-base ~=3.3,>=3.3.4", + "pandas !=1.4.0,!=1.4.1,!=1.4.2", + "pycifrw ~=4.4", + "pymatgen >=2019.7.2,<=2022.1.9,!=2019.9.7", + "pymysql ~=0.9.3", + "seekpath ~=1.9,>=1.9.3", + "spglib ~=1.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "238a086b0954be53e0c66da1fb920e35", + "name": "aiida-core.atomic_tools", + "noarch": "python", + "sha256": "c93b6451fa530e1b9c242e3cbd319454300144df7b40e6f0dde4d5e02e48d6f1", + "size": 5918, + "subdir": "noarch", + "timestamp": 1657567337563, + "version": "1.6.8" + }, + "aiida-core.atomic_tools-1.6.8-hd8ed1ab_2.tar.bz2": { + "build": "hd8ed1ab_2", + "build_number": 2, + "depends": [ + "aiida-core 1.6.8 pyh6c4a22f_2", + "ase ~=3.18", + "matplotlib-base ~=3.3,>=3.3.4", + "pandas !=1.4.0,!=1.4.1,!=1.4.2", + "pycifrw ~=4.4", + "pymatgen >=2019.7.2,<=2022.1.9,!=2019.9.7", + "pymysql ~=0.9.3", + "seekpath ~=1.9,>=1.9.3", + "spglib ~=1.14" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4e693ee32978fde24ee286338b08cea4", + "name": "aiida-core.atomic_tools", + "noarch": "python", + "sha256": "f42b6c3712cef27874ddc5b42db6d8f9d261d7f419b72a567a0a64e4a13395ba", + "size": 6127, + "subdir": "noarch", + "timestamp": 1658457045453, + "version": "1.6.8" + }, + "aiida-crystal17-0.4.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "aiida-core 0.12.2", + "ase >=3.12", + "ejplugins >=0.9.7", + "packaging", + "postgresql >=9.4", + "python 2.7.*", + "spglib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b0c737af6b1dab2beeb8048d9d659ab6", + "name": "aiida-crystal17", + "noarch": "python", + "sha256": "22ed97b59d62299be035da202478566d9bddca0679c72db6578c52faf300b0f7", + "size": 94073, + "subdir": "noarch", + "timestamp": 1551528606087, + "version": "0.4.0" + }, + "aiida-crystal17-0.4.0-py_1.tar.bz2": { + "build": "py_1", + "build_number": 1, + "depends": [ + "aiida-core 0.12.*", + "ase >=3.12", + "ejplugins >=0.9.7", + "packaging", + "postgresql >=9.4", + "python 2.7.*", + "spglib" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "77fbd1aee15963e27f2fbe9190f7fdf6", + "name": "aiida-crystal17", + "noarch": "python", + "sha256": "fe4de5dcd19cc89d56bafb0f707e300a202c369b8c857a7ede03d5eeb8c1e8f7", + "size": 94051, + "subdir": "noarch", + "timestamp": 1551848331105, + "version": "0.4.0" + }, + "aiida-cusp-0.1.0b2-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "aiida-core >=1.3.0,<2.0.0", + "ase", + "custodian", + "pymatgen", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "17b6a49e502c59a994b63df4659095c2", + "name": "aiida-cusp", + "noarch": "python", + "sha256": "1e93d6c73c53a0b6b0269eff2e402bb7d03ef51d94f033412442643a0af41413", + "size": 40793, + "subdir": "noarch", + "timestamp": 1597178435986, + "version": "0.1.0b2" + }, + "aiida-gaussian-1.4.3-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiida-core >=1.0.0,<2.0.0", + "ase", + "cclib >=1.6.1,<=1.7", + "pandas !=1.4.0,!=1.4.1,!=1.4.2", + "pymatgen >=2020.4,<2022.0.0", + "python >=3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5eb294aea136113d55fa8234756341a0", + "name": "aiida-gaussian", + "noarch": "python", + "sha256": "0738fb32d368a2b7ce66d15956cd0e348254739a7c6448ce1c064d77db9c7dc6", + "size": 21921, + "subdir": "noarch", + "timestamp": 1657550079893, + "version": "1.4.3" + }, + "aiida-nwchem-2.1.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiida-core >=1.2.1", + "numpy", + "python >=3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e4fd1e68a28e8c20722e6ed67e7d1e15", + "name": "aiida-nwchem", + "noarch": "python", + "sha256": "3b639864954f181b4ecb49c2cd49da2711f89c0aa2eaf91198c3cffb7466c40f", + "size": 15774, + "subdir": "noarch", + "timestamp": 1657549885960, + "version": "2.1.0" + }, + "aiida-nwchem-2.1.0-pyhd8ed1ab_2.tar.bz2": { + "build": "pyhd8ed1ab_2", + "build_number": 2, + "depends": [ + "aiida-core.atomic_tools >=1.2.1,<2", + "numpy", + "python >=3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "eb6d90393b7c160d110c778e1a0721dc", + "name": "aiida-nwchem", + "noarch": "python", + "sha256": "e92fa5af96515cab03040e2a72b14e67b9be441eb21cc61f739a9d98d4f9330b", + "size": 15839, + "subdir": "noarch", + "timestamp": 1657577535296, + "version": "2.1.0" + }, + "aiida-nwchem-2.1.0-pyhd8ed1ab_3.tar.bz2": { + "build": "pyhd8ed1ab_3", + "build_number": 3, + "constrains": [ + "aiida-nwchem.code ==2.1.0" + ], + "depends": [ + "aiida-core.atomic_tools >=1.2.1,<2", + "numpy", + "python >=3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "14b81404c56da34b1e1616b5d8995396", + "name": "aiida-nwchem", + "noarch": "python", + "sha256": "8f517720f956d842e141ca2f9acf2c82933b43694767c47405dc89daa75c8397", + "size": 15935, + "subdir": "noarch", + "timestamp": 1657639169445, + "version": "2.1.0" + }, + "aiida-nwchem.code-2.1.0-hd8ed1ab_2.tar.bz2": { + "build": "hd8ed1ab_2", + "build_number": 2, + "depends": [ + "aiida-nwchem 2.1.0 pyhd8ed1ab_2", + "nwchem 7.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f27253ee7b39d0e9786babed5c4e70bd", + "name": "aiida-nwchem.code", + "noarch": "python", + "sha256": "6f3bb898eaf6484f090570452fc72b054d71c5780b611b607c4a36cf46d74cee", + "size": 4712, + "subdir": "noarch", + "timestamp": 1657577541897, + "version": "2.1.0" + }, + "aiida-nwchem.code-2.1.0-hd8ed1ab_3.tar.bz2": { + "build": "hd8ed1ab_3", + "build_number": 3, + "depends": [ + "nwchem 7.*" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "82957eb3d7cc97278da249532ac1a540", + "name": "aiida-nwchem.code", + "noarch": "python", + "sha256": "3b06ff77e2e7c89efd4bf8325d0a4623a1631454d01a2e39ba41936552a41dca", + "size": 4790, + "subdir": "noarch", + "timestamp": 1657639174526, + "version": "2.1.0" + }, + "aiida-nwchem.meta-2.1.0-hd8ed1ab_3.tar.bz2": { + "build": "hd8ed1ab_3", + "build_number": 3, + "depends": [ + "aiida-nwchem 2.1.0 pyhd8ed1ab_3", + "aiida-nwchem.code 2.1.0 hd8ed1ab_3" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cc544f1e475523c79f9165a6d9ce0f76", + "name": "aiida-nwchem.meta", + "noarch": "python", + "sha256": "67b5186ea44e3543878401af4c0c015f3a3af55989312f0b24366f44e8764222", + "size": 4726, + "subdir": "noarch", + "timestamp": 1657639176706, + "version": "2.1.0" + }, + "aiida-orca-0.5.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiida-core >=1.0.0,<2.0.0", + "cclib", + "pandas !=1.4.0,!=1.4.1,!=1.4.2", + "python >=3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79caf8673292211a7e921681875fd34f", + "name": "aiida-orca", + "noarch": "python", + "sha256": "fa014bb37093e22cf8109f4d425d2aec91d7005651a7911536679c45733e0551", + "size": 15757, + "subdir": "noarch", + "timestamp": 1657549375072, + "version": "0.5.1" + }, + "aiida-orca-0.5.1-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "depends": [ + "aiida-core.atomic_tools >=1.0.0,<2", + "cclib", + "python >=3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71252b8b688a47dc313ca53da53ab4c5", + "name": "aiida-orca", + "noarch": "python", + "sha256": "a968dee8159ee7943897f576713b1c12152e744ed3a6967221e7c456a8e35b6c", + "size": 15691, + "subdir": "noarch", + "timestamp": 1657586706573, + "version": "0.5.1" + }, + "aiida-quantumespresso-3.5.2-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiida-core.atomic_tools >=1.4.4,<2", + "aiida-pseudo >=0.6.1,<0.7.0", + "importlib_resources", + "jsonschema", + "numpy", + "packaging", + "python >=3.6", + "qe-tools >1,<3", + "xmlschema >=1.2.5,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9541fda8132d45970cc81638caa487e", + "name": "aiida-quantumespresso", + "noarch": "python", + "sha256": "659791fed896b932f1766f8d8b6cc706dc2084654675ce9c6c92b1984ebcd346", + "size": 273053, + "subdir": "noarch", + "timestamp": 1657718728679, + "version": "3.5.2" + }, + "aiida-quantumespresso-3.5.2-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "constrains": [ + "aiida-quantumespresso.code ==3.5.2" + ], + "depends": [ + "aiida-core.atomic_tools >=1.4.4,<2", + "aiida-pseudo >=0.6.1,<0.7.0", + "importlib_resources", + "jsonschema", + "numpy", + "packaging", + "python >=3.6", + "qe-tools >1,<3", + "xmlschema >=1.2.5,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "639f778f044b4c32cff281fc9ac0b54e", + "name": "aiida-quantumespresso", + "noarch": "python", + "sha256": "788f8adc89008563b47470bcecf0222ccd3080626a6a0ca6396f13c15507207d", + "size": 271879, + "subdir": "noarch", + "timestamp": 1657719940508, + "version": "3.5.2" + }, + "aiida-tools-0.4.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiida-core >=1.0.0,<3.0.0", + "python >=3.7", + "pyyaml" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "f1c113234de36f16e96db45c57c8301f", + "name": "aiida-tools", + "noarch": "python", + "sha256": "f3e35e848a64355ad0437be96dfb2e7c2279c3bd2caf6ce392881d0fede5dc3e", + "size": 12599, + "subdir": "noarch", + "timestamp": 1657549697087, + "version": "0.4.1" + }, + "aiida-vasp-2.1.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiida-core.atomic_tools >=1.2.1,!=1.4.0,!=1.4.1", + "lxml", + "packaging", + "parsevasp >=2.0.1", + "pymatgen <=2020.12.3", + "python >=3.6", + "subprocess32" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0402e0f71eb8e38d9db9092ee019073", + "name": "aiida-vasp", + "noarch": "python", + "sha256": "3fd596ddc0468301dbb24c7d99fac5f6a0c64077babe5b9ab5f0b26077d70f47", + "size": 9235328, + "subdir": "noarch", + "timestamp": 1658511639664, + "version": "2.1.1" + }, + "aiida-wannier90-2.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiida-core >=1.0.0,<2", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0347facbf18f2b4fc443fbea1698007e", + "name": "aiida-wannier90", + "noarch": "python", + "sha256": "5fb4efec79aaebf0bdd46d52b493d5b0741cc0a2182b28178ab3af2326e7060a", + "size": 27835, + "subdir": "noarch", + "timestamp": 1657718880205, + "version": "2.0.1" + }, + "aiida-wannier90-2.0.1-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "constrains": [ + "aiida-wannier90.code ==2.0.1" + ], + "depends": [ + "aiida-core >=1.0.0,<2", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "de056e5d8a12ce4085fc96c4c03f1264", + "name": "aiida-wannier90", + "noarch": "python", + "sha256": "5aea598c257c211862bd7b3600dfd3125adffd5926782fce51f1457b4156ba47", + "size": 27968, + "subdir": "noarch", + "timestamp": 1657720923802, + "version": "2.0.1" + }, + "aiida-wannier90.code-2.0.1-hd8ed1ab_1.tar.bz2": { + "build": "hd8ed1ab_1", + "build_number": 1, + "depends": [ + "wannier90 >=1,<4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc7d0141caf4eaf91b89a79ed3d83138", + "name": "aiida-wannier90.code", + "noarch": "python", + "sha256": "ca1c060adfa630840e43ab7a106cd78a4ce95d72a0f113a495dcd5db2872b021", + "size": 4919, + "subdir": "noarch", + "timestamp": 1657720929909, + "version": "2.0.1" + }, + "aiida-wannier90.meta-2.0.1-hd8ed1ab_1.tar.bz2": { + "build": "hd8ed1ab_1", + "build_number": 1, + "depends": [ + "aiida-wannier90 2.0.1 pyhd8ed1ab_1", + "aiida-wannier90.code 2.0.1 hd8ed1ab_1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92fdea730e9a3abd25f41362ea21d4c2", + "name": "aiida-wannier90.meta", + "noarch": "python", + "sha256": "40cb85c20fe5946c497a779c0bfa2c9ac397813decb2943413fc45f653eb3970", + "size": 4862, + "subdir": "noarch", + "timestamp": 1657720932520, + "version": "2.0.1" + }, + "aiida-wannier90_workflows-1.0.2-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiida-core >=1.1.1,<2", + "aiida-quantumespresso >=3.0.0a6", + "aiida-wannier90 >=2.0.0", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d75010db6274a800a0a17a8b8075fdfc", + "name": "aiida-wannier90_workflows", + "noarch": "python", + "sha256": "11f64b47aaec46294029215dc0d38e6f9c1350f83b1a50be5baf3f03702c429e", + "size": 22430, + "subdir": "noarch", + "timestamp": 1658422080137, + "version": "1.0.2" + }, + "aiida-yambo-1.3.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiida-core.atomic_tools >=1.0.0a2", + "aiida-quantumespresso >=3.0.0a6,<4.0", + "h5py", + "netcdf4", + "pytest", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c8f78069838fb87077dbbf71ebbe94ba", + "name": "aiida-yambo", + "noarch": "python", + "sha256": "d34b361b275e52d3912453ef9640f0530f17388d6cdfbffe3e5e00c2b119cb35", + "size": 46418, + "subdir": "noarch", + "timestamp": 1658496279312, + "version": "1.3.0" + }, + "aimrecords-0.0.7-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "base58 2.0.1", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3949264dbf817a9758152ee1c1b9cb39", + "name": "aimrecords", + "noarch": "python", + "sha256": "7deeafe0448a4dba99a20b86eb9f2e5292bdb21e499a46dbcb413699c01aa272", + "size": 18470, + "subdir": "noarch", + "timestamp": 1625598623991, + "version": "0.0.7" + }, + "aio-executor-0.2.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c5b773584be296be961dd18c0d68e33a", + "name": "aio-executor", + "noarch": "python", + "sha256": "db0b89aa7075e980b47c3c7b72f19e393d4fac1749838f948995784651cd05e5", + "size": 7186, + "subdir": "noarch", + "timestamp": 1654466471210, + "version": "0.2.0" + }, + "aio-pika-6.8.1-pyh6c4a22f_0.tar.bz2": { + "build": "pyh6c4a22f_0", + "build_number": 0, + "depends": [ + "aiormq >=3.2.3,<4", + "python >=3.6", + "yarl" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e11fe0dec90da563f67bdfa62f4cf65f", + "name": "aio-pika", + "noarch": "python", + "sha256": "3f83100fcd16c7dc887a6df1a600e1922bd8c925145eae934da693f83bb5fe74", + "size": 34370, + "subdir": "noarch", + "timestamp": 1642726740369, + "version": "6.8.1" + }, + "aioboto3-10.1.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiobotocore 2.4.0", + "boto3 >=1.21.21", + "cryptography >=37.0.0", + "idna >=3.3.0", + "python >=3.8" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "773171f496d1b2463a53eae0ca11f25f", + "name": "aioboto3", + "noarch": "python", + "sha256": "11f10310b6d2e9a63b185e8e0ade42fe76b044d4ba270a0e5f9dd8194af6aa8d", + "size": 32639, + "subdir": "noarch", + "timestamp": 1665665934399, + "version": "10.1.0" + }, + "aiobotocore-0.12.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.15.3,<1.15.16", + "python >=3.6", + "wrapt >=1.10.10" + ], + "license": "Apache 2", + "license_family": "Apache", + "md5": "b3c9a6302d6ad039c31affaf27b163e6", + "name": "aiobotocore", + "noarch": "python", + "sha256": "1ec0374f87543e0800b6ac5cd8a7fb4cd69952ad2d32c3315235cf13620855ac", + "size": 25839, + "subdir": "noarch", + "timestamp": 1582528823037, + "version": "0.12.0" + }, + "aiobotocore-2.4.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.3.1", + "aioitertools >=0.5.1", + "botocore >=1.27.59,<1.27.60", + "python >=3.6", + "wrapt >=1.10.10" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "9adcdcd7539afff88018c18b650dee50", + "name": "aiobotocore", + "noarch": "python", + "sha256": "27e0984e22168a35bd42e2f844e53695604aeb1c69104c11b74b4c3f1d51c091", + "size": 54556, + "subdir": "noarch", + "timestamp": 1661463231364, + "version": "2.4.0" + }, + "aiocircuitbreaker-2.0.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.9" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "212d927b862d628a69ef23fa49eda8a1", + "name": "aiocircuitbreaker", + "noarch": "python", + "sha256": "3689defaae39409b50f61a0d0dcdf5c1cbf014cb8f394e17c31375850fcc0629", + "size": 10439, + "subdir": "noarch", + "timestamp": 1661530193482, + "version": "2.0.0" + }, + "aiocontextvars-0.2.2-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "contextvars 2.4", + "python >=3.5,<3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1c930fda265db82391624231d1f38536", + "name": "aiocontextvars", + "noarch": "python", + "sha256": "43d7d136dde819ae9ea7a8ba56bc84f861f70bda88247318d7d130fab5d28d85", + "size": 7740, + "subdir": "noarch", + "timestamp": 1554796503096, + "version": "0.2.2" + }, + "aiodns-3.0.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "pycares >=4.0.0", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ca51167c2f1e2e1d881c80f6c9e542aa", + "name": "aiodns", + "noarch": "python", + "sha256": "df026a45ea99e4bdb048b611d8e7c796773b204e96a656e01ac33157990a369b", + "size": 8929, + "subdir": "noarch", + "timestamp": 1637834712280, + "version": "3.0.0" + }, + "aioeasywebdav-2.4.0-pyha770c72_0.tar.bz2": { + "build": "pyha770c72_0", + "build_number": 0, + "depends": [ + "aiohttp", + "python >=3.6", + "setuptools-scm" + ], + "license": "ISC", + "md5": "dd5bf8931da06c21f9ea03e9621acfc7", + "name": "aioeasywebdav", + "noarch": "python", + "sha256": "6b4ad9e87fe69564f50f6aab77d03b506996d7ca7e5089dd6beb862bb94708d3", + "size": 12529, + "subdir": "noarch", + "timestamp": 1636484549358, + "version": "2.4.0" + }, + "aiofiles-0.6.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.4" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "40407f60e554d2fc9951c898f825bfdc", + "name": "aiofiles", + "noarch": "python", + "sha256": "1d3dba9d8f29c01704c6bc99d489384cd2dcc082809465b18f9838def1cfccd1", + "size": 14127, + "subdir": "noarch", + "timestamp": 1603888964530, + "version": "0.6.0" + }, + "aiofiles-0.8.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "c89acfd9023d35305ea12617cba6df2d", + "name": "aiofiles", + "noarch": "python", + "sha256": "7b777952bc0b17f1d7201ea66929fab4c1dbf19421b03bcbacc61ac4f41aa864", + "size": 16755, + "subdir": "noarch", + "timestamp": 1639589562165, + "version": "0.8.0" + }, + "aiofiles-22.1.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a88c206fdb78e34adb1c4081f5f838dd", + "name": "aiofiles", + "noarch": "python", + "sha256": "abc19fcb120907a45515980a2660e003b89d7143c21f95354f7f08dfa432603e", + "size": 17668, + "subdir": "noarch", + "timestamp": 1664378675243, + "version": "22.1.0" + }, + "aioftp-0.21.4-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.7" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "ac23a44177d21eed78a18467075caae4", + "name": "aioftp", + "noarch": "python", + "sha256": "7d338fb15ad024b76f033daacf531778245d5796bc92429e764e794537bc8d0f", + "size": 36359, + "subdir": "noarch", + "timestamp": 1665651070558, + "version": "0.21.4" + }, + "aiohttp-cors-0.7.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "aiohttp >=1.1", + "python >=3.6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "276767d5ffa1515c293d25bd78f22a0b", + "name": "aiohttp-cors", + "noarch": "python", + "sha256": "a076e73dbaafebab8b6a899d066fdb78407bd32c49774fa87aae412e228c6a1a", + "size": 22718, + "subdir": "noarch", + "timestamp": 1572720498288, + "version": "0.7.0" + }, + "aiohttp-graphql-1.1.0-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "aiohttp >=3,<4", + "graphql-core >=2.3,<3", + "graphql-server-core >=1.2,<2", + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b4359d51847bd1827515821f5070e1fe", + "name": "aiohttp-graphql", + "noarch": "python", + "sha256": "e6ccc2b042a2e592077687957d3aa5f2792e26e158e0db3ef46f34e3e3533092", + "size": 11959, + "subdir": "noarch", + "timestamp": 1588541020996, + "version": "1.1.0" + }, + "aiohttp-jinja2-1.1.2-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.2.0", + "jinja2 >=2.10.1", + "python >3.5.3" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "3255e83198d8beb0f3e14ead543f3a45", + "name": "aiohttp-jinja2", + "noarch": "python", + "sha256": "23e835219bd24dcf92c1877659a900dca1a42280c1dca16cf58a095ee87a6b10", + "size": 13336, + "subdir": "noarch", + "timestamp": 1564746159388, + "version": "1.1.2" + }, + "aiohttp-retry-2.8.3-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiohttp", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63075586964c3e0d53e1a8d804d89090", + "name": "aiohttp-retry", + "noarch": "python", + "sha256": "1a0098aa927a06daae6457eaaeee29092c1f6c174b2e1d3a523816d22b447bfe", + "size": 13142, + "subdir": "noarch", + "timestamp": 1660544804883, + "version": "2.8.3" + }, + "aiohttp-security-0.4.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.2.0", + "python >3.5" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "194497fe6b15707822e8d6e405c6de7b", + "name": "aiohttp-security", + "noarch": "python", + "sha256": "12c24d6724c853d750fbdfa56245e4641602a67600968264edb805a0344e27f5", + "size": 13525, + "subdir": "noarch", + "timestamp": 1560998782860, + "version": "0.4.0" + }, + "aiohttp-session-2.7.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "constrains": [ + "aioredis >=1.0.0", + "aiomcache >=0.5.2" + ], + "depends": [ + "aiohttp >=3.0.1", + "python >=3.5" + ], + "license": "Apache Software", + "license_family": "APACHE", + "md5": "1efd90b4cf022cd401e4b8bdc93f7b71", + "name": "aiohttp-session", + "noarch": "python", + "sha256": "29e8476750f663d2ca37b7d82d00c543cea244da4916ba3653be428182d8a6c8", + "size": 15538, + "subdir": "noarch", + "timestamp": 1560999520735, + "version": "2.7.0" + }, + "aiohttp-sse-2.1.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiohttp >=3.0", + "python >=3.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0167bc4d7f258e8c9b80c81f65feee90", + "name": "aiohttp-sse", + "noarch": "python", + "sha256": "deb4b04f416a7a9bb8988eb324dcc377deaaf6deb09d598fcb030e1df3d89afb", + "size": 8252, + "subdir": "noarch", + "timestamp": 1636812070378, + "version": "2.1.0" + }, + "aiohttp-sse-client-0.2.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiohttp >=3", + "attrs", + "multidict", + "python >=3.6", + "yarl" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "3c2e0701d91cc9603ae84442c6d53ae1", + "name": "aiohttp-sse-client", + "noarch": "python", + "sha256": "14d17321a639d89be5c7b5973a6d171df4854ee3eb6b1b3cd29906a253aaca08", + "size": 10014, + "subdir": "noarch", + "timestamp": 1614432169039, + "version": "0.2.1" + }, + "aiohttp-xmlrpc-1.5.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiohttp", + "lxml", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f024fdfcce015661a301ffd557e9d005", + "name": "aiohttp-xmlrpc", + "noarch": "python", + "sha256": "930a2cd77bed70ebe2057206a4f98a663f39b766bf402ccefefceff435e1f11e", + "size": 14149, + "subdir": "noarch", + "timestamp": 1661342655953, + "version": "1.5.0" + }, + "aioitertools-0.11.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "typing_extensions >=4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "59c40397276a286241c65faec5e1be3c", + "name": "aioitertools", + "noarch": "python", + "sha256": "be2dbd6710438fa48b83bf06841091227276ae545d145dfe5cb5149c6484e951", + "size": 22516, + "subdir": "noarch", + "timestamp": 1663521346032, + "version": "0.11.0" + }, + "aiomqtt-0.1.3-pyh6c4a22f_0.tar.bz2": { + "build": "pyh6c4a22f_0", + "build_number": 0, + "depends": [ + "paho-mqtt >=1.3.0", + "python" + ], + "license": "EPL-1.0", + "md5": "8a3b2ea1939f100f510b11c7696acdb5", + "name": "aiomqtt", + "noarch": "python", + "sha256": "f682bafda007b8a7296ec7cf0dd5de518dc3b7f629b91a1c3d8d14a6af6fb76f", + "size": 11828, + "subdir": "noarch", + "timestamp": 1623688129304, + "version": "0.1.3" + }, + "aiomultiprocess-0.9.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "67357a78fcf275e43d40dfc7d83e8538", + "name": "aiomultiprocess", + "noarch": "python", + "sha256": "60a6beaf99d8903753ea50d866b7c303fabb5af1ca574d42be9f6bae4308280e", + "size": 17071, + "subdir": "noarch", + "timestamp": 1615237460809, + "version": "0.9.0" + }, + "aioredis-1.3.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "async-timeout", + "hiredis", + "python >3.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "002e61a4b1bfa65a464aa2aea793a3a1", + "name": "aioredis", + "noarch": "python", + "sha256": "7fa47846aa93a4819e156bb24cd384db17141b6ed78378b79a8e50231fe432a4", + "size": 50345, + "subdir": "noarch", + "timestamp": 1591809757541, + "version": "1.3.1" + }, + "aioredis-2.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "async-timeout", + "python >=3.6", + "typing-extensions" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b6c127b17d286bc5fc4ce54be320d046", + "name": "aioredis", + "noarch": "python", + "sha256": "28ca718ee0f082168ce2d7bec7d44367b7e5a951e76c54e1b2d33f241e1eaa46", + "size": 60983, + "subdir": "noarch", + "timestamp": 1640650646516, + "version": "2.0.1" + }, + "aiormq-3.3.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "pamqp 2.3.0", + "python >=3.6", + "yarl" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "769748ebcdb3cbc006d44849379dfac1", + "name": "aiormq", + "noarch": "python", + "sha256": "89920881ea2998427ed56bda916a846eff430d8134d585fd7a4b6081a6651a5d", + "size": 25030, + "subdir": "noarch", + "timestamp": 1602806143468, + "version": "3.3.1" + }, + "aiorwlock-1.3.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.7" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "17ee368179a8f0443dd48d714c0855af", + "name": "aiorwlock", + "noarch": "python", + "sha256": "0d499db3e561fc3293c3f9fd32aa23de061fbe88c30f23a639b267e4f7679a05", + "size": 14249, + "subdir": "noarch", + "timestamp": 1649144134520, + "version": "1.3.0" + }, + "aioserial-1.3.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "pyserial", + "python >=3.6" + ], + "license": "MPL-2.0", + "license_family": "MOZILLA", + "md5": "49b0a5e5442b5365e975e24ba95de081", + "name": "aioserial", + "noarch": "python", + "sha256": "fef26d3be757c6572a53d3aed6b71f52ae71f0a13bfa4c156040780f33bda836", + "size": 14266, + "subdir": "noarch", + "timestamp": 1593596120660, + "version": "1.3.0" + }, + "aiosignal-1.3.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "frozenlist >=1.1.0", + "python >=3.7" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "d1e1eb7e21a9e2c74279d87dafb68156", + "name": "aiosignal", + "noarch": "python", + "sha256": "575c742e14c86575986dc867463582a970463da50b77264cdf54df74f5563783", + "size": 12730, + "subdir": "noarch", + "timestamp": 1667935912504, + "version": "1.3.1" + }, + "aioslacker-0.0.11-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "aiohttp >=1.3.0", + "python >=3.5", + "slacker <=0.9.42" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dc5fc9f12433983d49e95a800a2f4ae7", + "name": "aioslacker", + "noarch": "python", + "sha256": "d27697727af9fe457e355da27c7b4fc84b3cf5d1dfc87ec96717286d70d5f5cc", + "size": 6981, + "subdir": "noarch", + "timestamp": 1539628038020, + "version": "0.0.11" + }, + "aioslacker-0.0.11-py_1.tar.bz2": { + "build": "py_1", + "build_number": 1, + "depends": [ + "aiohttp >=1.3.0", + "async_timeout >=2.0.0", + "python >=3.5", + "slacker <=0.9.42" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6bf2a263c8a2591f61d2d561f94ec7a", + "name": "aioslacker", + "noarch": "python", + "sha256": "a9a12398f2c46e45b41c11e7476ba35a771cce9249845c44defeae941ef3a156", + "size": 7011, + "subdir": "noarch", + "timestamp": 1539654967560, + "version": "0.0.11" + }, + "aiosqlite-0.17.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "typing-extensions >=3.7.2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "ee5274fd3828e096cb7c90f003b0a67e", + "name": "aiosqlite", + "noarch": "python", + "sha256": "ee5b1cdeef500e464e531e93c627589c4eb475184e84beccd0a0de909adf232c", + "size": 16384, + "subdir": "noarch", + "timestamp": 1614150026340, + "version": "0.17.0" + }, + "aiostream-0.4.5-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "async-exit-stack", + "python >=3.6" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "91f79a9aec935978f302c1aa59882022", + "name": "aiostream", + "noarch": "python", + "sha256": "70511f689769f1285a960ed151f8ebd73915fac9768d582b3d6ffb0ccb28fb85", + "size": 37745, + "subdir": "noarch", + "timestamp": 1662064874602, + "version": "0.4.5" + }, + "aiounittest-1.4.2-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.4", + "wrapt" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb521fac04ed94c2652cd67e86c43af6", + "name": "aiounittest", + "noarch": "python", + "sha256": "edd5ac8f8c0d06b31c7365a5b6b4456cae1596fc52a0c05f9c219ec9845551be", + "size": 10211, + "subdir": "noarch", + "timestamp": 1655212556025, + "version": "1.4.2" + }, + "aiozmq-1.0.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "constrains": [ + "msgpack >=0.5.0" + ], + "depends": [ + "python >=3.6", + "pyzmq !=17.1.2,>=13.1" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "58e200cebeb005634657b205d55519ba", + "name": "aiozmq", + "noarch": "python", + "sha256": "ebcabff33316d23a57a03fa02820496e25cd1ccf56041b376c9f554bfefbbec9", + "size": 31398, + "subdir": "noarch", + "timestamp": 1667579053746, + "version": "1.0.0" + }, + "aisim-0.7.2-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "matplotlib-base", + "numpy", + "python >=3.4", + "scipy" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "f53fc0457a1e14c78a52c07a214d3ba6", + "name": "aisim", + "noarch": "python", + "sha256": "4a4fcb3d218eeae130cec7c8eab9b6e8cb815f258723b3bbc0fb75325e2fee38", + "size": 31115, + "subdir": "noarch", + "timestamp": 1600935096454, + "version": "0.7.2" + }, + "ajsonrpc-1.2.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b8bcea6e6561e2cfd0c3aaa899321496", + "name": "ajsonrpc", + "noarch": "python", + "sha256": "aca382399209b6394343ba0b2282969b6da59df4862907ab442bc8ffad59aeb1", + "size": 22394, + "subdir": "noarch", + "timestamp": 1635879632707, + "version": "1.2.0" + }, + "akismet-1.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.5", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b48f2ea17d3d67e3ce5fa51fcc8fcdbb", + "name": "akismet", + "noarch": "python", + "sha256": "aeef78653b390927113112a8ee6b40a820d6a82f8feaa09ab1ad543519759e05", + "size": 8972, + "subdir": "noarch", + "timestamp": 1643218151161, + "version": "1.0.1" + }, + "akismet-1.2.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.5", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b1b5b883e3bad00868d9f4b52a752a24", + "name": "akismet", + "noarch": "python", + "sha256": "ed44479870f1de849758629d30c6758bf23f46424f58d094f007434063a18ae9", + "size": 9158, + "subdir": "noarch", + "timestamp": 1653643326002, + "version": "1.2.1" + }, + "albumentations-1.3.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "numpy >=1.11.1", + "opencv >=4.1.1", + "python >=3.6", + "pyyaml", + "qudida >=0.0.4", + "scikit-image >=0.16.1", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6fe22fdc8813e7ae156b4f1ea9f4cdc6", + "name": "albumentations", + "noarch": "python", + "sha256": "d55174294492e9d459c479505234069925f683283161dae2a849fdb31e31c838", + "size": 92332, + "subdir": "noarch", + "timestamp": 1663682863678, + "version": "1.3.0" + }, + "alchemical-analysis-1.0.2-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "matplotlib", + "numpy", + "pymbar", + "python <3", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "94a851d83511f0eb2cb551c89f506443", + "name": "alchemical-analysis", + "noarch": "python", + "sha256": "30c541a6131c705a83d570e0f3767c49a3e4952fd7a39bb6cebb41aa65b81eb7", + "size": 36770, + "subdir": "noarch", + "timestamp": 1556288198312, + "version": "1.0.2" + }, + "alchemical-analysis-1.0.2-py_1.tar.bz2": { + "build": "py_1", + "build_number": 1, + "depends": [ + "matplotlib", + "numpy", + "pymbar", + "python <3", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "062cb130de5cc6aede8821b96dd7efd7", + "name": "alchemical-analysis", + "noarch": "python", + "sha256": "ceb270d15ee6c702aaf9fe922533df66cca44310716e15334a43879b8a503687", + "size": 36837, + "subdir": "noarch", + "timestamp": 1574330417889, + "version": "1.0.2" + }, + "alchemical-analysis-1.0.2-py_2.tar.bz2": { + "build": "py_2", + "build_number": 2, + "depends": [ + "matplotlib-base", + "numpy", + "pymbar 3.0.3.*", + "python <3", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2bad27f9b34bb86a76e98e992608393b", + "name": "alchemical-analysis", + "noarch": "python", + "sha256": "5dc7a4a97ad97939c5fde365e9bd3129fff05120a7bbdf8175dd6bb69bd83e5e", + "size": 36922, + "subdir": "noarch", + "timestamp": 1581920425829, + "version": "1.0.2" + }, + "aldjemy-2.4-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "django >=2.2", + "python >=3.6", + "sqlalchemy >=1.4" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "79fc0d6acfc2689a13513d2268b94661", + "name": "aldjemy", + "noarch": "python", + "sha256": "9c539c736beb323fcb7c27e7734211269935e34f4199118662baa660ac91aa98", + "size": 13321, + "subdir": "noarch", + "timestamp": 1633671576216, + "version": "2.4" + }, + "alembic-1.7.7-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "importlib_resources", + "mako", + "python >=3.6", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9637550104fade18bc6f91aef1f4f02c", + "name": "alembic", + "noarch": "python", + "sha256": "3cf09b1a22413261180347f0f95ca22901e76bf17eb198b183a1f3f89eb63b7f", + "size": 139804, + "subdir": "noarch", + "timestamp": 1647367806372, + "version": "1.7.7" + }, + "alembic-1.8.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "importlib_resources", + "mako", + "python >=3.6", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9599028cbacf894eb273f63c20090793", + "name": "alembic", + "noarch": "python", + "sha256": "ab5c1814c5219ebe2174e656ee9cc55cdb6c0075c2a04beb8a3c213dee3be510", + "size": 139823, + "subdir": "noarch", + "timestamp": 1654060594328, + "version": "1.8.0" + }, + "alembic-1.8.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "importlib-metadata", + "importlib_resources", + "mako", + "python >=3.6", + "sqlalchemy >=1.3.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bdde76f5d65a9374d07aa3dfa27571e0", + "name": "alembic", + "noarch": "python", + "sha256": "01ef4ddec9e64ebc29c476155d62436e6eb493acc58c8dd7365f1723dc2bbb86", + "size": 140450, + "subdir": "noarch", + "timestamp": 1657814007035, + "version": "1.8.1" + }, + "algopy-0.5.7-py_0.tar.bz2": { + "arch": null, + "build": "py_0", + "build_number": 0, + "depends": [ + "numpy", + "python", + "scipy" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "e13c33a471c233bdd2521e39e2b9df7f", + "name": "algopy", + "noarch": "python", + "platform": null, + "sha256": "c342887e6581d64e2c71e5367a5ce0d14c3e07bd0c7db5a15a09560f0c5c846f", + "size": 83058, + "subdir": "noarch", + "version": "0.5.7" + }, + "algorithms-0.1.4-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "af64077bb261a007af415b4697535d1a", + "name": "algorithms", + "noarch": "python", + "sha256": "fe1a09222d80832094008e69143b8445b7e7d6bfef5afadc68fefeebadf7d783", + "size": 134460, + "subdir": "noarch", + "timestamp": 1619187717547, + "version": "0.1.4" + }, + "alibi-0.7.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "absl-py >=0.10.0,<0.11.0", + "attrs >=19.2.0,<22.0.0", + "dill >=0.3.0,<0.4.0", + "matplotlib-base >=3.0.0,<4.0.0", + "numpy >=1.16.2,<2.0.0", + "pandas >=0.23.3,<2.0.0", + "pillow >=5.4.1,<9.0", + "python >=3.7", + "requests >=2.21.0,<3.0.0", + "scikit-image >=0.14.2,!=0.17.1,<0.19", + "scikit-learn >=0.20.2,<1.1.0", + "scipy >=1.1.0,<2.0.0", + "spacy >=2.0.0,<4.0.0", + "tensorflow >=2.0.0,!=2.6.0,!=2.6.1,<2.8.0", + "tqdm >=4.28.1,<5.0.0", + "transformers >=4.7.0,<5.0.0", + "typing-extensions >=3.7.2", + "wrapt >=1.12.1,<1.13.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "851d4a8622e19e5c2f1625493d8b6706", + "name": "alibi", + "noarch": "python", + "sha256": "d8d08c7f2aa9d1fe3e97cf1958895d9c59db77fcf4c9eee473b0c047e7090716", + "size": 364916, + "subdir": "noarch", + "timestamp": 1652891019311, + "version": "0.7.0" + }, + "allantools-2019.9-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "numpy", + "python", + "scipy" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "57e92e2c56bffb91c147c0c949c697b7", + "name": "allantools", + "noarch": "python", + "sha256": "3a6cea05826db803f5916804758d015e91ff0ff4b8b3ab0f58acc0850c33a9e5", + "size": 37972, + "subdir": "noarch", + "timestamp": 1569165171871, + "version": "2019.9" + }, + "allantools-2019.9-py_1.tar.bz2": { + "build": "py_1", + "build_number": 1, + "depends": [ + "numpy", + "python", + "scipy" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "6e1b0a336f904b3a8e4e745ccc8220c5", + "name": "allantools", + "noarch": "python", + "sha256": "4d33b817cac694d524dfb7bdb14a0c19153a2f5c86597a33c3cbe7be914a7914", + "size": 37998, + "subdir": "noarch", + "timestamp": 1569165206329, + "version": "2019.9" + }, + "allennlp-optuna-0.1.7-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "allennlp >=2,<3", + "optuna >=2.6,<3", + "python >=3.6.1" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d6cfbcc9db1365196fe84e8d3fbe8f82", + "name": "allennlp-optuna", + "noarch": "python", + "sha256": "7d074a28e9fc5d2b60b160bdca5c37d7dba216212a45fdd51d2e381e00a99db8", + "size": 12006, + "subdir": "noarch", + "timestamp": 1637742137453, + "version": "0.1.7" + }, + "allthekernels-1.2.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "ipykernel >=4.3", + "jupyter_client >=5", + "python >=3.5", + "pyzmq >=15.2", + "tornado >=4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "91e21e16f1624188ff921521c579f85b", + "name": "allthekernels", + "noarch": "python", + "sha256": "01e376e22a034006f744f028ec05ad6386098ecc48cdaae4523507982dddf1b0", + "size": 9918, + "subdir": "noarch", + "timestamp": 1661181478102, + "version": "1.2.0" + }, + "aloe-0.1.18-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "future", + "gherkin-official >=4,<5", + "nose", + "python", + "repoze.lru" + ], + "license": "GPL-3.0", + "md5": "b882433f0328095de9e2608ed7b6a2ca", + "name": "aloe", + "noarch": "python", + "sha256": "6f4547c556d20a53683a989dc415e0ba72be72afed397c1479986c2d09ed915b", + "size": 74946, + "subdir": "noarch", + "timestamp": 1549169828047, + "version": "0.1.18" + }, + "alpha_vantage-2.3.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "aiohttp", + "python >=3.4", + "requests" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d59b3d2dd8cd97114fc288c15fbf811c", + "name": "alpha_vantage", + "noarch": "python", + "sha256": "b186a803cfe36939e1183facff95759fc7ad8692becac697cc29004d0944e31a", + "size": 22948, + "subdir": "noarch", + "timestamp": 1610647790546, + "version": "2.3.1" + }, + "alphalens-0.3.6-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "ipython >=3.2.3", + "matplotlib >=1.4.0", + "numpy >=1.9.1", + "pandas >=0.18.0", + "python", + "scipy >=0.14.0", + "seaborn >=0.6.0", + "statsmodels >=0.6.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "45fa95a81fbaaba62f1759de7d7f178c", + "name": "alphalens", + "noarch": "python", + "sha256": "4fd3cf4393fd48e670b5407a123f2ff304f7ea381aaff84f9f7491716d0ba743", + "size": 18618203, + "subdir": "noarch", + "timestamp": 1549164959687, + "version": "0.3.6" + }, + "alphalens-0.3.6-py_1.tar.bz2": { + "build": "py_1", + "build_number": 1, + "depends": [ + "ipython >=3.2.3", + "matplotlib-base >=1.4.0", + "numpy >=1.9.1", + "pandas >=0.18.0", + "python", + "scipy >=0.14.0", + "seaborn >=0.6.0", + "statsmodels >=0.6.1" + ], + "license": "Apache 2.0", + "license_family": "Apache", + "md5": "ece89a6cc1b2110ee167ab8179737fd7", + "name": "alphalens", + "noarch": "python", + "sha256": "3b122990d62788fc2c2f56431a0e6b99b7547e32e1c9f82f113cb4083192eae8", + "size": 18539341, + "subdir": "noarch", + "timestamp": 1589637080589, + "version": "0.3.6" + }, + "alphashape-1.3.1-pyh44b312d_0.tar.bz2": { + "build": "pyh44b312d_0", + "build_number": 0, + "depends": [ + "click >=6.0", + "click-log >=0.3.2", + "geopandas >=0.6.2", + "networkx >=2.5", + "numpy >=1.6", + "python >=3.8", + "rtree >=0.9.7", + "scipy >=1.0.0", + "shapely >=1.4.0", + "trimesh >=3.9.8" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a27b68aa4dffbc4cceed9f71058f6356", + "name": "alphashape", + "noarch": "python", + "sha256": "3f7359afe1c52bc309c91d98f07be3a1aa1115e38aa733f221058997d176297e", + "size": 15561, + "subdir": "noarch", + "timestamp": 1618618499934, + "version": "1.3.1" + }, + "alphatwirl-0.30.0-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "atpbar >=1.0.3", + "mantichora >=0.9.5", + "numpy", + "python" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7b6ac55288d7cfe394e58e5b1c57d276", + "name": "alphatwirl", + "noarch": "python", + "sha256": "2829a476bf097b06446e60c24bbfc5b3baee0bd18a85f87f0b0dfc5e59da9ed4", + "size": 58928, + "subdir": "noarch", + "timestamp": 1586649054423, + "version": "0.30.0" + }, + "alsa-lib-cos6-x86_64-1.1.0-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "8bda4f72c91a442230413b92ba65d4cf", + "name": "alsa-lib-cos6-x86_64", + "noarch": "generic", + "sha256": "393c1c8ad1dad8ef59d374a2ded44e3c99325bfc7c385bae083cdf1a2d10755e", + "size": 435573, + "subdir": "noarch", + "timestamp": 1627477387551, + "version": "1.1.0" + }, + "alsa-lib-cos6-x86_64-1.1.0-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "43ce99d59958c058248c0fe8e32f98b9", + "name": "alsa-lib-cos6-x86_64", + "noarch": "generic", + "sha256": "134c948dc800f8626490ff54e03ae68ed465926e281e696296225f24ac6ee63f", + "size": 440257, + "subdir": "noarch", + "timestamp": 1627477524282, + "version": "1.1.0" + }, + "alsa-lib-cos6-x86_64-1.1.0-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "60bfade0832792fec22f68f87417c7ae", + "name": "alsa-lib-cos6-x86_64", + "noarch": "generic", + "sha256": "9e53f0ab9b59f311e217ef276c5797b87f08df988d3cb442c9f3a7a50e36086f", + "size": 430522, + "subdir": "noarch", + "timestamp": 1596319442518, + "version": "1.1.0" + }, + "alsa-lib-cos6-x86_64-1.1.0-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "9ba96dfa2882c78727a1c22a4c6e9129", + "name": "alsa-lib-cos6-x86_64", + "noarch": "generic", + "sha256": "f5bc69b1a37e4cdefa0eb11463eff231951fae7ff5d35b85ad0236b6531bb141", + "size": 440535, + "subdir": "noarch", + "timestamp": 1596320443527, + "version": "1.1.0" + }, + "alsa-lib-cos6-x86_64-1.1.0-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "13e23756a86aec6141fdda120a2db894", + "name": "alsa-lib-cos6-x86_64", + "noarch": "generic", + "sha256": "41358ad6319172d03190b3ffb9119d27dbffc2c6e7929a250267c3bccf998f6f", + "size": 439168, + "subdir": "noarch", + "timestamp": 1595534525708, + "version": "1.1.0" + }, + "alsa-lib-cos6-x86_64-1.1.0-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "2c97a1f62320b4b0d392e035cf36acf7", + "name": "alsa-lib-cos6-x86_64", + "noarch": "generic", + "sha256": "cc6a6bba35866890f34a728ce113bd5a110036f38e46c2efaee9968cffbb0e58", + "size": 436935, + "subdir": "noarch", + "timestamp": 1595534771085, + "version": "1.1.0" + }, + "alsa-lib-cos7-aarch64-1.1.8-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "4d07bd17f307b3736ef44ad3ac3fc691", + "name": "alsa-lib-cos7-aarch64", + "noarch": "generic", + "sha256": "32165ce1ce7b442b305d443832079a81de68d2b7b4afa60ef88056d8548840c7", + "size": 478005, + "subdir": "noarch", + "timestamp": 1627478117606, + "version": "1.1.8" + }, + "alsa-lib-cos7-aarch64-1.1.8-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "a20ec40b67cebb21dc9d6f882aafb3dc", + "name": "alsa-lib-cos7-aarch64", + "noarch": "generic", + "sha256": "da091c490be1edeb397dd48f7e55b22cd2cd9b9053b371efdcf7b9b94991672c", + "size": 465886, + "subdir": "noarch", + "timestamp": 1627528372327, + "version": "1.1.8" + }, + "alsa-lib-cos7-aarch64-1.1.8-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f4a7e31d178018c45650b9c13dd3b885", + "name": "alsa-lib-cos7-aarch64", + "noarch": "generic", + "sha256": "90b480070c17e8a8514a31cf22c5fefe59f263564c33886aa05125a24692c4a0", + "size": 477461, + "subdir": "noarch", + "timestamp": 1596319285686, + "version": "1.1.8" + }, + "alsa-lib-cos7-aarch64-1.1.8-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "e6f186eb81d44f8ef7e0f5ea16ab52cb", + "name": "alsa-lib-cos7-aarch64", + "noarch": "generic", + "sha256": "e6de58750101db476eb1f3aec2468fc861c8054f9262ed1f7c39073664e4d031", + "size": 460080, + "subdir": "noarch", + "timestamp": 1596320307253, + "version": "1.1.8" + }, + "alsa-lib-cos7-aarch64-1.1.8-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "7f50585eb217a05a1b5f572fb9793eda", + "name": "alsa-lib-cos7-aarch64", + "noarch": "generic", + "sha256": "02e6087511b26263b880dfeff01441ec16d0f446da32caa27c55f8b3b0ced664", + "size": 458176, + "subdir": "noarch", + "timestamp": 1595534402789, + "version": "1.1.8" + }, + "alsa-lib-cos7-aarch64-1.1.8-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "2c9b17173f11d8e50ec975f1d4225e43", + "name": "alsa-lib-cos7-aarch64", + "noarch": "generic", + "sha256": "58e6633737649e8a7bc8168dd5031815b22ca739e5b00aa761983d23f935df44", + "size": 461595, + "subdir": "noarch", + "timestamp": 1595534684231, + "version": "1.1.8" + }, + "alsa-lib-cos7-ppc64le-1.1.8-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "0df63d66c14228af0c1b4358023ab0d6", + "name": "alsa-lib-cos7-ppc64le", + "noarch": "generic", + "sha256": "02e64e7ca94d139c3629a1cb20200d29b74e810f180457aedc14790d3686dae4", + "size": 495289, + "subdir": "noarch", + "timestamp": 1627527771915, + "version": "1.1.8" + }, + "alsa-lib-cos7-ppc64le-1.1.8-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "3ecefd8f8c06f000d2821c9f3aa925ee", + "name": "alsa-lib-cos7-ppc64le", + "noarch": "generic", + "sha256": "0da7aa1294642a094814dbb1954248df8cfcc92bb09953278d0b43af9242d6da", + "size": 488697, + "subdir": "noarch", + "timestamp": 1627527953015, + "version": "1.1.8" + }, + "alsa-lib-cos7-ppc64le-1.1.8-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "2865a2ed678390774d49afb14d137a63", + "name": "alsa-lib-cos7-ppc64le", + "noarch": "generic", + "sha256": "2eeec555dae5579e34b6dc5d8c6058bbde84edf95e41c5ca280c275c867b7d42", + "size": 493137, + "subdir": "noarch", + "timestamp": 1596319602613, + "version": "1.1.8" + }, + "alsa-lib-cos7-ppc64le-1.1.8-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "ab39087e20890a9d9bfe3f6b7ee12188", + "name": "alsa-lib-cos7-ppc64le", + "noarch": "generic", + "sha256": "2b12aee3a69f004dab0ff7a619ec4cf2bf66fb65220b020d61f8ca6270b04321", + "size": 491711, + "subdir": "noarch", + "timestamp": 1596321283657, + "version": "1.1.8" + }, + "alsa-lib-cos7-ppc64le-1.1.8-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "65599b2936e8c554f376469471636330", + "name": "alsa-lib-cos7-ppc64le", + "noarch": "generic", + "sha256": "60532097f5e6a823444dd4a772597acc7bbef5059b17bfc0f55683965a925228", + "size": 496424, + "subdir": "noarch", + "timestamp": 1595534403277, + "version": "1.1.8" + }, + "alsa-lib-cos7-ppc64le-1.1.8-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "71206f680736a5927ecdfe01792960b2", + "name": "alsa-lib-cos7-ppc64le", + "noarch": "generic", + "sha256": "053c90a0266798c6b003de6db21a92eb0a23e0eb16f0d540f1a92febe8bff381", + "size": 499076, + "subdir": "noarch", + "timestamp": 1595534682633, + "version": "1.1.8" + }, + "alsa-lib-cos7-x86_64-1.1.8-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "bc3e92a78a9bd84ab1be2caddf44fe6f", + "name": "alsa-lib-cos7-x86_64", + "noarch": "generic", + "sha256": "a4534dbdcafdce9a3f387a17ef685ab8c4c3a15b6a7723f2744a5db3974feb00", + "size": 477838, + "subdir": "noarch", + "timestamp": 1627493361879, + "version": "1.1.8" + }, + "alsa-lib-cos7-x86_64-1.1.8-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "b3e59c666a597b6a14fb2a873f6708bb", + "name": "alsa-lib-cos7-x86_64", + "noarch": "generic", + "sha256": "249c39f5498d1580ba0cb20c10db5d3cb122d4942c64eeffd2fe61833aed23d1", + "size": 495169, + "subdir": "noarch", + "timestamp": 1596320829045, + "version": "1.1.8" + }, + "alsa-lib-cos7-x86_64-1.1.8-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "5d159ec567755c1e07d9500f8b28e730", + "name": "alsa-lib-cos7-x86_64", + "noarch": "generic", + "sha256": "8e48dbca9de5fc70ac73bfdbd2e37b57d04570936ec6732fc2a8dd725ae86ecb", + "size": 477191, + "subdir": "noarch", + "timestamp": 1595534578181, + "version": "1.1.8" + }, + "alsa-lib-devel-cos6-x86_64-1.1.0-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "alsa-lib-cos6-x86_64 ==1.1.0 *_105" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "94133ff6872106fc8cbbbcbba04b4bef", + "name": "alsa-lib-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "ceafcffcaa11c25a5c2c0e2c0d361e11602f22f0d93227225a1fc2bb94511b9f", + "size": 1130412, + "subdir": "noarch", + "timestamp": 1627481653389, + "version": "1.1.0" + }, + "alsa-lib-devel-cos6-x86_64-1.1.0-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "alsa-lib-cos6-x86_64 ==1.1.0 *_1105", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "a6183cb75397175ec2c01545f13ae645", + "name": "alsa-lib-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "123aa4b815111fb0ed21f914f74ae7c1e84dcfbe88410ff5155c5aa8dce0bbda", + "size": 1132388, + "subdir": "noarch", + "timestamp": 1627483840035, + "version": "1.1.0" + }, + "alsa-lib-devel-cos6-x86_64-1.1.0-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "alsa-lib-cos6-x86_64 ==1.1.0 *_104" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "487ff0bbb89e498bbfc1a3bcd79c850c", + "name": "alsa-lib-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "a1f7e6955b4791e84993d46c819deafc54964c46b7ceb6730ca3c3c1caafa310", + "size": 1167382, + "subdir": "noarch", + "timestamp": 1596320735459, + "version": "1.1.0" + }, + "alsa-lib-devel-cos6-x86_64-1.1.0-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "alsa-lib-cos6-x86_64 ==1.1.0 *_1104", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "932cb0c02fb1d6c19c050866e8f0cefd", + "name": "alsa-lib-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "4e073babbb6361d5f808202c7b52885209d9f5df039def2b7cd5f4dd79fe7342", + "size": 1148093, + "subdir": "noarch", + "timestamp": 1596322281716, + "version": "1.1.0" + }, + "alsa-lib-devel-cos6-x86_64-1.1.0-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "alsa-lib-cos6-x86_64 ==1.1.0 *_103" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "2b3edb29f4a09595dedb85097bb7692b", + "name": "alsa-lib-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "8af37c7a5ced9eb25b61287bb47aea0b53aa55787d97c9ff80ebce82fbcff920", + "size": 1164243, + "subdir": "noarch", + "timestamp": 1595534744063, + "version": "1.1.0" + }, + "alsa-lib-devel-cos6-x86_64-1.1.0-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "alsa-lib-cos6-x86_64 ==1.1.0 *_1103", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "19c74dbe55113fc3c447954ef98280a8", + "name": "alsa-lib-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "7531350c06497e2dfa936dec6574787a962dc63aa3651faef7db8cadf996494f", + "size": 1146657, + "subdir": "noarch", + "timestamp": 1595535022465, + "version": "1.1.0" + }, + "alsa-lib-devel-cos7-aarch64-1.1.8-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "alsa-lib-cos7-aarch64 ==1.1.8 *_105" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "7fca9ea7df2bbf5a015c221bd1d8de84", + "name": "alsa-lib-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "cab5c6752d64d19799e1cd83b1864e156ecd9093716868e76a78794b89f2da91", + "size": 1282868, + "subdir": "noarch", + "timestamp": 1627483482522, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-aarch64-1.1.8-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "alsa-lib-cos7-aarch64 ==1.1.8 *_1105", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "3de2481104dc57f3495c452b59d66e27", + "name": "alsa-lib-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "d018846f41bfb194848bb6b27732d6403ca066d69f2eb6525d0f42ba8860c4fa", + "size": 1290310, + "subdir": "noarch", + "timestamp": 1627534645142, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-aarch64-1.1.8-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "alsa-lib-cos7-aarch64 ==1.1.8 *_104" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "c25ea365125eb173d03bf302b1dac094", + "name": "alsa-lib-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "51629bc88a2c5bd17eef1185f4d4c109bdc1f225950da0b4f0d5353d573f24ab", + "size": 1276256, + "subdir": "noarch", + "timestamp": 1596320903292, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-aarch64-1.1.8-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "alsa-lib-cos7-aarch64 ==1.1.8 *_1104", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "c673afcaeb42a17332b4bfa0e818bec2", + "name": "alsa-lib-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "fe951dd551cebcf8b570de2f45164b6fc692aa16668d5b809b2fcd08e4cea67f", + "size": 1275028, + "subdir": "noarch", + "timestamp": 1596322800163, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-aarch64-1.1.8-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "alsa-lib-cos7-aarch64 ==1.1.8 *_103" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "36e5921a44367214364d7e1b0854201d", + "name": "alsa-lib-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "a6639a9e205a3117fb4c6f7c3df6d753c2827a9972b0d1b79d82b1b7aaf61db0", + "size": 1280361, + "subdir": "noarch", + "timestamp": 1595534822402, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-aarch64-1.1.8-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "alsa-lib-cos7-aarch64 ==1.1.8 *_1103", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "ed0d113673ba38c88029e0627109fc85", + "name": "alsa-lib-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "017e50e1824a690436c743430a951c3d49442511ad280d3f26fd82adeb9edfe0", + "size": 1284445, + "subdir": "noarch", + "timestamp": 1595535344609, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-ppc64le-1.1.8-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "alsa-lib-cos7-ppc64le ==1.1.8 *_105" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "fea2058c49fe1c04c523614d70fe0ecd", + "name": "alsa-lib-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "05e05fa0da9a5e2d98c2bc2c1ec6c856ff3da3bc319f88b0a439970b41f9ae9b", + "size": 1281987, + "subdir": "noarch", + "timestamp": 1627533526569, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-ppc64le-1.1.8-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "alsa-lib-cos7-ppc64le ==1.1.8 *_1105", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f932ee2de153bfe6a9e3f212b403250b", + "name": "alsa-lib-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "db060d056dde0037674ce47e02d83b9c314d5bbb113454092366702c22270ce9", + "size": 1307758, + "subdir": "noarch", + "timestamp": 1627535167052, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-ppc64le-1.1.8-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "alsa-lib-cos7-ppc64le ==1.1.8 *_104" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f2e10af8830868dda011709c822e5f81", + "name": "alsa-lib-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "c603a034b066fbeae77fc1b832bad0423b1aba5b8322bff02c210380cfe6fb12", + "size": 1306949, + "subdir": "noarch", + "timestamp": 1596321359038, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-ppc64le-1.1.8-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "alsa-lib-cos7-ppc64le ==1.1.8 *_1104", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "d29c11bf306331039eed2625d0c14da2", + "name": "alsa-lib-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "22e9a590e4f66460214e6979b689fc1d1b8260f7b9220d93d2546ea9efd06bd5", + "size": 1317922, + "subdir": "noarch", + "timestamp": 1596323832601, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-ppc64le-1.1.8-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "alsa-lib-cos7-ppc64le ==1.1.8 *_103" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "87db38245201d49e943d5399ef526751", + "name": "alsa-lib-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "25121b74fb50bb5cc09ed361ef47587db7bd146c0d71c0fb1c91b24dbd5aac8b", + "size": 1282988, + "subdir": "noarch", + "timestamp": 1595534841614, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-ppc64le-1.1.8-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "alsa-lib-cos7-ppc64le ==1.1.8 *_1103", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "af95cf5119af427f3d4f2798bbe707fc", + "name": "alsa-lib-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "8dddfc30d74d147f2005ab5add782cb367f318bcdf0c02691bf0ec9b2c8abfb1", + "size": 1281123, + "subdir": "noarch", + "timestamp": 1595535350244, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-x86_64-1.1.8-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "alsa-lib-cos7-x86_64 ==1.1.8 *_1105", + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "a474fccd509462d763b25ea242a0b964", + "name": "alsa-lib-devel-cos7-x86_64", + "noarch": "generic", + "sha256": "b8e7e0fd58473c68050b9d123c176a851736f25520af2447e36a7c745f00084f", + "size": 1310777, + "subdir": "noarch", + "timestamp": 1627498536530, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-x86_64-1.1.8-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "alsa-lib-cos7-x86_64 ==1.1.8 *_1104", + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "4d0d99ffc94aee95afa91bdba5f4dc3f", + "name": "alsa-lib-devel-cos7-x86_64", + "noarch": "generic", + "sha256": "0e42b60deca7a65ff677114504e6599045eb70e6e4d82c1dac416ffd11d25717", + "size": 1311544, + "subdir": "noarch", + "timestamp": 1596322727577, + "version": "1.1.8" + }, + "alsa-lib-devel-cos7-x86_64-1.1.8-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "alsa-lib-cos7-x86_64 ==1.1.8 *_1103", + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "461f560ebaef790d0e6cf22e5d3dd1d7", + "name": "alsa-lib-devel-cos7-x86_64", + "noarch": "generic", + "sha256": "2790a30a10b11a7c1bbdc2009c69782889bcfeda5febb1d5e76553afaf2868f4", + "size": 1282076, + "subdir": "noarch", + "timestamp": 1595535226261, + "version": "1.1.8" + }, + "altair_data_server-0.4.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "altair", + "portpicker", + "python >=3.6", + "tornado" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5412ec3d2792d3e2f18e075cb05ffdaf", + "name": "altair_data_server", + "noarch": "python", + "sha256": "f6ad77f888f6d9a9b42d58518f70ecc947935bea80019d56c08e9089510ea5c0", + "size": 13304, + "subdir": "noarch", + "timestamp": 1578467344047, + "version": "0.4.1" + }, + "altair_saver-0.5.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "altair", + "altair_data_server >=0.4.0", + "altair_viewer", + "nodejs", + "python >=3.6", + "selenium", + "vega-cli", + "vega-lite-cli" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2998d1c771e6a191bf35cc8bc4cd9d03", + "name": "altair_saver", + "noarch": "python", + "sha256": "80fc86f2a6668e1a41bcaa78d031d0fd7473dfaa89e5595de0d7a813a446eafb", + "size": 85363, + "subdir": "noarch", + "timestamp": 1585663343657, + "version": "0.5.0" + }, + "altair_viewer-0.4.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "altair", + "altair_data_server >=0.4.0", + "python >=3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c176ec8d6ade144f2a5f3677ad901221", + "name": "altair_viewer", + "noarch": "python", + "sha256": "5253e672189d8b8789a0a07cd7bcb7a0a8a2283d121ba28bcc394f06064bdfd5", + "size": 645375, + "subdir": "noarch", + "timestamp": 1636219343267, + "version": "0.4.0" + }, + "altdphi-1.0.5-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "numpy", + "python" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "d07b4c0c5bbc66185dd31d92ad8851d9", + "name": "altdphi", + "noarch": "python", + "sha256": "76faea558ed62d30e0997a3c3ead335718130ce6fefc1714d3f72c81f94ae321", + "size": 8414, + "subdir": "noarch", + "timestamp": 1557854617086, + "version": "1.0.5" + }, + "amazon-braket-ocean-plugin-1.0.11-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "amazon-braket-sdk >=1.25.0", + "boltons >=20.0.0", + "boto3 >=1.18.13", + "colorama >=0.4.3", + "dimod >=0.8.13", + "dwave-cloud-client >=0.9.4", + "jsonref", + "python >=3.7", + "wheel >=0.36.2" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "915fa17f375251ec33466198cf7f7162", + "name": "amazon-braket-ocean-plugin", + "noarch": "python", + "sha256": "ce6f6f6f66817001f54d361f972770ddc82a3101543809f1cc723d5d34cd34a8", + "size": 20355, + "subdir": "noarch", + "timestamp": 1657722404815, + "version": "1.0.11" + }, + "ambiance-1.3.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "numpy", + "python >=3.6", + "scipy" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "35c3bea0c3710479a8a6cabafedf6cf9", + "name": "ambiance", + "noarch": "python", + "sha256": "bbce442610e703692f4e1c8feda4c4bdfadd0e310b8d39b72a06b7dcf860bc70", + "size": 19668, + "subdir": "noarch", + "timestamp": 1664132393208, + "version": "1.3.1" + }, + "ammolite-0.8.0-pyhd8ed1ab_2.tar.bz2": { + "build": "pyhd8ed1ab_2", + "build_number": 2, + "depends": [ + "biotite >=0.22", + "pymol-open-source", + "python >=3.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "f1d6124b478054bd64f8b8e54efc2b3f", + "name": "ammolite", + "noarch": "python", + "sha256": "86d73920dc4f876b46ae35fa97c9bb8fb864bfbd719771807690f9f442f638ac", + "size": 19754, + "subdir": "noarch", + "timestamp": 1657279325460, + "version": "0.8.0" + }, + "amostra-1.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "doct", + "jsonschema", + "mongoquery", + "pymongo", + "python >=3.6", + "pyyaml", + "requests", + "tornado", + "ujson" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4b671d6c573eb8d452f69dde010089b7", + "name": "amostra", + "noarch": "python", + "sha256": "e876aa1d914d4aec27ae5a923f5af0b038b367d319c77533db62567557644ec3", + "size": 15380, + "subdir": "noarch", + "timestamp": 1626196620184, + "version": "1.0.1" + }, + "amptools-1.1.11-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "configobj", + "gmprocess >0.2.7", + "h5py >2.7.1", + "python 3.6.*" + ], + "license": "Public Domain", + "license_family": "Public Domain", + "md5": "c161259424da33fe5b508529d4089ad6", + "name": "amptools", + "noarch": "python", + "sha256": "8d1a92293ca4e6032aadfd31840b21bab5d219fbf0646c5140b89e61c3b0d7cf", + "size": 12468, + "subdir": "noarch", + "timestamp": 1570051983559, + "version": "1.1.11" + }, + "amqp-2.6.1-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "python", + "vine >=1.1.3" + ], + "license": "BSD 3-clause", + "license_family": "BSD", + "md5": "7e007457befb031180f6459921be113b", + "name": "amqp", + "noarch": "python", + "sha256": "962fae7a0cd2f434d67a8b4ff729b234e56ebc49464e6bbce7716424c8ea6cc9", + "size": 41692, + "subdir": "noarch", + "timestamp": 1596397106045, + "version": "2.6.1" + }, + "amqp-5.1.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "vine 5.0.0" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "a59814fb9125df2a852373254c76cc08", + "name": "amqp", + "noarch": "python", + "sha256": "4f941528fd16ea3c92cfd6a7107e7b079dc5298e7863667b57ef1f86c2776d2c", + "size": 44834, + "subdir": "noarch", + "timestamp": 1650283747359, + "version": "5.1.1" + }, + "anaconda-project-0.11.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "anaconda-client", + "conda-pack", + "jinja2", + "python >=3.6", + "requests", + "ruamel_yaml", + "tornado >=4.2", + "tqdm" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "85406089db6aa63ee45da8e9f0b966b6", + "name": "anaconda-project", + "noarch": "python", + "sha256": "5025ff5066e4a8765ca35bb4f6145f188b249634090236c8beb25f3fb5ed4874", + "size": 230476, + "subdir": "noarch", + "timestamp": 1660066945969, + "version": "0.11.1" + }, + "anaconda-verify-1.3.8-py_1.tar.bz2": { + "build": "py_1", + "build_number": 1, + "depends": [ + "python", + "pyyaml" + ], + "license": "BSD 3-Clause", + "md5": "d00aa8aa03a771f548548c4bb18f7d86", + "name": "anaconda-verify", + "noarch": "python", + "sha256": "bcb474bedc1fea2499a353f89e420c0de555fe8af3b3ee381b58ea2e94f2806b", + "size": 14523, + "subdir": "noarch", + "timestamp": 1531715279152, + "version": "1.3.8" + }, + "analysisstore-0.0.6-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "doct", + "jsonschema", + "mongoquery", + "pymongo", + "python >=3.6", + "pyyaml", + "requests", + "six", + "tornado <5", + "ujson" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "4a4f5b67d88a292b3b0e3b4f1b6dbc7b", + "name": "analysisstore", + "noarch": "python", + "sha256": "46b76cf0f02dc10639e96a908cd54c8a5eb3b26fcd02a41da6f75d29ee155fc5", + "size": 17918, + "subdir": "noarch", + "timestamp": 1643339032862, + "version": "0.0.6" + }, + "analysisstore-0.0.6-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "depends": [ + "doct", + "jsonschema", + "mongoquery", + "pymongo", + "python >=3.6", + "pyyaml", + "requests", + "six", + "tornado >=5", + "ujson" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "14c9fe1ecd455179774099254356f7f4", + "name": "analysisstore", + "noarch": "python", + "sha256": "f60ea53682b1eb790fc98b5e5312d0b42c2acc80ec719e695f4161ce8f3a2c90", + "size": 17881, + "subdir": "noarch", + "timestamp": 1644954404261, + "version": "0.0.6" + }, + "analytics-python-1.4.0-pyh6c4a22f_0.tar.bz2": { + "build": "pyh6c4a22f_0", + "build_number": 0, + "depends": [ + "backoff 1.10.0", + "monotonic >=1.5", + "python >=3.6", + "python-dateutil >2.1", + "requests >=2.7,<3.0", + "six >=1.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b18892301185f03fb7ae81f6c65ea82e", + "name": "analytics-python", + "noarch": "python", + "sha256": "b420b0d39a8817993becbceef4ce94ac8c83705fef901af8836df27c0c207243", + "size": 18363, + "subdir": "noarch", + "timestamp": 1658064927268, + "version": "1.4.0" + }, + "angreal-0.7.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "click >=6.0", + "cookiecutter >=1.6.0,<2.0.0", + "docker-py >=3.4.1,<4.0.0", + "doit >=0.31.1", + "future", + "pygithub >=1.43.7,<2.0.0", + "python >=3", + "python-gitlab >=1.5.1,<2.0.0", + "semver >=2.8.1", + "virtualenv >=16.0.0,<17.0.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "e098557aa5f1d65fced3b8cf60ec4b53", + "name": "angreal", + "noarch": "python", + "sha256": "2b6e9f45c67dc81081414bd53cd1fe8abdb88a7d15bfb3c79549360c44853135", + "size": 40185, + "subdir": "noarch", + "timestamp": 1590157482350, + "version": "0.7.0" + }, + "animatplot-0.4.2-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "matplotlib >=2.2", + "python >=3.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "3875f98a5598674f2755e2aec9a7a0ff", + "name": "animatplot", + "noarch": "python", + "sha256": "8c8492a7cde82cb209f7bcfd509abd21e209646e5c2280bd9daceeb2890a9fd7", + "size": 15775, + "subdir": "noarch", + "timestamp": 1601949675747, + "version": "0.4.2" + }, + "aniso8601-9.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=2.7", + "python-dateutil" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "36fba1a639f2d24723c5480345b78553", + "name": "aniso8601", + "noarch": "python", + "sha256": "201c040b6ee0045805a777f75f37a8648eb8dfd4725d62a4fcddc24d7d6c2a9f", + "size": 38716, + "subdir": "noarch", + "timestamp": 1618789622646, + "version": "9.0.1" + }, + "ann_visualizer-2.5-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cb5f35359e6caa136c1ff18e6c71ae1d", + "name": "ann_visualizer", + "noarch": "python", + "sha256": "1d92b6e16f773b2efeebf02a3099f759862b32d5cf54f88343e6d5e384a75481", + "size": 7382, + "subdir": "noarch", + "timestamp": 1557417678496, + "version": "2.5" + }, + "annexremote-1.2.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python >=3" + ], + "license": "GNU General Public v3 (GPLv3)", + "license_family": "GPL3", + "md5": "56cfa013a570a24a15ad5d705fa12b14", + "name": "annexremote", + "noarch": "python", + "sha256": "5c7ddbbe52b17a990053556d06c4b3c9789c364efacc67f5d3c988244e955fec", + "size": 23578, + "subdir": "noarch", + "timestamp": 1546932760920, + "version": "1.2.1" + }, + "ansi-0.3.6-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "typing-extensions >=3.6.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "add5ed1bc5585306010255f3ff4604f3", + "name": "ansi", + "noarch": "python", + "sha256": "1831ffd396f5089ff7081865a3a0a9f989264ffa18b761974c090c533db0597c", + "size": 11269, + "subdir": "noarch", + "timestamp": 1644601170750, + "version": "0.3.6" + }, + "ansible-base-2.10.17-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "cryptography", + "jinja2", + "packaging", + "python !=3.0,!=3.1,!=3.2,!=3.3,!=3.4", + "pyyaml" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "2fb9d8c2aea1a82f9db970519a692493", + "name": "ansible-base", + "noarch": "python", + "sha256": "1ea885f54e08b04bcb8e139f4df1cd6957af77393e81c023fff88d508e5b3f26", + "size": 1200321, + "subdir": "noarch", + "timestamp": 1643672859064, + "version": "2.10.17" + }, + "ansible-bender-0.8.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "ansible", + "jsonschema", + "python >=3.6", + "pyyaml", + "tabulate" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4bfa81578456f1c7d2f2aa29538428b2", + "name": "ansible-bender", + "noarch": "python", + "sha256": "9e79839db9e4e61873d13d96758680258ade882a6c73c02ec2a6ca3cbc4659ce", + "size": 34686, + "subdir": "noarch", + "timestamp": 1591817336334, + "version": "0.8.1" + }, + "ansible-kernel-1.0.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "ansible", + "ansible-runner >=1.1.0", + "docopt", + "ipywidgets", + "psutil", + "python >=3.6", + "pyyaml", + "six", + "tqdm" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "f3eaf0a010399d0b8f08e7fa57322f05", + "name": "ansible-kernel", + "noarch": "python", + "sha256": "e11ae8a33caa521559fa09c1b209255c1c3d0f21ba926c616f37fc6bc46584a6", + "size": 88649, + "subdir": "noarch", + "timestamp": 1644635041192, + "version": "1.0.0" + }, + "ansible-vault-2.1.0-pyh44b312d_0.tar.bz2": { + "build": "pyh44b312d_0", + "build_number": 0, + "depends": [ + "ansible", + "python" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "8ea5d463da7f652044696e7855168d08", + "name": "ansible-vault", + "noarch": "python", + "sha256": "1ffc71aed0c155d4269fb2fdc4afdd34a9d5b65dcb23b972086dca98539aafc3", + "size": 19987, + "subdir": "noarch", + "timestamp": 1612706282051, + "version": "2.1.0" + }, + "ansicolors-1.1.8-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e4929dd673bcb012fab516878e72f6f6", + "name": "ansicolors", + "noarch": "python", + "sha256": "e78147c36ed63f758cc8d39436bc1af89bb07441934cccbb9711d8b3cccc48c0", + "size": 13949, + "subdir": "noarch", + "timestamp": 1661653861646, + "version": "1.1.8" + }, + "ansimarkup-1.5.0-pyh44b312d_0.tar.bz2": { + "build": "pyh44b312d_0", + "build_number": 0, + "depends": [ + "colorama", + "python" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "06afdd510039f89cd3a846a63fbfdbac", + "name": "ansimarkup", + "noarch": "python", + "sha256": "88b8d4095bd80c11cc97e60e8933b05827334d420c4e3b5d2fa9e82a100c3532", + "size": 13746, + "subdir": "noarch", + "timestamp": 1611779835053, + "version": "1.5.0" + }, + "ansitable-0.9.7-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "colored", + "numpy", + "python >=3.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e1400108ed7d0ebbfa2dcee17bcd7b7f", + "name": "ansitable", + "noarch": "python", + "sha256": "f6c8abb5aae00f0b61846e52c5e3a969b4f181b10fad62cdf407a020674c4585", + "size": 17336, + "subdir": "noarch", + "timestamp": 1665118378562, + "version": "0.9.7" + }, + "ansiwrap-0.8.4-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python", + "textwrap3" + ], + "license": "Apache 2.0", + "license_family": "APACHE", + "md5": "f09557e2a7cbd2470a2ab6353000cebd", + "name": "ansiwrap", + "noarch": "python", + "sha256": "34e2445a78857c7418ab738b3a3c88f3226923676c3c185688dd570a6f9129a4", + "size": 9545, + "subdir": "noarch", + "timestamp": 1548523210816, + "version": "0.8.4" + }, + "ansys-api-mapdl-v0-0.4.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "google-api-python-client", + "grpcio", + "protobuf", + "python >=3.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "cd46141e183c943f7779604455a18b84", + "name": "ansys-api-mapdl-v0", + "noarch": "python", + "sha256": "3fe9fecbc01bca72a7524db07b6fa29d356decebe5d37969881a2381da94bec9", + "size": 16384, + "subdir": "noarch", + "timestamp": 1641673231347, + "version": "0.4.1" + }, + "antlr-python-runtime-4.9.2-pyhd8ed1ab_2.tar.bz2": { + "build": "pyhd8ed1ab_2", + "build_number": 2, + "depends": [ + "python >=3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5cde41310c9c24b8631281260fa9a057", + "name": "antlr-python-runtime", + "noarch": "python", + "sha256": "7e3c38b0feda2954cfe3b5d330ec417650bf1f4c9e44d8fce93066c5f75cc456", + "size": 101095, + "subdir": "noarch", + "timestamp": 1638312239509, + "version": "4.9.2" + }, + "antlr-python-runtime-4.9.3-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "depends": [ + "python >=3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c88eaec8de9ae1fa161205aa18e7a5b1", + "name": "antlr-python-runtime", + "noarch": "python", + "sha256": "b91f8ab4ac2b48972fbee1fc8e092cc452fdf59156e4ff2322c94bbf73650f94", + "size": 101065, + "subdir": "noarch", + "timestamp": 1638309284042, + "version": "4.9.3" + }, + "antlr4-python3-runtime-4.10-pyh1a96a4e_0.tar.bz2": { + "build": "pyh1a96a4e_0", + "build_number": 0, + "depends": [ + "antlr-python-runtime 4.10.*", + "python >=3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b69e92052f24e1e3a42fb35da6177033", + "name": "antlr4-python3-runtime", + "noarch": "python", + "sha256": "0b9e8726308d434be55de963abb2aec53164b13d1e89f18e53c93356e722b7e7", + "size": 5140, + "subdir": "noarch", + "timestamp": 1649721351514, + "version": "4.10" + }, + "antlr4-python3-runtime-4.11.1-pyh1a96a4e_0.tar.bz2": { + "build": "pyh1a96a4e_0", + "build_number": 0, + "depends": [ + "antlr-python-runtime 4.11.1.*", + "python >=3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "557482c214d0e6194a427711d41980b0", + "name": "antlr4-python3-runtime", + "noarch": "python", + "sha256": "91758f2b5264015047d80c8fef85925301c9cc8eaa745ab9cd44569fa4f754c0", + "size": 5023, + "subdir": "noarch", + "timestamp": 1662478441664, + "version": "4.11.1" + }, + "antlr4-python3-runtime-4.9.2-pyh1a96a4e_2.tar.bz2": { + "build": "pyh1a96a4e_2", + "build_number": 2, + "depends": [ + "antlr-python-runtime 4.9.2.*", + "python >=3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "acde020ff383669179a84187543178a7", + "name": "antlr4-python3-runtime", + "noarch": "python", + "sha256": "c885f54dfbd444bf67296b9c381c12dfe2c8a4a41ac4309ec3eda56b48acb0ef", + "size": 5638, + "subdir": "noarch", + "timestamp": 1638312249223, + "version": "4.9.2" + }, + "anybadge-1.14.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "packaging", + "python >=3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "83a13edaecd343d77650f8bcd78cc4e1", + "name": "anybadge", + "noarch": "python", + "sha256": "52ddc620e19fbafcf7d3d07528544567863bdd1a3806658eb0eb00519e31d4f9", + "size": 26544, + "subdir": "noarch", + "timestamp": 1661549582958, + "version": "1.14.0" + }, + "anyconfig-0.10.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f11fc0562fab5df0b75029aed96f269f", + "name": "anyconfig", + "noarch": "python", + "sha256": "a93000b9c4d4e66077c81b29d36715b2c39c4802b334c6509e0a0a331a6fb5ca", + "size": 48433, + "subdir": "noarch", + "timestamp": 1619079200972, + "version": "0.10.1" + }, + "anyconfig-0.13.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "fd766d94e251f27d9dbfa45d949b64b2", + "name": "anyconfig", + "noarch": "python", + "sha256": "6b0d63c6d05fa925327a4b56222790500bcf9fe28953373ce1241a6f6fbffb5b", + "size": 56804, + "subdir": "noarch", + "timestamp": 1648970115301, + "version": "0.13.0" + }, + "anyjson-0.3.3-pyhd8ed1ab_1004.tar.bz2": { + "build": "pyhd8ed1ab_1004", + "build_number": 1004, + "depends": [ + "python >=3.6" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "264dc7e0f13eed3284402817dd193254", + "name": "anyjson", + "noarch": "python", + "sha256": "6125478128faf5a098ff1748dc278c266092fbb83ce41199eee063713f747f53", + "size": 8499, + "subdir": "noarch", + "timestamp": 1620792155416, + "version": "0.3.3" + }, + "anyqt-0.2.0-pyh6c4a22f_0.tar.bz2": { + "build": "pyh6c4a22f_0", + "build_number": 0, + "depends": [ + "pyqt", + "python >=3.6" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "03b1ce4eda574f2cd65656aed506068e", + "name": "anyqt", + "noarch": "python", + "sha256": "e2d7f3955e2b835446b9a0925dc13a2b1b658256472160d024b1480e50ac85fb", + "size": 50185, + "subdir": "noarch", + "timestamp": 1659515321386, + "version": "0.2.0" + }, + "anys-0.2.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "deprecated >=1.2,<2", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b9147726272f5a5d1c1fe1a0db37b240", + "name": "anys", + "noarch": "python", + "sha256": "db807de8d4a111d961d5767233d224e9f07fad0935864da6cc78a463a22f446d", + "size": 17446, + "subdir": "noarch", + "timestamp": 1633475314016, + "version": "0.2.1" + }, + "anytree-2.8.0-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "python", + "six >=1.9.0" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "614f4c72f03e3b29f5079e2c523bbb9c", + "name": "anytree", + "noarch": "python", + "sha256": "f5983336c746871df497f259144937825cb0558e500710519b6a300847757b7b", + "size": 31646, + "subdir": "noarch", + "timestamp": 1587333075272, + "version": "2.8.0" + }, + "aoe2netwrapper-0.3.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "loguru >=0.5.3,<0.6.0", + "pydantic >=1.7.3,<2.0.0", + "python >=3.6,<4.0", + "requests >=2.25.1,<3.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "dcc58c9b12dfd45685bcc464bf7e0bda", + "name": "aoe2netwrapper", + "noarch": "python", + "sha256": "2c13411a6f77cb3133fa17b2c8fa5a4e51a8cc5e977146e24ac7f40c059af817", + "size": 19559, + "subdir": "noarch", + "timestamp": 1637096007102, + "version": "0.3.1" + }, + "aospy-0.3.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "cftime >=1.0.0", + "cloudpickle >=0.2.1", + "dask-core >=0.14", + "distributed >=1.17.1", + "netcdf4 >=1.2", + "numpy >=1.7", + "pandas >=0.15.0", + "python >=3.6", + "scipy >=0.16", + "toolz >=0.7.2", + "xarray >=0.10.6" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b111c73711b099de56ca42463271449b", + "name": "aospy", + "noarch": "python", + "sha256": "7d87f9a23612ea02f344a67d771fc99ca9765234605f6004700ff32f202cac8b", + "size": 3178571, + "subdir": "noarch", + "timestamp": 1637006990525, + "version": "0.3.1" + }, + "apache-airflow-providers-apache-hive-2.3.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "apache-airflow >=2.1.0", + "hmsclient >=0.1.0", + "pandas >=0.17.1,<1.4", + "pyhive >=0.6.0", + "python >=3.6", + "sasl >=0.2.1", + "sasl >=0.3.1", + "thrift >=0.10.0", + "thrift >=0.9.2", + "thrift_sasl >=0.1.0" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "158caf0876784929b59b26edbe5f4b69", + "name": "apache-airflow-providers-apache-hive", + "noarch": "python", + "sha256": "4ef06bee4c125d5ed21eccc63a2f2814b8ce612f69843ec8700f1d6f8260aedd", + "size": 37147, + "subdir": "noarch", + "timestamp": 1646985394308, + "version": "2.3.0" + }, + "apache-airflow-providers-jira-3.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "apache-airflow >=2.2.0", + "jira >1.0.7", + "python >=3.7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "0c06ab0e9968b1c324c84203a523c131", + "name": "apache-airflow-providers-jira", + "noarch": "python", + "sha256": "4a3f21f264fe313d0ba6563df31b981023efd3dacc7feed58f5d57b5a4effec0", + "size": 17353, + "subdir": "noarch", + "timestamp": 1658868314848, + "version": "3.0.1" + }, + "apache-airflow-providers-microsoft-azure-4.0.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "apache-airflow >=2.2.0", + "azure-batch >=8.0.0", + "azure-cosmos >=4.0.0", + "azure-datalake-store >=0.0.45", + "azure-identity >=1.3.1", + "azure-keyvault-secrets >=4.1.0,<5.0", + "azure-kusto-data >=0.0.43,<0.1", + "azure-mgmt-containerinstance >=1.5.0,<2.0", + "azure-mgmt-datafactory >=1.0.0,<2.0", + "azure-mgmt-datalake-store >=0.5.0", + "azure-mgmt-resource >=2.2.0", + "azure-storage-blob >=12.7.0,<12.9.0", + "azure-storage-common >=2.1.0", + "azure-storage-file >=2.1.0", + "python >=3.7" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ce1a99bd6f37291fcb1b63a8436d7016", + "name": "apache-airflow-providers-microsoft-azure", + "noarch": "python", + "sha256": "a7ad2ed116f82993a09a6170922332eef7df58d0867a289d65d94eaa59803ba6", + "size": 55728, + "subdir": "noarch", + "timestamp": 1655193377966, + "version": "4.0.0" + }, + "apache-libcloud-2.8.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "certifi", + "python" + ], + "license": "Apache 2.0", + "md5": "ea2861a39ffe6fe7df10cd6c19ba4fc2", + "name": "apache-libcloud", + "noarch": "python", + "sha256": "9114652e82d8a2e2174c5b7eabe321a6183a561c6fec2b1c7f62d1bddee5a7f2", + "size": 1731213, + "subdir": "noarch", + "timestamp": 1583284211930, + "version": "2.8.1" + }, + "apav-1.2.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "fast-histogram", + "lmfit >=1.0", + "numba", + "numpy >=1.17", + "periodictable", + "pyqt >=5.11", + "pyqtgraph >=0.11.0", + "pytest >=5", + "pytest-qt >=3", + "python >=3.8", + "tabulate" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "ecdba36ac33d9dc80b7a1cf8ca66430e", + "name": "apav", + "noarch": "python", + "sha256": "7e77f532ee2c2068c16ef6cb6b6f5d358d386a2199962bedc87cae03577f05dd", + "size": 50464297, + "subdir": "noarch", + "timestamp": 1629918594502, + "version": "1.2.1" + }, + "api2db-1.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "dill >=0.3.3", + "google-cloud-bigquery >=2.11.0", + "pandas >=1.1.5", + "pandas-gbq >=0.14.1", + "pyarrow >=3.0.0", + "python >=3.6,<4.0", + "requests >=2.25.1", + "schedule >=1.1.0", + "sqlalchemy >=1.4.11", + "sqlalchemy-utils >=0.37.0", + "urllib3 >=1.26.4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "e41957466d3199651ff7b219f404f3b1", + "name": "api2db", + "noarch": "python", + "sha256": "016fe8109f54db8579ec7745b3f0df3e7b668904e7598856b40d2edbfb84fdc6", + "size": 42192, + "subdir": "noarch", + "timestamp": 1622760047806, + "version": "1.0.1" + }, + "apicurio-keycloak-extensions-9.0.1-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b1aff1537a827131e0212f3ba6c1a46a", + "name": "apicurio-keycloak-extensions", + "noarch": "generic", + "sha256": "4cd9035651fa39c2f968cf25f3fcd84cd6584aae793dd99f5c1a8464078003ac", + "size": 15468, + "subdir": "noarch", + "timestamp": 1595746469325, + "version": "9.0.1" + }, + "apicurio-keycloak-extensions-9.0.1-hd8ed1ab_1.tar.bz2": { + "build": "hd8ed1ab_1", + "build_number": 1, + "depends": [], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "4349860f1060a4be75529123c4fc1a6d", + "name": "apicurio-keycloak-extensions", + "noarch": "generic", + "sha256": "1bcf9668e6abbdcc56b7baf56c55d83cfb4993005b4f5c6970d26c6a0c75e0b3", + "size": 15499, + "subdir": "noarch", + "timestamp": 1619808615647, + "version": "9.0.1" + }, + "apipkg-3.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1a216806cfcb32f49b6701b88c04c611", + "name": "apipkg", + "noarch": "python", + "sha256": "a8de89db83738eb495821cf1963426ab0c3d0bc035915bf74644c7249903e654", + "size": 11302, + "subdir": "noarch", + "timestamp": 1654774766801, + "version": "3.0.1" + }, + "apispec-webframeworks-0.5.2-pyhd8ed1ab_4.tar.bz2": { + "build": "pyhd8ed1ab_4", + "build_number": 4, + "depends": [ + "apispec >=2.0.0", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5350a4e4bc91c6796ad96192fe8122e6", + "name": "apispec-webframeworks", + "noarch": "python", + "sha256": "a1be7219489092abb10dd9b5970a5c9c23b49c5efae5284a0cabbe9986cd29a7", + "size": 12826, + "subdir": "noarch", + "timestamp": 1636503161122, + "version": "0.5.2" + }, + "apistar-0.7.2-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "click", + "jinja2", + "python >=3.6", + "pyyaml", + "requests", + "typesystem >=0.2.0" + ], + "license": "BSD 3-Clause", + "license_family": "BSD", + "md5": "11cdbb760ed93dea3b18bf06eea13859", + "name": "apistar", + "noarch": "python", + "sha256": "5a849c95fa936bf832cbb5a22e86f2ea545aa0f92772af6759bac9e325561a42", + "size": 2884402, + "subdir": "noarch", + "timestamp": 1554280692763, + "version": "0.7.2" + }, + "aplpy-2.0.3-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "astropy >=3.1", + "matplotlib >=2.0", + "numpy", + "pillow >=4.0", + "pyavm >=0.9.4", + "pyregion >=2.0", + "python >=3.5", + "reproject >=0.4", + "scikit-image >=0.14", + "shapely >=1.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "2e02d71194fdcf490f464916a6116a9b", + "name": "aplpy", + "noarch": "python", + "sha256": "ade6979764daafb7a6f1aec52640506b07faf84f217d812ba06c1ad57960ad60", + "size": 53889, + "subdir": "noarch", + "timestamp": 1550587110736, + "version": "2.0.3" + }, + "aplpy-2.0.3-py_1.tar.bz2": { + "build": "py_1", + "build_number": 1, + "depends": [ + "astropy >=3.1", + "matplotlib-base >=2.0", + "numpy", + "pillow >=4.0", + "pyavm >=0.9.4", + "pyregion >=2.0", + "python >=3.5", + "reproject >=0.4", + "scikit-image >=0.14", + "shapely >=1.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c487f819ae8af97dfb597a63c7595929", + "name": "aplpy", + "noarch": "python", + "sha256": "bbfe7a70780d2659358954ec9734913bcd6830e994b73cf80b20e29ac8ab392e", + "size": 54235, + "subdir": "noarch", + "timestamp": 1589637987410, + "version": "2.0.3" + }, + "aplus-0.11.0-py_1.tar.bz2": { + "build": "py_1", + "build_number": 1, + "depends": [ + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7785bb1ae3202fb550f23699c6f89121", + "name": "aplus", + "noarch": "python", + "sha256": "7f2734233106b9ccfcf0bcd916cfdd39b59dcedf1a8832e6b1ec0048b6bc1ba2", + "size": 6486, + "subdir": "noarch", + "timestamp": 1531795851367, + "version": "0.11.0" + }, + "appdirs-1.4.4-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5f095bc6454094e96f146491fd03633b", + "name": "appdirs", + "noarch": "python", + "sha256": "ae9fb8f68281f84482f2c234379aa12405a9e365151d43af20b3ae1f17312111", + "size": 12840, + "subdir": "noarch", + "timestamp": 1603108499239, + "version": "1.4.4" + }, + "appium-python-client-1.0.2-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "python", + "selenium >=3.14.1,<4" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "6d5f6f653446e243fe6dba017adf668d", + "name": "appium-python-client", + "noarch": "python", + "sha256": "24fb24fe6fb36cdd6110ae08d3079c69c9c31c7c3db907e9f2eaebcc5c38861b", + "size": 51782, + "subdir": "noarch", + "timestamp": 1599587538461, + "version": "1.0.2" + }, + "applaunchservices-0.3.0-pyhd8ed1ab_2.tar.bz2": { + "build": "pyhd8ed1ab_2", + "build_number": 2, + "depends": [ + "__osx", + "pyobjc-framework-coreservices", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "bfbbcab359fc3d878e1818f0972a7378", + "name": "applaunchservices", + "noarch": "python", + "sha256": "dda15c5eb77bd779ebcd4c6c4371efc3cbe75228e594ff6fd78f969361e7b5ac", + "size": 8991, + "subdir": "noarch", + "timestamp": 1653840810367, + "version": "0.3.0" + }, + "applicationinsights-0.11.9-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "198add8c53c9e1bb16f3c4a3d7a8a15d", + "name": "applicationinsights", + "noarch": "python", + "sha256": "ee4ab132c75046d4be724ffe8e2fa2609f23a559b790674e6709b272dd6f07f8", + "size": 33918, + "subdir": "noarch", + "timestamp": 1558147286125, + "version": "0.11.9" + }, + "apply_defaults-0.1.6-pyh6c4a22f_0.tar.bz2": { + "build": "pyh6c4a22f_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4082201e1ec1633e1812c26bbe9050c6", + "name": "apply_defaults", + "noarch": "python", + "sha256": "c3d709bb41717eacea5cc54d1b4b492eec873179be845eae1aa39be19155f782", + "size": 6976, + "subdir": "noarch", + "timestamp": 1626779912527, + "version": "0.1.6" + }, + "appmap-1.3.2-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "importlib-metadata >=0.8", + "inflection >=0.3.0", + "python >=3.6,<4.0", + "pyyaml >=5.3.0,<6.0.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "555f78fb665de55c6cc74f3352ad292c", + "name": "appmap", + "noarch": "python", + "sha256": "6e9bb425c5f57e0656002b744fea70c25d53527fd6083645a3ceb2b719a12d20", + "size": 68771, + "subdir": "noarch", + "timestamp": 1636531879378, + "version": "1.3.2" + }, + "appmar-1.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "cartopy", + "cfgrib", + "gdal", + "kneed", + "matplotlib-base 3.2.*", + "numpy", + "pandas", + "pillow", + "python >=3.7", + "scikit-learn", + "scipy", + "wxpython", + "xarray" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "10c89ee761d01496c9817308ec173b96", + "name": "appmar", + "noarch": "python", + "sha256": "6bc7f586c6d652ee175b62f6c392ec8db682ad1e7dd6638f37f67a107ff7843e", + "size": 61419, + "subdir": "noarch", + "timestamp": 1665079474408, + "version": "1.0.1" + }, + "appmode-0.1.0-py_0.tar.bz2": { + "arch": null, + "build": "py_0", + "build_number": 0, + "depends": [ + "notebook >=5", + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7281b7d0993eb6d228a5d17a8c00602b", + "name": "appmode", + "noarch": "python", + "platform": null, + "sha256": "e630d9f74c65b81aaaf4461e81db327563dc65fccadb5574a71ec9562e8065b0", + "size": 9654, + "subdir": "noarch", + "version": "0.1.0" + }, + "appnope-0.1.3-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=2.7" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "54ac328d703bff191256ffa1183126d1", + "name": "appnope", + "noarch": "python", + "sha256": "b209a68ac55eb9ecad7042f0d4eedef5da924699f6cdf54ac1826869cfdae742", + "size": 8095, + "subdir": "noarch", + "timestamp": 1649077760928, + "version": "0.1.3" + }, + "approxposterior-0.4-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "corner", + "emcee >=3", + "george", + "h5py", + "matplotlib", + "numpy", + "python >=3.5", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "b1f51ca4795dc5decb79cc1c727b1fde", + "name": "approxposterior", + "noarch": "python", + "sha256": "db3744334ad5ffdad31f9380673bab08a25ba841c95100e4392eda60474772aa", + "size": 32357, + "subdir": "noarch", + "timestamp": 1578517230684, + "version": "0.4" + }, + "approxposterior-0.4-py_1.tar.bz2": { + "build": "py_1", + "build_number": 1, + "depends": [ + "corner", + "emcee >=3", + "george", + "h5py", + "matplotlib-base", + "numpy", + "python >=3.5", + "scikit-learn", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "4d2a2743f13fc5f14ed43a2be8056d4f", + "name": "approxposterior", + "noarch": "python", + "sha256": "131f35963f92757abd9e09597a5ff8fdf8c02d0ef5a85e1d9230c0004f02d0b2", + "size": 32344, + "subdir": "noarch", + "timestamp": 1581977735913, + "version": "0.4" + }, + "apptools-5.1.0-pyh44b312d_0.tar.bz2": { + "build": "pyh44b312d_0", + "build_number": 0, + "depends": [ + "configobj", + "pyface", + "python", + "traits", + "traitsui" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "67f86126bb65837378ddd31caff9f420", + "name": "apptools", + "noarch": "python", + "sha256": "61a07541a6de3d67a0d80b7b62713154e9de65184d5046b898d62e95b0501c92", + "size": 126196, + "subdir": "noarch", + "timestamp": 1610582727155, + "version": "5.1.0" + }, + "aproc-0.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "26279678bddc9a7019322483ccfeb5af", + "name": "aproc", + "noarch": "python", + "sha256": "9242e16c9f527973a475d765cf7d5f79b7478a4f1ba4d8e2ad4d7000032c0a53", + "size": 7824, + "subdir": "noarch", + "timestamp": 1636355037055, + "version": "0.0.1" + }, + "arabic_reshaper-2.1.4-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "configparser", + "future", + "python >=3.6", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "53d956267f9e2ed8596e61ac8c5f2578", + "name": "arabic_reshaper", + "noarch": "python", + "sha256": "6b606087cf98476b6373f0be623aaecf8df7d2c691be1a42c0d9902a1c6c6b74", + "size": 21376, + "subdir": "noarch", + "timestamp": 1663811947404, + "version": "2.1.4" + }, + "arbol-2021.5.27.641-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "BSD-3-Clause OR MIT", + "md5": "2331b7ecdd460c466fb0516d8f8397ab", + "name": "arbol", + "noarch": "python", + "sha256": "e4171c2265a4b43cc220392681b69a326404693f878c5bbec2dcd7e1987cb04c", + "size": 10911, + "subdir": "noarch", + "timestamp": 1644770107438, + "version": "2021.5.27.641" + }, + "arby-1.0.2-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "attrs", + "numpy", + "python >=3.6", + "scipy" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "7f6d5dde0b4a6644d7dcbd54b5b83fcf", + "name": "arby", + "noarch": "python", + "sha256": "4d4627044b915682d2aec3960c113970f66ec01d42c8f6b745e09329915a9d33", + "size": 16349, + "subdir": "noarch", + "timestamp": 1660140662881, + "version": "1.0.2" + }, + "arc3o-0.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "numpy", + "pandas", + "pathos", + "python >=3.5", + "tqdm", + "xarray" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "d13e847ac87abd95ed3dc8a0127a9f19", + "name": "arc3o", + "noarch": "python", + "sha256": "2b06ad4993d9ca86486104cac52684e6a3d19b4934af091aa098a5c98ad4bc46", + "size": 48940, + "subdir": "noarch", + "timestamp": 1600922892951, + "version": "0.1" + }, + "archspec-0.1.4-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "click >=8,<9", + "python >=3.6", + "six >=1.13.0,<2.0.0" + ], + "license": "MIT OR Apache-2.0", + "md5": "eb34c7bc3f7daaa5c01db7ce9afcc33f", + "name": "archspec", + "noarch": "python", + "sha256": "fdce70d338b929cee03604f1ad30b182e0f17f2a91ba4554bccaf75b418635eb", + "size": 37883, + "subdir": "noarch", + "timestamp": 1661539739014, + "version": "0.1.4" + }, + "arcp-0.2.0-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "8b2565c631f590ea82ab0f50a5811ce5", + "name": "arcp", + "noarch": "python", + "sha256": "17e9114851dd8dfcb1c12291d65bf2cc9b7990093b8d0e18e0b406132c7169dc", + "size": 20688, + "subdir": "noarch", + "timestamp": 1592406470852, + "version": "0.2.0" + }, + "area-detector-handlers-0.0.10-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "dask", + "entrypoints", + "h5py", + "pandas", + "python >=3.6", + "tifffile >=2020.8.25" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e410310445f38d0371ab90f76d27c798", + "name": "area-detector-handlers", + "noarch": "python", + "sha256": "75ea052a3fd16d518612e2165b7fb2b53c91226552b557755949ab301b871550", + "size": 21977, + "subdir": "noarch", + "timestamp": 1664603052349, + "version": "0.0.10" + }, + "argcomplete-1.12.3-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b1cce9f8d3d0cd07bdd9cce4ead2b055", + "name": "argcomplete", + "noarch": "python", + "sha256": "0b36060737ddae9dbfff1b9eb7a6f0f2ffab0d5fe8c3a7e39799098afc98ea32", + "size": 35235, + "subdir": "noarch", + "timestamp": 1618900055246, + "version": "1.12.3" + }, + "argcomplete-1.12.3-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "depends": [ + "importlib_metadata >=0.23,<4", + "python >=3.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "a7cc8d8a05a710006718248521ed0807", + "name": "argcomplete", + "noarch": "python", + "sha256": "ead25511c29c9e298b8e0c6b00c74ae89a4f88246c3cac66d2e266ff42359810", + "size": 35281, + "subdir": "noarch", + "timestamp": 1618900722774, + "version": "1.12.3" + }, + "argcomplete-1.12.3-pyhd8ed1ab_2.tar.bz2": { + "build": "pyhd8ed1ab_2", + "build_number": 2, + "depends": [ + "importlib_metadata >=0.23,<5", + "python >=3.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b8152341fc3fc9880c6e1b9d188974e5", + "name": "argcomplete", + "noarch": "python", + "sha256": "2abb116f5bdc62d5e83c9dd15e5fc30c2a9571f728ccc012fad03350ed1d581e", + "size": 35310, + "subdir": "noarch", + "timestamp": 1619128850100, + "version": "1.12.3" + }, + "argo-models-2.4.2-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "bf36839418018dc92adeb85c84ca8a8e", + "name": "argo-models", + "noarch": "python", + "sha256": "2f8776a6b5f9c352eeee0ebaa7aa62f363f9f26c5ec7b98397a93747c107c1b9", + "size": 41152, + "subdir": "noarch", + "timestamp": 1574610281410, + "version": "2.4.2" + }, + "argo-workflows-5.0.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.6", + "python-dateutil", + "six", + "urllib3" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "19cb76f034a3f635251794b5d6cf1a7a", + "name": "argo-workflows", + "noarch": "python", + "sha256": "c967f8ffee1e9594a22139fb9a4d9de7b634b65847f20080900d5565bfc31539", + "size": 156730, + "subdir": "noarch", + "timestamp": 1617821345727, + "version": "5.0.0" + }, + "argo-workflows-6.3.5-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "certifi", + "python >=3.6", + "python-dateutil", + "six", + "urllib3" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "b3e18a1d1d1fde05868cf5b693085d87", + "name": "argo-workflows", + "noarch": "python", + "sha256": "3fe0208c34f1bd4acc090e2c26274e74115081882b65d17d8b6a7fe2c4422082", + "size": 238669, + "subdir": "noarch", + "timestamp": 1651659939907, + "version": "6.3.5" + }, + "argo-workflows-dsl-0.1.0rc0-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "argo-workflows >=2.1.4", + "inflection", + "python", + "pyyaml" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "0ece0407056b9b86c6905ae7e313642e", + "name": "argo-workflows-dsl", + "noarch": "python", + "sha256": "5e23fb15baa1d4a74a785498e70e7fceabe9f9b1b0710a9bcbee9bfeadf6b990", + "size": 121482, + "subdir": "noarch", + "timestamp": 1591183796264, + "version": "0.1.0rc0" + }, + "argon2-cffi-21.3.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "constrains": [ + "argon2_cffi ==999" + ], + "depends": [ + "argon2-cffi-bindings", + "flit-core >=3.4,<4", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a0b402db58f73aaab8ee0ca1025a362e", + "name": "argon2-cffi", + "noarch": "python", + "sha256": "3a53cfd674641d9ff9901f5d4e1cc5e9a3ce9bb8b6a7dca826db840c2e39bc23", + "size": 15708, + "subdir": "noarch", + "timestamp": 1640817831095, + "version": "21.3.0" + }, + "argopandas-0.0.5-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "netcdf4", + "numpy", + "pandas", + "pyarrow", + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "be63065da492f7ca9b20bed492cf52ed", + "name": "argopandas", + "noarch": "python", + "sha256": "9ced56a58ff5f3f41083c1365294aa636dd2f53747c36e0c85f76284cb85793e", + "size": 23737, + "subdir": "noarch", + "timestamp": 1633459783609, + "version": "0.0.5" + }, + "args-0.1.0-pyhd8ed1ab_1004.tar.bz2": { + "build": "pyhd8ed1ab_1004", + "build_number": 1004, + "depends": [ + "python >=3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "b3e9eb9a3e991276d5dfbd548a75da73", + "name": "args", + "noarch": "python", + "sha256": "b83fb78293e13683a613e8ed95e16c614ea98207d1be9e123ce3159792063ee1", + "size": 8054, + "subdir": "noarch", + "timestamp": 1637347351047, + "version": "0.1.0" + }, + "argutils-0.3.3-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python", + "pyyaml", + "six" + ], + "license": "GPL-2.0-or-later", + "license_family": "GPL2", + "md5": "9f9315b20887fda216184cdd71b7b3e3", + "name": "argutils", + "noarch": "python", + "sha256": "d54376796696949b708aa3087a259c788a6a3a0613b488d0414ed50a9fc316dd", + "size": 17407, + "subdir": "noarch", + "timestamp": 1568101214021, + "version": "0.3.3" + }, + "arn-0.1.5-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.7" + ], + "license": "BSD-3-Clause-Clear", + "license_family": "BSD", + "md5": "9afd69c7b75a4e3bba35ffdb9ae8691e", + "name": "arn", + "noarch": "python", + "sha256": "1a35827d779b986e01b7471139840f93653b857d53d7c58ec4f56bacdee23c4d", + "size": 12161, + "subdir": "noarch", + "timestamp": 1614983313010, + "version": "0.1.5" + }, + "arn-0.1.5-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "depends": [ + "dataclasses", + "python >=3.6" + ], + "license": "BSD-3-Clause-Clear", + "license_family": "BSD", + "md5": "aff46c8a015cbaa2c989855d7a2dc9fa", + "name": "arn", + "noarch": "python", + "sha256": "640d9669ff4fd5d0183a831749a5a2bafa7d628fc03b49ff9c82133054329d1e", + "size": 12158, + "subdir": "noarch", + "timestamp": 1614983931700, + "version": "0.1.5" + }, + "arosics-0.9.24-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "cmocean", + "folium >=0.6.0", + "gdal", + "geoarray >=0.8.30", + "geojson", + "geopandas", + "matplotlib-base", + "numpy", + "pandas", + "plotly", + "py-tools-ds >=0.14.28,<=0.15.11", + "python", + "scikit-image", + "shapely", + "six" + ], + "license": "GPL-3.0-only", + "license_family": "GPL", + "md5": "03c66ac580eb40ba4ba33e85b8a1991d", + "name": "arosics", + "noarch": "python", + "sha256": "0535919b0cd612b6ac5f106034fb5bdcc832db869a1c9c219710b125a88b48fe", + "size": 19242835, + "subdir": "noarch", + "timestamp": 1601299667630, + "version": "0.9.24" + }, + "array2gif-1.0.4-pyh24bf2e0_0.tar.bz2": { + "arch": null, + "build": "pyh24bf2e0_0", + "build_number": 0, + "depends": [ + "numpy", + "python" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0a1fc0c3bb78fb4d3a61faf0b56e86b5", + "name": "array2gif", + "noarch": "python", + "platform": null, + "sha256": "f1a8e7d4a2809ad85a0808a1c0e6f477fe36b02739c1234c4272273ae2f0f98a", + "size": 10216, + "subdir": "noarch", + "timestamp": 1529689544842, + "version": "1.0.4" + }, + "array_split-0.5.2-pyh95af2a2_0.tar.bz2": { + "build": "pyh95af2a2_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "63dbfd2117015403fd4b51dd361b0d17", + "name": "array_split", + "noarch": "python", + "sha256": "ace5bcea54ad186fb2f0ae7113c5f6e012af5d15c1d60013fa15b362e45066f4", + "size": 28688, + "subdir": "noarch", + "timestamp": 1586628515400, + "version": "0.5.2" + }, + "arrow-1.2.3-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "python-dateutil >=2.7.0", + "typing_extensions" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "fd1967c76eda3a3dd9e8e6cb7a15a028", + "name": "arrow", + "noarch": "python", + "sha256": "a0434c2770cf5b0ab5a33913c0b202b1521bc13f755b762d16a86b110425cdc2", + "size": 93703, + "subdir": "noarch", + "timestamp": 1662382594353, + "version": "1.2.3" + }, + "artificial-adversary-1.1.1-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "nltk", + "pandas", + "python", + "textblob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "0cdca7d2aebaeae4406b3740d32436dd", + "name": "artificial-adversary", + "noarch": "python", + "sha256": "f4b14904047c2e1a7b4190614644c0e1517ae990f3fc970b2101df6a46a41717", + "size": 51464, + "subdir": "noarch", + "timestamp": 1595860965980, + "version": "1.1.1" + }, + "artificial-adversary-1.1.1-pyhd3deb0d_1.tar.bz2": { + "build": "pyhd3deb0d_1", + "build_number": 1, + "depends": [ + "nltk", + "pandas", + "python", + "textblob" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "65aba9b02b7a372ebb1ba023caa696fc", + "name": "artificial-adversary", + "noarch": "python", + "sha256": "571e712b2a8c4fc8d1f36d7cd17fef05ffd5cc479f7e75ca0da3699e5f2b7c3e", + "size": 51733, + "subdir": "noarch", + "timestamp": 1619808713239, + "version": "1.1.1" + }, + "artview-1.3.7-py_2.tar.bz2": { + "build": "py_2", + "build_number": 2, + "depends": [ + "arm_pyart >=1.6", + "matplotlib >=1.1,<3", + "pyqt >=4.6", + "pyqt >=5.9.2,<5.10.0a0", + "python" + ], + "license": "BSD 3-Clause", + "md5": "d153d9d39df13bab9a929d5658ef0af1", + "name": "artview", + "noarch": "python", + "sha256": "0d3c038597c9e6c3c223ea678e276c328f838598f46bdbbf52a389b9eeab0d5e", + "size": 153365, + "subdir": "noarch", + "timestamp": 1570545833794, + "version": "1.3.7" + }, + "artview-1.3.7-py_3.tar.bz2": { + "build": "py_3", + "build_number": 3, + "depends": [ + "arm_pyart >=1.6", + "matplotlib-base >=1.1,<3", + "pyqt >=4.6", + "pyqt >=5.12.3,<5.13.0a0", + "python" + ], + "license": "BSD 3-Clause", + "md5": "1afd9002c96982a5a3615f34bf01b34f", + "name": "artview", + "noarch": "python", + "sha256": "cd7090fb7c57ad56507fc97cf825f5f04b284b3883a1eb8e760d02f94448d232", + "size": 153506, + "subdir": "noarch", + "timestamp": 1581538172465, + "version": "1.3.7" + }, + "arvpyf-0.4.3-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "numpy", + "pandas", + "python >=3.6", + "pytz", + "requests" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "7471139e79c784774523a3b12e9d584c", + "name": "arvpyf", + "noarch": "python", + "sha256": "057ae1176ef93bf885a0d06e190177124066fc3e8bf90c78fd70e2bcf2ce62df", + "size": 13013, + "subdir": "noarch", + "timestamp": 1624643150665, + "version": "0.4.3" + }, + "arxiv-collector-0.4.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=2.7" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "129c8f42a71a872f799769ac9ce192d3", + "name": "arxiv-collector", + "noarch": "python", + "sha256": "c4b2546844482e754171f760ece19c627f1aafb299d1bc282d7a8fedd0c7d9ed", + "size": 13424, + "subdir": "noarch", + "timestamp": 1635525219969, + "version": "0.4.1" + }, + "asammdf-7.0.3-pyhe74cb21_0.tar.bz2": { + "build": "pyhe74cb21_0", + "build_number": 0, + "depends": [ + "canmatrix", + "chardet", + "lxml", + "lz4", + "matplotlib-base", + "natsort", + "numexpr", + "numpy >=1.21", + "pandas", + "python >=3.7", + "python-isal", + "typing_extensions", + "wheel" + ], + "license": "LGPLv3+", + "license_family": "LGPL", + "md5": "7927718121776861b9a97a8784f7f55d", + "name": "asammdf", + "noarch": "python", + "sha256": "a56386fd10f000947cd655982b53833e2a574b86992a381b7a9b004e244717f8", + "size": 511364, + "subdir": "noarch", + "timestamp": 1641452555168, + "version": "7.0.3" + }, + "ascii_graph-1.5.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "9d469ae2a764a1e36e71c0cc569278e0", + "name": "ascii_graph", + "noarch": "python", + "sha256": "8035ba94535e13730b3fe44a42c5c759cf7641b2062728269b777ed433692f24", + "size": 13069, + "subdir": "noarch", + "timestamp": 1554137842971, + "version": "1.5.1" + }, + "asciichartpy-1.5.25-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "setuptools" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "79ed7602e0fb1e3c476e1b0184df4bc0", + "name": "asciichartpy", + "noarch": "python", + "sha256": "840ed79c64df58810bea5c34dd2953dabb0eea4b9947650ddeb39ffb59390dc4", + "size": 10482, + "subdir": "noarch", + "timestamp": 1646775104557, + "version": "1.5.25" + }, + "asciietch-1.0.6-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "future", + "parsedatetime 2.4", + "python >=3.6", + "setuptools >=30" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "0ffe93f330c4ce4abb3c256caae98401", + "name": "asciietch", + "noarch": "python", + "sha256": "129924ebf366bd7b36601f0fd2e742e1cb11ca35a031fe8b6939d86cbe0ebd55", + "size": 10607, + "subdir": "noarch", + "timestamp": 1661177424378, + "version": "1.0.6" + }, + "asciitree-0.3.3-py_2.tar.bz2": { + "arch": null, + "build": "py_2", + "build_number": 2, + "depends": [ + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "c0481c9de49f040272556e2cedf42816", + "name": "asciitree", + "noarch": "python", + "platform": null, + "sha256": "b3e9369529fe7d721b66f18680ff4b561e20dbf6507e209e1f60eac277c97560", + "size": 6164, + "subdir": "noarch", + "timestamp": 1531050741142, + "version": "0.3.3" + }, + "asdf-2.10.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "importlib_resources >=3", + "jmespath >=0.6.2", + "jsonschema >=3.0.2,<4", + "numpy >=1.10", + "packaging >=16.0", + "python >=3.6", + "pyyaml >=3.10", + "semantic_version >=2.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e5c64bb79c050eb190b232aa466824ae", + "name": "asdf", + "noarch": "python", + "sha256": "eab5f60b7a906f88395219bb953fbba2fa3e07c94d2d3802c8af0b91b6adfb90", + "size": 342997, + "subdir": "noarch", + "timestamp": 1645193963321, + "version": "2.10.0" + }, + "asdf-2.10.0-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "depends": [ + "asdf-standard >=1.0.1", + "asdf-transform-schemas >=0.2.2", + "importlib_resources >=3", + "jmespath >=0.6.2", + "jsonschema >=3.0.2,<4", + "numpy >=1.10", + "packaging >=16.0", + "python >=3.7", + "pyyaml >=3.10", + "semantic_version >=2.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "0c1a649286d117a8eb5a27fbb7a1dd20", + "name": "asdf", + "noarch": "python", + "sha256": "c11e30926195293af18144ebbf276766b75f2030c12ea89c1386c02a306b3936", + "size": 330344, + "subdir": "noarch", + "timestamp": 1646330540670, + "version": "2.10.0" + }, + "asdf-standard-1.0.3-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "importlib-resources >=3", + "python >=3.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2ca9474f64f29a1c2f9cef1462fb99e4", + "name": "asdf-standard", + "noarch": "python", + "sha256": "e190f2331114c9d79f7aa061d868febb3dce72548d8621f0232d638e887c8d9b", + "size": 33929, + "subdir": "noarch", + "timestamp": 1660057725525, + "version": "1.0.3" + }, + "asdf-transform-schemas-0.3.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "asdf-standard >=1.0.1", + "importlib-resources >=3", + "python >=3.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "e704e9d7f580868d1d3045faf146be19", + "name": "asdf-transform-schemas", + "noarch": "python", + "sha256": "3715c8401a797c82f321edbd019054d101e46d7606cbcb193987a5ee89b16a04", + "size": 56488, + "subdir": "noarch", + "timestamp": 1661279521913, + "version": "0.3.0" + }, + "asdf-unit-schemas-0.1.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "asdf-standard >=1.0.1", + "importlib-resources >=3", + "python >=3.8" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "ece19e23ba5e35a7125016ce61abab45", + "name": "asdf-unit-schemas", + "noarch": "python", + "sha256": "a0942c94ea3f98d002e9f1ea6111de41f63ecde675a0c84057bde21d6c8ac037", + "size": 10917, + "subdir": "noarch", + "timestamp": 1665649806678, + "version": "0.1.0" + }, + "asdf-wcs-schemas-0.1.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "asdf >=2.8.0", + "importlib_resources >=3", + "python >=3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "938f5d01c8814a02783a2b489d881cd4", + "name": "asdf-wcs-schemas", + "noarch": "python", + "sha256": "a47e02083132fce84f0d7c02e58d674d68d86a31906f1cfb263382b396a8f350", + "size": 16765, + "subdir": "noarch", + "timestamp": 1650659359732, + "version": "0.1.1" + }, + "asdfghjkl-0.1a2-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "pytorch >=1.9.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "62abf290e96db18a7f1008a06ad4395b", + "name": "asdfghjkl", + "noarch": "python", + "sha256": "092377cbda14cdeff83c67c57b5f2f4239b20fcb965a19e74425b30cfbb66ae5", + "size": 33290, + "subdir": "noarch", + "timestamp": 1636368441091, + "version": "0.1a2" + }, + "ase-3.19.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "flask", + "matplotlib", + "numpy", + "python >=3.5", + "scipy" + ], + "license": "LGPL-2.1+", + "md5": "ef67a54b23da25b286e0175e56b54b34", + "name": "ase", + "noarch": "python", + "sha256": "da8423c52b3f30081c007ac21016baf532847437cce7823c657b59c71f502bdd", + "size": 1620076, + "subdir": "noarch", + "timestamp": 1576601913296, + "version": "3.19.0" + }, + "ase-3.19.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "flask", + "matplotlib-base", + "numpy", + "python >=3.5", + "scipy" + ], + "license": "LGPL-2.1-or-later", + "md5": "f9728b6e4a56ba7fbf63a6ec1857a6fb", + "name": "ase", + "noarch": "python", + "sha256": "d77292ad815070b608462cafe030c4c2a2d91a6aa5b50fe4f89304afcc334bda", + "size": 1608527, + "subdir": "noarch", + "timestamp": 1586095897254, + "version": "3.19.1" + }, + "ase-3.22.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "flask", + "matplotlib-base", + "numpy", + "python >=3.5", + "scipy" + ], + "license": "LGPL-2.1-or-later", + "md5": "9bc518949d4a5e3c4d70b90ed2260bcb", + "name": "ase", + "noarch": "python", + "sha256": "7ca3deb96f7cd0d43053d4ce336219b2f6be46559fc4605f48639d9670cb1712", + "size": 1644735, + "subdir": "noarch", + "timestamp": 1638383283679, + "version": "3.22.1" + }, + "ase-3.22.1-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "depends": [ + "flask", + "matplotlib-base", + "numpy", + "python >=3.5", + "scipy" + ], + "license": "LGPL-2.1-or-later", + "md5": "9f83f7881be9083630c532b5b3208a7d", + "name": "ase", + "noarch": "python", + "sha256": "93f1a4c4d8cc0e176a52c761a32e0be7f28f6b07bc985d5a4dc1ddd7b4f24239", + "size": 1646559, + "subdir": "noarch", + "timestamp": 1638384447509, + "version": "3.22.1" + }, + "ase-notebook-0.3.2-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "ase >=3.18,<4", + "attrs >=19,<20", + "importlib_resources >=1,<2", + "ipywidgets >=7.5,<8", + "matplotlib-base >=3.1,<4", + "numpy >=1.16", + "python >=3.5", + "pythreejs >=2.1,<3", + "svgutils >=0.3,<0.4", + "svgwrite >=1.3,<2" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "225b1290df2e76429da31f4b231845a3", + "name": "ase-notebook", + "noarch": "python", + "sha256": "218ce3d9f6f37c9b18532f243a7f7122e5a828d2bae5c6a9e3b32ae813e292dc", + "size": 46246, + "subdir": "noarch", + "timestamp": 1586434165673, + "version": "0.3.2" + }, + "asgi-csrf-0.9-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "itsdangerous", + "python >=3.6", + "python-multipart" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "eae21b40ce9beded0ce0e5c67180b1e7", + "name": "asgi-csrf", + "noarch": "python", + "sha256": "9e8d86083dac575490045e570147ff44879aa8412dafa04cff3e539f77eb263f", + "size": 15148, + "subdir": "noarch", + "timestamp": 1624496306542, + "version": "0.9" + }, + "asgiref-3.5.2-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "typing_extensions" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "cea70257c4c605a4417632ba6cb3a20a", + "name": "asgiref", + "noarch": "python", + "sha256": "9dd2b251410d3c50406fa5262826e8c392803a12490e25af342d9f9cb8cda4ea", + "size": 22725, + "subdir": "noarch", + "timestamp": 1652752139617, + "version": "3.5.2" + }, + "asks-3.0.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "anyio", + "async_generator", + "h11", + "python >=3.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "92ab84acf5b0d4301c5ab7b1ad99854c", + "name": "asks", + "noarch": "python", + "sha256": "703d49d15679f908587964f83271a50e75abfe7542262799084d8e6e34e6e3d6", + "size": 24468, + "subdir": "noarch", + "timestamp": 1648902581092, + "version": "3.0.0" + }, + "asn1crypto-1.5.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f3f2ab3ce28979a24d1a988ba211eb9b", + "name": "asn1crypto", + "noarch": "python", + "sha256": "1354731d0eb1b406b66b3cb3d6ab74d7cbe9c0ec1d30b9e5afa366d4539e4687", + "size": 81077, + "subdir": "noarch", + "timestamp": 1647369241204, + "version": "1.5.1" + }, + "aspy-0.4.2-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "isodate", + "python >=3.6" + ], + "license": "LGPL-3.0-or-later", + "license_family": "LGPL", + "md5": "b8973df39e14016bbed2ef8cd0bbddf0", + "name": "aspy", + "noarch": "python", + "sha256": "690f2b45957518e2f23e8102092f5dd43c71577168327bbb0810979f6c7dd86e", + "size": 11554, + "subdir": "noarch", + "timestamp": 1588885403045, + "version": "0.4.2" + }, + "aspy.refactor-imports-2.1.1-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "cached-property", + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4194676a7860903b5b4ced6aaf36991", + "name": "aspy.refactor-imports", + "noarch": "python", + "sha256": "32d305247b09774701156d2adf1d142030346ef5d2dbfa221fd4005c80c09f55", + "size": 10379, + "subdir": "noarch", + "timestamp": 1588890362404, + "version": "2.1.1" + }, + "aspy.yaml-1.3.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python", + "pyyaml" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "5ef2908a752797ce71d33dc84517c680", + "name": "aspy.yaml", + "noarch": "python", + "sha256": "bfc8a482ba07bc9f46a8f2870cc3cc417c4ebb750bb4acb91a4844df41aeadd7", + "size": 6758, + "subdir": "noarch", + "timestamp": 1558641601130, + "version": "1.3.0" + }, + "asr-0.4.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "ase", + "click >=7.0", + "flask", + "matplotlib-base", + "phonopy", + "plotly", + "pymatgen", + "python >=3.5", + "spglib" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "0a512a23202524965ef25ab8d429461b", + "name": "asr", + "noarch": "python", + "sha256": "adf57d07f5938a79c3c45f407af581366215787d73190f7999fa332cda3ad6f1", + "size": 191842, + "subdir": "noarch", + "timestamp": 1616526620566, + "version": "0.4.1" + }, + "assembly_stats-0.1.4-pyh5ca1d4c_0.tar.bz2": { + "build": "pyh5ca1d4c_0", + "build_number": 0, + "depends": [ + "numpy", + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "81c0082dfae23a24c744b171b6a8b72d", + "name": "assembly_stats", + "noarch": "python", + "sha256": "1240ccc30e34246a3b2c5abf99fff3ac4c684615f1154fcb69a642c5f19f8221", + "size": 7779, + "subdir": "noarch", + "timestamp": 1577462115781, + "version": "0.1.4" + }, + "assertpy-1.1-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "BSD 3-Clause", + "md5": "c34b8235b261232b7500009cced2663e", + "name": "assertpy", + "noarch": "python", + "sha256": "df2af8d80193b312774fc4023612724b2efa1d1b158fe7ee9c99137099954091", + "size": 24677, + "subdir": "noarch", + "timestamp": 1595172172287, + "version": "1.1" + }, + "asset-0.6.13-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "aadict >=0.2.2", + "globre >=0.1.5", + "python", + "six >=1.10.0" + ], + "license": "GPL-3.0-or-later", + "license_family": "GPL", + "md5": "182bb9f46d6f19506d5453abc20d53ec", + "name": "asset", + "noarch": "python", + "sha256": "e9684d4b5dc70e3516f99e90a370f046148e15d79f7c66f9b3cec6343dd9bbec", + "size": 31456, + "subdir": "noarch", + "timestamp": 1602618210167, + "version": "0.6.13" + }, + "assetid-1.0.0-py_1.tar.bz2": { + "build": "py_1", + "build_number": 1, + "depends": [ + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "26affc221731c79da3c469bcc21a211c", + "name": "assetid", + "noarch": "python", + "sha256": "bd4182fc572c675f1a986b4c66671a1d50a5fb1d3c0bf0cf40bc7c5495ef1919", + "size": 8356, + "subdir": "noarch", + "timestamp": 1531795617786, + "version": "1.0.0" + }, + "ast-selector-0.2.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6,<4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "a4410fe9053e8cc8029397506af188c6", + "name": "ast-selector", + "noarch": "python", + "sha256": "451310af579ef6669d920f04a4cc297e47a10bd5fab8d84ea21996be71e68b14", + "size": 10853, + "subdir": "noarch", + "timestamp": 1658615146277, + "version": "0.2.0" + }, + "astcheck-0.3.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "db1a4c5c72d60797e502df84829e4143", + "name": "astcheck", + "noarch": "python", + "sha256": "1b8f6f6929431d805765297fbc63274374351a84f4d0444bcd4412d4bb9d0868", + "size": 8712, + "subdir": "noarch", + "timestamp": 1625654702414, + "version": "0.3.0" + }, + "astmonkey-0.3.6-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "pydot", + "python >=3.6" + ], + "license": "Apache-2.0", + "license_family": "APACHE", + "md5": "baa896a2d8257bb6963d2e245ff6440f", + "name": "astmonkey", + "noarch": "python", + "sha256": "f86092923dd49cbf7f197d6f4ad75d4c32f7c9108c8a837e11be133c1a856b4b", + "size": 13391, + "subdir": "noarch", + "timestamp": 1636145796015, + "version": "0.3.6" + }, + "astor-0.8.1-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "6ae770689be59dc391ef974d2e849b56", + "name": "astor", + "noarch": "python", + "sha256": "cb4ae0e3055907983f21a24dc2ac47d5a77d7c1dd98b1e21fed06956437e52c7", + "size": 25792, + "subdir": "noarch", + "timestamp": 1593610550883, + "version": "0.8.1" + }, + "astpretty-2.1.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "13400f2184854dc5d3ff2b9c89af50ec", + "name": "astpretty", + "noarch": "python", + "sha256": "a4c695c0dcf317858d8b5f4dfe0a3378a76bcac597f7648dc85c1b8be700de1b", + "size": 9037, + "subdir": "noarch", + "timestamp": 1609497125592, + "version": "2.1.0" + }, + "astral-2.2-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "pytz", + "requests" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "ad1fbffed870820569b10d407f5f5e89", + "name": "astral", + "noarch": "python", + "sha256": "d9260ed7b935d6de6cbcd19820ea629127c7eeb500829eab5be0fe9001f4c5a6", + "size": 32059, + "subdir": "noarch", + "timestamp": 1632617758272, + "version": "2.2" + }, + "astral-2.2-pyhd8ed1ab_1.tar.bz2": { + "build": "pyhd8ed1ab_1", + "build_number": 1, + "depends": [ + "dataclasses", + "python >=3.6", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e2d7c6fa7d56fc5b67a6747242490c11", + "name": "astral", + "noarch": "python", + "sha256": "7f09572136f6bc16f3a1bdbe5ffe65fe20d36129a8c8fe6ce52b39578294e45b", + "size": 32056, + "subdir": "noarch", + "timestamp": 1632623839247, + "version": "2.2" + }, + "astral-3.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "dataclasses", + "python >=3.6", + "pytz" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "e0044c568dfb5677bc9d77622d5c2ff3", + "name": "astral", + "noarch": "python", + "sha256": "5607fed094385d244d9f57b0633278b6dd8b62448e771d719267d2bea4d9a4f3", + "size": 39175, + "subdir": "noarch", + "timestamp": 1665245958983, + "version": "3.0" + }, + "astroalign-2.4.1-pyh6c4a22f_0.tar.bz2": { + "build": "pyh6c4a22f_0", + "build_number": 0, + "depends": [ + "numpy >=1.6.2", + "python >=3.5", + "scikit-image", + "scipy >=0.15", + "sep" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "04d40739d805eef41132f3aab2357be3", + "name": "astroalign", + "noarch": "python", + "sha256": "3b5bb2ddcf56215aac63b97f1f39807ca65e991aac0f537cb1cf32b3a7a15d45", + "size": 17346, + "subdir": "noarch", + "timestamp": 1645020488875, + "version": "2.4.1" + }, + "astrocats-0.3.37-py_0.tar.bz2": { + "arch": null, + "build": "py_0", + "build_number": 0, + "depends": [ + "ads", + "astropy <3.0", + "beautifulsoup4", + "bokeh", + "future", + "gitpython", + "inflect", + "palettable", + "psutil", + "python", + "seaborn", + "tqdm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d9f18d365bddf6e780bf4543cff124a9", + "name": "astrocats", + "noarch": "python", + "platform": null, + "sha256": "05d37b18f1f33677a4cd1d947a381262c87571319f614e3ce223f3822a3b0510", + "size": 91203, + "subdir": "noarch", + "timestamp": 1529888005389, + "version": "0.3.37" + }, + "astrocats-0.3.37-py_1.tar.bz2": { + "build": "py_1", + "build_number": 1, + "depends": [ + "ads", + "astropy", + "beautifulsoup4", + "bokeh", + "future", + "gitpython", + "inflect", + "palettable", + "psutil", + "python", + "seaborn", + "tqdm" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "f2d325cbd9178748b0faf2f1aef527fd", + "name": "astrocats", + "noarch": "python", + "sha256": "18a5f1c94af856c7b4a8172b83bbffed3d7a2b1178a86a19e15da2fa2bbc25be", + "size": 94382, + "subdir": "noarch", + "timestamp": 1537653186568, + "version": "0.3.37" + }, + "astroedu-0.4.3a0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "fire >=0.4.0", + "importlib-resources >=5.1.2", + "ipywidgets >=7.6.0", + "jupyterlab >=3.0.0", + "matplotlib-base >=3.3.0", + "numpy >=1.20.0", + "pandas >=1.1", + "python >=3.7", + "scipy >=1.6.0" + ], + "license": "AGPL-3.0-or-later", + "license_family": "AGPL", + "md5": "ce7c91c90537d771a585d0f07c712514", + "name": "astroedu", + "noarch": "python", + "sha256": "686e00ea8ac3593c758b76f30e84df12cbee7b084b7523d75c7eeca076d477cd", + "size": 158586, + "subdir": "noarch", + "timestamp": 1649950189038, + "version": "0.4.3a0" + }, + "astroml-1.0.2.post1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "astropy >3", + "matplotlib-base >=3", + "numpy >=1.13", + "python >=3.6", + "scikit-learn >=0.18", + "scipy >=0.18" + ], + "license": "BSD-2-Clause", + "license_family": "BSD", + "md5": "efb4c0711c28ebe00675f32b56860d84", + "name": "astroml", + "noarch": "python", + "sha256": "5f4c85b6305ff0724adb708c962b59b02b68d95cc33c8adea8409163fe47db31", + "size": 94073, + "subdir": "noarch", + "timestamp": 1646194409050, + "version": "1.0.2.post1" + }, + "astropy-helpers-4.0.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb65a41800295de95124b2611ae6aca5", + "name": "astropy-helpers", + "noarch": "python", + "sha256": "e0697c9123b997404fcf42770e85fda829a3fca8c105b5ef6ec83df7c15e3ef1", + "size": 33190, + "subdir": "noarch", + "timestamp": 1576538005864, + "version": "4.0.1" + }, + "astropy-sphinx-theme-1.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "BSD", + "md5": "1190bec6b78aaf8e602e8fc829ce7b3f", + "name": "astropy-sphinx-theme", + "noarch": "python", + "sha256": "67bb76dc046e5ede5d51bd71cec326a463b4684ade659e347807c17655436bfc", + "size": 31770, + "subdir": "noarch", + "timestamp": 1556185512793, + "version": "1.1" + }, + "astroquery-0.4.6-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "astropy >=3.1.2", + "beautifulsoup4 >=4.3.2", + "html5lib >=0.999", + "keyring >=4.0", + "numpy >=1.15.0", + "python >=3.7", + "pyvo >=1.1", + "requests >=2.4.3" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "c87214674eb094465c824a07e22ce922", + "name": "astroquery", + "noarch": "python", + "sha256": "953ee6800d9f68b997717bd3d7b32fb0bee0c6eef6be2bb53f6f70ea0a65e38c", + "size": 3953129, + "subdir": "noarch", + "timestamp": 1648038039893, + "version": "0.4.6" + }, + "astsearch-0.2.0-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "astcheck", + "python" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "6dd5a7cc6230317688e4aaf4a85d09a7", + "name": "astsearch", + "noarch": "python", + "sha256": "702577bdead42e51d4527b3677a1f634af44d89daefcb60bc157623c83d50cfc", + "size": 10761, + "subdir": "noarch", + "timestamp": 1597152943294, + "version": "0.2.0" + }, + "asttokens-2.0.4-pyh9f0ad1d_0.tar.bz2": { + "build": "pyh9f0ad1d_0", + "build_number": 0, + "depends": [ + "python", + "six" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "540220eb33e3056af7f80094d6a89623", + "name": "asttokens", + "noarch": "python", + "sha256": "3d1ac2f675420ca8480da5cd4c5219609ce62c04eaf71dd10b435238442bca41", + "size": 21073, + "subdir": "noarch", + "timestamp": 1586659590018, + "version": "2.0.4" + }, + "astunparse-1.6.3-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "six >=1.6.1,<2.0" + ], + "license": "BSD-3-Clause AND PSF-2.0", + "md5": "000b6f68a0bfaba800ced7500c11780f", + "name": "astunparse", + "noarch": "python", + "sha256": "e5173d1ed038038e24c0623f0219dc587ee8663cf7efa737e7075128edbc6c60", + "size": 15539, + "subdir": "noarch", + "timestamp": 1610696401707, + "version": "1.6.3" + }, + "async-3.1.0-0.tar.bz2": { + "build": "0", + "build_number": 0, + "depends": [], + "license": "MIT", + "license_family": "MIT", + "md5": "8b453467d824f642b1397e6a8f2cc857", + "name": "async", + "noarch": "generic", + "sha256": "3f137b9cbfda6e20c70ebe18c895b119c3d4cd6aab6ec1af03f9b86214f15486", + "size": 1008956, + "subdir": "noarch", + "timestamp": 1561960140105, + "version": "3.1.0" + }, + "async-exit-stack-1.0.1-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.5" + ], + "license": "BSD-4-Clause", + "md5": "c76151135c040e151b2ab21d3b7636fd", + "name": "async-exit-stack", + "noarch": "python", + "sha256": "25ef477d4de8a71404e1c7fc39ad06dbc7dd9e65041c037ffe649dfc2fd16d2b", + "size": 9479, + "subdir": "noarch", + "timestamp": 1617751273877, + "version": "1.0.1" + }, + "async-timeout-3.0.1-py_1000.tar.bz2": { + "build": "py_1000", + "build_number": 1000, + "depends": [ + "python >=3.5.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "8b11024b2762a07aaa07d2743231a41b", + "name": "async-timeout", + "noarch": "python", + "sha256": "a75ea30a49aefa0ce3e9dc1678ef8d2c1b35a3c17979c2a7c3911b6466735d70", + "size": 11510, + "subdir": "noarch", + "timestamp": 1541967111278, + "version": "3.0.1" + }, + "async-timeout-4.0.2-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6", + "typing-extensions >=3.6.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "25e79f9a1133556671becbd65a170c78", + "name": "async-timeout", + "noarch": "python", + "sha256": "a08b78e6fadee1ffac0f255363d2a08a0c589c7403fd2a71c1c0b6aafd5e0737", + "size": 9300, + "subdir": "noarch", + "timestamp": 1640026786670, + "version": "4.0.2" + }, + "async_generator-1.10-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python >2.7" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "d56c596e61b1c4952acf0a9920856c12", + "name": "async_generator", + "noarch": "python", + "sha256": "b45a479387f9eab020da572f87f37d55182e5b41c21a7851d6fc7dcb635a3cf0", + "size": 18014, + "subdir": "noarch", + "timestamp": 1533114627495, + "version": "1.10" + }, + "async_timeout-3.0.1-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python >=3.5.3" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "25ab3f1e467a0bb2067b78f2cf2a4193", + "name": "async_timeout", + "noarch": "python", + "sha256": "530d5a9e71fc0d5d62d52410ac1b428e4030102270ea35d4d38fcd48405216c7", + "size": 9872, + "subdir": "noarch", + "timestamp": 1539642356832, + "version": "3.0.1" + }, + "asyncer-0.0.2-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "anyio >=3.4.0,<4.0.0", + "python >=3.6,<4.0" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "508d80e6c11116ff0fd5d74733f9c7ed", + "name": "asyncer", + "noarch": "python", + "sha256": "1ca7634962a3c9c5cd021acee582e6d9519b4225fb6e297ad1fa5e5a16366fb2", + "size": 12471, + "subdir": "noarch", + "timestamp": 1667642098871, + "version": "0.0.2" + }, + "asyncinit-0.2.4-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.5" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "71ce2460130935bba53494a5a1b121e2", + "name": "asyncinit", + "noarch": "python", + "sha256": "f9c9e08326b9e9a0fed4f260e163a6702befa0da3410beb17964a1bf485f38cf", + "size": 6885, + "subdir": "noarch", + "timestamp": 1611347247665, + "version": "0.2.4" + }, + "asyncio-helpers-0.4.2-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "logging-helpers", + "python >=2.7,<3.7", + "trollius" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "fb3fefee6ad579a0956163a2257231c4", + "name": "asyncio-helpers", + "noarch": "python", + "sha256": "cc8de228b7a0eea46f6bea7a5f3c385f6ca0e06f19bf706795246b660ef2ba3d", + "size": 9139, + "subdir": "noarch", + "timestamp": 1562602005111, + "version": "0.4.2" + }, + "asyncio-helpers-0.4.2-pyhd8ed1ab_2.tar.bz2": { + "build": "pyhd8ed1ab_2", + "build_number": 2, + "depends": [ + "logging-helpers", + "python >=3.6" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "5a4d1693f385a1801e525159a67b2bcf", + "name": "asyncio-helpers", + "noarch": "python", + "sha256": "c1ec15f6ae86d2a69e64e7911a9b28d3e352790f0620b3f4b35343b3becc83ef", + "size": 10385, + "subdir": "noarch", + "timestamp": 1667374877555, + "version": "0.4.2" + }, + "asyncio-throttle-1.0.2-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "python >=3.6" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "1f43d794aeb4452c30a35b6ca5636cb3", + "name": "asyncio-throttle", + "noarch": "python", + "sha256": "f0cf53ad9a4246e37ba3ef3b545c78ab8c3c09371dafdbcd32a18196a98bb4ac", + "size": 8305, + "subdir": "noarch", + "timestamp": 1666595829348, + "version": "1.0.2" + }, + "asyncqt-0.8.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "constrains": [ + "pyside2", + "pyqt >=5" + ], + "depends": [ + "python >=3.5" + ], + "license": "BSD", + "license_family": "BSD", + "md5": "b89979dfea307f1d535437fcf77b17fd", + "name": "asyncqt", + "noarch": "python", + "sha256": "f9d0f02f588d86a48fcd0da759e8cc9d09d0f09c296645d9b4297a41cb830aa9", + "size": 14403, + "subdir": "noarch", + "timestamp": 1585490214126, + "version": "0.8.0" + }, + "asynctest-0.13.0-py_0.tar.bz2": { + "build": "py_0", + "build_number": 0, + "depends": [ + "python >=3.5" + ], + "license": "Apache-2.0", + "license_family": "Apache", + "md5": "b0e68312b9cdf1696f49c454d4864dfd", + "name": "asynctest", + "noarch": "python", + "sha256": "c09fb3080c207b42a394b4fd472c01d278cc256e9b07359fd7faee647d4a3105", + "size": 24963, + "subdir": "noarch", + "timestamp": 1587732345842, + "version": "0.13.0" + }, + "at-spi-cos6-x86_64-1.28.1-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "atk-cos6-x86_64 >=1.13.0 *_105", + "gtk2-cos6-x86_64 >=2.10.0 *_105", + "libbonobo-cos6-x86_64 >=2.4.0 *_105", + "orbit2-cos6-x86_64 >=2.6.0 *_105" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "51ef2ed29d4f1f2718e4d85479d9eadb", + "name": "at-spi-cos6-x86_64", + "noarch": "generic", + "sha256": "f41fb23548d54a45cc4640e4823fce84350d5716bfd739f2b7925aed08df8ba9", + "size": 244287, + "subdir": "noarch", + "timestamp": 1627484989375, + "version": "1.28.1" + }, + "at-spi-cos6-x86_64-1.28.1-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "atk-cos6-x86_64 >=1.13.0 *_1105", + "gtk2-cos6-x86_64 >=2.10.0 *_1105", + "libbonobo-cos6-x86_64 >=2.4.0 *_1105", + "orbit2-cos6-x86_64 >=2.6.0 *_1105", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "91f4c19b1163b6ba9f47bb9888ccfaa2", + "name": "at-spi-cos6-x86_64", + "noarch": "generic", + "sha256": "d894b49c00d35cd2e58d25282f020bcc7d0e02ecbf3bc05dd1bd2c5750aee3d0", + "size": 244296, + "subdir": "noarch", + "timestamp": 1627487673937, + "version": "1.28.1" + }, + "at-spi-cos6-x86_64-1.28.1-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "atk-cos6-x86_64 >=1.13.0 *_104", + "gtk2-cos6-x86_64 >=2.10.0 *_104", + "gtk2-cos6-x86_64 >=2.24.23 *_104", + "libbonobo-cos6-x86_64 >=2.4.0 *_104", + "orbit2-cos6-x86_64 >=2.6.0 *_104" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "a937ce03ef7a570d275cb101f3e8405b", + "name": "at-spi-cos6-x86_64", + "noarch": "generic", + "sha256": "c6a86f211d1c960bdd403802d424eaa48b4fd4c2a231a269da2474d7e4b90c57", + "size": 241511, + "subdir": "noarch", + "timestamp": 1596323322248, + "version": "1.28.1" + }, + "at-spi-cos6-x86_64-1.28.1-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "atk-cos6-x86_64 >=1.13.0 *_1104", + "gtk2-cos6-x86_64 >=2.10.0 *_1104", + "gtk2-cos6-x86_64 >=2.24.23 *_1104", + "libbonobo-cos6-x86_64 >=2.4.0 *_1104", + "orbit2-cos6-x86_64 >=2.6.0 *_1104", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "8b732a738808752d6d5cbbef7355f365", + "name": "at-spi-cos6-x86_64", + "noarch": "generic", + "sha256": "d132309091e17cc7f5806ad286473c9ec85edac85c377d3cb10c3a6a3b9e42d8", + "size": 241678, + "subdir": "noarch", + "timestamp": 1596325460712, + "version": "1.28.1" + }, + "at-spi-cos6-x86_64-1.28.1-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "atk-cos6-x86_64 >=1.13.0 *_103", + "gtk2-cos6-x86_64 >=2.10.0 *_103", + "gtk2-cos6-x86_64 >=2.24.23 *_103", + "libbonobo-cos6-x86_64 >=2.4.0 *_103", + "orbit2-cos6-x86_64 >=2.6.0 *_103" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "85af1bf53058c24112e257285af6a9ea", + "name": "at-spi-cos6-x86_64", + "noarch": "generic", + "sha256": "f98dd20305803d6d70a464482648d351f891328180086dac009a537b0e34f5b9", + "size": 241551, + "subdir": "noarch", + "timestamp": 1595460553461, + "version": "1.28.1" + }, + "at-spi-cos6-x86_64-1.28.1-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "atk-cos6-x86_64 >=1.13.0 *_1103", + "gtk2-cos6-x86_64 >=2.10.0 *_1103", + "gtk2-cos6-x86_64 >=2.24.23 *_1103", + "libbonobo-cos6-x86_64 >=2.4.0 *_1103", + "orbit2-cos6-x86_64 >=2.6.0 *_1103", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "05547f4dad9a8e81a12d15d39f84044d", + "name": "at-spi-cos6-x86_64", + "noarch": "generic", + "sha256": "aa7c8cf1c8ab058b8b0d72839833b73004bfcba6fe878ae6a815d9a507c2b104", + "size": 241681, + "subdir": "noarch", + "timestamp": 1595462356820, + "version": "1.28.1" + }, + "at-spi-cos6-x86_64-1.28.1-hdf0574f_102.tar.bz2": { + "build": "hdf0574f_102", + "build_number": 102, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "atk-cos6-x86_64 >=1.13.0 *_102", + "gtk2-cos6-x86_64 >=2.10.0 *_102", + "gtk2-cos6-x86_64 >=2.24.23 *_102", + "libbonobo-cos6-x86_64 >=2.4.0 *_102", + "orbit2-cos6-x86_64 >=2.6.0 *_102" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "da9f1b6b86eda477745d98a833b8f1a8", + "name": "at-spi-cos6-x86_64", + "noarch": "generic", + "sha256": "08c391a8ba1049d97b45312b8923d45c830f02987a461674ba731bc49f7f2c21", + "size": 241343, + "subdir": "noarch", + "timestamp": 1595254502731, + "version": "1.28.1" + }, + "at-spi-cos6-x86_64-1.28.1-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "atk-cos6-x86_64 >=1.13.0 *_1102", + "gtk2-cos6-x86_64 >=2.10.0 *_1102", + "gtk2-cos6-x86_64 >=2.24.23 *_1102", + "libbonobo-cos6-x86_64 >=2.4.0 *_1102", + "orbit2-cos6-x86_64 >=2.6.0 *_1102", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "93c28691166ed59bb8ba4d0d8f99e954", + "name": "at-spi-cos6-x86_64", + "noarch": "generic", + "sha256": "f2bddd23c1bdff02cc81d2baa36bb8d89ba1e091de711ff0589c9e682447c28b", + "size": 241383, + "subdir": "noarch", + "timestamp": 1595255036571, + "version": "1.28.1" + }, + "at-spi-cos7-aarch64-1.32.0-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "atk-cos7-aarch64 >=1.29.2 *_105", + "gtk2-cos7-aarch64 >=2.10.0 *_105", + "libbonobo-cos7-aarch64 >=2.4.0 *_105", + "orbit2-cos7-aarch64 >=2.6.0 *_105" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "2d31e1f766b4e1fe363365cdee82abe0", + "name": "at-spi-cos7-aarch64", + "noarch": "generic", + "sha256": "07157e7e50b857eadfe4505ede1eb190170c40c658826412b6f9ebf39083727c", + "size": 274792, + "subdir": "noarch", + "timestamp": 1627489033045, + "version": "1.32.0" + }, + "at-spi-cos7-aarch64-1.32.0-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "atk-cos7-aarch64 >=1.29.2 *_1105", + "gtk2-cos7-aarch64 >=2.10.0 *_1105", + "libbonobo-cos7-aarch64 >=2.4.0 *_1105", + "orbit2-cos7-aarch64 >=2.6.0 *_1105", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "d9387756e88636e3e0dd17cdb43f2f72", + "name": "at-spi-cos7-aarch64", + "noarch": "generic", + "sha256": "ac8d93f0fca0a43a365fa19598fa0bc4fca5e1f6d96ccb9c61f93731018a0cfc", + "size": 271819, + "subdir": "noarch", + "timestamp": 1627542280914, + "version": "1.32.0" + }, + "at-spi-cos7-aarch64-1.32.0-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "atk-cos7-aarch64 >=1.29.2 *_104", + "gtk2-cos7-aarch64 >=2.10.0 *_104", + "gtk2-cos7-aarch64 >=2.24.31 *_104", + "libbonobo-cos7-aarch64 >=2.4.0 *_104", + "orbit2-cos7-aarch64 >=2.6.0 *_104" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "4a6c37703cadfa54483898dd6afa24d0", + "name": "at-spi-cos7-aarch64", + "noarch": "generic", + "sha256": "90a7c07b6b5011b9a2fbcd3230b0346d94310948b8ac76a8b1503a14ba050bfa", + "size": 267658, + "subdir": "noarch", + "timestamp": 1596324269877, + "version": "1.32.0" + }, + "at-spi-cos7-aarch64-1.32.0-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "atk-cos7-aarch64 >=1.29.2 *_1104", + "gtk2-cos7-aarch64 >=2.10.0 *_1104", + "gtk2-cos7-aarch64 >=2.24.31 *_1104", + "libbonobo-cos7-aarch64 >=2.4.0 *_1104", + "orbit2-cos7-aarch64 >=2.6.0 *_1104", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "2f7b76ea5a5ce4fa62b476f5565083b3", + "name": "at-spi-cos7-aarch64", + "noarch": "generic", + "sha256": "fac91a3e2d23407fb29092b407b3aab727f0d593d1706a8d7bb1a0f4d8095fd5", + "size": 259676, + "subdir": "noarch", + "timestamp": 1596327275405, + "version": "1.32.0" + }, + "at-spi-cos7-aarch64-1.32.0-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "atk-cos7-aarch64 >=1.29.2 *_103", + "gtk2-cos7-aarch64 >=2.10.0 *_103", + "gtk2-cos7-aarch64 >=2.24.31 *_103", + "libbonobo-cos7-aarch64 >=2.4.0 *_103", + "orbit2-cos7-aarch64 >=2.6.0 *_103" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "c1c25046c56bf35ed9d3a97bdfc967ff", + "name": "at-spi-cos7-aarch64", + "noarch": "generic", + "sha256": "9086d5a1b0735598ca577f037a5b5b0bd7dd63d853f6092b75af036153f93751", + "size": 261113, + "subdir": "noarch", + "timestamp": 1595460351293, + "version": "1.32.0" + }, + "at-spi-cos7-aarch64-1.32.0-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "atk-cos7-aarch64 >=1.29.2 *_1103", + "gtk2-cos7-aarch64 >=2.10.0 *_1103", + "gtk2-cos7-aarch64 >=2.24.31 *_1103", + "libbonobo-cos7-aarch64 >=2.4.0 *_1103", + "orbit2-cos7-aarch64 >=2.6.0 *_1103", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "65ff0d67535a9311f51ab3da5c37ae5d", + "name": "at-spi-cos7-aarch64", + "noarch": "generic", + "sha256": "80d0defb314ec251492fbc6282491717f173bd612fa1cd168f52cb5465200ff3", + "size": 258951, + "subdir": "noarch", + "timestamp": 1595461865259, + "version": "1.32.0" + }, + "at-spi-cos7-aarch64-1.32.0-hdf0574f_102.tar.bz2": { + "build": "hdf0574f_102", + "build_number": 102, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "atk-cos7-aarch64 >=1.29.2 *_102", + "gtk2-cos7-aarch64 >=2.10.0 *_102", + "gtk2-cos7-aarch64 >=2.24.31 *_102", + "libbonobo-cos7-aarch64 >=2.4.0 *_102", + "orbit2-cos7-aarch64 >=2.6.0 *_102" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "3260c303b2c223d7285a2c76e1c58240", + "name": "at-spi-cos7-aarch64", + "noarch": "generic", + "sha256": "d89c7b4f591d9d26fef372e2d9191ff8e21f6bd10a607f10dcdc657af82fe8a5", + "size": 263263, + "subdir": "noarch", + "timestamp": 1595254467935, + "version": "1.32.0" + }, + "at-spi-cos7-aarch64-1.32.0-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "atk-cos7-aarch64 >=1.29.2 *_1102", + "gtk2-cos7-aarch64 >=2.10.0 *_1102", + "gtk2-cos7-aarch64 >=2.24.31 *_1102", + "libbonobo-cos7-aarch64 >=2.4.0 *_1102", + "orbit2-cos7-aarch64 >=2.6.0 *_1102", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "6aadf6947a777785aa07c63af2b38449", + "name": "at-spi-cos7-aarch64", + "noarch": "generic", + "sha256": "1c712c124f23ad1b7084951fa234168e68a2a91828e7ac5b90e90b80b6c6e967", + "size": 260769, + "subdir": "noarch", + "timestamp": 1595254962053, + "version": "1.32.0" + }, + "at-spi-cos7-ppc64le-1.32.0-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "atk-cos7-ppc64le >=1.29.2 *_105", + "gtk2-cos7-ppc64le >=2.10.0 *_105", + "libbonobo-cos7-ppc64le >=2.4.0 *_105", + "orbit2-cos7-ppc64le >=2.6.0 *_105" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "7aa2c55c20056f0ad879328669ec044c", + "name": "at-spi-cos7-ppc64le", + "noarch": "generic", + "sha256": "00c5c0505c4f0840262cf7d8d680fe64edcea5ac4ca70d22f7520e5f0d2d2f19", + "size": 288282, + "subdir": "noarch", + "timestamp": 1627538470723, + "version": "1.32.0" + }, + "at-spi-cos7-ppc64le-1.32.0-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "atk-cos7-ppc64le >=1.29.2 *_1105", + "gtk2-cos7-ppc64le >=2.10.0 *_1105", + "libbonobo-cos7-ppc64le >=2.4.0 *_1105", + "orbit2-cos7-ppc64le >=2.6.0 *_1105", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "ca03ecf52a181193bcc6887313f948c2", + "name": "at-spi-cos7-ppc64le", + "noarch": "generic", + "sha256": "679c75bf79d6c234ac3f161460e8f292467a0392b13c277893989f79886d92c2", + "size": 278325, + "subdir": "noarch", + "timestamp": 1627540106084, + "version": "1.32.0" + }, + "at-spi-cos7-ppc64le-1.32.0-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "atk-cos7-ppc64le >=1.29.2 *_104", + "gtk2-cos7-ppc64le >=2.10.0 *_104", + "gtk2-cos7-ppc64le >=2.24.31 *_104", + "libbonobo-cos7-ppc64le >=2.4.0 *_104", + "orbit2-cos7-ppc64le >=2.6.0 *_104" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "1171f5f532ea723a543890533dfc8259", + "name": "at-spi-cos7-ppc64le", + "noarch": "generic", + "sha256": "b7de90d9be1eb9bf4629fe6730d46fa0a32afa3633f4015d9b98fa961f433222", + "size": 285725, + "subdir": "noarch", + "timestamp": 1596323943894, + "version": "1.32.0" + }, + "at-spi-cos7-ppc64le-1.32.0-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "atk-cos7-ppc64le >=1.29.2 *_1104", + "gtk2-cos7-ppc64le >=2.10.0 *_1104", + "gtk2-cos7-ppc64le >=2.24.31 *_1104", + "libbonobo-cos7-ppc64le >=2.4.0 *_1104", + "orbit2-cos7-ppc64le >=2.6.0 *_1104", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "4870b389bba0d1b584b5b738acd679fb", + "name": "at-spi-cos7-ppc64le", + "noarch": "generic", + "sha256": "d1abee98d9478dc9387f8b990e7ee41583c9cdd215fd1bb70ef2567b437eb29b", + "size": 285114, + "subdir": "noarch", + "timestamp": 1596327644023, + "version": "1.32.0" + }, + "at-spi-cos7-ppc64le-1.32.0-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "atk-cos7-ppc64le >=1.29.2 *_103", + "gtk2-cos7-ppc64le >=2.10.0 *_103", + "gtk2-cos7-ppc64le >=2.24.31 *_103", + "libbonobo-cos7-ppc64le >=2.4.0 *_103", + "orbit2-cos7-ppc64le >=2.6.0 *_103" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "ce014fdbe7e8269daf187647d6dfc77d", + "name": "at-spi-cos7-ppc64le", + "noarch": "generic", + "sha256": "23c30cf4f6821dd53afee12a33969930223c320cd49f22900d900d24b7b02697", + "size": 285117, + "subdir": "noarch", + "timestamp": 1595459981033, + "version": "1.32.0" + }, + "at-spi-cos7-ppc64le-1.32.0-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "atk-cos7-ppc64le >=1.29.2 *_1103", + "gtk2-cos7-ppc64le >=2.10.0 *_1103", + "gtk2-cos7-ppc64le >=2.24.31 *_1103", + "libbonobo-cos7-ppc64le >=2.4.0 *_1103", + "orbit2-cos7-ppc64le >=2.6.0 *_1103", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "27e81de0fd0449235bcfc75b28de9e33", + "name": "at-spi-cos7-ppc64le", + "noarch": "generic", + "sha256": "6a5b72a99ad4d7f65f31b3e9823ce2b455523525d480534ba3ff653c72ca853b", + "size": 286006, + "subdir": "noarch", + "timestamp": 1595462619115, + "version": "1.32.0" + }, + "at-spi-cos7-ppc64le-1.32.0-hdf0574f_102.tar.bz2": { + "build": "hdf0574f_102", + "build_number": 102, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "atk-cos7-ppc64le >=1.29.2 *_102", + "gtk2-cos7-ppc64le >=2.10.0 *_102", + "gtk2-cos7-ppc64le >=2.24.31 *_102", + "libbonobo-cos7-ppc64le >=2.4.0 *_102", + "orbit2-cos7-ppc64le >=2.6.0 *_102" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "2887104a263d53b8dd03098b5bf8e067", + "name": "at-spi-cos7-ppc64le", + "noarch": "generic", + "sha256": "59765581bbf00b5a885f5b7e90c20a3cc1b7449636f51895fdf44746b99849e4", + "size": 285884, + "subdir": "noarch", + "timestamp": 1595254366747, + "version": "1.32.0" + }, + "at-spi-cos7-ppc64le-1.32.0-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "atk-cos7-ppc64le >=1.29.2 *_1102", + "gtk2-cos7-ppc64le >=2.10.0 *_1102", + "gtk2-cos7-ppc64le >=2.24.31 *_1102", + "libbonobo-cos7-ppc64le >=2.4.0 *_1102", + "orbit2-cos7-ppc64le >=2.6.0 *_1102", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "8068af6b0758c9077b6be52ab3b322ed", + "name": "at-spi-cos7-ppc64le", + "noarch": "generic", + "sha256": "43fdb15dd30074051bcc9ba751fcb4ca14dbbe829ce4d645085d1b7cab95799d", + "size": 277392, + "subdir": "noarch", + "timestamp": 1595254846071, + "version": "1.32.0" + }, + "at-spi-cos7-x86_64-1.32.0-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "atk-cos7-x86_64 >=1.29.2 *_1105", + "gtk2-cos7-x86_64 >=2.10.0 *_1105", + "libbonobo-cos7-x86_64 >=2.4.0 *_1105", + "orbit2-cos7-x86_64 >=2.6.0 *_1105", + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "b96022959a41e4c9fd05b45b3ffac65e", + "name": "at-spi-cos7-x86_64", + "noarch": "generic", + "sha256": "04c6a7ef7b485be61364baa4f4cd5077fb87da0d63c811aa1a06a70157346d33", + "size": 280350, + "subdir": "noarch", + "timestamp": 1627507430214, + "version": "1.32.0" + }, + "at-spi-cos7-x86_64-1.32.0-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "atk-cos7-x86_64 >=1.29.2 *_1104", + "gtk2-cos7-x86_64 >=2.10.0 *_1104", + "gtk2-cos7-x86_64 >=2.24.31 *_1104", + "libbonobo-cos7-x86_64 >=2.4.0 *_1104", + "orbit2-cos7-x86_64 >=2.6.0 *_1104", + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "4618ab87767e77d05d33616803c34712", + "name": "at-spi-cos7-x86_64", + "noarch": "generic", + "sha256": "447880bc7336bc3b6a6f5a8e880386ff26be68a078d0f1d15e920adbe79c9ae9", + "size": 276730, + "subdir": "noarch", + "timestamp": 1596326213164, + "version": "1.32.0" + }, + "at-spi-cos7-x86_64-1.32.0-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "atk-cos7-x86_64 >=1.29.2 *_1103", + "gtk2-cos7-x86_64 >=2.10.0 *_1103", + "gtk2-cos7-x86_64 >=2.24.31 *_1103", + "libbonobo-cos7-x86_64 >=2.4.0 *_1103", + "orbit2-cos7-x86_64 >=2.6.0 *_1103", + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "9661d2be486c72146f26fbe8e551f556", + "name": "at-spi-cos7-x86_64", + "noarch": "generic", + "sha256": "c76e56b63b6cadd691bf36aecfac50730eb7cd99af1c27b3b20984ce7d9ca9c3", + "size": 278357, + "subdir": "noarch", + "timestamp": 1595461045758, + "version": "1.32.0" + }, + "at-spi-cos7-x86_64-1.32.0-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "atk-cos7-x86_64 >=1.29.2 *_1102", + "gtk2-cos7-x86_64 >=2.10.0 *_1102", + "gtk2-cos7-x86_64 >=2.24.31 *_1102", + "libbonobo-cos7-x86_64 >=2.4.0 *_1102", + "orbit2-cos7-x86_64 >=2.6.0 *_1102", + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f7f928ec94fd41adbaead8e39823fc8f", + "name": "at-spi-cos7-x86_64", + "noarch": "generic", + "sha256": "0a1027bc99c4d22881e3131642c232506ec450d6ae000812febeada08537ba2a", + "size": 272265, + "subdir": "noarch", + "timestamp": 1595254743849, + "version": "1.32.0" + }, + "at-spi-devel-cos6-x86_64-1.28.1-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "at-spi-cos6-x86_64 ==1.28.1 *_105", + "atk-devel-cos6-x86_64 >=1.13.0 *_105", + "gtk2-devel-cos6-x86_64 >=2.10.0 *_105", + "libbonobo-devel-cos6-x86_64 >=2.4.0 *_105", + "orbit2-devel-cos6-x86_64 >=2.6.0 *_105" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "5edd50e1243954bf90c6b9657a86dc02", + "name": "at-spi-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "a49918353f3eb2f2985f91c1b7e28b7e85cef7b3c67c7bf68195b169ff19e43e", + "size": 279330, + "subdir": "noarch", + "timestamp": 1627485429251, + "version": "1.28.1" + }, + "at-spi-devel-cos6-x86_64-1.28.1-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "at-spi-cos6-x86_64 ==1.28.1 *_1105", + "atk-devel-cos6-x86_64 >=1.13.0 *_1105", + "gtk2-devel-cos6-x86_64 >=2.10.0 *_1105", + "libbonobo-devel-cos6-x86_64 >=2.4.0 *_1105", + "orbit2-devel-cos6-x86_64 >=2.6.0 *_1105", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "c8d8e6096a838297e58d4bc06e1220a1", + "name": "at-spi-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "28d082b6076c19ddfcc0bf0f00d8029530c249626767f0bbcb0576bbe83255b7", + "size": 281115, + "subdir": "noarch", + "timestamp": 1627488165985, + "version": "1.28.1" + }, + "at-spi-devel-cos6-x86_64-1.28.1-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "at-spi-cos6-x86_64 ==1.28.1 *_104", + "atk-devel-cos6-x86_64 >=1.13.0 *_104", + "gtk2-devel-cos6-x86_64 >=2.10.0 *_104", + "gtk2-devel-cos6-x86_64 >=2.24.23 *_104", + "libbonobo-devel-cos6-x86_64 >=2.4.0 *_104", + "orbit2-devel-cos6-x86_64 >=2.6.0 *_104" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "9c4689f1956ae5d26911b3fc5bbc7b12", + "name": "at-spi-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "febba17953f84e7bbedb4b1cd200d55d5a4c2abf1ac134568682f42ccd7ae51b", + "size": 280248, + "subdir": "noarch", + "timestamp": 1596323617910, + "version": "1.28.1" + }, + "at-spi-devel-cos6-x86_64-1.28.1-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "at-spi-cos6-x86_64 ==1.28.1 *_1104", + "atk-devel-cos6-x86_64 >=1.13.0 *_1104", + "gtk2-devel-cos6-x86_64 >=2.10.0 *_1104", + "gtk2-devel-cos6-x86_64 >=2.24.23 *_1104", + "libbonobo-devel-cos6-x86_64 >=2.4.0 *_1104", + "orbit2-devel-cos6-x86_64 >=2.6.0 *_1104", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "7aa6d5518d47eacb1538f1c6b5306c58", + "name": "at-spi-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "d13593eff5d47430ac7b3a82a08fbf09d88197c532b0f56ab5f9fda5ecdc3853", + "size": 284892, + "subdir": "noarch", + "timestamp": 1596325791492, + "version": "1.28.1" + }, + "at-spi-devel-cos6-x86_64-1.28.1-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "at-spi-cos6-x86_64 ==1.28.1 *_103", + "atk-devel-cos6-x86_64 >=1.13.0 *_103", + "gtk2-devel-cos6-x86_64 >=2.10.0 *_103", + "gtk2-devel-cos6-x86_64 >=2.24.23 *_103", + "libbonobo-devel-cos6-x86_64 >=2.4.0 *_103", + "orbit2-devel-cos6-x86_64 >=2.6.0 *_103" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "d47060e4a27496afb9a59a077a59c615", + "name": "at-spi-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "58add6eec7e51a29c4f4173a84bd16aaae4029ae9461e8fdcd204b8935f06c58", + "size": 285541, + "subdir": "noarch", + "timestamp": 1595460861954, + "version": "1.28.1" + }, + "at-spi-devel-cos6-x86_64-1.28.1-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "at-spi-cos6-x86_64 ==1.28.1 *_1103", + "atk-devel-cos6-x86_64 >=1.13.0 *_1103", + "gtk2-devel-cos6-x86_64 >=2.10.0 *_1103", + "gtk2-devel-cos6-x86_64 >=2.24.23 *_1103", + "libbonobo-devel-cos6-x86_64 >=2.4.0 *_1103", + "orbit2-devel-cos6-x86_64 >=2.6.0 *_1103", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "d1f165c6ba80e6ef3be8168ada76a478", + "name": "at-spi-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "61ba6b423157657fe3866e20125a6034d7ae3c089a89dcb51035f09cc4e5e7a1", + "size": 285364, + "subdir": "noarch", + "timestamp": 1595462682162, + "version": "1.28.1" + }, + "at-spi-devel-cos6-x86_64-1.28.1-hdf0574f_102.tar.bz2": { + "build": "hdf0574f_102", + "build_number": 102, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "at-spi-cos6-x86_64 ==1.28.1 *_102", + "atk-devel-cos6-x86_64 >=1.13.0 *_102", + "gtk2-devel-cos6-x86_64 >=2.10.0 *_102", + "gtk2-devel-cos6-x86_64 >=2.24.23 *_102", + "libbonobo-devel-cos6-x86_64 >=2.4.0 *_102", + "orbit2-devel-cos6-x86_64 >=2.6.0 *_102" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "4284b7951c3fd5c256039923ce83b4e0", + "name": "at-spi-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "31b950fa3a1b285db8d719594d7a063b731f0caaf0fb8f4b9c6480f348f34eff", + "size": 279837, + "subdir": "noarch", + "timestamp": 1595254828093, + "version": "1.28.1" + }, + "at-spi-devel-cos6-x86_64-1.28.1-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "at-spi-cos6-x86_64 ==1.28.1 *_1102", + "atk-devel-cos6-x86_64 >=1.13.0 *_1102", + "gtk2-devel-cos6-x86_64 >=2.10.0 *_1102", + "gtk2-devel-cos6-x86_64 >=2.24.23 *_1102", + "libbonobo-devel-cos6-x86_64 >=2.4.0 *_1102", + "orbit2-devel-cos6-x86_64 >=2.6.0 *_1102", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "6508f3bb9d6b9834ee3bf04d4904b7a4", + "name": "at-spi-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "6f28ef98d8c7c04f78027f43ea35a9985f0b00014415550f9a19ecb035e53523", + "size": 277898, + "subdir": "noarch", + "timestamp": 1595255455193, + "version": "1.28.1" + }, + "at-spi-devel-cos7-aarch64-1.32.0-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "at-spi-cos7-aarch64 ==1.32.0 *_105", + "atk-devel-cos7-aarch64 >=1.29.2 *_105", + "gtk2-devel-cos7-aarch64 >=2.10.0 *_105", + "libbonobo-devel-cos7-aarch64 >=2.4.0 *_105", + "orbit2-devel-cos7-aarch64 >=2.6.0 *_105" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "cbd1c9a3e7b0785a6f29acd124a00eb3", + "name": "at-spi-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "926ce20729c02180d40e92c0a2aead9c723db52e034a5ff4e94374048ae30427", + "size": 289391, + "subdir": "noarch", + "timestamp": 1627489328579, + "version": "1.32.0" + }, + "at-spi-devel-cos7-aarch64-1.32.0-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "at-spi-cos7-aarch64 ==1.32.0 *_1105", + "atk-devel-cos7-aarch64 >=1.29.2 *_1105", + "gtk2-devel-cos7-aarch64 >=2.10.0 *_1105", + "libbonobo-devel-cos7-aarch64 >=2.4.0 *_1105", + "orbit2-devel-cos7-aarch64 >=2.6.0 *_1105", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "94b159bbee3fffabfc8bb380abfe5e09", + "name": "at-spi-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "cb1c311c14c3eda73a4763e1bf2a5617c56611777a4c61e217123d94f8343091", + "size": 290258, + "subdir": "noarch", + "timestamp": 1627542593734, + "version": "1.32.0" + }, + "at-spi-devel-cos7-aarch64-1.32.0-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "at-spi-cos7-aarch64 ==1.32.0 *_104", + "atk-devel-cos7-aarch64 >=1.29.2 *_104", + "gtk2-devel-cos7-aarch64 >=2.10.0 *_104", + "gtk2-devel-cos7-aarch64 >=2.24.31 *_104", + "libbonobo-devel-cos7-aarch64 >=2.4.0 *_104", + "orbit2-devel-cos7-aarch64 >=2.6.0 *_104" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "7a7b60537acd350e32c5443b253783e8", + "name": "at-spi-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "5df7f9fbcca38067d0c51d90b0dd721fb095a5237daabbf6f5c4a428b9529035", + "size": 290383, + "subdir": "noarch", + "timestamp": 1596324479194, + "version": "1.32.0" + }, + "at-spi-devel-cos7-aarch64-1.32.0-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "at-spi-cos7-aarch64 ==1.32.0 *_1104", + "atk-devel-cos7-aarch64 >=1.29.2 *_1104", + "gtk2-devel-cos7-aarch64 >=2.10.0 *_1104", + "gtk2-devel-cos7-aarch64 >=2.24.31 *_1104", + "libbonobo-devel-cos7-aarch64 >=2.4.0 *_1104", + "orbit2-devel-cos7-aarch64 >=2.6.0 *_1104", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "17380b25805abf3e42cd8b48a00a9ed6", + "name": "at-spi-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "197afcc84f1f28b91f479733cd03211bcadd3c23f353903bfcf53321f26b7cd6", + "size": 294481, + "subdir": "noarch", + "timestamp": 1596327499769, + "version": "1.32.0" + }, + "at-spi-devel-cos7-aarch64-1.32.0-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "at-spi-cos7-aarch64 ==1.32.0 *_103", + "atk-devel-cos7-aarch64 >=1.29.2 *_103", + "gtk2-devel-cos7-aarch64 >=2.10.0 *_103", + "gtk2-devel-cos7-aarch64 >=2.24.31 *_103", + "libbonobo-devel-cos7-aarch64 >=2.4.0 *_103", + "orbit2-devel-cos7-aarch64 >=2.6.0 *_103" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "347c4ce8b2243568e9a0e3a84973b55d", + "name": "at-spi-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "db5da1515f57d8c1d9d8397a9dea2d7b752631bdd9cdbfe2373ec6b0f5be6a5a", + "size": 281402, + "subdir": "noarch", + "timestamp": 1595460537797, + "version": "1.32.0" + }, + "at-spi-devel-cos7-aarch64-1.32.0-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "at-spi-cos7-aarch64 ==1.32.0 *_1103", + "atk-devel-cos7-aarch64 >=1.29.2 *_1103", + "gtk2-devel-cos7-aarch64 >=2.10.0 *_1103", + "gtk2-devel-cos7-aarch64 >=2.24.31 *_1103", + "libbonobo-devel-cos7-aarch64 >=2.4.0 *_1103", + "orbit2-devel-cos7-aarch64 >=2.6.0 *_1103", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "33f32c2b0dd8c94d6985445242106ece", + "name": "at-spi-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "612958b341f1b7e0f16682d874dfc28da52a997a8e042ca48b6fd7677b4bd6dc", + "size": 296768, + "subdir": "noarch", + "timestamp": 1595462043674, + "version": "1.32.0" + }, + "at-spi-devel-cos7-aarch64-1.32.0-hdf0574f_102.tar.bz2": { + "build": "hdf0574f_102", + "build_number": 102, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "at-spi-cos7-aarch64 ==1.32.0 *_102", + "atk-devel-cos7-aarch64 >=1.29.2 *_102", + "gtk2-devel-cos7-aarch64 >=2.10.0 *_102", + "gtk2-devel-cos7-aarch64 >=2.24.31 *_102", + "libbonobo-devel-cos7-aarch64 >=2.4.0 *_102", + "orbit2-devel-cos7-aarch64 >=2.6.0 *_102" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "c59fc9f94bbe183e23e3c67f827d02e5", + "name": "at-spi-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "9b2e41f4a3931e82e890dc7adbb2e5a8d7c5fffca3f6dc3278c4e8603ad37377", + "size": 290256, + "subdir": "noarch", + "timestamp": 1595254703931, + "version": "1.32.0" + }, + "at-spi-devel-cos7-aarch64-1.32.0-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "at-spi-cos7-aarch64 ==1.32.0 *_1102", + "atk-devel-cos7-aarch64 >=1.29.2 *_1102", + "gtk2-devel-cos7-aarch64 >=2.10.0 *_1102", + "gtk2-devel-cos7-aarch64 >=2.24.31 *_1102", + "libbonobo-devel-cos7-aarch64 >=2.4.0 *_1102", + "orbit2-devel-cos7-aarch64 >=2.6.0 *_1102", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f74093d48d95198aefd5c1ba85d91d00", + "name": "at-spi-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "26653644b624a52644f09a9eeaedf15b1f25687638d273780b3e0bcd1842e245", + "size": 291002, + "subdir": "noarch", + "timestamp": 1595255261955, + "version": "1.32.0" + }, + "at-spi-devel-cos7-ppc64le-1.32.0-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "at-spi-cos7-ppc64le ==1.32.0 *_105", + "atk-devel-cos7-ppc64le >=1.29.2 *_105", + "gtk2-devel-cos7-ppc64le >=2.10.0 *_105", + "libbonobo-devel-cos7-ppc64le >=2.4.0 *_105", + "orbit2-devel-cos7-ppc64le >=2.6.0 *_105" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "eea0522eac693a0b29ecfdf25ac4cdf0", + "name": "at-spi-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "476903736e22b59bfdd1f3cf87e814215a1793ef7383e84ef475f4eea1d4129a", + "size": 287502, + "subdir": "noarch", + "timestamp": 1627538740589, + "version": "1.32.0" + }, + "at-spi-devel-cos7-ppc64le-1.32.0-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "at-spi-cos7-ppc64le ==1.32.0 *_1105", + "atk-devel-cos7-ppc64le >=1.29.2 *_1105", + "gtk2-devel-cos7-ppc64le >=2.10.0 *_1105", + "libbonobo-devel-cos7-ppc64le >=2.4.0 *_1105", + "orbit2-devel-cos7-ppc64le >=2.6.0 *_1105", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "68bb1f56ef2c6218424549f4dce94174", + "name": "at-spi-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "185dbc62125384042a38f09ead5c2df76102b92f84835a82f6e88804f27a861e", + "size": 287140, + "subdir": "noarch", + "timestamp": 1627540373760, + "version": "1.32.0" + }, + "at-spi-devel-cos7-ppc64le-1.32.0-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "at-spi-cos7-ppc64le ==1.32.0 *_104", + "atk-devel-cos7-ppc64le >=1.29.2 *_104", + "gtk2-devel-cos7-ppc64le >=2.10.0 *_104", + "gtk2-devel-cos7-ppc64le >=2.24.31 *_104", + "libbonobo-devel-cos7-ppc64le >=2.4.0 *_104", + "orbit2-devel-cos7-ppc64le >=2.6.0 *_104" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "46ad3966639dfb103b0e491505fed99c", + "name": "at-spi-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "9fcb84337a02c58ec340a05cf81cad0fbbdca792e7c957dfb2051a777b528f68", + "size": 293461, + "subdir": "noarch", + "timestamp": 1596324129010, + "version": "1.32.0" + }, + "at-spi-devel-cos7-ppc64le-1.32.0-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "at-spi-cos7-ppc64le ==1.32.0 *_1104", + "atk-devel-cos7-ppc64le >=1.29.2 *_1104", + "gtk2-devel-cos7-ppc64le >=2.10.0 *_1104", + "gtk2-devel-cos7-ppc64le >=2.24.31 *_1104", + "libbonobo-devel-cos7-ppc64le >=2.4.0 *_1104", + "orbit2-devel-cos7-ppc64le >=2.6.0 *_1104", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "8bc9255aca80ba85314401f00e6188e5", + "name": "at-spi-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "c96cb746ccb1219cc1567233c6d97d5fc692b8f7060968bbb64e6a9fa42b8552", + "size": 295378, + "subdir": "noarch", + "timestamp": 1596327910838, + "version": "1.32.0" + }, + "at-spi-devel-cos7-ppc64le-1.32.0-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "at-spi-cos7-ppc64le ==1.32.0 *_103", + "atk-devel-cos7-ppc64le >=1.29.2 *_103", + "gtk2-devel-cos7-ppc64le >=2.10.0 *_103", + "gtk2-devel-cos7-ppc64le >=2.24.31 *_103", + "libbonobo-devel-cos7-ppc64le >=2.4.0 *_103", + "orbit2-devel-cos7-ppc64le >=2.6.0 *_103" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "9f96a79e3294bf60695b4f6e4b7a7aff", + "name": "at-spi-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "52a3c02d0c7ebe7e446b3419b591bbb383a964e29d218433e34393c8338d082d", + "size": 290854, + "subdir": "noarch", + "timestamp": 1595460137211, + "version": "1.32.0" + }, + "at-spi-devel-cos7-ppc64le-1.32.0-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "at-spi-cos7-ppc64le ==1.32.0 *_1103", + "atk-devel-cos7-ppc64le >=1.29.2 *_1103", + "gtk2-devel-cos7-ppc64le >=2.10.0 *_1103", + "gtk2-devel-cos7-ppc64le >=2.24.31 *_1103", + "libbonobo-devel-cos7-ppc64le >=2.4.0 *_1103", + "orbit2-devel-cos7-ppc64le >=2.6.0 *_1103", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "08c0cf01081cb18283d73adc4453da64", + "name": "at-spi-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "34473ab3e5370e20dca514d0781547a152425c47fbac8d7af3488a206004608a", + "size": 292216, + "subdir": "noarch", + "timestamp": 1595462838242, + "version": "1.32.0" + }, + "at-spi-devel-cos7-ppc64le-1.32.0-hdf0574f_102.tar.bz2": { + "build": "hdf0574f_102", + "build_number": 102, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "at-spi-cos7-ppc64le ==1.32.0 *_102", + "atk-devel-cos7-ppc64le >=1.29.2 *_102", + "gtk2-devel-cos7-ppc64le >=2.10.0 *_102", + "gtk2-devel-cos7-ppc64le >=2.24.31 *_102", + "libbonobo-devel-cos7-ppc64le >=2.4.0 *_102", + "orbit2-devel-cos7-ppc64le >=2.6.0 *_102" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "159e481c3f11c1cb7a028d14cb7f9d2a", + "name": "at-spi-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "a097974a69d0d7f71f4e439d038cbcd2b988cc7fd70098a6f6fd7fa910b32480", + "size": 289990, + "subdir": "noarch", + "timestamp": 1595254574586, + "version": "1.32.0" + }, + "at-spi-devel-cos7-ppc64le-1.32.0-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "at-spi-cos7-ppc64le ==1.32.0 *_1102", + "atk-devel-cos7-ppc64le >=1.29.2 *_1102", + "gtk2-devel-cos7-ppc64le >=2.10.0 *_1102", + "gtk2-devel-cos7-ppc64le >=2.24.31 *_1102", + "libbonobo-devel-cos7-ppc64le >=2.4.0 *_1102", + "orbit2-devel-cos7-ppc64le >=2.6.0 *_1102", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "dc62ee75bbab5e07011511a1bdfa5616", + "name": "at-spi-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "8d1e4d9d7c0974b1b41133ddb9f6a0f380ca2ae028f3c2e25bbd8af051403fec", + "size": 288251, + "subdir": "noarch", + "timestamp": 1595255119156, + "version": "1.32.0" + }, + "at-spi-devel-cos7-x86_64-1.32.0-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "at-spi-cos7-x86_64 ==1.32.0 *_1105", + "atk-devel-cos7-x86_64 >=1.29.2 *_1105", + "gtk2-devel-cos7-x86_64 >=2.10.0 *_1105", + "libbonobo-devel-cos7-x86_64 >=2.4.0 *_1105", + "orbit2-devel-cos7-x86_64 >=2.6.0 *_1105", + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "ea755271f5a3249874244105b85c5659", + "name": "at-spi-devel-cos7-x86_64", + "noarch": "generic", + "sha256": "1c23b4748ad140304d8b12d92b54950383b280ed65111fe8ac16ca1028cd6baa", + "size": 298733, + "subdir": "noarch", + "timestamp": 1627507729478, + "version": "1.32.0" + }, + "at-spi-devel-cos7-x86_64-1.32.0-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "at-spi-cos7-x86_64 ==1.32.0 *_1104", + "atk-devel-cos7-x86_64 >=1.29.2 *_1104", + "gtk2-devel-cos7-x86_64 >=2.10.0 *_1104", + "gtk2-devel-cos7-x86_64 >=2.24.31 *_1104", + "libbonobo-devel-cos7-x86_64 >=2.4.0 *_1104", + "orbit2-devel-cos7-x86_64 >=2.6.0 *_1104", + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "9f31ef8eb9fb57faa892d5e89d6ff1dd", + "name": "at-spi-devel-cos7-x86_64", + "noarch": "generic", + "sha256": "ae93bcd7f85069de85e60c461fa7843b73905e0594081d611150c52e128d0f82", + "size": 297235, + "subdir": "noarch", + "timestamp": 1596326452490, + "version": "1.32.0" + }, + "at-spi-devel-cos7-x86_64-1.32.0-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "at-spi-cos7-x86_64 ==1.32.0 *_1103", + "atk-devel-cos7-x86_64 >=1.29.2 *_1103", + "gtk2-devel-cos7-x86_64 >=2.10.0 *_1103", + "gtk2-devel-cos7-x86_64 >=2.24.31 *_1103", + "libbonobo-devel-cos7-x86_64 >=2.4.0 *_1103", + "orbit2-devel-cos7-x86_64 >=2.6.0 *_1103", + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "dbd7ab486cd636c89c29f72f36fb6742", + "name": "at-spi-devel-cos7-x86_64", + "noarch": "generic", + "sha256": "5fdbd2753f0230ee91102dce814cc33862c9b11c0ac179baaa6c0dc7bc66828c", + "size": 293592, + "subdir": "noarch", + "timestamp": 1595461224424, + "version": "1.32.0" + }, + "at-spi-devel-cos7-x86_64-1.32.0-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "at-spi-cos7-x86_64 ==1.32.0 *_1102", + "atk-devel-cos7-x86_64 >=1.29.2 *_1102", + "gtk2-devel-cos7-x86_64 >=2.10.0 *_1102", + "gtk2-devel-cos7-x86_64 >=2.24.31 *_1102", + "libbonobo-devel-cos7-x86_64 >=2.4.0 *_1102", + "orbit2-devel-cos7-x86_64 >=2.6.0 *_1102", + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "9414e1a352ccf36eb997a4e2cf52f97e", + "name": "at-spi-devel-cos7-x86_64", + "noarch": "generic", + "sha256": "499560660984e5b0117b7d087e13944fc8c184498678d4c2ffe9a8ed2aa0c56d", + "size": 285466, + "subdir": "noarch", + "timestamp": 1595254982875, + "version": "1.32.0" + }, + "atap_widgets-0.4.0-pyhd8ed1ab_0.tar.bz2": { + "build": "pyhd8ed1ab_0", + "build_number": 0, + "depends": [ + "bokeh >=2.0,<3.0", + "ipywidgets >=8.0,<9.0", + "pandas >=1.3,<2.0", + "python >=3.8,<3.12", + "spacy >=3.0,<4.0", + "textacy", + "xlsxwriter >=3,<4" + ], + "license": "MIT", + "license_family": "MIT", + "md5": "34282cc0351eea89960fa66fa940fa4d", + "name": "atap_widgets", + "noarch": "python", + "sha256": "2548f2bdd68ac79238be13e25a18a9afaf8143f0bb098a8f4cd43d323f469fec", + "size": 25316, + "subdir": "noarch", + "timestamp": 1666837482908, + "version": "0.4.0" + }, + "atdict-0.9.4-pyh6c4a22f_0.tar.bz2": { + "build": "pyh6c4a22f_0", + "build_number": 0, + "depends": [ + "python" + ], + "license": "BSD-3-Clause", + "license_family": "BSD", + "md5": "2f941bf13aad487e57f549cd71107502", + "name": "atdict", + "noarch": "python", + "sha256": "def9ce454744a727dd82888c1b05f13724ce26792b1e045825267f2401204a5d", + "size": 9016, + "subdir": "noarch", + "timestamp": 1621212235194, + "version": "0.9.4" + }, + "atk-cos6-x86_64-1.30.0-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "353e0a578e474b37c571dc68d38154d6", + "name": "atk-cos6-x86_64", + "noarch": "generic", + "sha256": "493193e29836051130f51c0426b4124d1b0a414e92d6c4098b0efa236e5a2d39", + "size": 203063, + "subdir": "noarch", + "timestamp": 1627477920692, + "version": "1.30.0" + }, + "atk-cos6-x86_64-1.30.0-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "c31e394dbb395bb98a7e8f0f59259669", + "name": "atk-cos6-x86_64", + "noarch": "generic", + "sha256": "fc6fe0413509764c90839422c02baed7306735dd53b475b4a829f704b8580edf", + "size": 201721, + "subdir": "noarch", + "timestamp": 1627478582485, + "version": "1.30.0" + }, + "atk-cos6-x86_64-1.30.0-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "6a041f6f36069ad63ba19d9a5824c29f", + "name": "atk-cos6-x86_64", + "noarch": "generic", + "sha256": "8de63ce1f06fe422f15f900e255e6a5e4af0722fdff52bc8ee8b1c45dff077aa", + "size": 205363, + "subdir": "noarch", + "timestamp": 1596318742874, + "version": "1.30.0" + }, + "atk-cos6-x86_64-1.30.0-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "fdca6088851b990854a66d91e1061fbf", + "name": "atk-cos6-x86_64", + "noarch": "generic", + "sha256": "514ef89eebdf0f887d67fd6dc263444e7c5e917acb8945f87041f7df448eadff", + "size": 196497, + "subdir": "noarch", + "timestamp": 1596319014781, + "version": "1.30.0" + }, + "atk-cos6-x86_64-1.30.0-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "dabeeeb2035e9eec2bc8d5200adcfb58", + "name": "atk-cos6-x86_64", + "noarch": "generic", + "sha256": "be2f812bd9f49a515657f70e8d98b9be98cbd8defa0450b04fc695faa8f7d6d0", + "size": 202434, + "subdir": "noarch", + "timestamp": 1595456826165, + "version": "1.30.0" + }, + "atk-cos6-x86_64-1.30.0-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "46a28de19fd065eb9d1706c30a84b1bc", + "name": "atk-cos6-x86_64", + "noarch": "generic", + "sha256": "2dedd5acfdfce8c227b852bb37c955fd16b9b2600fd1f93c7657e3bbf27b4e59", + "size": 195861, + "subdir": "noarch", + "timestamp": 1595457227812, + "version": "1.30.0" + }, + "atk-cos6-x86_64-1.30.0-hdf0574f_102.tar.bz2": { + "build": "hdf0574f_102", + "build_number": 102, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "a1359ebef588b4699a372e12a44ffac2", + "name": "atk-cos6-x86_64", + "noarch": "generic", + "sha256": "6d38928da603598d9ebad310f730ef1257afb8d2d0f13f6fed9738e229e11459", + "size": 195186, + "subdir": "noarch", + "timestamp": 1595253785293, + "version": "1.30.0" + }, + "atk-cos6-x86_64-1.30.0-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "fc676cd5bfb7447e2b91b8d3b64f3a83", + "name": "atk-cos6-x86_64", + "noarch": "generic", + "sha256": "730bceb46169350f2244c7470a33d95f0894690ba0ac4a43582d3fb0b4ea917d", + "size": 197432, + "subdir": "noarch", + "timestamp": 1595253966056, + "version": "1.30.0" + }, + "atk-cos7-aarch64-2.28.1-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "ad8963c13eba654a51c25adea33de068", + "name": "atk-cos7-aarch64", + "noarch": "generic", + "sha256": "305acb75a0e5388f2a7f5f074216aed6aeb6ed3ad4de7293d2fce7db28297635", + "size": 282247, + "subdir": "noarch", + "timestamp": 1627477447385, + "version": "2.28.1" + }, + "atk-cos7-aarch64-2.28.1-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "078ec7b3cf52baebd5b2a033224e595b", + "name": "atk-cos7-aarch64", + "noarch": "generic", + "sha256": "f73b627032a12845139ac5f3eed8d522e3a9c0326621859edbcfdde2c0e51dfc", + "size": 289786, + "subdir": "noarch", + "timestamp": 1627528382338, + "version": "2.28.1" + }, + "atk-cos7-aarch64-2.28.1-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "72e59249e1e01807f920e0044401dde6", + "name": "atk-cos7-aarch64", + "noarch": "generic", + "sha256": "a8bf1a78659d175fda358341a47f2319d95f52e2fce74de9fae617cda599a86f", + "size": 279651, + "subdir": "noarch", + "timestamp": 1596319584997, + "version": "2.28.1" + }, + "atk-cos7-aarch64-2.28.1-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "3e7cfa7bfb3958145a665d499303c116", + "name": "atk-cos7-aarch64", + "noarch": "generic", + "sha256": "952d9415c4c3e2280a943ca6a0ea2972d5a24a89a660546f6046d9b01b7ab696", + "size": 279869, + "subdir": "noarch", + "timestamp": 1596320967143, + "version": "2.28.1" + }, + "atk-cos7-aarch64-2.28.1-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "790f52acaf3e6689ebdfdd533f900838", + "name": "atk-cos7-aarch64", + "noarch": "generic", + "sha256": "f4ce700318bfc1335baeba9c923d596a9b3aaa30dc7c6e30bf862ea898e42446", + "size": 275422, + "subdir": "noarch", + "timestamp": 1595456566496, + "version": "2.28.1" + }, + "atk-cos7-aarch64-2.28.1-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "1d4eadaa15acd98565f0f51ab6ae1ff8", + "name": "atk-cos7-aarch64", + "noarch": "generic", + "sha256": "88d7ef41a125f2a2ac06145ec2e841d4c0c4089ed9a5374a29b1079989e64d79", + "size": 278297, + "subdir": "noarch", + "timestamp": 1595456664983, + "version": "2.28.1" + }, + "atk-cos7-aarch64-2.28.1-hdf0574f_102.tar.bz2": { + "build": "hdf0574f_102", + "build_number": 102, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "7aa7e42e3013a3ae08a385012200fbf5", + "name": "atk-cos7-aarch64", + "noarch": "generic", + "sha256": "80d21ac7ef806b7b16238770cfde939e4342e13c5b7fc6aac9a3b803c18a3ac6", + "size": 285110, + "subdir": "noarch", + "timestamp": 1595253934013, + "version": "2.28.1" + }, + "atk-cos7-aarch64-2.28.1-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "49a3bc2d4af52ca182a86f7bc0715a4d", + "name": "atk-cos7-aarch64", + "noarch": "generic", + "sha256": "085628fbe0482f708363240f3a9e75891eef49647900768130b3f05799fded5c", + "size": 271865, + "subdir": "noarch", + "timestamp": 1595254256536, + "version": "2.28.1" + }, + "atk-cos7-ppc64le-2.28.1-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "8c8aa84f9322bc2b39ed648926606e24", + "name": "atk-cos7-ppc64le", + "noarch": "generic", + "sha256": "df5b9650ba67602fe9cfdb84cc81f94078697b01034ddb4bb04b18704b5c6885", + "size": 286790, + "subdir": "noarch", + "timestamp": 1627529231400, + "version": "2.28.1" + }, + "atk-cos7-ppc64le-2.28.1-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "6760fb37cc39bbaed90e5553f3767b46", + "name": "atk-cos7-ppc64le", + "noarch": "generic", + "sha256": "13801daf5f33febb6943789da714dab1ca0066821e7eae4a6d991d211f1001b4", + "size": 277109, + "subdir": "noarch", + "timestamp": 1627530389914, + "version": "2.28.1" + }, + "atk-cos7-ppc64le-2.28.1-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "fdf0ce721e48e85bc577a20eb91f4cac", + "name": "atk-cos7-ppc64le", + "noarch": "generic", + "sha256": "ba76477dfe14d713be59e1615217049a5d0ed1391566caa158b497c2c8a7f494", + "size": 275364, + "subdir": "noarch", + "timestamp": 1596319125956, + "version": "2.28.1" + }, + "atk-cos7-ppc64le-2.28.1-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "8f5bc524ec921d67ca0c052ebc4a3384", + "name": "atk-cos7-ppc64le", + "noarch": "generic", + "sha256": "9eaae087873eb8289e15a1bc91585cab30ab6e42e1d5185edcc2f6016042d870", + "size": 275655, + "subdir": "noarch", + "timestamp": 1596320167973, + "version": "2.28.1" + }, + "atk-cos7-ppc64le-2.28.1-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "3514a09bd5d5771b8122d2d12549e166", + "name": "atk-cos7-ppc64le", + "noarch": "generic", + "sha256": "d8d66e22b353a632738c1acad4eaf433df718cca94d2ee757c9e04b14a530341", + "size": 284499, + "subdir": "noarch", + "timestamp": 1595456791752, + "version": "2.28.1" + }, + "atk-cos7-ppc64le-2.28.1-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "fa250d5f35d7f35a8c7cbd383851af66", + "name": "atk-cos7-ppc64le", + "noarch": "generic", + "sha256": "233ad7e24521eb487119db3cdb83db19e5c92f2983a74b4c19e19ad19522e4d7", + "size": 282984, + "subdir": "noarch", + "timestamp": 1595457339298, + "version": "2.28.1" + }, + "atk-cos7-ppc64le-2.28.1-hdf0574f_102.tar.bz2": { + "build": "hdf0574f_102", + "build_number": 102, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "db4993a9c768dffe925395fc52db8c66", + "name": "atk-cos7-ppc64le", + "noarch": "generic", + "sha256": "fb6e9f8508da1563229e605aecdf9d26a5792b9a4f100df45dd450577440570b", + "size": 288146, + "subdir": "noarch", + "timestamp": 1595254020284, + "version": "2.28.1" + }, + "atk-cos7-ppc64le-2.28.1-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "d41781db50b57b608e7d9bb05b708c0d", + "name": "atk-cos7-ppc64le", + "noarch": "generic", + "sha256": "930c3e0e709139c46314b1b6ce364f3397dc23169078c7c9bca549c6aab6b2ff", + "size": 275048, + "subdir": "noarch", + "timestamp": 1595254418235, + "version": "2.28.1" + }, + "atk-cos7-x86_64-2.28.1-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "b5d4d41cb474c26f7d0c3c1694fc8021", + "name": "atk-cos7-x86_64", + "noarch": "generic", + "sha256": "40bcaa27ea78a8397db97009053e26389bd791a12326bcdfe00d158a26470ad5", + "size": 285304, + "subdir": "noarch", + "timestamp": 1627494599900, + "version": "2.28.1" + }, + "atk-cos7-x86_64-2.28.1-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "f4f97c7a72c3b2d9970535aa0ed70136", + "name": "atk-cos7-x86_64", + "noarch": "generic", + "sha256": "a00ed4a87f8439ac8579c0b7e64aaefd7108d8d8a6d81b24df796c055ef0136f", + "size": 289612, + "subdir": "noarch", + "timestamp": 1596318844146, + "version": "2.28.1" + }, + "atk-cos7-x86_64-2.28.1-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "e9d94c6d3a5da52bc744b245f6b3aa79", + "name": "atk-cos7-x86_64", + "noarch": "generic", + "sha256": "8ea2f0d517e234c7092e6dc90e74f3ac0d2e30550f82cc9ae438ec12bb85a9a9", + "size": 280879, + "subdir": "noarch", + "timestamp": 1595456623554, + "version": "2.28.1" + }, + "atk-cos7-x86_64-2.28.1-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "sysroot_linux-64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "379d935a395689258da5fc43b97aee3e", + "name": "atk-cos7-x86_64", + "noarch": "generic", + "sha256": "fd7564b0da6e3d68cdacc4126107855e90627bdb1350a9d145031a9c43989dc5", + "size": 283038, + "subdir": "noarch", + "timestamp": 1595254001186, + "version": "2.28.1" + }, + "atk-devel-cos6-x86_64-1.30.0-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "atk-cos6-x86_64 ==1.30.0 *_105", + "glib2-devel-cos6-x86_64 >=2.6.0 *_105" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "4bf0ae0f6ccfc2450ace3072b4665b11", + "name": "atk-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "fd464a3dda1223ee28e3b1453e7c3f0419f30b531cb98ddf876e36ca86972b15", + "size": 100733, + "subdir": "noarch", + "timestamp": 1627483110665, + "version": "1.30.0" + }, + "atk-devel-cos6-x86_64-1.30.0-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "atk-cos6-x86_64 ==1.30.0 *_1105", + "glib2-devel-cos6-x86_64 >=2.6.0 *_1105", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "33f54c536cdb037e7f8b5d631c56c050", + "name": "atk-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "90c9b45916f65c877241bbe69c20c1e8c1981304b7cf3f531ab6170127189938", + "size": 97528, + "subdir": "noarch", + "timestamp": 1627485488356, + "version": "1.30.0" + }, + "atk-devel-cos6-x86_64-1.30.0-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "atk-cos6-x86_64 ==1.30.0 *_104", + "glib2-devel-cos6-x86_64 >=2.6.0 *_104" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "4f100d5e764527bc4eb4c4847ded0f84", + "name": "atk-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "c51c1f723f887738dde66cc2680c40b5330bc9fdb41af092560248a01207c486", + "size": 100102, + "subdir": "noarch", + "timestamp": 1596322406561, + "version": "1.30.0" + }, + "atk-devel-cos6-x86_64-1.30.0-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "atk-cos6-x86_64 ==1.30.0 *_1104", + "glib2-devel-cos6-x86_64 >=2.6.0 *_1104", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "007cbe1eaebaf5a9efbdd3bb084ff153", + "name": "atk-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "8f5b5f0befb25f444d2de3102d0b1b086256aa22f7712ebadfff014293864f7a", + "size": 100772, + "subdir": "noarch", + "timestamp": 1596324375495, + "version": "1.30.0" + }, + "atk-devel-cos6-x86_64-1.30.0-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "atk-cos6-x86_64 ==1.30.0 *_103", + "glib2-devel-cos6-x86_64 >=2.6.0 *_103" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "634965c51c0fb5c91707c1e53f4d8368", + "name": "atk-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "866ea4c79297a5640e7ce4fd0753d21326a2280fee0ec6592064a43c288b87b7", + "size": 98182, + "subdir": "noarch", + "timestamp": 1595459026133, + "version": "1.30.0" + }, + "atk-devel-cos6-x86_64-1.30.0-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "atk-cos6-x86_64 ==1.30.0 *_1103", + "glib2-devel-cos6-x86_64 >=2.6.0 *_1103", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "49670cdadf751a586f37cbc649dbc00f", + "name": "atk-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "fd974a4e48e2827e4cf38483b66dcf7d9fa26e4686230f3a6ff72245a20595b1", + "size": 99771, + "subdir": "noarch", + "timestamp": 1595460476218, + "version": "1.30.0" + }, + "atk-devel-cos6-x86_64-1.30.0-hdf0574f_102.tar.bz2": { + "build": "hdf0574f_102", + "build_number": 102, + "constrains": [ + "sysroot_linux-64 ==99999999999" + ], + "depends": [ + "atk-cos6-x86_64 ==1.30.0 *_102", + "glib2-devel-cos6-x86_64 >=2.6.0 *_102" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "6d41528525a8b6c40372cea2a4609384", + "name": "atk-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "ddfa37768dd5621c56a8f61b54314051f245bdc2a2f557ae5043c171be528ac0", + "size": 94838, + "subdir": "noarch", + "timestamp": 1595254339184, + "version": "1.30.0" + }, + "atk-devel-cos6-x86_64-1.30.0-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "atk-cos6-x86_64 ==1.30.0 *_1102", + "glib2-devel-cos6-x86_64 >=2.6.0 *_1102", + "sysroot_linux-64 2.12.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "947fdb88de9f85e206014292145351c4", + "name": "atk-devel-cos6-x86_64", + "noarch": "generic", + "sha256": "246bd832e4a0fa6657d0c6d974f940473f150a7d218729a60da6c4fa8cf49268", + "size": 91399, + "subdir": "noarch", + "timestamp": 1595254864022, + "version": "1.30.0" + }, + "atk-devel-cos7-aarch64-2.28.1-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "atk-cos7-aarch64 ==2.28.1 *_105" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "45ed1b53e1d2bd6fbebe5fdfd0ab819f", + "name": "atk-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "ac2b2ee258fe66473689861664e86ea42efb73f098c92014d59ae3a24018150e", + "size": 182004, + "subdir": "noarch", + "timestamp": 1627482451206, + "version": "2.28.1" + }, + "atk-devel-cos7-aarch64-2.28.1-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "atk-cos7-aarch64 ==2.28.1 *_1105", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "7b2ba9d7eb201f4772a874a27b211c09", + "name": "atk-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "5256efe8c6b1ae054ed8fbfd9286120326f07cc21d040ef49ec541a82a83adce", + "size": 183456, + "subdir": "noarch", + "timestamp": 1627535799842, + "version": "2.28.1" + }, + "atk-devel-cos7-aarch64-2.28.1-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "atk-cos7-aarch64 ==2.28.1 *_104" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "41d1ed1eae5d36f1b868ed5dc5cda17d", + "name": "atk-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "8e72be80d3386701ebe9e1067a504227d1ec9741c6b720cdbc91a153cb60f062", + "size": 178959, + "subdir": "noarch", + "timestamp": 1596320489217, + "version": "2.28.1" + }, + "atk-devel-cos7-aarch64-2.28.1-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "atk-cos7-aarch64 ==2.28.1 *_1104", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "747e54b02de5f140a41cb323ed12cdc2", + "name": "atk-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "ce865c96a1ff253b01f41dfe4f42d3c3cd04f104edc28f37e21a84bd0ab53650", + "size": 180283, + "subdir": "noarch", + "timestamp": 1596322260693, + "version": "2.28.1" + }, + "atk-devel-cos7-aarch64-2.28.1-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [ + "atk-cos7-aarch64 ==2.28.1 *_103" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "ca4008fd523ccd6ea8a1cf6b772413fb", + "name": "atk-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "0659e1240d4e8d445080dcaaa5bb81fd1cb61dcd4f4196b3da15b7851a00f331", + "size": 182891, + "subdir": "noarch", + "timestamp": 1595458315252, + "version": "2.28.1" + }, + "atk-devel-cos7-aarch64-2.28.1-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "atk-cos7-aarch64 ==2.28.1 *_1103", + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "b232bba844f2d4a40bbb15d118bf6a20", + "name": "atk-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "682ea04813c79d1c91aac404ba9867d3897a5e3caeb19ff8e993d73ca2f70497", + "size": 185565, + "subdir": "noarch", + "timestamp": 1595459496580, + "version": "2.28.1" + }, + "atk-devel-cos7-aarch64-2.28.1-hdf0574f_102.tar.bz2": { + "build": "hdf0574f_102", + "build_number": 102, + "constrains": [ + "sysroot_linux-aarch64 ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "a848840e1ae0e5580f7ad91e3ddf47cb", + "name": "atk-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "5d05c5ca3752babf706dab7b32d2b2eb43df9bc449c52a13573795ef64e92114", + "size": 183856, + "subdir": "noarch", + "timestamp": 1595254056915, + "version": "2.28.1" + }, + "atk-devel-cos7-aarch64-2.28.1-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "sysroot_linux-aarch64 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "cc264e9acd80e33933f5e9334d25268e", + "name": "atk-devel-cos7-aarch64", + "noarch": "generic", + "sha256": "bbf88b8cf2744008336911fc1348d6f812ff71fc9ac2bd687158fadc2a1da70e", + "size": 182544, + "subdir": "noarch", + "timestamp": 1595254452890, + "version": "2.28.1" + }, + "atk-devel-cos7-ppc64le-2.28.1-h9b0a68f_105.tar.bz2": { + "build": "h9b0a68f_105", + "build_number": 105, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "atk-cos7-ppc64le ==2.28.1 *_105" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "a5d1513e93289fdf0b72020a36168f6d", + "name": "atk-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "f8775da00aa34085ed553b5e7096007686a2b7ddd29322dc547be9d991698f92", + "size": 177229, + "subdir": "noarch", + "timestamp": 1627533197408, + "version": "2.28.1" + }, + "atk-devel-cos7-ppc64le-2.28.1-h9b0a68f_1105.tar.bz2": { + "build": "h9b0a68f_1105", + "build_number": 1105, + "depends": [ + "atk-cos7-ppc64le ==2.28.1 *_1105", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "741da2766e30ec9c148245799d520c4f", + "name": "atk-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "8ae61c71992c3c73336c7706294c141516360df4e13b55f4132c3005e3de27d4", + "size": 177916, + "subdir": "noarch", + "timestamp": 1627534849125, + "version": "2.28.1" + }, + "atk-devel-cos7-ppc64le-2.28.1-h9d98e8f_104.tar.bz2": { + "build": "h9d98e8f_104", + "build_number": 104, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "atk-cos7-ppc64le ==2.28.1 *_104" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "de5b9169d3617b30f5c75f803c437fc6", + "name": "atk-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "7b0920b671712a90a2f8cfaba720c3b1695eea4cd0fecb2eb321deaf32b1e49b", + "size": 179335, + "subdir": "noarch", + "timestamp": 1596320799982, + "version": "2.28.1" + }, + "atk-devel-cos7-ppc64le-2.28.1-h9d98e8f_1104.tar.bz2": { + "build": "h9d98e8f_1104", + "build_number": 1104, + "depends": [ + "atk-cos7-ppc64le ==2.28.1 *_1104", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "04b6ae9c56b9a1964cef395876f54200", + "name": "atk-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "7b86458eb4474731ab11ed731a28f8a9e51460f3faff7abfe19af67384a55211", + "size": 178948, + "subdir": "noarch", + "timestamp": 1596322987110, + "version": "2.28.1" + }, + "atk-devel-cos7-ppc64le-2.28.1-ha826a6f_103.tar.bz2": { + "build": "ha826a6f_103", + "build_number": 103, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [ + "atk-cos7-ppc64le ==2.28.1 *_103" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "59d7f788e1a9d30ff6a39363d14af7c4", + "name": "atk-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "89063a8a58b10b6287f473f928652f0260a3e93fb865f5bc292c80a58ad8f25c", + "size": 176610, + "subdir": "noarch", + "timestamp": 1595457354414, + "version": "2.28.1" + }, + "atk-devel-cos7-ppc64le-2.28.1-ha826a6f_1103.tar.bz2": { + "build": "ha826a6f_1103", + "build_number": 1103, + "depends": [ + "atk-cos7-ppc64le ==2.28.1 *_1103", + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "285d1e51c680a350178870aa1afac437", + "name": "atk-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "c07bbceab953da36602904be254dbe1c0b087e92cbcd78e753ed5e1e001f5552", + "size": 189855, + "subdir": "noarch", + "timestamp": 1595458615733, + "version": "2.28.1" + }, + "atk-devel-cos7-ppc64le-2.28.1-hdf0574f_102.tar.bz2": { + "build": "hdf0574f_102", + "build_number": 102, + "constrains": [ + "sysroot_linux-ppc64le ==99999999999" + ], + "depends": [], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "23c87a8158e1d5654d07bb4cdff6450f", + "name": "atk-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "ece6b89bd8de856b2ffae2714be57f7afae0b50699624b9bdcf3c2d4dd2cc4e8", + "size": 180546, + "subdir": "noarch", + "timestamp": 1595253834385, + "version": "2.28.1" + }, + "atk-devel-cos7-ppc64le-2.28.1-hdf0574f_1102.tar.bz2": { + "build": "hdf0574f_1102", + "build_number": 1102, + "depends": [ + "sysroot_linux-ppc64le 2.17.*" + ], + "license": "LGPL-2.0-or-later", + "license_family": "LGPL", + "md5": "1f18402487e901c04bb2d2ad8f7fce4b", + "name": "atk-devel-cos7-ppc64le", + "noarch": "generic", + "sha256": "a8fbc583557f751b1c4aef81f007dd82702d0568defe7251395bffd247be8f54", + "size": 188867, + "subdir": "noarch", + "timestamp": 1595254079138, + "version": "2.28.1" + } + }, + "removed": [ + "robotframework-seleniumlibrary-5.0.0-pyh44b312d_0.tar.bz2", + "ryven-3.1.1-pyhd8ed1ab_0.tar.bz2", + "ryven-3.1.1-pyhd8ed1ab_1.tar.bz2", + "ryven-3.1.1-pyhd8ed1ab_2.tar.bz2", + "sardana-3.4.0-pyhd8ed1ab_0.conda", + "sardana-client-3.4.0-pyhd8ed1ab_0.conda", + "sardana-config-3.4.0-pyhd8ed1ab_0.conda", + "sardana-server-3.4.0-pyhd8ed1ab_0.conda", + "scienceplots-1.0.9-pyhd8ed1ab_0.tar.bz2", + "scienceplots-1.0.9-pyhd8ed1ab_1.tar.bz2", + "sdmetrics-0.4.0-pyhd8ed1ab_0.tar.bz2", + "segregation-2.3.1-pyhd8ed1ab_0.tar.bz2", + "sendgrid-5.3.0-py_0.tar.bz2", + "sentry-sdk-0.5.3-py_0.tar.bz2", + "setuptools-65.6.0-pyhd8ed1ab_0.conda", + "setuptools-scm-6.1.0-pyh6c4a22f_0.tar.bz2", + "setuptools-scm-6.1.0-pyhd8ed1ab_1.tar.bz2", + "setuptools_scm-6.1.0-hd8ed1ab_0.tar.bz2", + "setuptools_scm-6.1.0-hd8ed1ab_1.tar.bz2", + "shakenbreak-22.12.2-pyhd8ed1ab_0.conda", + "shakenbreak-23.1.7-pyhd8ed1ab_0.conda", + "shakenbreak-23.4.27-pyhd8ed1ab_0.conda", + "shakenbreak-23.4.27-pyhd8ed1ab_2.conda", + "sysroot_linux-ppc64le-2.17-h8b29623_3.tar.bz2", + "sysroot_linux-ppc64le-2.17-h8b29623_4.tar.bz2", + "sysroot_linux-ppc64le-2.17-h8b29623_8.tar.bz2", + "sysroot_linux-ppc64le-2.17-h8b29623_9.tar.bz2", + "tomli-2.0.0-pyhd8ed1ab_0.tar.bz2", + "tpot-0.11.6.post2-pyhd3deb0d_0.tar.bz2", + "tqdm-4.53.0-pyhd3deb0d_0.tar.bz2", + "unyt-2.9.0-pyhd8ed1ab_0.tar.bz2", + "unyt-2.9.2-pyhd8ed1ab_0.tar.bz2", + "vaex-2.6.0-pyh9f0ad1d_0.tar.bz2", + "weldx-0.3.2-pyh44b312d_0.tar.bz2", + "xbitinfo-0.0.4.dev0-pyhd8ed1ab_0.conda", + "xbitinfo-0.0.4.dev1-hd8ed1ab_0.conda", + "xbyak-6.69.1-h4af843d_1.conda", + "xradarsat2-2025.5.16-pyhd8ed1ab_0.conda", + "yamllint-1.24.0-pyh9f0ad1d_0.tar.bz2" + ], + "repodata_version": 1 +} diff --git a/robocorp-code/tests/robocorp_code_tests/deps/test_conda_cloud/test_conda_cloud_index.yml b/robocorp-code/tests/robocorp_code_tests/deps/test_conda_cloud/test_conda_cloud_index.yml new file mode 100644 index 0000000000..459d0740ac --- /dev/null +++ b/robocorp-code/tests/robocorp_code_tests/deps/test_conda_cloud/test_conda_cloud_index.yml @@ -0,0 +1,14 @@ +- package_name: aadict + subdir_to_build_and_depends_json_bytes: + noarch: + - - pyh9f0ad1d_0 + - '["python","six >=1.6.0"]' + timestamp: 1602526568722 + version: 0.2.3 +- package_name: aadict + subdir_to_build_and_depends_json_bytes: + noarch: + - - pyh9f0ad1d_0 + - '["python","six >=1.6.0"]' + timestamp: 1602526578722 + version: 0.2.5 diff --git a/robocorp-code/tests/robocorp_code_tests/deps/test_deps.py b/robocorp-code/tests/robocorp_code_tests/deps/test_deps.py index 4db8ae37d8..89f6121d71 100644 --- a/robocorp-code/tests/robocorp_code_tests/deps/test_deps.py +++ b/robocorp-code/tests/robocorp_code_tests/deps/test_deps.py @@ -44,7 +44,7 @@ def test_python_version(check_conda_yaml, name: str, patch_pypi_cloud) -> None: check_conda_yaml(name) -def test_hover_conda_yaml_pos(datadir, patch_pypi_cloud): +def test_hover_conda_yaml_pip_package(datadir, patch_pypi_cloud): from robocorp_code.deps.analyzer import Analyzer doc = get_conda_yaml_doc(datadir, "check_python_version") @@ -55,14 +55,29 @@ def test_hover_conda_yaml_pos(datadir, patch_pypi_cloud): assert pip_dep.name == "rpaframework" -def test_hover_conda_yaml_rpaframework(datadir, data_regression, patch_pypi_cloud): +def test_hover_conda_yaml_conda_package(datadir, patch_pypi_cloud): + from robocorp_code.deps.analyzer import Analyzer + + doc = get_conda_yaml_doc(datadir, "check_python_version") + + analyzer = Analyzer(doc.source, doc.path) + conda_dep = analyzer.find_conda_dep_at(10, 7) + assert conda_dep is not None + assert conda_dep.name == "python" + + +def test_hover_conda_yaml_rpaframework( + datadir, data_regression, patch_pypi_cloud, cached_conda_cloud +): from robocorp_code.deps.pypi_cloud import PyPiCloud from robocorp_code.hover import hover_on_conda_yaml doc = get_conda_yaml_doc(datadir, "check_python_version") pypi_cloud = PyPiCloud() - data_regression.check(hover_on_conda_yaml(doc, 14, 17, pypi_cloud)) + data_regression.check( + hover_on_conda_yaml(doc, 14, 17, pypi_cloud, cached_conda_cloud) + ) def test_conda_version_spec_api(): diff --git a/robocorp-code/tests/robocorp_code_tests/deps/test_deps/test_hover_conda_yaml_rpaframework.yml b/robocorp-code/tests/robocorp_code_tests/deps/test_deps/test_hover_conda_yaml_rpaframework.yml index 861bb7d3dd..48a4cf35c7 100644 --- a/robocorp-code/tests/robocorp_code_tests/deps/test_deps/test_hover_conda_yaml_rpaframework.yml +++ b/robocorp-code/tests/robocorp_code_tests/deps/test_deps/test_hover_conda_yaml_rpaframework.yml @@ -1,23 +1,22 @@ contents: kind: markdown - value: "# rpaframework\nVersion `22.5.3` was released at: `2023-05-02T04:59:50`\n\ - \nLast release version: `24.1.2` done at: `2023-07-27T17:37:55`.\n\nVersions released\ - \ in the last 12 months:\n`24.1.2`, `24.1.1`, `24.1.0`, `24.0.0`, `23.5.2`, `23.5.1`,\ - \ `23.5.0`, `23.4.0`, `23.3.0`, `23.2.1`, `23.2.0`, `23.1.0`, `23.0.0`, `22.5.3`,\ - \ `22.5.2`, `22.5.1`, `22.5.0`, `22.4.0`, `22.3.0`, `22.2.3`, `22.2.2`, `22.2.1`,\ - \ `22.2.0`, `22.1.1`, `22.1.0`, `22.0.1`, `22.0.0`, `21.1.1`, `21.1.0`, `21.0.1`,\ - \ `21.0.0`, `20.1.2`, `20.1.1`, `20.1.0`, `20.0.2`, `20.0.1`, `20.0.0`, `19.4.2`,\ - \ `19.4.1`, `19.4.0`, `19.3.1`, `19.3.0`, `19.2.0`, `19.1.2`, `19.1.1`, `19.1.0`,\ - \ `19.0.0`, `18.0.0`, `17.7.0`, `17.6.0`, `17.5.2`, `17.5.1`, `17.5.0`, `17.4.0`,\ - \ `17.3.0`, `17.2.0`, `17.1.1`, `17.1.0`, `17.0.1`, `17.0.0`, `16.3.0`, `16.2.0`,\ - \ `16.1.0`, `16.0.0`, `15.9.0`, `15.8.1`, `15.8.0`, `15.7.0`\n\n**Home Page**:\ - \ https://rpaframework.org/\n\n**Package URL**: https://pypi.org/project/rpaframework/\n\ - \n**Repository**: https://github.com/robocorp/rpaframework\n## Requirements:\n\ - - docutils\n- rpaframework-core (>=11.0.5,<12.0.0)\n- rpaframework-pdf (>=7.1.5,<8.0.0)\n\ - - rpaframework-windows (>=7.3.2,<8.0.0) ; sys_platform == \"win32\"\n- java-access-bridge-wrapper\ - \ (==0.14.1)\n- robocorp-storage (>=0.3.2,<0.4.0)\n- jsonpath-ng (>=1.5.2,<2.0.0)\n\ - - robotframework (>=4.0.0,!=4.0.1,<6.0.0)\n- robotframework-sapguilibrary (>=1.1,<2.0)\ - \ ; sys_platform == \"win32\"\n- robotframework-seleniumlibrary (>=6.0.0,<7.0.0)\n\ + value: "# rpaframework\nVersion `22.5.3` was released at: `2023-05-02`\n\nLast release\ + \ version: `24.1.2` done at: `2023-07-27`.\n\nVersions released in the last 12\ + \ months:\n`24.1.2`, `24.1.1`, `24.1.0`, `24.0.0`, `23.5.2`, `23.5.1`, `23.5.0`,\ + \ `23.4.0`, `23.3.0`, `23.2.1`, `23.2.0`, `23.1.0`, `23.0.0`, `22.5.3`, `22.5.2`,\ + \ `22.5.1`, `22.5.0`, `22.4.0`, `22.3.0`, `22.2.3`, `22.2.2`, `22.2.1`, `22.2.0`,\ + \ `22.1.1`, `22.1.0`, `22.0.1`, `22.0.0`, `21.1.1`, `21.1.0`, `21.0.1`, `21.0.0`,\ + \ `20.1.2`, `20.1.1`, `20.1.0`, `20.0.2`, `20.0.1`, `20.0.0`, `19.4.2`, `19.4.1`,\ + \ `19.4.0`, `19.3.1`, `19.3.0`, `19.2.0`, `19.1.2`, `19.1.1`, `19.1.0`, `19.0.0`,\ + \ `18.0.0`, `17.7.0`, `17.6.0`, `17.5.2`, `17.5.1`, `17.5.0`, `17.4.0`, `17.3.0`,\ + \ `17.2.0`, `17.1.1`, `17.1.0`, `17.0.1`, `17.0.0`, `16.3.0`, `16.2.0`, `16.1.0`,\ + \ `16.0.0`, `15.9.0`, `15.8.1`, `15.8.0`, `15.7.0`\n\n**Home Page**: https://rpaframework.org/\n\ + \n**Package URL**: https://pypi.org/project/rpaframework/\n\n**Repository**: https://github.com/robocorp/rpaframework\n\ + ## Requirements:\n- docutils\n- rpaframework-core (>=11.0.5,<12.0.0)\n- rpaframework-pdf\ + \ (>=7.1.5,<8.0.0)\n- rpaframework-windows (>=7.3.2,<8.0.0) ; sys_platform ==\ + \ \"win32\"\n- java-access-bridge-wrapper (==0.14.1)\n- robocorp-storage (>=0.3.2,<0.4.0)\n\ + - jsonpath-ng (>=1.5.2,<2.0.0)\n- robotframework (>=4.0.0,!=4.0.1,<6.0.0)\n- robotframework-sapguilibrary\ + \ (>=1.1,<2.0) ; sys_platform == \"win32\"\n- robotframework-seleniumlibrary (>=6.0.0,<7.0.0)\n\ - robotframework-seleniumtestability (>=2.0.0,<3.0.0)\n- robotframework-requests\ \ (>=0.9.1,<0.10.0)\n- pywinauto (>=0.6.8,<0.7.0) ; python_full_version != \"\ 3.7.6\" and python_full_version != \"3.8.1\" and sys_platform == \"win32\"\n-\ diff --git a/robocorp-code/tests/robocorp_code_tests/fixtures.py b/robocorp-code/tests/robocorp_code_tests/fixtures.py index 21a1a1e772..702d228ee1 100644 --- a/robocorp-code/tests/robocorp_code_tests/fixtures.py +++ b/robocorp-code/tests/robocorp_code_tests/fixtures.py @@ -83,6 +83,55 @@ def cases(tmpdir_factory) -> CasesFixture: return CasesFixture(copy_to, original_resources_dir) +@pytest.fixture( + scope="session", +) +def cached_conda_cloud(): + from robocorp_code.deps import conda_cloud + + f = __file__ + original_resources_dir = Path(os.path.join(os.path.dirname(f), "_resources")) + assert original_resources_dir.exists() + conda_cache = original_resources_dir / "conda-forge cache" + conda_indexes = conda_cache / ".conda_indexes" + + # Uncomment to update with the latest conda forge information. + # Note: remove existing first to generate with the same index number. + # Note: we generate just for the libraries we're interested in to keep + # the sqlite db small. + # + # import shutil + # conda_cloud.INDEX_FOR_LIBRARIES = set(["numpy", "mu_repo", "python", "pip"]) + # if conda_indexes.exists(): + # shutil.rmtree(conda_indexes) + # conda = conda_cloud.CondaCloud(conda_indexes) + # conda.schedule_update(wait=True, force=True) + + assert conda_cache.exists() + assert (conda_indexes / "index_0001" / "win-64.db").exists() + conda = conda_cloud.CondaCloud(conda_indexes, reindex_if_old=False) + assert conda.is_information_cached() + return conda + + +@pytest.fixture(scope="session", autouse=True) +def patch_conda_forge_cloud_setup(cached_conda_cloud): + from pytest import MonkeyPatch + from robocorp_code.robocorp_language_server import RobocorpLanguageServer + + def _create_conda_cloud(self, _cache_dir: str): + return cached_conda_cloud + + monkeypatch = MonkeyPatch() + monkeypatch.setattr( + RobocorpLanguageServer, + "_create_conda_cloud", + _create_conda_cloud, + ) + yield + monkeypatch.undo() + + @pytest.fixture def robocorp_home(tmpdir) -> str: # import shutil diff --git a/robocorp-code/tests/robocorp_code_tests/test_language_server_directly.py b/robocorp-code/tests/robocorp_code_tests/test_language_server_directly.py index 06a5d42826..d70ecfd68c 100644 --- a/robocorp-code/tests/robocorp_code_tests/test_language_server_directly.py +++ b/robocorp-code/tests/robocorp_code_tests/test_language_server_directly.py @@ -1,6 +1,7 @@ -from robocorp_code_tests.fixtures import RccPatch import pytest +from robocorp_code_tests.fixtures import RccPatch + def test_cloud_list_workspaces_cache_invalidate( rcc_patch: RccPatch, @@ -9,9 +10,9 @@ def test_cloud_list_workspaces_cache_invalidate( ci_endpoint: str, rcc_config_location: str, ): + from robocorp_code.rcc import AccountInfo from robocorp_code.robocorp_language_server import RobocorpLanguageServer from robocorp_ls_core.constants import NULL - from robocorp_code.rcc import AccountInfo rcc_patch.apply() @@ -42,9 +43,7 @@ def test_cloud_list_workspaces_cache_invalidate( rcc_patch.disallow_calls() assert language_server._cloud_list_workspaces({"refresh": False})["success"] - rcc.last_verified_account_info.account = AccountInfo( - "another account", "123", "", "" - ) + rcc._last_verified_account_info = AccountInfo("another account", "123", "", "") # As account changed, the data should be fetched (as we can't due to the patching # the error is expected). diff --git a/robocorp-code/tests/robocorp_code_tests/test_vscode_integration.py b/robocorp-code/tests/robocorp_code_tests/test_vscode_integration.py index 3ef1038f6c..5435696a66 100644 --- a/robocorp-code/tests/robocorp_code_tests/test_vscode_integration.py +++ b/robocorp-code/tests/robocorp_code_tests/test_vscode_integration.py @@ -526,7 +526,62 @@ def test_compute_python_launch_from_robocorp_code_launch( } -def test_hover_conda_yaml_versions( +@pytest.mark.skipif( + sys.platform != "win32", reason="As the base platform changes so does the result." +) +def test_hover_conda_yaml_conda_forge_versions( + language_server_initialized: IRobocorpLanguageServerClient, + data_regression, + patch_pypi_cloud, + patch_conda_forge_cloud_setup, +): + from robocorp_ls_core.workspace import Document + + client = language_server_initialized + uri = "x/y/conda.yaml" + txt = """ +channels: + - conda-forge + +dependencies: + - python=3.7 + - pip=22.1.2 + - mu_repo=1.8.2""" + doc = Document("", txt) + client.open_doc(uri, 1, txt) + line, col = doc.get_last_line_col() + col -= 10 + ret = client.hover(uri, line, col) + data_regression.check(ret["result"]) + + +@pytest.mark.skipif( + sys.platform != "win32", reason="As the base platform changes so does the result." +) +def test_hover_conda_yaml_conda_forge_numpy_versions( + language_server_initialized: IRobocorpLanguageServerClient, + data_regression, + patch_pypi_cloud, +): + from robocorp_ls_core.workspace import Document + + client = language_server_initialized + uri = "x/y/conda.yaml" + txt = """ +channels: + - conda-forge + +dependencies: + - numpy""" + doc = Document("", txt) + client.open_doc(uri, 1, txt) + line, col = doc.get_last_line_col() + col -= 2 + ret = client.hover(uri, line, col) + data_regression.check(ret["result"]) + + +def test_hover_conda_yaml_pypi_versions( language_server_initialized: IRobocorpLanguageServerClient, data_regression, patch_pypi_cloud, diff --git a/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_conda_forge_numpy_versions.yml b/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_conda_forge_numpy_versions.yml new file mode 100644 index 0000000000..6a84f4b248 --- /dev/null +++ b/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_conda_forge_numpy_versions.yml @@ -0,0 +1,62 @@ +contents: + kind: markdown + value: '# numpy + + Conda-forge information: + + + Last release version: `1.25.2` done at: `2023-08-03`. + + ## Requirements (win-64): + + - libblas + + - libcblas + + - liblapack + + - pypy3.9 + + - python + + - python_abi + + - ucrt + + - vc + + - vc14_runtime + + ## Requirements difference in linux-64 (compared with win-64): + + - Added: libgcc-ng + + - Added: libstdcxx-ng + + - Removed: ucrt + + - Removed: vc + + - Removed: vc14_runtime + + ## Requirements difference in osx-64 (compared with win-64): + + - Added: libcxx + + - Removed: ucrt + + - Removed: vc + + - Removed: vc14_runtime + + + Versions released in the last 12 months: + + `1.25.2`, `1.24.4`, `1.24.3`, `1.23.5`' +range: + end: + character: 9 + line: 5 + start: + character: 4 + line: 5 diff --git a/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_conda_forge_versions.yml b/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_conda_forge_versions.yml new file mode 100644 index 0000000000..983e096fb5 --- /dev/null +++ b/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_conda_forge_versions.yml @@ -0,0 +1,24 @@ +contents: + kind: markdown + value: '# mu_repo + + Conda-forge information: + + + Last release version: `1.8.2` done at: `2022-09-01`. + + ## Requirements (noarch): + + - python + + + Versions released in the last 12 months: + + `1.8.2`' +range: + end: + character: 17 + line: 7 + start: + character: 4 + line: 7 diff --git a/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_versions.yml b/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_pypi_versions.yml similarity index 95% rename from robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_versions.yml rename to robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_pypi_versions.yml index 113d498b2d..fc884f97c4 100644 --- a/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_versions.yml +++ b/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_pypi_versions.yml @@ -1,23 +1,22 @@ contents: kind: markdown - value: "# rpaframework\nVersion `22.5.3` was released at: `2023-05-02T04:59:50`\n\ - \nLast release version: `24.1.2` done at: `2023-07-27T17:37:55`.\n\nVersions released\ - \ in the last 12 months:\n`24.1.2`, `24.1.1`, `24.1.0`, `24.0.0`, `23.5.2`, `23.5.1`,\ - \ `23.5.0`, `23.4.0`, `23.3.0`, `23.2.1`, `23.2.0`, `23.1.0`, `23.0.0`, `22.5.3`,\ - \ `22.5.2`, `22.5.1`, `22.5.0`, `22.4.0`, `22.3.0`, `22.2.3`, `22.2.2`, `22.2.1`,\ - \ `22.2.0`, `22.1.1`, `22.1.0`, `22.0.1`, `22.0.0`, `21.1.1`, `21.1.0`, `21.0.1`,\ - \ `21.0.0`, `20.1.2`, `20.1.1`, `20.1.0`, `20.0.2`, `20.0.1`, `20.0.0`, `19.4.2`,\ - \ `19.4.1`, `19.4.0`, `19.3.1`, `19.3.0`, `19.2.0`, `19.1.2`, `19.1.1`, `19.1.0`,\ - \ `19.0.0`, `18.0.0`, `17.7.0`, `17.6.0`, `17.5.2`, `17.5.1`, `17.5.0`, `17.4.0`,\ - \ `17.3.0`, `17.2.0`, `17.1.1`, `17.1.0`, `17.0.1`, `17.0.0`, `16.3.0`, `16.2.0`,\ - \ `16.1.0`, `16.0.0`, `15.9.0`, `15.8.1`, `15.8.0`, `15.7.0`\n\n**Home Page**:\ - \ https://rpaframework.org/\n\n**Package URL**: https://pypi.org/project/rpaframework/\n\ - \n**Repository**: https://github.com/robocorp/rpaframework\n## Requirements:\n\ - - docutils\n- rpaframework-core (>=11.0.5,<12.0.0)\n- rpaframework-pdf (>=7.1.5,<8.0.0)\n\ - - rpaframework-windows (>=7.3.2,<8.0.0) ; sys_platform == \"win32\"\n- java-access-bridge-wrapper\ - \ (==0.14.1)\n- robocorp-storage (>=0.3.2,<0.4.0)\n- jsonpath-ng (>=1.5.2,<2.0.0)\n\ - - robotframework (>=4.0.0,!=4.0.1,<6.0.0)\n- robotframework-sapguilibrary (>=1.1,<2.0)\ - \ ; sys_platform == \"win32\"\n- robotframework-seleniumlibrary (>=6.0.0,<7.0.0)\n\ + value: "# rpaframework\nVersion `22.5.3` was released at: `2023-05-02`\n\nLast release\ + \ version: `24.1.2` done at: `2023-07-27`.\n\nVersions released in the last 12\ + \ months:\n`24.1.2`, `24.1.1`, `24.1.0`, `24.0.0`, `23.5.2`, `23.5.1`, `23.5.0`,\ + \ `23.4.0`, `23.3.0`, `23.2.1`, `23.2.0`, `23.1.0`, `23.0.0`, `22.5.3`, `22.5.2`,\ + \ `22.5.1`, `22.5.0`, `22.4.0`, `22.3.0`, `22.2.3`, `22.2.2`, `22.2.1`, `22.2.0`,\ + \ `22.1.1`, `22.1.0`, `22.0.1`, `22.0.0`, `21.1.1`, `21.1.0`, `21.0.1`, `21.0.0`,\ + \ `20.1.2`, `20.1.1`, `20.1.0`, `20.0.2`, `20.0.1`, `20.0.0`, `19.4.2`, `19.4.1`,\ + \ `19.4.0`, `19.3.1`, `19.3.0`, `19.2.0`, `19.1.2`, `19.1.1`, `19.1.0`, `19.0.0`,\ + \ `18.0.0`, `17.7.0`, `17.6.0`, `17.5.2`, `17.5.1`, `17.5.0`, `17.4.0`, `17.3.0`,\ + \ `17.2.0`, `17.1.1`, `17.1.0`, `17.0.1`, `17.0.0`, `16.3.0`, `16.2.0`, `16.1.0`,\ + \ `16.0.0`, `15.9.0`, `15.8.1`, `15.8.0`, `15.7.0`\n\n**Home Page**: https://rpaframework.org/\n\ + \n**Package URL**: https://pypi.org/project/rpaframework/\n\n**Repository**: https://github.com/robocorp/rpaframework\n\ + ## Requirements:\n- docutils\n- rpaframework-core (>=11.0.5,<12.0.0)\n- rpaframework-pdf\ + \ (>=7.1.5,<8.0.0)\n- rpaframework-windows (>=7.3.2,<8.0.0) ; sys_platform ==\ + \ \"win32\"\n- java-access-bridge-wrapper (==0.14.1)\n- robocorp-storage (>=0.3.2,<0.4.0)\n\ + - jsonpath-ng (>=1.5.2,<2.0.0)\n- robotframework (>=4.0.0,!=4.0.1,<6.0.0)\n- robotframework-sapguilibrary\ + \ (>=1.1,<2.0) ; sys_platform == \"win32\"\n- robotframework-seleniumlibrary (>=6.0.0,<7.0.0)\n\ - robotframework-seleniumtestability (>=2.0.0,<3.0.0)\n- robotframework-requests\ \ (>=0.9.1,<0.10.0)\n- pywinauto (>=0.6.8,<0.7.0) ; python_full_version != \"\ 3.7.6\" and python_full_version != \"3.8.1\" and sys_platform == \"win32\"\n-\ diff --git a/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_versions_no_releases.yml b/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_versions_no_releases.yml index 64c632afd4..0d735087bb 100644 --- a/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_versions_no_releases.yml +++ b/robocorp-code/tests/robocorp_code_tests/test_vscode_integration/test_hover_conda_yaml_versions_no_releases.yml @@ -1,14 +1,14 @@ contents: kind: markdown - value: "# rpaframework\nVersion `22.5.3` was released at: `2023-05-02T04:59:50`\n\ - \nLast release version: `24.1.2` done at: `2023-07-27T17:37:55`.\n\nNote: no releases\ - \ in the last 12 months.\n\n**Home Page**: https://rpaframework.org/\n\n**Package\ - \ URL**: https://pypi.org/project/rpaframework/\n\n**Repository**: https://github.com/robocorp/rpaframework\n\ - ## Requirements:\n- docutils\n- rpaframework-core (>=11.0.5,<12.0.0)\n- rpaframework-pdf\ - \ (>=7.1.5,<8.0.0)\n- rpaframework-windows (>=7.3.2,<8.0.0) ; sys_platform ==\ - \ \"win32\"\n- java-access-bridge-wrapper (==0.14.1)\n- robocorp-storage (>=0.3.2,<0.4.0)\n\ - - jsonpath-ng (>=1.5.2,<2.0.0)\n- robotframework (>=4.0.0,!=4.0.1,<6.0.0)\n- robotframework-sapguilibrary\ - \ (>=1.1,<2.0) ; sys_platform == \"win32\"\n- robotframework-seleniumlibrary (>=6.0.0,<7.0.0)\n\ + value: "# rpaframework\nVersion `22.5.3` was released at: `2023-05-02`\n\nLast release\ + \ version: `24.1.2` done at: `2023-07-27`.\n\nNote: no releases in the last 12\ + \ months.\n\n**Home Page**: https://rpaframework.org/\n\n**Package URL**: https://pypi.org/project/rpaframework/\n\ + \n**Repository**: https://github.com/robocorp/rpaframework\n## Requirements:\n\ + - docutils\n- rpaframework-core (>=11.0.5,<12.0.0)\n- rpaframework-pdf (>=7.1.5,<8.0.0)\n\ + - rpaframework-windows (>=7.3.2,<8.0.0) ; sys_platform == \"win32\"\n- java-access-bridge-wrapper\ + \ (==0.14.1)\n- robocorp-storage (>=0.3.2,<0.4.0)\n- jsonpath-ng (>=1.5.2,<2.0.0)\n\ + - robotframework (>=4.0.0,!=4.0.1,<6.0.0)\n- robotframework-sapguilibrary (>=1.1,<2.0)\ + \ ; sys_platform == \"win32\"\n- robotframework-seleniumlibrary (>=6.0.0,<7.0.0)\n\ - robotframework-seleniumtestability (>=2.0.0,<3.0.0)\n- robotframework-requests\ \ (>=0.9.1,<0.10.0)\n- pywinauto (>=0.6.8,<0.7.0) ; python_full_version != \"\ 3.7.6\" and python_full_version != \"3.8.1\" and sys_platform == \"win32\"\n-\ diff --git a/robocorp-code/vscode-client/src/rcc.ts b/robocorp-code/vscode-client/src/rcc.ts index 54b78d3169..b5ca8c0c2d 100644 --- a/robocorp-code/vscode-client/src/rcc.ts +++ b/robocorp-code/vscode-client/src/rcc.ts @@ -139,9 +139,9 @@ async function downloadRcc( // Note: python tests scan this file and get these contants, so, if the format // changes the (failing) test also needs to change. -const BASENAME_PREBUILT_WIN_AMD64 = "8b52318016cc550a_windows_amd64.zip"; -const BASENAME_PREBUILT_DARWIN = "10fe8858c1480f5a_darwin_amd64.zip"; -const BASENAME_PREBUILT_LINUX_AMD64 = "ad4ecd607ed40a13_linux_amd64.zip"; +const BASENAME_PREBUILT_WIN_AMD64 = "17c6f860e21a31b3_windows_amd64.zip"; +const BASENAME_PREBUILT_DARWIN = "2e9b88103258a075_darwin_amd64.zip"; +const BASENAME_PREBUILT_LINUX_AMD64 = "628406c347fb148c_linux_amd64.zip"; function getBaseAsZipBasename() { let basename: string; diff --git a/robotframework-ls/.settings/org.eclipse.core.resources.prefs b/robotframework-ls/.settings/org.eclipse.core.resources.prefs index 4a15be984b..45d1ead408 100644 --- a/robotframework-ls/.settings/org.eclipse.core.resources.prefs +++ b/robotframework-ls/.settings/org.eclipse.core.resources.prefs @@ -1,5 +1,6 @@ eclipse.preferences.version=1 encoding//.settings/org.python.pydev.yaml=UTF-8 +encoding//src/robotframework_debug_adapter/vendored/vendored_pydevd/pydevd_attach_to_process/winappdbg/interactive.py=utf-8 encoding//src/robotframework_debug_adapter/vendored/vendored_pydevd/tests_python/test_debugger.py=utf-8 encoding//tests/robotframework_debug_adapter_tests/fixtures.py=utf-8 encoding//tests/robotframework_ls_tests/fixtures.py=utf-8