架构#

Conda 是一个由许多组件组成的复杂系统,对于用户和开发者来说可能难以理解。以下基于 C4 模型 的架构图将有助于解决这个问题。回顾一下,C4 模型试图以不同的细节级别可视化复杂的软件系统,并向不同类型的受众解释功能。

注意

这些图代表了在为 conda 24.7.1(2024 年 7 月 24 日)构建文档时 Conda 的状态。文档构建过程是自动的,作为 Conda 开发过程的一部分。

C4 代表四个级别

  1. 上下文

  2. 容器

  3. 组件

  4. 代码

级别 1:上下文#

这是 Conda 的概述,30,000 英尺的视角,以便更好地理解 Conda 如何与其他系统交互以及用户如何与之关联。图中 Conda 处于中心位置。

有关如何解释此图的更多信息,请参阅有关 C4 模型 的文档,其中介绍了 系统上下文图

@startuml
!include <C4/C4_Dynamic>
!include ../includes/base.puml

System(conda, "conda", "Software package and environment management system")
SystemDb_Ext(channels, "Channels", "Software package storage systems")

' Include relationships here once we've set the differences.
!include ../includes/rels.puml

@enduml

级别 2:容器#

此级别是对 Conda 的系统级放大,在级别 1 图中处于中心位置,以显示 Conda 的软件架构的高级形状以及 Conda 中的各种职责,包括主要技术选择和各个容器之间通信模式。

有关如何解释以下图的更多信息,请参阅有关 C4 模型 的文档,其中介绍了 容器图

频道#

以下图重点介绍了级别 1 图中的“频道”容器。

@startuml
!include <C4/C4_Container.puml>
!include ../includes/base.puml

' Define the items different to the base diagram
Container(conda, "conda", "Software package and environment management system")

Container_Boundary(channels, "Channels") {
  Container_Boundary(community, "Community-maintained channels") {
    ContainerDb_Ext(bioconda, "bioconda", "Bioinformatics software")
    ContainerDb_Ext(conda_forge, "conda-forge", "General purpose software")
    ContainerDb_Ext(other_channels, "other", "Other channels")
  }
  Container_Boundary(defaults, "Defaults channel, maintained by Anaconda Inc.") {
    ContainerDb(msys2, "MSYS2", "Windows-only software packages")
    ContainerDb(mro, "R", "Microsoft R Open software packages")
    ContainerDb(anaconda, "anaconda", "Main software packages")
  }
}

' Include relationships here once we've set the differences.
!include ../includes/rels.puml

@enduml

Conda#

以下图重点介绍了级别 1 图中的“Conda”容器。

@startuml
!include <C4/C4_Container.puml>
!include ../includes/base.puml

' Define the items different to the base diagram
Container_Boundary(conda, "Conda") {
  Container(conda_api, "conda.api", "Python API", "High-level, public Python API to interact with lower-level functionality")
  Container(conda_base, "conda.base", "Base", "Fast base code loaded on every conda run")
  Container(conda_cli, "conda.cli", "Command Line Interface", "Handles user commands and is divided into subcommands")
  Container(conda_core, "conda.core", "Core", "Contains core application logic, e.g. solver")
  Container(conda_common, "conda.common", "Common", "Generic code that lives next to rest of Conda")
  Container(conda_exceptions, "conda.exceptions", "Exceptions", "Project-wide exception subclasses")
  Container(conda_gateways, "conda.gateways", "I/O", "File and network handling code")
  Container(conda_models, "conda.models", "Models", "Data classes for conda-internal handling")
  Container(conda_resolve, "conda.resolve", "Resolve", "Low-level solver code")
  Container(conda_shell, "conda.shell", "Shell", "Shell support code")
  Container(conda_vendor, "conda._vendor", "Vendor", "Manually maintained")
}

ContainerDb_Ext(channels, "Channels", "Software package storage systems")

' Include relationships here once we've set the differences.
!include ../includes/rels.puml

@enduml

级别 3:组件#

进一步放大,其中从级别 2 中的单个容器分解为 Conda 中的主要构建块及其交互。这些构建块被称为组件,因为它们各自具有更高的功能,并与可识别的职责和实现细节相关。

@startuml packages_conda
set namespaceSeparator none
left to right direction
skinparam nodesep 5
skinparam ranksep 5
package "conda" as conda #77AADD {
}
package "conda.__main__" as conda.__main__ #77AADD {
}
package "conda._version" as conda._version #77AADD {
}
package "conda.activate" as conda.activate #77AADD {
}
package "conda.auxlib" as conda.auxlib #99DDFF {
}
package "conda.auxlib.collection" as conda.auxlib.collection #99DDFF {
}
package "conda.auxlib.decorators" as conda.auxlib.decorators #99DDFF {
}
package "conda.auxlib.entity" as conda.auxlib.entity #99DDFF {
}
package "conda.auxlib.exceptions" as conda.auxlib.exceptions #99DDFF {
}
package "conda.auxlib.ish" as conda.auxlib.ish #99DDFF {
}
package "conda.auxlib.logz" as conda.auxlib.logz #99DDFF {
}
package "conda.auxlib.type_coercion" as conda.auxlib.type_coercion #99DDFF {
}
package "conda.base" as conda.base #44BB99 {
}
package "conda.base.constants" as conda.base.constants #44BB99 {
}
package "conda.base.context" as conda.base.context #44BB99 {
}
package "conda.base.exceptions" as conda.base.exceptions #44BB99 {
}
package "conda.cli" as conda.cli #BBCC33 {
}
package "conda.cli.actions" as conda.cli.actions #BBCC33 {
}
package "conda.cli.common" as conda.cli.common #BBCC33 {
}
package "conda.cli.conda_argparse" as conda.cli.conda_argparse #BBCC33 {
}
package "conda.cli.find_commands" as conda.cli.find_commands #BBCC33 {
}
package "conda.cli.helpers" as conda.cli.helpers #BBCC33 {
}
package "conda.cli.install" as conda.cli.install #BBCC33 {
}
package "conda.cli.main" as conda.cli.main #BBCC33 {
}
package "conda.cli.main_clean" as conda.cli.main_clean #BBCC33 {
}
package "conda.cli.main_compare" as conda.cli.main_compare #BBCC33 {
}
package "conda.cli.main_config" as conda.cli.main_config #BBCC33 {
}
package "conda.cli.main_create" as conda.cli.main_create #BBCC33 {
}
package "conda.cli.main_env" as conda.cli.main_env #BBCC33 {
}
package "conda.cli.main_env_config" as conda.cli.main_env_config #BBCC33 {
}
package "conda.cli.main_env_create" as conda.cli.main_env_create #BBCC33 {
}
package "conda.cli.main_env_export" as conda.cli.main_env_export #BBCC33 {
}
package "conda.cli.main_env_list" as conda.cli.main_env_list #BBCC33 {
}
package "conda.cli.main_env_remove" as conda.cli.main_env_remove #BBCC33 {
}
package "conda.cli.main_env_update" as conda.cli.main_env_update #BBCC33 {
}
package "conda.cli.main_env_vars" as conda.cli.main_env_vars #BBCC33 {
}
package "conda.cli.main_export" as conda.cli.main_export #BBCC33 {
}
package "conda.cli.main_info" as conda.cli.main_info #BBCC33 {
}
package "conda.cli.main_init" as conda.cli.main_init #BBCC33 {
}
package "conda.cli.main_install" as conda.cli.main_install #BBCC33 {
}
package "conda.cli.main_list" as conda.cli.main_list #BBCC33 {
}
package "conda.cli.main_mock_activate" as conda.cli.main_mock_activate #BBCC33 {
}
package "conda.cli.main_mock_deactivate" as conda.cli.main_mock_deactivate #BBCC33 {
}
package "conda.cli.main_notices" as conda.cli.main_notices #BBCC33 {
}
package "conda.cli.main_package" as conda.cli.main_package #BBCC33 {
}
package "conda.cli.main_pip" as conda.cli.main_pip #BBCC33 {
}
package "conda.cli.main_remove" as conda.cli.main_remove #BBCC33 {
}
package "conda.cli.main_rename" as conda.cli.main_rename #BBCC33 {
}
package "conda.cli.main_run" as conda.cli.main_run #BBCC33 {
}
package "conda.cli.main_search" as conda.cli.main_search #BBCC33 {
}
package "conda.cli.main_update" as conda.cli.main_update #BBCC33 {
}
package "conda.cli.python_api" as conda.cli.python_api #BBCC33 {
}
package "conda.common" as conda.common #AAAA00 {
}
package "conda.common._logic" as conda.common._logic #AAAA00 {
}
package "conda.common._os" as conda.common._os #EEDD88 {
}
package "conda.common._os.linux" as conda.common._os.linux #EEDD88 {
}
package "conda.common._os.unix" as conda.common._os.unix #EEDD88 {
}
package "conda.common._os.windows" as conda.common._os.windows #EEDD88 {
}
package "conda.common.configuration" as conda.common.configuration #AAAA00 {
}
package "conda.common.constants" as conda.common.constants #AAAA00 {
}
package "conda.common.decorators" as conda.common.decorators #AAAA00 {
}
package "conda.common.disk" as conda.common.disk #AAAA00 {
}
package "conda.common.io" as conda.common.io #AAAA00 {
}
package "conda.common.iterators" as conda.common.iterators #AAAA00 {
}
package "conda.common.logic" as conda.common.logic #AAAA00 {
}
package "conda.common.path" as conda.common.path #AAAA00 {
}
package "conda.common.pkg_formats" as conda.common.pkg_formats #EE8866 {
}
package "conda.common.pkg_formats.python" as conda.common.pkg_formats.python #EE8866 {
}
package "conda.common.serialize" as conda.common.serialize #AAAA00 {
}
package "conda.common.signals" as conda.common.signals #AAAA00 {
}
package "conda.common.toposort" as conda.common.toposort #AAAA00 {
}
package "conda.common.url" as conda.common.url #AAAA00 {
}
package "conda.core" as conda.core #FFAABB {
}
package "conda.core.envs_manager" as conda.core.envs_manager #FFAABB {
}
package "conda.core.index" as conda.core.index #FFAABB {
}
package "conda.core.initialize" as conda.core.initialize #FFAABB {
}
package "conda.core.link" as conda.core.link #FFAABB {
}
package "conda.core.package_cache" as conda.core.package_cache #FFAABB {
}
package "conda.core.package_cache_data" as conda.core.package_cache_data #FFAABB {
}
package "conda.core.path_actions" as conda.core.path_actions #FFAABB {
}
package "conda.core.portability" as conda.core.portability #FFAABB {
}
package "conda.core.prefix_data" as conda.core.prefix_data #FFAABB {
}
package "conda.core.solve" as conda.core.solve #FFAABB {
}
package "conda.core.subdir_data" as conda.core.subdir_data #FFAABB {
}
package "conda.deprecations" as conda.deprecations #77AADD {
}
package "conda.env" as conda.env #DDDDDD {
}
package "conda.env.env" as conda.env.env #DDDDDD {
}
package "conda.env.installers" as conda.env.installers #77AADD {
}
package "conda.env.installers.base" as conda.env.installers.base #77AADD {
}
package "conda.env.installers.conda" as conda.env.installers.conda #77AADD {
}
package "conda.env.installers.pip" as conda.env.installers.pip #77AADD {
}
package "conda.env.pip_util" as conda.env.pip_util #DDDDDD {
}
package "conda.env.specs" as conda.env.specs #99DDFF {
}
package "conda.env.specs.binstar" as conda.env.specs.binstar #99DDFF {
}
package "conda.env.specs.requirements" as conda.env.specs.requirements #99DDFF {
}
package "conda.env.specs.yaml_file" as conda.env.specs.yaml_file #99DDFF {
}
package "conda.exception_handler" as conda.exception_handler #77AADD {
}
package "conda.exceptions" as conda.exceptions #77AADD {
}
package "conda.gateways" as conda.gateways #44BB99 {
}
package "conda.gateways.anaconda_client" as conda.gateways.anaconda_client #44BB99 {
}
package "conda.gateways.connection" as conda.gateways.connection #BBCC33 {
}
package "conda.gateways.connection.adapters" as conda.gateways.connection.adapters #AAAA00 {
}
package "conda.gateways.connection.adapters.ftp" as conda.gateways.connection.adapters.ftp #AAAA00 {
}
package "conda.gateways.connection.adapters.http" as conda.gateways.connection.adapters.http #AAAA00 {
}
package "conda.gateways.connection.adapters.localfs" as conda.gateways.connection.adapters.localfs #AAAA00 {
}
package "conda.gateways.connection.adapters.s3" as conda.gateways.connection.adapters.s3 #AAAA00 {
}
package "conda.gateways.connection.download" as conda.gateways.connection.download #BBCC33 {
}
package "conda.gateways.connection.session" as conda.gateways.connection.session #BBCC33 {
}
package "conda.gateways.disk" as conda.gateways.disk #EEDD88 {
}
package "conda.gateways.disk.create" as conda.gateways.disk.create #EEDD88 {
}
package "conda.gateways.disk.delete" as conda.gateways.disk.delete #EEDD88 {
}
package "conda.gateways.disk.link" as conda.gateways.disk.link #EEDD88 {
}
package "conda.gateways.disk.lock" as conda.gateways.disk.lock #EEDD88 {
}
package "conda.gateways.disk.permissions" as conda.gateways.disk.permissions #EEDD88 {
}
package "conda.gateways.disk.read" as conda.gateways.disk.read #EEDD88 {
}
package "conda.gateways.disk.test" as conda.gateways.disk.test #EEDD88 {
}
package "conda.gateways.disk.update" as conda.gateways.disk.update #EEDD88 {
}
package "conda.gateways.logging" as conda.gateways.logging #44BB99 {
}
package "conda.gateways.repodata" as conda.gateways.repodata #EE8866 {
}
package "conda.gateways.repodata.jlap" as conda.gateways.repodata.jlap #FFAABB {
}
package "conda.gateways.repodata.jlap.core" as conda.gateways.repodata.jlap.core #FFAABB {
}
package "conda.gateways.repodata.jlap.fetch" as conda.gateways.repodata.jlap.fetch #FFAABB {
}
package "conda.gateways.repodata.jlap.interface" as conda.gateways.repodata.jlap.interface #FFAABB {
}
package "conda.gateways.repodata.lock" as conda.gateways.repodata.lock #EE8866 {
}
package "conda.gateways.subprocess" as conda.gateways.subprocess #44BB99 {
}
package "conda.history" as conda.history #77AADD {
}
package "conda.instructions" as conda.instructions #77AADD {
}
package "conda.models" as conda.models #DDDDDD {
}
package "conda.models.channel" as conda.models.channel #DDDDDD {
}
package "conda.models.dist" as conda.models.dist #DDDDDD {
}
package "conda.models.enums" as conda.models.enums #DDDDDD {
}
package "conda.models.leased_path_entry" as conda.models.leased_path_entry #DDDDDD {
}
package "conda.models.match_spec" as conda.models.match_spec #DDDDDD {
}
package "conda.models.package_info" as conda.models.package_info #DDDDDD {
}
package "conda.models.prefix_graph" as conda.models.prefix_graph #DDDDDD {
}
package "conda.models.records" as conda.models.records #DDDDDD {
}
package "conda.models.version" as conda.models.version #DDDDDD {
}
package "conda.notices" as conda.notices #77AADD {
}
package "conda.notices.cache" as conda.notices.cache #77AADD {
}
package "conda.notices.core" as conda.notices.core #77AADD {
}
package "conda.notices.fetch" as conda.notices.fetch #77AADD {
}
package "conda.notices.types" as conda.notices.types #77AADD {
}
package "conda.notices.views" as conda.notices.views #77AADD {
}
package "conda.plan" as conda.plan #77AADD {
}
package "conda.plugins" as conda.plugins #99DDFF {
}
package "conda.plugins.hookspec" as conda.plugins.hookspec #99DDFF {
}
package "conda.plugins.manager" as conda.plugins.manager #99DDFF {
}
package "conda.plugins.post_solves" as conda.plugins.post_solves #44BB99 {
}
package "conda.plugins.post_solves.signature_verification" as conda.plugins.post_solves.signature_verification #44BB99 {
}
package "conda.plugins.solvers" as conda.plugins.solvers #99DDFF {
}
package "conda.plugins.subcommands" as conda.plugins.subcommands #BBCC33 {
}
package "conda.plugins.subcommands.doctor" as conda.plugins.subcommands.doctor #AAAA00 {
}
package "conda.plugins.subcommands.doctor.health_checks" as conda.plugins.subcommands.doctor.health_checks #AAAA00 {
}
package "conda.plugins.types" as conda.plugins.types #99DDFF {
}
package "conda.plugins.virtual_packages" as conda.plugins.virtual_packages #EEDD88 {
}
package "conda.plugins.virtual_packages.archspec" as conda.plugins.virtual_packages.archspec #EEDD88 {
}
package "conda.plugins.virtual_packages.conda" as conda.plugins.virtual_packages.conda #EEDD88 {
}
package "conda.plugins.virtual_packages.cuda" as conda.plugins.virtual_packages.cuda #EEDD88 {
}
package "conda.plugins.virtual_packages.freebsd" as conda.plugins.virtual_packages.freebsd #EEDD88 {
}
package "conda.plugins.virtual_packages.linux" as conda.plugins.virtual_packages.linux #EEDD88 {
}
package "conda.plugins.virtual_packages.osx" as conda.plugins.virtual_packages.osx #EEDD88 {
}
package "conda.plugins.virtual_packages.windows" as conda.plugins.virtual_packages.windows #EEDD88 {
}
package "conda.resolve" as conda.resolve #77AADD {
}
package "conda.testing" as conda.testing #EE8866 {
}
package "conda.testing.cases" as conda.testing.cases #EE8866 {
}
package "conda.testing.fixtures" as conda.testing.fixtures #EE8866 {
}
package "conda.testing.gateways" as conda.testing.gateways #FFAABB {
}
package "conda.testing.gateways.fixtures" as conda.testing.gateways.fixtures #FFAABB {
}
package "conda.testing.helpers" as conda.testing.helpers #EE8866 {
}
package "conda.testing.integration" as conda.testing.integration #EE8866 {
}
package "conda.testing.notices" as conda.testing.notices #DDDDDD {
}
package "conda.testing.notices.fixtures" as conda.testing.notices.fixtures #DDDDDD {
}
package "conda.testing.notices.helpers" as conda.testing.notices.helpers #DDDDDD {
}
package "conda.testing.solver_helpers" as conda.testing.solver_helpers #EE8866 {
}
package "conda.trust" as conda.trust #77AADD {
}
package "conda.trust.constants" as conda.trust.constants #77AADD {
}
package "conda.trust.signature_verification" as conda.trust.signature_verification #77AADD {
}
conda --> conda._version
conda --> conda.exceptions
conda.__main__ --> conda.cli
conda.__main__ --> conda.cli.main
conda.activate --> conda.base.constants
conda.activate --> conda.base.context
conda.activate --> conda.cli.conda_argparse
conda.activate --> conda.cli.find_commands
conda.activate --> conda.common.path
conda.activate --> conda.deprecations
conda.activate --> conda.exceptions
conda.auxlib.entity --> conda.auxlib.collection
conda.auxlib.entity --> conda.auxlib.exceptions
conda.auxlib.entity --> conda.auxlib.ish
conda.auxlib.entity --> conda.auxlib.logz
conda.auxlib.entity --> conda.auxlib.type_coercion
conda.auxlib.type_coercion --> conda.auxlib.decorators
conda.auxlib.type_coercion --> conda.auxlib.exceptions
conda.base.context --> conda.base.constants
conda.base.context --> conda.base.exceptions
conda.cli --> conda.cli.main
conda.cli.actions --> conda.cli.common
conda.cli.conda_argparse --> conda.cli.actions
conda.cli.conda_argparse --> conda.cli.common
conda.cli.conda_argparse --> conda.cli.find_commands
conda.cli.conda_argparse --> conda.cli.helpers
conda.cli.conda_argparse --> conda.cli.main_clean
conda.cli.conda_argparse --> conda.cli.main_compare
conda.cli.conda_argparse --> conda.cli.main_config
conda.cli.conda_argparse --> conda.cli.main_create
conda.cli.conda_argparse --> conda.cli.main_env
conda.cli.conda_argparse --> conda.cli.main_export
conda.cli.conda_argparse --> conda.cli.main_info
conda.cli.conda_argparse --> conda.cli.main_init
conda.cli.conda_argparse --> conda.cli.main_install
conda.cli.conda_argparse --> conda.cli.main_list
conda.cli.conda_argparse --> conda.cli.main_mock_activate
conda.cli.conda_argparse --> conda.cli.main_mock_deactivate
conda.cli.conda_argparse --> conda.cli.main_notices
conda.cli.conda_argparse --> conda.cli.main_package
conda.cli.conda_argparse --> conda.cli.main_remove
conda.cli.conda_argparse --> conda.cli.main_rename
conda.cli.conda_argparse --> conda.cli.main_run
conda.cli.conda_argparse --> conda.cli.main_search
conda.cli.conda_argparse --> conda.cli.main_update
conda.cli.find_commands --> conda.cli.common
conda.cli.helpers --> conda.cli.actions
conda.cli.helpers --> conda.cli.common
conda.cli.install --> conda.cli.common
conda.cli.install --> conda.cli.common
conda.cli.install --> conda.cli.main_config
conda.cli.main --> conda.cli.common
conda.cli.main --> conda.cli.conda_argparse
conda.cli.main_clean --> conda.cli.actions
conda.cli.main_clean --> conda.cli.common
conda.cli.main_clean --> conda.cli.helpers
conda.cli.main_compare --> conda.cli.common
conda.cli.main_compare --> conda.cli.helpers
conda.cli.main_config --> conda.cli.common
conda.cli.main_config --> conda.cli.common
conda.cli.main_config --> conda.cli.helpers
conda.cli.main_create --> conda.cli.actions
conda.cli.main_create --> conda.cli.common
conda.cli.main_create --> conda.cli.common
conda.cli.main_create --> conda.cli.helpers
conda.cli.main_create --> conda.cli.install
conda.cli.main_env_config --> conda.cli.main_env_vars
conda.cli.main_env_create --> conda.cli.helpers
conda.cli.main_env_export --> conda.cli.main_export
conda.cli.main_env_export --> conda.deprecations
conda.cli.main_env_list --> conda.cli.helpers
conda.cli.main_env_list --> conda.cli.main_info
conda.cli.main_env_list --> conda.deprecations
conda.cli.main_env_remove --> conda.cli.helpers
conda.cli.main_env_update --> conda.cli.helpers
conda.cli.main_env_vars --> conda.cli.helpers
conda.cli.main_export --> conda.cli.common
conda.cli.main_export --> conda.cli.common
conda.cli.main_export --> conda.cli.helpers
conda.cli.main_info --> conda.cli.common
conda.cli.main_info --> conda.cli.common
conda.cli.main_info --> conda.cli.find_commands
conda.cli.main_info --> conda.cli.helpers
conda.cli.main_init --> conda.cli.common
conda.cli.main_init --> conda.cli.helpers
conda.cli.main_install --> conda.cli.actions
conda.cli.main_install --> conda.cli.common
conda.cli.main_install --> conda.cli.helpers
conda.cli.main_install --> conda.cli.install
conda.cli.main_list --> conda.cli.common
conda.cli.main_list --> conda.cli.helpers
conda.cli.main_notices --> conda.cli.helpers
conda.cli.main_package --> conda.cli.common
conda.cli.main_package --> conda.cli.helpers
conda.cli.main_pip --> conda.cli.main
conda.cli.main_remove --> conda.cli.actions
conda.cli.main_remove --> conda.cli.common
conda.cli.main_remove --> conda.cli.common
conda.cli.main_remove --> conda.cli.helpers
conda.cli.main_remove --> conda.cli.install
conda.cli.main_rename --> conda.cli.common
conda.cli.main_rename --> conda.cli.helpers
conda.cli.main_run --> conda.cli.actions
conda.cli.main_run --> conda.cli.common
conda.cli.main_run --> conda.cli.common
conda.cli.main_run --> conda.cli.helpers
conda.cli.main_search --> conda.cli.common
conda.cli.main_search --> conda.cli.helpers
conda.cli.main_update --> conda.cli.common
conda.cli.main_update --> conda.cli.helpers
conda.cli.main_update --> conda.cli.install
conda.cli.python_api --> conda.cli.common
conda.cli.python_api --> conda.cli.conda_argparse
conda.common._logic --> conda.common.constants
conda.common._os --> conda.common._os.windows
conda.common.configuration --> conda.common.constants
conda.common.configuration --> conda.common.serialize
conda.common.io --> conda.common.constants
conda.common.io --> conda.common.io
conda.common.io --> conda.common.path
conda.common.logic --> conda.common._logic
conda.common.path --> conda.common.url
conda.common.serialize --> conda.common.io
conda.common.url --> conda.common.path
conda.core.envs_manager --> conda.core.prefix_data
conda.core.index --> conda.core.package_cache_data
conda.core.index --> conda.core.prefix_data
conda.core.index --> conda.core.subdir_data
conda.core.initialize --> conda.core.portability
conda.core.link --> conda.core.package_cache_data
conda.core.link --> conda.core.path_actions
conda.core.link --> conda.core.prefix_data
conda.core.package_cache --> conda.core.package_cache_data
conda.core.package_cache_data --> conda.core.path_actions
conda.core.path_actions --> conda.core.envs_manager
conda.core.path_actions --> conda.core.package_cache_data
conda.core.path_actions --> conda.core.portability
conda.core.path_actions --> conda.core.prefix_data
conda.core.solve --> conda.core.index
conda.core.solve --> conda.core.link
conda.core.solve --> conda.core.prefix_data
conda.core.solve --> conda.core.subdir_data
conda.core.subdir_data --> conda.core.index
conda.env.installers.conda --> conda.env.installers.base
conda.env.installers.pip --> conda.env.installers.base
conda.env.specs --> conda.env.specs.binstar
conda.env.specs --> conda.env.specs.requirements
conda.env.specs --> conda.env.specs.yaml_file
conda.exception_handler --> conda.auxlib.entity
conda.exception_handler --> conda.auxlib.type_coercion
conda.exception_handler --> conda.base.context
conda.exception_handler --> conda.cli.common
conda.exception_handler --> conda.cli.main
conda.exception_handler --> conda.cli.main_info
conda.exception_handler --> conda.common.io
conda.exception_handler --> conda.exceptions
conda.exceptions --> conda.auxlib.entity
conda.exceptions --> conda.auxlib.ish
conda.exceptions --> conda.auxlib.logz
conda.exceptions --> conda.base.constants
conda.exceptions --> conda.base.context
conda.exceptions --> conda.cli.find_commands
conda.exceptions --> conda.cli.main
conda.exceptions --> conda.common.io
conda.exceptions --> conda.common.iterators
conda.exceptions --> conda.common.signals
conda.exceptions --> conda.common.url
conda.exceptions --> conda.deprecations
conda.exceptions --> conda.exception_handler
conda.exceptions --> conda.models.channel
conda.exceptions --> conda.models.match_spec
conda.exceptions --> conda.models.records
conda.gateways.anaconda_client --> conda.gateways.disk.delete
conda.gateways.anaconda_client --> conda.gateways.logging
conda.gateways.connection.download --> conda.gateways.connection.session
conda.gateways.connection.session --> conda.gateways.connection.adapters.ftp
conda.gateways.connection.session --> conda.gateways.connection.adapters.http
conda.gateways.connection.session --> conda.gateways.connection.adapters.localfs
conda.gateways.connection.session --> conda.gateways.connection.adapters.s3
conda.gateways.disk --> conda.gateways.logging
conda.gateways.disk --> conda.gateways.subprocess
conda.gateways.disk.create --> conda.gateways.disk.delete
conda.gateways.disk.create --> conda.gateways.disk.link
conda.gateways.disk.create --> conda.gateways.disk.permissions
conda.gateways.disk.create --> conda.gateways.disk.update
conda.gateways.disk.delete --> conda.gateways.disk.link
conda.gateways.disk.delete --> conda.gateways.disk.permissions
conda.gateways.disk.permissions --> conda.gateways.disk.link
conda.gateways.disk.read --> conda.gateways.disk.create
conda.gateways.disk.read --> conda.gateways.disk.link
conda.gateways.disk.test --> conda.gateways.disk.create
conda.gateways.disk.test --> conda.gateways.disk.delete
conda.gateways.disk.test --> conda.gateways.disk.link
conda.gateways.disk.update --> conda.gateways.disk.delete
conda.gateways.disk.update --> conda.gateways.disk.link
conda.gateways.logging --> conda.gateways.logging
conda.gateways.repodata --> conda.gateways.connection
conda.gateways.repodata --> conda.gateways.connection.session
conda.gateways.repodata --> conda.gateways.disk
conda.gateways.repodata --> conda.gateways.disk.lock
conda.gateways.repodata --> conda.gateways.repodata.jlap.interface
conda.gateways.repodata.jlap.fetch --> conda.common.url
conda.gateways.repodata.jlap.fetch --> conda.gateways.repodata.jlap.core
conda.gateways.subprocess --> conda.gateways.logging
conda.gateways.subprocess --> conda.gateways.subprocess
conda.history --> conda.auxlib.ish
conda.history --> conda.base.constants
conda.history --> conda.base.context
conda.history --> conda.common.iterators
conda.history --> conda.common.path
conda.history --> conda.core.prefix_data
conda.history --> conda.exceptions
conda.history --> conda.gateways.disk.update
conda.history --> conda.models.dist
conda.history --> conda.models.match_spec
conda.history --> conda.models.version
conda.instructions --> conda.core.link
conda.instructions --> conda.core.package_cache_data
conda.instructions --> conda.deprecations
conda.instructions --> conda.exceptions
conda.instructions --> conda.gateways.disk.link
conda.models.dist --> conda.models.channel
conda.models.dist --> conda.models.match_spec
conda.models.dist --> conda.models.package_info
conda.models.dist --> conda.models.records
conda.models.leased_path_entry --> conda.models.enums
conda.models.match_spec --> conda.models.channel
conda.models.match_spec --> conda.models.records
conda.models.match_spec --> conda.models.version
conda.models.package_info --> conda.models.channel
conda.models.package_info --> conda.models.enums
conda.models.package_info --> conda.models.records
conda.models.prefix_graph --> conda.models.enums
conda.models.prefix_graph --> conda.models.match_spec
conda.models.records --> conda.models.channel
conda.models.records --> conda.models.enums
conda.models.records --> conda.models.match_spec
conda.notices --> conda.core
conda.notices.cache --> conda.notices.types
conda.notices.core --> conda.notices.types
conda.notices.fetch --> conda.notices.cache
conda.notices.fetch --> conda.notices.types
conda.notices.views --> conda.notices.types
conda.plan --> conda.base.constants
conda.plan --> conda.base.context
conda.plan --> conda.cli.install
conda.plan --> conda.common.constants
conda.plan --> conda.common.io
conda.plan --> conda.common.iterators
conda.plan --> conda.core.index
conda.plan --> conda.core.link
conda.plan --> conda.core.package_cache_data
conda.plan --> conda.core.prefix_data
conda.plan --> conda.deprecations
conda.plan --> conda.exceptions
conda.plan --> conda.instructions
conda.plan --> conda.models.channel
conda.plan --> conda.models.dist
conda.plan --> conda.models.enums
conda.plan --> conda.models.match_spec
conda.plan --> conda.models.records
conda.plan --> conda.models.version
conda.plugins --> conda.plugins.hookspec
conda.plugins --> conda.plugins.types
conda.plugins.manager --> conda.plugins.hookspec
conda.plugins.manager --> conda.plugins.subcommands.doctor
conda.plugins.manager --> conda.plugins.subcommands.doctor.health_checks
conda.resolve --> conda.auxlib.decorators
conda.resolve --> conda.base.constants
conda.resolve --> conda.base.context
conda.resolve --> conda.common.io
conda.resolve --> conda.common.iterators
conda.resolve --> conda.common.logic
conda.resolve --> conda.common.toposort
conda.resolve --> conda.core.subdir_data
conda.resolve --> conda.exceptions
conda.resolve --> conda.models.channel
conda.resolve --> conda.models.enums
conda.resolve --> conda.models.match_spec
conda.resolve --> conda.models.records
conda.resolve --> conda.models.version
conda.testing --> conda.activate
conda.testing --> conda.auxlib.entity
conda.testing --> conda.base.constants
conda.testing --> conda.base.context
conda.testing --> conda.cli.main
conda.testing --> conda.common.url
conda.testing --> conda.core.package_cache_data
conda.testing --> conda.deprecations
conda.testing --> conda.exceptions
conda.testing --> conda.models.records
conda.testing.integration --> conda.testing.gateways
conda.trust.signature_verification --> conda.trust.constants
conda.plugins.hookspec ..> conda.plugins.types
conda.plugins.manager ..> conda.plugins.types
@enduml

有关如何解释此图的更多信息,请参阅有关 C4 模型 的文档,其中介绍了 组件图

级别 4:代码#

这部分是根据当前代码自动生成的,显示了代码的结构以及代码之间的交互方式。为了简洁起见,这部分忽略了一些子系统,例如公共 API 和导出模块、实用程序和供应商包。

有关如何解释此图的更多信息,请参阅有关 C4 模型 的文档,其中介绍了 代码图

@startuml classes_conda
set namespaceSeparator none
left to right direction
skinparam nodesep 5
skinparam ranksep 5
class "ActionGroup" as conda.core.link.ActionGroup #FFAABB {
  actions : Iterable[_Action]
  pkg_data : PackageInfo | None
  target_prefix : str
  type : str
}
class "<color:red>ActivateHelp</color>" as conda.exceptions.ActivateHelp #77AADD {
}
class "AggregateCompileMultiPycAction" as conda.core.path_actions.AggregateCompileMultiPycAction #FFAABB {
}
class "Arch" as conda.models.enums.Arch #DDDDDD {
  name
  from_sys()
}
class "ArgParseRawParameter" as conda.common.configuration.ArgParseRawParameter #AAAA00 {
  source : str
  keyflag()
  make_raw_parameters(args_from_argparse)
  value(parameter_obj)
  valueflags(parameter_obj)
}
class "<color:red>ArgumentError</color>" as conda.exceptions.ArgumentError #77AADD {
  return_code : int
}
class "ArgumentParser" as conda.cli.conda_argparse.ArgumentParser #BBCC33 {
  parse_args()
}
class "<color:red>AssignmentError</color>" as conda.auxlib.exceptions.AssignmentError #99DDFF {
}
class "AttrDict" as conda.auxlib.collection.AttrDict #99DDFF {
}
class "AuthBase" as requests.auth.AuthBase #99DDFF {
}
class "<color:red>AuthenticationError</color>" as conda.exceptions.AuthenticationError #77AADD {
}
class "<color:red>AuthenticationError</color>" as conda.auxlib.exceptions.AuthenticationError #99DDFF {
}
class "AuxlibError" as conda.auxlib.exceptions.AuxlibError #99DDFF {
}
class "BaseAdapter" as requests.adapters.BaseAdapter #99DDFF {
  {abstract}close()
  {abstract}send(request, stream, timeout, verify, cert, proxies)
}
class "BaseSpec" as conda.models.version.BaseSpec #DDDDDD {
  exact_value
  match
  raw_value
  spec
  spec_str
  all_match(spec_str)
  always_true_match(spec_str)
  any_match(spec_str)
  exact_match(spec_str)
  is_exact()
  {abstract}merge(other)
  operator_match(spec_str)
  regex_match(spec_str)
}
class "BaseTestCase" as conda.testing.cases.BaseTestCase #EE8866 {
  fixture_names : tuple
  auto_injector_fixture(request)
}
class "<color:red>BasicClobberError</color>" as conda.exceptions.BasicClobberError #77AADD {
}
class "<color:red>BinaryPrefixReplacementError</color>" as conda.exceptions.BinaryPrefixReplacementError #77AADD {
}
class "BinstarSpec" as conda.env.specs.binstar.BinstarSpec #99DDFF {
  binstar
  environment
  file_data
  msg : NoneType
  name : NoneType
  package
  packagename
  username
  can_handle() -> bool
  valid_name() -> bool
  valid_package() -> bool
}
class "BooleanField" as conda.auxlib.entity.BooleanField #99DDFF {
  box(instance, instance_type, val)
}
class "BuildNumberMatch" as conda.models.version.BuildNumberMatch #DDDDDD {
  exact_value
  matcher_vo
  operator_func
  regex
  get_matcher(vspec)
  merge(other)
  union(other)
}
class "CacheUrlAction" as conda.core.path_actions.CacheUrlAction #FFAABB {
  hold_path
  md5 : NoneType
  sha256 : NoneType
  size : NoneType
  target_full_path
  target_package_basename
  target_pkgs_dir
  url
  cleanup()
  execute(progress_update_callback)
  reverse()
  verify()
}
class "<color:red>CancelOperation</color>" as conda.gateways.disk.update.CancelOperation #EEDD88 {
}
class "CaptureTarget" as conda.common.io.CaptureTarget #AAAA00 {
  name
}
class "CapturedText" as conda.common.io.captured.CapturedText #44BB99 {
  stderr : NoneType, StringIO
  stdout : StringIO
}
class "CaseInsensitiveDict" as requests.structures.CaseInsensitiveDict #99DDFF {
  copy()
  lower_items()
}
class "CaseInsensitiveStrMatch" as conda.models.match_spec.CaseInsensitiveStrMatch #DDDDDD {
  match(other)
}
class "ChangeReport" as conda.core.link.ChangeReport #FFAABB {
  downgraded_precs : Iterable[PackageRecord]
  fetch_precs : Iterable[PackageRecord]
  new_precs : Iterable[PackageRecord]
  prefix : str
  removed_precs : Iterable[PackageRecord]
  specs_to_add : Iterable[MatchSpec]
  specs_to_remove : Iterable[MatchSpec]
  superseded_precs : Iterable[PackageRecord]
  updated_precs : Iterable[PackageRecord]
}
class "Channel" as conda.models.channel.Channel #DDDDDD {
  auth : NoneType
  base_url
  base_urls
  canonical_name
  channel_location
  channel_name
  location : NoneType
  name : str
  package_filename : NoneType
  platform : NoneType
  scheme : NoneType
  subdir
  subdir_url
  token : NoneType
  url_channel_wtf
  dump()
  from_channel_name(channel_name)
  from_url(url)
  from_value(value)
  make_simple_channel(channel_alias, channel_url, name)
  url(with_credentials)
  urls(with_credentials, subdirs)
}
class "ChannelAuthBase" as conda.plugins.types.ChannelAuthBase #99DDFF {
}
class "<color:red>ChannelError</color>" as conda.exceptions.ChannelError #77AADD {
}
class "ChannelField" as conda.models.records.ChannelField #DDDDDD {
  dump(instance, instance_type, val)
}
class "ChannelMatch" as conda.models.match_spec.ChannelMatch #DDDDDD {
  match(other)
}
class "ChannelNameMixin" as conda.plugins.types.ChannelNameMixin #99DDFF {
  channel_name : str
}
class "<color:red>ChannelNotAllowed</color>" as conda.exceptions.ChannelNotAllowed #77AADD {
}
class "ChannelNotice" as conda.notices.types.ChannelNotice #77AADD {
  channel_name : str | None
  created_at : datetime | None
  expired_at : datetime | None
  id : str
  interval : int | None
  level
  message : str | None
  to_dict()
}
class "ChannelNoticeResponse" as conda.notices.types.ChannelNoticeResponse #77AADD {
  json_data : dict | None
  name : str
  notices
  url : str
  get_cache_key(url: str, cache_dir: Path) -> Path
}
class "ChannelNoticeResultSet" as conda.notices.types.ChannelNoticeResultSet #77AADD {
  channel_notices : Sequence[ChannelNotice]
  total_number_channel_notices : int
  viewed_channel_notices : int
}
class "ChannelPriority" as conda.base.constants.ChannelPriority #44BB99 {
  DISABLED : str
  FLEXIBLE : str
  STRICT : str
}
class "ChannelPriorityMeta" as conda.base.constants.ChannelPriorityMeta #44BB99 {
}
class "ChannelType" as conda.models.channel.ChannelType #DDDDDD {
}
class "<color:red>ChecksumMismatchError</color>" as conda.exceptions.ChecksumMismatchError #77AADD {
}
class "Clauses" as conda.common._logic.Clauses #AAAA00 {
  add_clause
  add_clauses
  m : int
  unsat : bool
  All(iter, polarity)
  And(f, g, polarity, add_new_clauses)
  Any(iter, polarity)
  AtMostOne_BDD(vals, polarity)
  AtMostOne_NSQ(vals, polarity)
  BDD(lits, coeffs, nterms, lo, hi, polarity)
  Combine(args, polarity)
  Eval(func, args, polarity)
  ExactlyOne_BDD(vals, polarity)
  ExactlyOne_NSQ(vals, polarity)
  ITE(c, t, f, polarity, add_new_clauses)
  LB_Preprocess(lits, coeffs)
  LinearBound(lits, coeffs, lo, hi, preprocess, polarity)
  Not(x, polarity, add_new_clauses)
  Or(f, g, polarity, add_new_clauses)
  Prevent(func)
  Require(func)
  Xor(f, g, polarity, add_new_clauses)
  as_list()
  assign(vals)
  get_clause_count()
  minimize(lits, coeffs, bestsol, trymax)
  new_var()
  sat(additional, includeIf, limit)
}
class "Clauses" as conda.common.logic.Clauses #AAAA00 {
  indices : dict
  m
  names : dict
  unsat
  All(iter, polarity, name)
  And(f, g, polarity, name)
  Any(vals, polarity, name)
  AtMostOne(vals, polarity, name)
  AtMostOne_BDD(vals, polarity, name)
  AtMostOne_NSQ(vals, polarity, name)
  ExactlyOne(vals, polarity, name)
  ExactlyOne_BDD(vals, polarity, name)
  ExactlyOne_NSQ(vals, polarity, name)
  ITE(c, t, f, polarity, name)
  LinearBound(equation, lo, hi, preprocess, polarity, name)
  Not(x, polarity, name)
  Or(f, g, polarity, name)
  Prevent(what)
  Require(what)
  Xor(f, g, polarity, name)
  add_clause(clause)
  add_clauses(clauses)
  as_list()
  from_index(m)
  from_name(name)
  get_clause_count()
  itersolve(constraints, m)
  minimize(objective, bestsol, trymax)
  name_var(m, name)
  new_var(name)
  sat(additional, includeIf, names, limit)
}
class "<color:red>ClobberError</color>" as conda.exceptions.ClobberError #77AADD {
  path_conflict
}
class "CmdExeActivator" as conda.activate.CmdExeActivator #77AADD {
  command_join : str
  export_var_tmpl : str
  hook_source_path : NoneType
  path_conversion : staticmethod
  pathsep_join
  run_script_tmpl : str
  script_extension : str
  sep : str
  set_var_tmpl : str
  tempfile_extension : str
  unset_var_tmpl : str
}
class "<color:red>CommandNotFoundError</color>" as conda.exceptions.CommandNotFoundError #77AADD {
}
class "Commands" as conda.cli.python_api.Commands #BBCC33 {
  CLEAN : str
  CONFIG : str
  CREATE : str
  INFO : str
  INSTALL : str
  LIST : str
  NOTICES : str
  REMOVE : str
  RUN : str
  SEARCH : str
  UPDATE : str
}
class "Commands" as conda.testing.integration.Commands #EE8866 {
  CLEAN : str
  COMPARE : str
  CONFIG : str
  CREATE : str
  INFO : str
  INSTALL : str
  LIST : str
  REMOVE : str
  RUN : str
  SEARCH : str
  UPDATE : str
}
class "Comparable" as tqdm.utils.Comparable #BBCC33 {
}
class "CompileMultiPycAction" as conda.core.path_actions.CompileMultiPycAction #FFAABB {
  package_info
  prefix_path_data : NoneType
  prefix_paths_data
  source_full_paths
  source_short_paths
  target_full_paths
  target_prefix
  target_short_paths
  transaction_context
  {abstract}cleanup()
  create_actions(transaction_context, package_info, target_prefix, requested_link_type, file_link_actions)
  execute()
  reverse()
  verify()
}
class "ComposableField" as conda.auxlib.entity.ComposableField #99DDFF {
  box(instance, instance_type, val)
  dump(instance, instance_type, val)
}
class "CondaAuthHandler" as conda.plugins.types.CondaAuthHandler #99DDFF {
  handler : type[ChannelAuthBase]
  name : str
}
class "CondaCLIFixture" as conda.testing.CondaCLIFixture #77AADD {
  capsys
}
class "<color:red>CondaDependencyError</color>" as conda.exceptions.CondaDependencyError #77AADD {
}
class "<color:red>CondaEnvException</color>" as conda.exceptions.CondaEnvException #77AADD {
}
class "<color:red>CondaEnvironmentError</color>" as conda.exceptions.CondaEnvironmentError #77AADD {
}
class "<color:red>CondaError</color>" as conda.CondaError #77AADD {
  message
  reportable : bool
  return_code : int
  dump_map()
}
class "<color:red>CondaExitZero</color>" as conda.CondaExitZero #77AADD {
  return_code : int
}
class "<color:red>CondaFileIOError</color>" as conda.exceptions.CondaFileIOError #77AADD {
  filepath
}
class "<color:red>CondaHTTPError</color>" as conda.exceptions.CondaHTTPError #77AADD {
}
class "CondaHealthCheck" as conda.plugins.types.CondaHealthCheck #99DDFF {
  action : Callable[[str, bool], None]
  name : str
}
class "<color:red>CondaHistoryError</color>" as conda.exceptions.CondaHistoryError #77AADD {
}
class "<color:red>CondaHistoryWarning</color>" as conda.history.CondaHistoryWarning #77AADD {
}
class "CondaHttpAuth" as conda.gateways.connection.session.CondaHttpAuth #BBCC33 {
  add_binstar_token(url)
  handle_407(response)
}
class "<color:red>CondaIOError</color>" as conda.exceptions.CondaIOError #77AADD {
}
class "<color:red>CondaImportError</color>" as conda.exceptions.CondaImportError #77AADD {
}
class "<color:red>CondaIndexError</color>" as conda.exceptions.CondaIndexError #77AADD {
}
class "<color:red>CondaKeyError</color>" as conda.exceptions.CondaKeyError #77AADD {
  key
  msg
}
class "<color:red>CondaMemoryError</color>" as conda.exceptions.CondaMemoryError #77AADD {
}
class "<color:red>CondaMultiError</color>" as conda.CondaMultiError #77AADD {
  errors
  contains(exception_class)
  dump_map()
}
class "<color:red>CondaOSError</color>" as conda.exceptions.CondaOSError #77AADD {
}
class "CondaPluginManager" as conda.plugins.manager.CondaPluginManager #99DDFF {
  get_cached_solver_backend : NoneType
  disable_external_plugins() -> None
  get_auth_handler(name: str) -> type[AuthBase] | None
  get_canonical_name(plugin: object) -> str
  get_hook_results(name: Literal['subcommands']) -> list[CondaSubcommand]
  get_settings() -> dict[str, ParameterLoader]
  get_solver_backend(name: str | None) -> type[Solver]
  get_solvers() -> dict[str, CondaSolver]
  get_subcommands() -> dict[str, CondaSubcommand]
  get_virtual_packages() -> tuple[CondaVirtualPackage, ...]
  invoke_health_checks(prefix: str, verbose: bool) -> None
  invoke_post_commands(command: str) -> None
  invoke_post_solves(repodata_fn: str, unlink_precs: tuple[PackageRecord, ...], link_precs: tuple[PackageRecord, ...]) -> None
  invoke_pre_commands(command: str) -> None
  invoke_pre_solves(specs_to_add: frozenset[MatchSpec], specs_to_remove: frozenset[MatchSpec]) -> None
  load_entrypoints(group: str, name: str | None) -> int
  load_plugins() -> int
  load_settings() -> None
  register(plugin, name: str | None) -> str | None
}
class "CondaPostCommand" as conda.plugins.types.CondaPostCommand #99DDFF {
  action : Callable[[str], None]
  name : str
  run_for : set[str]
}
class "CondaPostSolve" as conda.plugins.types.CondaPostSolve #99DDFF {
  action : Callable[[str, tuple[PackageRecord, ...], tuple[PackageRecord, ...]], None]
  name : str
}
class "CondaPreCommand" as conda.plugins.types.CondaPreCommand #99DDFF {
  action : Callable[[str], None]
  name : str
  run_for : set[str]
}
class "CondaPreSolve" as conda.plugins.types.CondaPreSolve #99DDFF {
  action : Callable[[frozenset[MatchSpec], frozenset[MatchSpec]], None]
  name : str
}
class "CondaRepoInterface" as conda.gateways.repodata.CondaRepoInterface #44BB99 {
  repodata(state: RepodataState) -> str | None
}
class "<color:red>CondaSSLError</color>" as conda.exceptions.CondaSSLError #77AADD {
}
class "CondaSession" as conda.gateways.connection.session.CondaSession #BBCC33 {
  auth
  cert : tuple
  verify : bool
  cache_clear()
}
class "CondaSessionType" as conda.gateways.connection.session.CondaSessionType #BBCC33 {
}
class "CondaSetting" as conda.plugins.types.CondaSetting #99DDFF {
  aliases : tuple[str, ...]
  description : str
  name : str
  parameter
}
class "<color:red>CondaSignalInterrupt</color>" as conda.exceptions.CondaSignalInterrupt #77AADD {
}
class "CondaSolver" as conda.plugins.types.CondaSolver #99DDFF {
  backend : type[Solver]
  name : str
}
class "CondaSpecs" as conda.plugins.hookspec.CondaSpecs #99DDFF {
  {abstract}conda_auth_handlers() -> Iterable[CondaAuthHandler]
  {abstract}conda_health_checks() -> Iterable[CondaHealthCheck]
  {abstract}conda_post_commands() -> Iterable[CondaPostCommand]
  {abstract}conda_post_solves() -> Iterable[CondaPostSolve]
  {abstract}conda_pre_commands() -> Iterable[CondaPreCommand]
  {abstract}conda_pre_solves() -> Iterable[CondaPreSolve]
  {abstract}conda_settings() -> Iterable[CondaSetting]
  {abstract}conda_solvers() -> Iterable[CondaSolver]
  {abstract}conda_subcommands() -> Iterable[CondaSubcommand]
  {abstract}conda_virtual_packages() -> Iterable[CondaVirtualPackage]
}
class "CondaSubcommand" as conda.plugins.types.CondaSubcommand #99DDFF {
  action : Callable[[Namespace | tuple[str]], int | None]
  configure_parser : Callable[[ArgumentParser], None] | None
  name : str
  summary : str
}
class "<color:red>CondaSystemExit</color>" as conda.exceptions.CondaSystemExit #77AADD {
}
class "<color:red>CondaUpgradeError</color>" as conda.exceptions.CondaUpgradeError #77AADD {
}
class "<color:red>CondaValueError</color>" as conda.exceptions.CondaValueError #77AADD {
}
class "<color:red>CondaVerificationError</color>" as conda.exceptions.CondaVerificationError #77AADD {
}
class "CondaVirtualPackage" as conda.plugins.types.CondaVirtualPackage #99DDFF {
  build : str | None
  name : str
  version : str | None
}
class "Configuration" as conda.common.configuration.Configuration #AAAA00 {
  raw_data : dict
  check_source(source)
  collect_all()
  describe_parameter(parameter_name)
  {abstract}get_descriptions()
  list_parameters()
  post_build_validation()
  register_reset_callaback(callback)
  typify_parameter(parameter_name, value, source)
  validate_all()
  validate_configuration()
}
class "<color:red>ConfigurationError</color>" as conda.common.configuration.ConfigurationError #AAAA00 {
}
class "<color:red>ConfigurationLoadError</color>" as conda.common.configuration.ConfigurationLoadError #AAAA00 {
}
class "ConfigurationObject" as conda.common.configuration.ConfigurationObject #AAAA00 {
}
class "ConfigurationType" as conda.common.configuration.ConfigurationType #AAAA00 {
}
class "Context" as conda.base.context.Context #44BB99 {
  active_prefix
  add_anaconda_token
  add_pip_as_python_dependency
  aggressive_update_packages
  allow_conda_downgrades
  allow_cycles
  allow_non_channel_urls
  allow_softlinks
  allowlist_channels
  always_copy
  always_softlink
  always_yes
  anaconda_upload
  arch_name
  auto_activate_base
  auto_stack
  auto_update_conda
  av_data_dir
  binstar_upload
  bits
  bld_path
  category_map
  changeps1
  channel_priority
  channel_settings
  channels
  client_ssl_cert
  client_ssl_cert_key
  clobber
  conda_build
  conda_build_local_paths
  conda_build_local_urls
  conda_exe
  conda_exe_vars_dict
  conda_prefix
  config_files
  cpu_flags
  create_default_packages
  croot
  debug
  default_prefix
  default_python
  default_threads
  deps_modifier
  dev
  disallowed_packages
  download_only
  dry_run
  enable_private_envs
  env_prompt
  envs_dirs
  envvars_force_uppercase
  error_upload_url
  execute_threads
  experimental
  extra_safety_checks
  fetch_threads
  force
  force_32bit
  force_reinstall
  force_remove
  ignore_pinned
  info
  json
  local_build_root
  local_repodata_ttl
  log_level
  migrated_channel_aliases
  migrated_custom_channels
  no_lock
  no_plugins
  non_admin_enabled
  notify_outdated_conda
  number_channel_notices
  offline
  override_channels_enabled
  path_conflict
  pinned_packages
  pip_interop_enabled
  pkgs_dirs
  platform
  plugin_manager
  plugins
  prefix_specified
  proxy_servers
  quiet
  register_envs
  remote_backoff_factor
  remote_connect_timeout_secs
  remote_max_retries
  remote_read_timeout_secs
  repodata_fns
  repodata_threads
  repodata_use_zst
  report_errors
  restore_free_channel
  rollback_enabled
  root_dir
  root_writable
  safety_checks
  sat_solver
  separate_format_cache
  shlvl
  shortcuts
  shortcuts_only
  show_channel_urls
  signing_metadata_url_base
  solver
  solver_ignore_timestamps
  ssl_verify
  subdir
  subdirs
  target_prefix
  target_prefix_override
  trace
  track_features
  unsatisfiable_hints
  unsatisfiable_hints_check_depth
  update_modifier
  use_index_cache
  use_local
  use_only_tar_bz2
  verbose
  verbosity
  verify_threads
  channel_alias()
  custom_channels()
  custom_multichannels()
  default_channels()
  description_map()
  get_descriptions()
  known_subdirs()
  libc_family_version()
  os_distribution_name_version()
  platform_system_release()
  post_build_validation()
  python_implementation_name_version()
  reporters() -> tuple[Mapping[str, str]]
  requests_version()
  root_prefix()
  solver_user_agent()
  trash_dir()
  user_agent()
}
class "ContextDecorator" as conda.common.io.ContextDecorator #AAAA00 {
}
class "ContextStack" as conda.base.context.ContextStack #44BB99 {
  apply()
  pop()
  push(search_path, argparse_args)
  replace(search_path, argparse_args)
}
class "ContextStackObject" as conda.base.context.ContextStackObject #44BB99 {
  argparse_args : NoneType
  search_path : tuple
  apply()
  set_value(search_path, argparse_args)
}
class "<color:red>CorruptedEnvironmentError</color>" as conda.exceptions.CorruptedEnvironmentError #77AADD {
}
class "<color:red>CouldntParseError</color>" as conda.exceptions.CouldntParseError #77AADD {
  reason
}
class "CreateInPrefixPathAction" as conda.core.path_actions.CreateInPrefixPathAction #FFAABB {
  package_info
  source_full_path
  source_prefix
  source_short_path
  {abstract}cleanup()
  verify()
}
class "CreateNonadminAction" as conda.core.path_actions.CreateNonadminAction #FFAABB {
  create_actions(transaction_context, package_info, target_prefix, requested_link_type)
  execute()
  reverse()
}
class "CreatePrefixRecordAction" as conda.core.path_actions.CreatePrefixRecordAction #FFAABB {
  all_link_path_actions : list
  prefix_record
  requested_link_type
  requested_spec
  create_actions(transaction_context, package_info, target_prefix, requested_link_type, requested_spec, all_link_path_actions)
  execute()
  reverse()
}
class "CreatePythonEntryPointAction" as conda.core.path_actions.CreatePythonEntryPointAction #FFAABB {
  func
  module
  prefix_path_data
  create_actions(transaction_context, package_info, target_prefix, requested_link_type)
  execute()
  reverse()
}
class "CshActivator" as conda.activate.CshActivator #77AADD {
  command_join : str
  export_var_tmpl : str
  hook_source_path : Path
  path_conversion : staticmethod
  pathsep_join
  run_script_tmpl : str
  script_extension : str
  sep : str
  set_var_tmpl : str
  tempfile_extension : NoneType
  unset_var_tmpl : str
}
class "<color:red>CustomValidationError</color>" as conda.common.configuration.CustomValidationError #AAAA00 {
}
class "<color:red>CyclicalDependencyError</color>" as conda.exceptions.CyclicalDependencyError #77AADD {
}
class "DateField" as conda.auxlib.entity.DateField #99DDFF {
  box(instance, instance_type, val)
  dump(instance, instance_type, val)
}
class "<color:red>DeactivateHelp</color>" as conda.exceptions.DeactivateHelp #77AADD {
}
class "DefaultValueRawParameter" as conda.common.configuration.DefaultValueRawParameter #AAAA00 {
  keyflag()
  value(parameter_obj)
  valueflags(parameter_obj)
}
class "DeltaSecondsFormatter" as conda.common.io.DeltaSecondsFormatter #AAAA00 {
  prev_time
  format(record)
}
class "Dependencies" as conda.env.env.Dependencies #DDDDDD {
  raw
  add(package_name)
  parse()
}
class "<color:red>DeprecatedError</color>" as conda.deprecations.DeprecatedError #77AADD {
}
class "DeprecationHandler" as conda.deprecations.DeprecationHandler #77AADD {
  action(deprecate_in: str, remove_in: str, action: ActionType) -> ActionType
  argument(deprecate_in: str, remove_in: str, argument: str) -> Callable[[Callable[P, T]], Callable[P, T]]
  constant(deprecate_in: str, remove_in: str, constant: str, value: Any) -> None
  module(deprecate_in: str, remove_in: str) -> None
  topic(deprecate_in: str, remove_in: str) -> None
}
class "DeprecationMixin" as conda.deprecations.DeprecationHandler.action.DeprecationMixin #AAAA00 {
  category : type[Warning]
  help : str
}
class "DepsModifier" as conda.base.constants.DepsModifier #44BB99 {
  name
}
class "DictSafeMixin" as conda.auxlib.entity.DictSafeMixin #99DDFF {
  copy()
  get(item, default)
  items()
  setdefault(key, default_value)
  update(E)
}
class "<color:red>DirectoryNotACondaEnvironmentError</color>" as conda.exceptions.DirectoryNotACondaEnvironmentError #77AADD {
}
class "<color:red>DirectoryNotFoundError</color>" as conda.exceptions.DirectoryNotFoundError #77AADD {
}
class "DisableOnWriteError" as tqdm.utils.DisableOnWriteError #BBCC33 {
  disable_on_exception(tqdm_instance, func)
}
class "<color:red>DisallowedPackageError</color>" as conda.exceptions.DisallowedPackageError #77AADD {
}
class "Dist" as conda.models.dist.Dist #DDDDDD {
  base_url
  build
  build_number
  build_string
  channel
  dist_name
  fmt
  fn
  full_name
  is_channel
  is_feature_package
  name
  pair
  platform
  quad
  subdir
  version
  from_string(string, channel_override)
  from_url(url)
  parse_dist_name(string)
  rsplit(sep, maxsplit)
  split(sep, maxsplit)
  startswith(match)
  to_filename(extension)
  to_match_spec()
  to_matchspec()
  to_package_ref()
  to_url()
}
class "DistDetails" as conda.models.dist.DistDetails #DDDDDD {
  build_number : str
  build_string : str
  dist_name : str
  fmt : str
  name : str
  version : str
}
class "DistType" as conda.models.dist.DistType #DDDDDD {
}
class "<color:red>DryRunExit</color>" as conda.exceptions.DryRunExit #77AADD {
}
class "DummyArgs" as conda.testing.notices.helpers.DummyArgs #DDDDDD {
  no_ansi_colors : bool
}
class "DummyExecutor" as conda.common.io.DummyExecutor #AAAA00 {
  map(func)
  shutdown(wait)
  submit(fn)
}
class "DumpEncoder" as conda.auxlib.logz.DumpEncoder #99DDFF {
  default(obj)
}
class "EMA" as tqdm.std.EMA #BBCC33 {
  alpha : float
  calls : int
  last : int
}
class "ERROR" as conda.common._os.windows.ERROR #EEDD88 {
  name
}
class "<color:red>EncodingError</color>" as conda.exceptions.EncodingError #77AADD {
}
class "EnforceUnusedAdapter" as conda.gateways.connection.session.EnforceUnusedAdapter #BBCC33 {
  {abstract}close()
  send(request)
}
class "Entity" as conda.auxlib.entity.Entity #99DDFF {
  dump()
  from_json(json_str)
  from_objects()
  json(indent, separators)
  load(data_dict)
  pretty_json(indent, separators)
  validate()
}
class "EntityEncoder" as conda.auxlib.entity.EntityEncoder #99DDFF {
  default(obj)
}
class "EntityType" as conda.auxlib.entity.EntityType #99DDFF {
  fields
}
class "EnumField" as conda.auxlib.entity.EnumField #99DDFF {
  box(instance, instance_type, val)
  dump(instance, instance_type, val)
}
class "EnvAppDirs" as conda.gateways.anaconda_client.EnvAppDirs #44BB99 {
  appauthor
  appname
  root_path
  site_data_dir
  user_cache_dir
  user_data_dir
  user_log_dir
}
class "EnvRawParameter" as conda.common.configuration.EnvRawParameter #AAAA00 {
  source : str
  keyflag()
  make_raw_parameters(appname)
  value(parameter_obj)
  valueflags(parameter_obj)
}
class "Environment" as conda.env.env.Environment #DDDDDD {
  channels : NoneType, list
  dependencies
  filename : NoneType
  name : NoneType
  prefix : NoneType
  variables : NoneType
  add_channels(channels)
  remove_channels()
  save()
  to_dict(stream)
  to_yaml(stream)
}
class "<color:red>EnvironmentFileEmpty</color>" as conda.exceptions.EnvironmentFileEmpty #77AADD {
  filename
}
class "<color:red>EnvironmentFileExtensionNotValid</color>" as conda.exceptions.EnvironmentFileExtensionNotValid #77AADD {
  filename
}
class "<color:red>EnvironmentFileNotDownloaded</color>" as conda.exceptions.EnvironmentFileNotDownloaded #77AADD {
  packagename
  username
}
class "<color:red>EnvironmentFileNotFound</color>" as conda.exceptions.EnvironmentFileNotFound #77AADD {
  filename
}
class "<color:red>EnvironmentLocationNotFound</color>" as conda.exceptions.EnvironmentLocationNotFound #77AADD {
}
class "<color:red>EnvironmentNameNotFound</color>" as conda.exceptions.EnvironmentNameNotFound #77AADD {
}
class "<color:red>EnvironmentNotWritableError</color>" as conda.exceptions.EnvironmentNotWritableError #77AADD {
}
class "Evaluator" as conda.common.pkg_formats.python.Evaluator #EE8866 {
  operations : dict
  evaluate(expr, context)
}
class "ExactLowerStrMatch" as conda.models.match_spec.ExactLowerStrMatch #DDDDDD {
  match(other)
}
class "ExactStrMatch" as conda.models.match_spec.ExactStrMatch #DDDDDD {
  match(other)
}
class "ExceptionHandler" as conda.exception_handler.ExceptionHandler #77AADD {
  error_upload_url
  http_timeout
  user_agent
  get_error_report(exc_val, exc_tb)
  handle_application_exception(exc_val, exc_tb)
  handle_exception(exc_val, exc_tb)
  handle_reportable_application_exception(exc_val, exc_tb)
  handle_unexpected_exception(exc_val, exc_tb)
  print_expected_error_report(error_report)
  print_unexpected_error_report(error_report)
  write_out()
}
class "ExtendConstAction" as conda.cli.actions.ExtendConstAction #BBCC33 {
}
class "ExtractPackageAction" as conda.core.path_actions.ExtractPackageAction #FFAABB {
  hold_path
  md5
  record_or_spec
  sha256
  size
  source_full_path
  target_extracted_dirname
  target_full_path
  target_pkgs_dir
  cleanup()
  execute(progress_update_callback)
  reverse()
  verify()
}
class "FTPAdapter" as conda.gateways.connection.adapters.ftp.FTPAdapter #AAAA00 {
  conn : FTP
  func_table : dict
  {abstract}close()
  get_host_and_path_from_url(request)
  get_username_password_from_header(request)
  list(path, request)
  nlst(path, request)
  retr(path, request)
  send(request)
  stor(path, request)
}
class "FeatureMatch" as conda.models.match_spec.FeatureMatch #DDDDDD {
  exact_value
  match(other)
}
class "Field" as conda.auxlib.entity.Field #99DDFF {
  default
  default_in_dump
  immutable
  in_dump
  is_nullable
  name
  nullable
  required
  type
  box(instance, instance_type, val)
  dump(instance, instance_type, val)
  set_name(name)
  unbox(instance, instance_type, val)
  validate(instance, val)
}
class "FileMode" as conda.models.enums.FileMode #DDDDDD {
  name
}
class "FilenameField" as conda.models.records.FilenameField #DDDDDD {
}
class "FishActivator" as conda.activate.FishActivator #77AADD {
  command_join : str
  export_var_tmpl : str
  hook_source_path : Path
  path_conversion : staticmethod
  pathsep_join
  run_script_tmpl : str
  script_extension : str
  sep : str
  set_var_tmpl : str
  tempfile_extension : NoneType
  unset_var_tmpl : str
}
class "GeneralGraph" as conda.models.prefix_graph.GeneralGraph #DDDDDD {
  graph_by_name : dict
  specs_by_name : defaultdict
  breadth_first_search_by_name(root_spec, target_spec)
}
class "<color:red>GenericHelp</color>" as conda.exceptions.GenericHelp #77AADD {
}
class "GlobLowerStrMatch" as conda.models.match_spec.GlobLowerStrMatch #DDDDDD {
}
class "GlobStrMatch" as conda.models.match_spec.GlobStrMatch #DDDDDD {
  exact_value
  matches_all
  match(other)
}
class "HTTPAdapter" as conda.gateways.connection.adapters.http.HTTPAdapter #AAAA00 {
}
class "HTTPAdapter" as requests.adapters.HTTPAdapter #99DDFF {
  config : dict
  max_retries : NoneType, int
  poolmanager
  proxy_manager : dict
  {abstract}add_headers(request)
  build_response(req, resp)
  cert_verify(conn, url, verify, cert)
  close()
  get_connection(url, proxies)
  init_poolmanager(connections, maxsize, block)
  proxy_headers(proxy)
  proxy_manager_for(proxy)
  request_url(request, proxies)
  send(request, stream, timeout, verify, cert, proxies)
}
class "HashWriter" as conda.gateways.repodata.jlap.fetch.HashWriter #FFAABB {
  backing
  hasher
  close()
  write(b: bytes)
}
class "<color:red>Help</color>" as conda.exceptions.Help #77AADD {
}
class "History" as conda.history.History #77AADD {
  com_pat
  conda_v_pat
  meta_dir
  path
  prefix
  spec_pat
  construct_states()
  file_is_empty()
  get_requested_specs_map()
  get_state(rev)
  get_user_requests()
  init_log_file()
  object_log()
  parse() -> list[tuple[str, set[str], list[str]]]
  print_log()
  update() -> None
  write_changes(last_state, current_state)
  write_specs(remove_specs, update_specs, neutered_specs)
}
class "ImmutableEntity" as conda.auxlib.entity.ImmutableEntity #99DDFF {
}
class "IndexedSet" as boltons.setutils.IndexedSet #EEDD88 {
  dead_indices : list
  item_index_map : dict
  item_list : list
  add(item)
  clear()
  count(val)
  difference()
  difference_update()
  discard(item)
  from_iterable(it)
  index(val)
  intersection()
  intersection_update()
  isdisjoint(other)
  issubset(other)
  issuperset(other)
  iter_difference()
  iter_intersection()
  iter_slice(start, stop, step)
  pop(index)
  remove(item)
  reverse()
  sort()
  symmetric_difference()
  symmetric_difference_update(other)
  union()
  update()
}
class "<color:red>InitializationError</color>" as conda.auxlib.exceptions.InitializationError #99DDFF {
}
class "IntegerField" as conda.auxlib.entity.IntegerField #99DDFF {
}
class "<color:red>InvalidInstaller</color>" as conda.exceptions.InvalidInstaller #77AADD {
}
class "<color:red>InvalidMatchSpec</color>" as conda.exceptions.InvalidMatchSpec #77AADD {
}
class "<color:red>InvalidSpec</color>" as conda.exceptions.InvalidSpec #77AADD {
}
class "<color:red>InvalidTypeError</color>" as conda.common.configuration.InvalidTypeError #AAAA00 {
  valid_types
  wrong_type
}
class "<color:red>InvalidVersionSpec</color>" as conda.exceptions.InvalidVersionSpec #77AADD {
}
class "JLAP" as conda.gateways.repodata.jlap.core.JLAP #FFAABB {
  body
  last
  penultimate
  add(line: str)
  from_lines(lines: Iterable[bytes], iv: bytes, pos, verify)
  from_path(path: Path | str, verify)
  terminate()
  write(path: Path)
}
class "JSONFormatMixin" as conda.activate.JSONFormatMixin #77AADD {
  command_join : list
  pathsep_join : list
  tempfile_extension : NoneType
  get_scripts_export_unset_vars()
}
class "<color:red>Jlap304NotModified</color>" as conda.gateways.repodata.jlap.fetch.Jlap304NotModified #FFAABB {
}
class "<color:red>JlapPatchNotFound</color>" as conda.gateways.repodata.jlap.fetch.JlapPatchNotFound #FFAABB {
}
class "JlapRepoInterface" as conda.gateways.repodata.jlap.interface.JlapRepoInterface #FFAABB {
  repodata(state: dict | RepodataState) -> str | None
  repodata_parsed(state: dict | RepodataState) -> dict | None
}
class "<color:red>JlapSkipZst</color>" as conda.gateways.repodata.jlap.fetch.JlapSkipZst #FFAABB {
}
class "<color:red>KnownPackageClobberError</color>" as conda.exceptions.KnownPackageClobberError #77AADD {
}
class "LeasedPathEntry" as conda.models.leased_path_entry.LeasedPathEntry #DDDDDD {
  leased_path
  leased_path_type
  package_name
  target_path
  target_prefix
}
class "LeasedPathType" as conda.models.enums.LeasedPathType #DDDDDD {
  name
}
class "Link" as conda.models.records.Link #DDDDDD {
  source
  type
}
class "<color:red>LinkError</color>" as conda.exceptions.LinkError #77AADD {
}
class "LinkPathAction" as conda.core.path_actions.LinkPathAction #FFAABB {
  link_type
  prefix_path_data : NoneType
  source_path_data
  create_directory_actions(transaction_context, package_info, target_prefix, requested_link_type, file_link_actions)
  create_file_link_actions(transaction_context, package_info, target_prefix, requested_link_type)
  create_python_entry_point_windows_exe_action(transaction_context, package_info, target_prefix, requested_link_type, entry_point_def)
  execute()
  reverse()
  verify()
}
class "LinkType" as conda.models.enums.LinkType #DDDDDD {
  name
}
class "LinkTypeField" as conda.models.records.LinkTypeField #DDDDDD {
  box(instance, instance_type, val)
}
class "ListField" as conda.auxlib.entity.ListField #99DDFF {
  box(instance, instance_type, val)
  dump(instance, instance_type, val)
  unbox(instance, instance_type, val)
  validate(instance, val)
}
class "LoadedParameter" as conda.common.configuration.LoadedParameter #AAAA00 {
  key_flag
  value
  value_flags
  collect_errors(instance, typed_value, source)
  expand()
  {abstract}merge(matches)
  typify(source)
}
class "LocalFSAdapter" as conda.gateways.connection.adapters.localfs.LocalFSAdapter #AAAA00 {
  {abstract}close()
  send(request, stream, timeout, verify, cert, proxies)
}
class "<color:red>LockError</color>" as conda.exceptions.LockError #77AADD {
}
class "MakeMenuAction" as conda.core.path_actions.MakeMenuAction #FFAABB {
  create_actions(transaction_context, package_info, target_prefix, requested_link_type)
  execute()
  reverse()
}
class "MapField" as conda.auxlib.entity.MapField #99DDFF {
  box(instance, instance_type, val)
}
class "MapLoadedParameter" as conda.common.configuration.MapLoadedParameter #AAAA00 {
  collect_errors(instance, typed_value, source)
  merge(parameters: Sequence[MapLoadedParameter]) -> MapLoadedParameter
}
class "MapParameter" as conda.common.configuration.MapParameter #AAAA00 {
  get_all_matches(name, names, instance)
  load(name, match)
}
class "MatchInterface" as conda.models.match_spec.MatchInterface #DDDDDD {
  exact_value
  raw_value
  {abstract}match(other)
  matches(value)
  merge(other)
  union(other)
}
class "MatchSpec" as conda.models.match_spec.MatchSpec #DDDDDD {
  FIELD_NAMES : tuple
  FIELD_NAMES_SET : frozenset
  fn
  is_name_only_spec
  name
  optional
  original_spec_str
  spec
  strictness
  target
  version
  conda_build_form()
  dist_str()
  from_dist_str(dist_str)
  get(field_name, default)
  get_exact_value(field_name)
  get_raw_value(field_name)
  match(rec)
  merge(match_specs, union)
  union(match_specs)
}
class "MatchSpecType" as conda.models.match_spec.MatchSpecType #DDDDDD {
}
class "Md5Field" as conda.models.records.Md5Field #DDDDDD {
}
class "<color:red>MetadataWarning</color>" as conda.common.pkg_formats.python.MetadataWarning #EE8866 {
}
class "Minio" as conda.testing.gateways.fixtures.minio_s3_server.Minio #EE8866 {
  endpoint
  name : str
  port : int
  server_url
  populate_bucket(endpoint, bucket_name, channel_dir)
}
class "MockResponse" as conda.testing.notices.helpers.MockResponse #DDDDDD {
  json_data
  raise_exc : bool
  status_code
  json()
}
class "MultiChannel" as conda.models.channel.MultiChannel #DDDDDD {
  auth : NoneType
  base_url
  base_urls
  canonical_name
  channel_location
  location : NoneType
  name
  package_filename : NoneType
  platform : NoneType
  scheme : NoneType
  token : NoneType
  dump()
  url(with_credentials)
  urls(with_credentials, subdirs)
}
class "MultiPathAction" as conda.core.path_actions.MultiPathAction #FFAABB {
  target_full_paths
}
class "<color:red>MultiValidationError</color>" as conda.common.configuration.MultiValidationError #AAAA00 {
}
class "<color:red>MultipleKeysError</color>" as conda.common.configuration.MultipleKeysError #AAAA00 {
  keys
  source
}
class "MutableListField" as conda.auxlib.entity.MutableListField #99DDFF {
}
class "<color:red>NoBaseEnvironmentError</color>" as conda.exceptions.NoBaseEnvironmentError #77AADD {
}
class "<color:red>NoSpaceLeftError</color>" as conda.exceptions.NoSpaceLeftError #77AADD {
}
class "<color:red>NoWritableEnvsDirError</color>" as conda.exceptions.NoWritableEnvsDirError #77AADD {
}
class "<color:red>NoWritablePkgsDirError</color>" as conda.exceptions.NoWritablePkgsDirError #77AADD {
}
class "Noarch" as conda.models.package_info.Noarch #DDDDDD {
  entry_points
  type
}
class "NoarchField" as conda.models.records.NoarchField #DDDDDD {
  box(instance, instance_type, val)
}
class "NoarchField" as conda.models.package_info.NoarchField #DDDDDD {
  box(instance, instance_type, val)
}
class "NoarchType" as conda.models.enums.NoarchType #DDDDDD {
  name
  coerce(val)
}
class "<color:red>NotFoundError</color>" as conda.auxlib.exceptions.NotFoundError #99DDFF {
}
class "<color:red>NotWritableError</color>" as conda.exceptions.NotWritableError #77AADD {
  errno
}
class "NoticeLevel" as conda.base.constants.NoticeLevel #44BB99 {
  name
}
class "NullCountAction" as conda.cli.actions.NullCountAction #BBCC33 {
}
class "NullHandler" as conda.auxlib.NullHandler #77AADD {
  {abstract}emit(record)
}
class "NumberField" as conda.auxlib.entity.NumberField #99DDFF {
}
class "ObjectLoadedParameter" as conda.common.configuration.ObjectLoadedParameter #AAAA00 {
  collect_errors(instance, typed_value, source)
  merge(parameters: Sequence[ObjectLoadedParameter]) -> ObjectLoadedParameter
}
class "ObjectParameter" as conda.common.configuration.ObjectParameter #AAAA00 {
  get_all_matches(name, names, instance)
  load(name, match)
}
class "ObjectWrapper" as tqdm.utils.ObjectWrapper #BBCC33 {
  wrapper_getattr(name)
  wrapper_setattr(name, value)
}
class "<color:red>OperationNotAllowed</color>" as conda.exceptions.OperationNotAllowed #77AADD {
}
class "PackageCacheData" as conda.core.package_cache_data.PackageCacheData #FFAABB {
  is_writable
  pkgs_dir
  all_caches_writable_first(pkgs_dirs)
  clear()
  first_writable(pkgs_dirs)
  get(package_ref, default)
  get_all_extracted_entries()
  get_entry_to_link(package_ref)
  insert(package_cache_record)
  iter_records()
  itervalues()
  load()
  query(package_ref_or_match_spec)
  query_all(package_ref_or_match_spec, pkgs_dirs)
  read_only_caches(pkgs_dirs)
  reload()
  remove(package_ref, default)
  tarball_file_in_cache(tarball_path, md5sum, exclude_caches)
  tarball_file_in_this_cache(tarball_path, md5sum)
  values()
  writable_caches(pkgs_dirs)
}
class "PackageCacheRecord" as conda.models.records.PackageCacheRecord #DDDDDD {
  extracted_package_dir
  is_extracted
  is_fetched
  md5
  package_tarball_full_path
  tarball_basename
}
class "PackageCacheType" as conda.core.package_cache_data.PackageCacheType #FFAABB {
}
class "PackageInfo" as conda.models.package_info.PackageInfo #DDDDDD {
  build
  build_number
  channel
  extracted_package_dir
  icondata
  name
  package_metadata
  package_tarball_full_path
  paths_data
  repodata_record
  url
  version
  dist_str()
}
class "PackageMetadata" as conda.models.package_info.PackageMetadata #DDDDDD {
  noarch
  package_metadata_version
  preferred_env
}
class "<color:red>PackageNotInstalledError</color>" as conda.exceptions.PackageNotInstalledError #77AADD {
}
class "PackageRecord" as conda.models.records.PackageRecord #DDDDDD {
  arch
  build
  build_number
  channel
  combined_depends
  constrains
  date
  depends
  features
  fn
  is_unmanageable
  legacy_bz2_md5
  legacy_bz2_size
  license
  license_family
  md5
  metadata : set[str]
  name
  namekey
  noarch
  package_type
  platform
  preferred_env
  schannel
  sha256
  size
  subdir
  timestamp
  track_features
  url
  version
  dist_fields_dump()
  dist_str()
  record_id()
  to_match_spec()
  to_simple_match_spec()
}
class "PackageRecordList" as conda.core.subdir_data.PackageRecordList #FFAABB {
}
class "PackageType" as conda.models.enums.PackageType #DDDDDD {
  name
  conda_package_types()
  unmanageable_package_types()
}
class "PackageTypeField" as conda.models.records.PackageTypeField #DDDDDD {
}
class "<color:red>PackagesNotFoundError</color>" as conda.exceptions.PackagesNotFoundError #77AADD {
}
class "<color:red>PaddingError</color>" as conda.exceptions.PaddingError #77AADD {
}
class "Parameter" as conda.common.configuration.Parameter #AAAA00 {
  default
  get_all_matches(name, names, instance)
  {abstract}load(name, match)
  typify(name, source, value)
}
class "ParameterFlag" as conda.common.configuration.ParameterFlag #AAAA00 {
  name
  from_name(name)
  from_string(string)
  from_value(value)
}
class "ParameterLoader" as conda.common.configuration.ParameterLoader #AAAA00 {
  aliases : tuple
  name
  names
  type
  raw_parameters_from_single_source(name, names, raw_parameters)
}
class "<color:red>ParseError</color>" as conda.exceptions.ParseError #77AADD {
}
class "PathAction" as conda.core.path_actions.PathAction #FFAABB {
  target_full_path
}
class "PathConflict" as conda.base.constants.PathConflict #44BB99 {
  name
}
class "PathData" as conda.models.records.PathData #DDDDDD {
  file_mode
  no_link
  path
  path_type
  prefix_placeholder
}
class "PathDataV1" as conda.models.records.PathDataV1 #DDDDDD {
  inode_paths
  sha256
  sha256_in_prefix
  size_in_bytes
}
class "PathFactoryFixture" as conda.testing.PathFactoryFixture #77AADD {
  tmp_path : Path
}
class "<color:red>PathNotFoundError</color>" as conda.exceptions.PathNotFoundError #77AADD {
}
class "PathType" as conda.models.enums.PathType #DDDDDD {
  name
  basic_types()
}
class "PathsData" as conda.models.records.PathsData #DDDDDD {
  paths
  paths_version
}
class "Platform" as conda.models.enums.Platform #DDDDDD {
  name
  from_sys()
}
class "PluginConfig" as conda.base.context.PluginConfig #44BB99 {
  raw_data : defaultdict
}
class "<color:red>PluginError</color>" as conda.exceptions.PluginError #77AADD {
}
class "PluginManager" as pluggy._manager.PluginManager #FFAABB {
  hook
  project_name
  trace : Final[_tracing.TagTracerSub]
  add_hookcall_monitoring(before: _BeforeTrace, after: _AfterTrace) -> Callable[[], None]
  add_hookspecs(module_or_class: _Namespace) -> None
  check_pending() -> None
  enable_tracing() -> Callable[[], None]
  get_canonical_name(plugin: _Plugin) -> str
  get_hookcallers(plugin: _Plugin) -> list[HookCaller] | None
  get_name(plugin: _Plugin) -> str | None
  get_plugin(name: str) -> Any | None
  get_plugins() -> set[Any]
  has_plugin(name: str) -> bool
  is_blocked(name: str) -> bool
  is_registered(plugin: _Plugin) -> bool
  list_name_plugin() -> list[tuple[str, _Plugin]]
  list_plugin_distinfo() -> list[tuple[_Plugin, DistFacade]]
  load_setuptools_entrypoints(group: str, name: str | None) -> int
  parse_hookimpl_opts(plugin: _Plugin, name: str) -> HookimplOpts | None
  parse_hookspec_opts(module_or_class: _Namespace, name: str) -> HookspecOpts | None
  register(plugin: _Plugin, name: str | None) -> str | None
  set_blocked(name: str) -> None
  subset_hook_caller(name: str, remove_plugins: Iterable[_Plugin]) -> HookCaller
  unregister(plugin: _Plugin | None, name: str | None) -> Any | None
}
class "PoolManager" as urllib3.poolmanager.PoolManager #DDDDDD {
  connection_pool_kw : dict
  key_fn_by_scheme : dict
  pool_classes_by_scheme : dict
  pools : RecentlyUsedContainer[PoolKey, HTTPConnectionPool]
  proxy : Url | None
  proxy_config : ProxyConfig | None
  clear() -> None
  connection_from_context(request_context: dict[str, typing.Any]) -> HTTPConnectionPool
  connection_from_host(host: str | None, port: int | None, scheme: str | None, pool_kwargs: dict[str, typing.Any] | None) -> HTTPConnectionPool
  connection_from_pool_key(pool_key: PoolKey, request_context: dict[str, typing.Any]) -> HTTPConnectionPool
  connection_from_url(url: str, pool_kwargs: dict[str, typing.Any] | None) -> HTTPConnectionPool
  urlopen(method: str, url: str, redirect: bool) -> BaseHTTPResponse
}
class "PosixActivator" as conda.activate.PosixActivator #77AADD {
  command_join : str
  export_var_tmpl : str
  hook_source_path : Path
  path_conversion : staticmethod
  pathsep_join
  run_script_tmpl : str
  script_extension : str
  sep : str
  set_var_tmpl : str
  tempfile_extension : NoneType
  unset_var_tmpl : str
}
class "PowerShellActivator" as conda.activate.PowerShellActivator #77AADD {
  command_join : str
  export_var_tmpl : str
  hook_source_path : Path
  path_conversion : staticmethod
  pathsep_join
  run_script_tmpl : str
  script_extension : str
  sep : str
  set_var_tmpl : str
  tempfile_extension : NoneType
  unset_var_tmpl : str
}
class "PreferredEnv" as conda.models.package_info.PreferredEnv #DDDDDD {
  executable_paths
  name
  softlink_paths
}
class "PrefixActionGroup" as conda.core.link.PrefixActionGroup #FFAABB {
  compile_action_groups : Iterable[ActionGroup]
  entry_point_action_groups : Iterable[ActionGroup]
  link_action_groups : Iterable[ActionGroup]
  make_menu_action_groups : Iterable[ActionGroup]
  prefix_record_groups : Iterable[ActionGroup]
  register_action_groups : Iterable[ActionGroup]
  remove_menu_action_groups : Iterable[ActionGroup]
  unlink_action_groups : Iterable[ActionGroup]
  unregister_action_groups : Iterable[ActionGroup]
}
class "PrefixData" as conda.core.prefix_data.PrefixData #FFAABB {
  is_writable
  prefix_path : Path
  all_subdir_urls()
  get(package_name, default)
  get_environment_env_vars()
  insert(prefix_record, remove_auth)
  iter_records()
  iter_records_sorted()
  load()
  query(package_ref_or_match_spec)
  reload()
  remove(package_name)
  set_environment_env_vars(env_vars)
  unset_environment_env_vars(env_vars)
}
class "PrefixDataType" as conda.core.prefix_data.PrefixDataType #FFAABB {
}
class "PrefixGraph" as conda.models.prefix_graph.PrefixGraph #DDDDDD {
  graph : dict
  records
  spec_matches : dict
  all_ancestors(node)
  all_descendants(node)
  get_node_by_name(name)
  prune()
  remove_spec(spec)
  remove_youngest_descendant_nodes_with_specs()
}
class "PrefixPathAction" as conda.core.path_actions.PrefixPathAction #FFAABB {
  target_full_path
  target_prefix
  target_short_path
  target_short_paths
  transaction_context
}
class "PrefixRecord" as conda.models.records.PrefixRecord #DDDDDD {
  auth
  extracted_package_dir
  files
  link
  package_tarball_full_path
  paths_data
  requested_spec
}
class "PrefixReplaceLinkAction" as conda.core.path_actions.PrefixReplaceLinkAction #FFAABB {
  file_mode
  intermediate_path : NoneType
  prefix_path_data
  prefix_placeholder
  execute()
  verify()
}
class "PrefixSetup" as conda.core.link.PrefixSetup #FFAABB {
  link_precs : tuple[PackageRecord, ...]
  neutered_specs : tuple[MatchSpec, ...]
  remove_specs : tuple[MatchSpec, ...]
  target_prefix : str
  unlink_precs : tuple[PackageRecord, ...]
  update_specs : tuple[MatchSpec, ...]
}
class "PrimitiveLoadedParameter" as conda.common.configuration.PrimitiveLoadedParameter #AAAA00 {
  merge(matches)
}
class "PrimitiveParameter" as conda.common.configuration.PrimitiveParameter #AAAA00 {
  load(name, match)
}
class "ProgressBar" as conda.common.io.ProgressBar #AAAA00 {
  description
  enabled : bool
  json : bool
  pbar : NoneType
  close()
  finish()
  get_lock()
  refresh()
  update_to(fraction)
}
class "ProgressFileWrapper" as conda.gateways.disk.create.ProgressFileWrapper #EEDD88 {
  progress_file
  progress_file_size
  progress_max_pos : int
  progress_update_callback
  progress_update()
  read(size)
}
class "ProgressiveFetchExtract" as conda.core.package_cache_data.ProgressiveFetchExtract #FFAABB {
  cache_actions
  extract_actions
  link_precs
  paired_actions : dict
  execute()
  make_actions_for_record(pref_or_spec)
  prepare()
}
class "<color:red>ProxyError</color>" as conda.exceptions.ProxyError #77AADD {
}
class "PythonDistribution" as conda.common.pkg_formats.python.PythonDistribution #EE8866 {
  ENTRY_POINTS_FILES : tuple
  MANDATORY_FILES : tuple
  MANIFEST_FILES : tuple
  REQUIRES_FILES : tuple
  anchor_full_path
  conda_name
  name
  norm_name
  python_version
  version
  get_conda_dependencies()
  get_dist_requirements()
  get_entry_points()
  get_external_requirements()
  get_extra_provides()
  {abstract}get_optional_dependencies()
  get_paths()
  get_python_requirements()
  init(prefix_path, anchor_file, python_version)
  manifest_full_path()
}
class "PythonDistributionMetadata" as conda.common.pkg_formats.python.PythonDistributionMetadata #EE8866 {
  FILE_NAMES : tuple
  MULTIPLE_USE_KEYS
  SINGLE_USE_KEYS
  name
  version
  get_classifiers()
  get_dist_obsolete()
  get_dist_provides()
  get_dist_requirements()
  get_external_requirements()
  get_extra_provides()
  get_python_requirements()
}
class "PythonEggInfoDistribution" as conda.common.pkg_formats.python.PythonEggInfoDistribution #EE8866 {
  ENTRY_POINTS_FILES : tuple
  MANDATORY_FILES : tuple
  MANIFEST_FILES : tuple
  REQUIRES_FILES : tuple
  is_manageable
  sp_reference
}
class "PythonEggLinkDistribution" as conda.common.pkg_formats.python.PythonEggLinkDistribution #EE8866 {
  is_manageable : bool
}
class "PythonInstalledDistribution" as conda.common.pkg_formats.python.PythonInstalledDistribution #EE8866 {
  ENTRY_POINTS_FILES : tuple
  MANDATORY_FILES : tuple
  MANIFEST_FILES : tuple
  REQUIRES_FILES : tuple
  is_manageable : bool
  sp_reference
}
class "REPARSE_DATA_BUFFER" as conda.gateways.disk.link.REPARSE_DATA_BUFFER #EEDD88 {
  get_print_name()
  get_substitute_name()
}
class "RawParameter" as conda.common.configuration.RawParameter #AAAA00 {
  key
  source
  {abstract}keyflag()
  make_raw_parameters(source, from_map)
  {abstract}value(parameter_obj)
  {abstract}valueflags(parameter_obj)
}
class "RecentlyUsedContainer" as urllib3._collections.RecentlyUsedContainer #DDDDDD {
  dispose_func : typing.Callable[[_VT], None] | None
  lock
  clear() -> None
  keys() -> set[_KT]
}
class "RegisterEnvironmentLocationAction" as conda.core.path_actions.RegisterEnvironmentLocationAction #FFAABB {
  target_full_path
  target_prefix
  transaction_context
  {abstract}cleanup()
  execute()
  {abstract}reverse()
  verify()
}
class "<color:red>RemoveError</color>" as conda.exceptions.RemoveError #77AADD {
}
class "RemoveFromPrefixPathAction" as conda.core.path_actions.RemoveFromPrefixPathAction #FFAABB {
  linked_package_data
  verify()
}
class "RemoveLinkedPackageRecordAction" as conda.core.path_actions.RemoveLinkedPackageRecordAction #FFAABB {
  execute()
  reverse()
}
class "RemoveMenuAction" as conda.core.path_actions.RemoveMenuAction #FFAABB {
  {abstract}cleanup()
  create_actions(transaction_context, linked_package_data, target_prefix)
  execute()
  reverse()
}
class "RepoInterface" as conda.gateways.repodata.RepoInterface #44BB99 {
  repodata(state: dict) -> str
}
class "RepodataCache" as conda.gateways.repodata.RepodataCache #44BB99 {
  cache_dir : Path
  cache_path_json
  cache_path_state
  name : str
  repodata_fn
  state
  load() -> str
  load_state()
  lock(mode)
  refresh(refresh_ns)
  replace(temp_path: Path)
  save(data: str)
  stale()
  timeout()
}
class "RepodataFetch" as conda.gateways.repodata.RepodataFetch #44BB99 {
  cache_path_base : Path
  cache_path_json
  cache_path_state
  channel
  repo_cache
  repo_interface_cls
  repodata_fn : str
  url_w_credentials : str
  url_w_repodata_fn
  url_w_subdir : str
  fetch_latest() -> tuple[dict | str, RepodataState]
  fetch_latest_parsed() -> tuple[dict, RepodataState]
  fetch_latest_path() -> tuple[Path, RepodataState]
  read_cache() -> tuple[str, RepodataState]
}
class "<color:red>RepodataIsEmpty</color>" as conda.gateways.repodata.RepodataIsEmpty #44BB99 {
}
class "<color:red>RepodataOnDisk</color>" as conda.gateways.repodata.RepodataOnDisk #44BB99 {
}
class "RepodataState" as conda.gateways.repodata.RepodataState #44BB99 {
  cache_control
  cache_path_json : Path
  cache_path_state : Path
  etag
  mod
  repodata_fn : str
  clear_has_format(format: str)
  has_format(format: str) -> tuple[bool, datetime.datetime | None]
  set_has_format(format: str, value: bool)
  should_check_format(format: str) -> bool
}
class "RepodataStateSkipFormat" as conda.gateways.repodata.jlap.interface.RepodataStateSkipFormat #FFAABB {
  skip_formats : set[str]
  should_check_format(format)
}
class "RequestMethods" as urllib3._request_methods.RequestMethods #DDDDDD {
  headers : dict
  request(method: str, url: str, body: _TYPE_BODY | None, fields: _TYPE_FIELDS | None, headers: typing.Mapping[str, str] | None, json: typing.Any | None) -> BaseHTTPResponse
  request_encode_body(method: str, url: str, fields: _TYPE_FIELDS | None, headers: typing.Mapping[str, str] | None, encode_multipart: bool, multipart_boundary: str | None) -> BaseHTTPResponse
  request_encode_url(method: str, url: str, fields: _TYPE_ENCODE_URL_FIELDS | None, headers: typing.Mapping[str, str] | None) -> BaseHTTPResponse
  {abstract}urlopen(method: str, url: str, body: _TYPE_BODY | None, headers: typing.Mapping[str, str] | None, encode_multipart: bool, multipart_boundary: str | None) -> BaseHTTPResponse
}
class "RequestsCookieJar" as requests.cookies.RequestsCookieJar #99DDFF {
  copy()
  get(name, default, domain, path)
  get_dict(domain, path)
  get_policy()
  items()
  iteritems()
  iterkeys()
  itervalues()
  keys()
  list_domains()
  list_paths()
  multiple_domains()
  set(name, value)
  set_cookie(cookie)
  update(other)
  values()
}
class "RequirementsSpec" as conda.env.specs.requirements.RequirementsSpec #99DDFF {
  environment
  extensions : set
  filename : NoneType
  msg : NoneType
  name : NoneType
  can_handle()
}
class "Resolve" as conda.resolve.Resolve #77AADD {
  channels : tuple
  groups : dict
  index
  ms_depends_ : dict
  trackers : defaultdict
  bad_installed(installed, new_specs)
  breadth_first_search_for_dep_graph(root_spec, target_name, dep_graph, num_targets)
  build_conflict_map(specs, specs_to_add, history_specs)
  build_graph_of_deps(spec)
  default_filter(features, filter)
  dependency_sort(must_have: dict[str, PackageRecord]) -> list[PackageRecord]
  environment_is_consistent(installed)
  find_conflicts(specs, specs_to_add, history_specs)
  find_matches(spec: MatchSpec) -> tuple[PackageRecord]
  find_matches_with_strict(ms, strict_channel_priority)
  gen_clauses()
  generate_feature_count(C)
  generate_feature_metric(C)
  generate_install_count(C, specs)
  generate_package_count(C, missing)
  generate_removal_count(C, specs)
  generate_spec_constraints(C, specs)
  generate_update_count(C, specs)
  generate_version_metrics(C, specs, include0)
  get_conflicting_specs(specs, explicit_specs)
  get_pkgs(ms, emptyok)
  get_reduced_index(explicit_specs, sort_by_exactness, exit_on_conflict)
  install(specs, installed, update_deps, returnall)
  install_specs(specs, installed, update_deps)
  invalid_chains(spec, filter, optional)
  match_any(mss, prec)
  ms_depends(prec: PackageRecord) -> list[MatchSpec]
  push_MatchSpec(C, spec)
  remove(specs, installed)
  remove_specs(specs, installed)
  restore_bad(pkgs, preserve)
  solve(specs: list, returnall: bool, _remove, specs_to_add, history_specs, should_retry_solve) -> list[PackageRecord]
  to_feature_metric_id(prec_dist_str, feat)
  to_sat_name(val)
  valid(spec_or_prec, filter, optional)
  valid2(spec_or_prec, filter_out, optional)
  verify_specs(specs)
  version_key(prec, vtype)
}
class "<color:red>ResolvePackageNotFound</color>" as conda.exceptions.ResolvePackageNotFound #77AADD {
  bad_deps : tuple
}
class "<color:red>Response304ContentUnchanged</color>" as conda.gateways.repodata.Response304ContentUnchanged #44BB99 {
}
class "Result" as conda.core.initialize.Result #FFAABB {
  MODIFIED : str
  NEEDS_SUDO : str
  NO_CHANGE : str
}
class "Retry" as urllib3.util.retry.Retry #77AADD {
  DEFAULT : typing.ClassVar[Retry]
  DEFAULT_ALLOWED_METHODS : frozenset
  DEFAULT_BACKOFF_MAX : int
  DEFAULT_REMOVE_HEADERS_ON_REDIRECT : frozenset
  RETRY_AFTER_STATUS_CODES : frozenset
  allowed_methods : typing.Collection[str] | None
  backoff_factor : float
  backoff_jitter : float
  backoff_max : float
  connect : int | None
  history : tuple
  other : int | None
  raise_on_redirect : bool
  raise_on_status : bool
  read : int | None
  redirect : bool | int | None
  remove_headers_on_redirect : frozenset
  respect_retry_after_header : bool
  status : int | None
  status_forcelist : set
  total : bool | int | None
  from_int(retries: Retry | bool | int | None, redirect: bool | int | None, default: Retry | bool | int | None) -> Retry
  get_backoff_time() -> float
  get_retry_after(response: BaseHTTPResponse) -> float | None
  increment(method: str | None, url: str | None, response: BaseHTTPResponse | None, error: Exception | None, _pool: ConnectionPool | None, _stacktrace: TracebackType | None) -> Self
  is_exhausted() -> bool
  is_retry(method: str, status_code: int, has_retry_after: bool) -> bool
  new() -> Self
  parse_retry_after(retry_after: str) -> float
  sleep(response: BaseHTTPResponse | None) -> None
  sleep_for_retry(response: BaseHTTPResponse) -> bool
}
class "S3Adapter" as conda.gateways.connection.adapters.s3.S3Adapter #AAAA00 {
  {abstract}close()
  send(request: PreparedRequest, stream: bool, timeout: None | float | tuple[float, float] | tuple[float, None], verify: bool | str, cert: None | bytes | str | tuple[bytes | str, bytes | str], proxies: dict[str, str] | None) -> Response
}
class "SECURITY_ATTRIBUTES" as conda.gateways.disk.link.SECURITY_ATTRIBUTES #EEDD88 {
}
class "STRING" as conda.common.io.CaptureTarget.STRING #44BB99 {
  name
  value
}
class "SW" as conda.common._os.windows.SW #EEDD88 {
  name
}
class "SafetyChecks" as conda.base.constants.SafetyChecks #44BB99 {
  name
}
class "<color:red>SafetyError</color>" as conda.exceptions.SafetyError #77AADD {
}
class "SatSolverChoice" as conda.base.constants.SatSolverChoice #44BB99 {
  name
}
class "<color:red>SenderError</color>" as conda.auxlib.exceptions.SenderError #99DDFF {
}
class "SequenceLoadedParameter" as conda.common.configuration.SequenceLoadedParameter #AAAA00 {
  collect_errors(instance, typed_value, source)
  merge(matches)
}
class "SequenceParameter" as conda.common.configuration.SequenceParameter #AAAA00 {
  string_delimiter : str
  get_all_matches(name, names, instance)
  load(name, match)
}
class "Session" as requests.sessions.Session #99DDFF {
  adapters : OrderedDict
  auth : NoneType
  cert : NoneType
  cookies : NoneType
  headers
  hooks
  max_redirects : int
  params : dict
  proxies : dict
  stream : bool
  trust_env : bool
  verify : bool
  close()
  delete(url)
  get(url)
  get_adapter(url)
  head(url)
  merge_environment_settings(url, proxies, stream, verify, cert)
  mount(prefix, adapter)
  options(url)
  patch(url, data)
  post(url, data, json)
  prepare_request(request)
  put(url, data)
  request(method, url, params, data, headers, cookies, files, auth, timeout, allow_redirects, proxies, hooks, stream, verify, cert, json)
  send(request)
}
class "SessionRedirectMixin" as requests.sessions.SessionRedirectMixin #99DDFF {
  get_redirect_target(resp)
  rebuild_auth(prepared_request, response)
  rebuild_method(prepared_request, response)
  rebuild_proxies(prepared_request, proxies)
  resolve_redirects(resp, req, stream, timeout, verify, cert, proxies, yield_requests)
  should_strip_auth(old_url, new_url)
}
class "<color:red>SharedLinkPathClobberError</color>" as conda.exceptions.SharedLinkPathClobberError #77AADD {
}
class "ShellExecuteInfo" as conda.common._os.windows.ShellExecuteInfo #EEDD88 {
  cbSize
}
class "SimpleEnvironment" as conda.testing.solver_helpers.SimpleEnvironment #EE8866 {
  REPO_DATA_KEYS : tuple
  installed_packages : list
  repo_packages : list[str] | dict[str, list[str]]
  subdirs
  install()
  remove()
  solver(add, remove)
  solver_transaction(add, remove, as_specs)
}
class "SingleStrArgCachingType" as conda.models.version.SingleStrArgCachingType #DDDDDD {
}
class "Solver" as conda.core.solve.Solver #FFAABB {
  channels
  neutered_specs : tuple
  prefix : str
  specs_to_add : frozenset, tuple
  specs_to_add_names : frozenset
  specs_to_remove : frozenset
  ssc
  subdirs : tuple
  determine_constricting_specs(spec, solution_precs)
  get_constrained_packages(pre_packages, post_packages, index_keys)
  get_request_package_in_solution(solution_precs, specs_map)
  solve_final_state(update_modifier, deps_modifier, prune, ignore_pinned, force_remove, should_retry_solve)
  solve_for_diff(update_modifier, deps_modifier, prune, ignore_pinned, force_remove, force_reinstall, should_retry_solve) -> tuple[tuple[PackageRecord, ...], tuple[PackageRecord, ...]]
  solve_for_transaction(update_modifier, deps_modifier, prune, ignore_pinned, force_remove, force_reinstall, should_retry_solve)
}
class "SolverStateContainer" as conda.core.solve.SolverStateContainer #FFAABB {
  add_back_map : dict
  deps_modifier
  final_environment_specs : NoneType
  force_remove
  ignore_pinned
  index : NoneType
  prefix
  prune
  r : NoneType
  should_retry_solve : bool
  solution_precs : NoneType, tuple
  specs_map : dict
  update_modifier
  pinned_specs()
  prefix_data()
  set_repository_metadata(index, r)
  specs_from_history_map()
  track_features_specs()
  working_state_reset()
}
class "SolverTests" as conda.testing.solver_helpers.SolverTests #EE8866 {
  env : NoneType
  solver_class
  tests_to_skip
  assert_unsatisfiable(exc_info, entries)
  env()
  find_package()
  find_package_in_list(packages)
  skip_tests(request)
  test_accelerate(env)
  test_anaconda_nomkl(env)
  test_arch_preferred_over_noarch_when_otherwise_equal(env)
  test_channel_priority_1(monkeypatch, env)
  test_circular_dependencies(env)
  test_empty(env)
  test_get_dists(env)
  test_get_reduced_index_broadening_preferred_solution(env)
  test_get_reduced_index_broadening_with_unsatisfiable_early_dep(env)
  test_install_package_with_feature(env)
  test_iopro_mkl(env)
  test_iopro_nomkl(env)
  test_irrational_version(env)
  test_mkl(env)
  test_no_features(env)
  test_noarch_preferred_over_arch_when_build_greater(env)
  test_noarch_preferred_over_arch_when_build_greater_dep(env)
  test_noarch_preferred_over_arch_when_version_greater(env)
  test_noarch_preferred_over_arch_when_version_greater_dep(env)
  test_nonexistent(env)
  test_nonexistent_deps(env)
  test_pseudo_boolean(env)
  test_remove(env)
  test_scipy_mkl(env)
  test_surplus_features_1(env)
  test_surplus_features_2(env)
  test_timestamps_and_deps(env)
  test_unintentional_feature_downgrade(env)
  test_unsat_any_two_not_three(env)
  test_unsat_chain(env)
  test_unsat_channel_priority(monkeypatch, env)
  test_unsat_expand_single(env)
  test_unsat_from_r1(env)
  test_unsat_missing_dep(env)
  test_unsat_shortest_chain_1(env)
  test_unsat_shortest_chain_2(env)
  test_unsat_shortest_chain_3(env)
  test_unsat_shortest_chain_4(env)
  test_unsat_simple(env)
}
class "<color:red>SpecNotFound</color>" as conda.exceptions.SpecNotFound #77AADD {
}
class "<color:red>SpecsConfigurationConflictError</color>" as conda.exceptions.SpecsConfigurationConflictError #77AADD {
}
class "Spinner" as conda.common.io.Spinner #AAAA00 {
  enabled : bool
  fail_message : str
  fh : StringIO, TextIOWrapper
  json : bool
  message
  show_spin : bool
  spinner_cycle : cycle
  start()
  stop()
}
class "SplitStrMatch" as conda.models.match_spec.SplitStrMatch #DDDDDD {
  exact_value
  match(other)
}
class "Starter" as conda.testing.gateways.fixtures.minio_s3_server.Starter #EE8866 {
  args : list
  pattern : str
  terminate_on_interrupt : bool
  timeout : int
  startup_check(port)
}
class "StdStreamHandler" as conda.gateways.logging.StdStreamHandler #44BB99 {
  sys_stream
  terminator : str
  emit(record)
}
class "StringField" as conda.auxlib.entity.StringField #99DDFF {
  box(instance, instance_type, val)
}
class "SubdirData" as conda.core.subdir_data.SubdirData #FFAABB {
  RepoInterface
  cache_path_base
  cache_path_json
  cache_path_pickle
  cache_path_state
  channel
  repo_cache
  repo_fetch
  repodata_fn : str
  url_w_credentials : str
  url_w_repodata_fn
  url_w_subdir
  clear_cached_local_channel_data(exclude_file)
  iter_records()
  load()
  query(package_ref_or_match_spec)
  query_all(package_ref_or_match_spec, channels, subdirs, repodata_fn)
  reload()
}
class "SubdirDataType" as conda.core.subdir_data.SubdirDataType #FFAABB {
}
class "SubdirField" as conda.models.records.SubdirField #DDDDDD {
}
class "SwallowBrokenPipe" as conda.common.io.SwallowBrokenPipe #AAAA00 {
}
class "TemporaryDirectory" as conda.gateways.disk.create.TemporaryDirectory #EEDD88 {
  name : NoneType
  cleanup(_warn, _warnings)
}
class "<color:red>ThisShouldNeverHappenError</color>" as conda.auxlib.exceptions.ThisShouldNeverHappenError #99DDFF {
}
class "ThreadLimitedThreadPoolExecutor" as conda.common.io.ThreadLimitedThreadPoolExecutor #AAAA00 {
  submit(fn)
}
class "<color:red>TimeoutException</color>" as conda.common.io.timeout.TimeoutException #44BB99 {
}
class "TimestampField" as conda.models.records.TimestampField #DDDDDD {
  box(instance, instance_type, val)
  dump(instance, instance_type, val)
}
class "TmpChannelFixture" as conda.testing.TmpChannelFixture #77AADD {
  conda_cli
  path_factory
}
class "TmpDownload" as conda.gateways.connection.download.TmpDownload #BBCC33 {
  tmp_dir : NoneType
  url
  verbose : bool
}
class "TmpEnvFixture" as conda.testing.TmpEnvFixture #77AADD {
  conda_cli
  path_factory
}
class "TokenURLFilter" as conda.gateways.logging.TokenURLFilter #44BB99 {
  TOKEN_REPLACE : partial
  TOKEN_URL_PATTERN
  filter(record)
}
class "<color:red>TooManyArgumentsError</color>" as conda.exceptions.TooManyArgumentsError #77AADD {
  expected
  offending_arguments
  optional_message : str
  received
}
class "TqdmHBox" as tqdm.notebook.TqdmHBox #BBCC33 {
  pbar
}
class "<color:red>TypeCoercionError</color>" as conda.auxlib.type_coercion.TypeCoercionError #99DDFF {
  value
}
class "<color:red>UnavailableInvalidChannel</color>" as conda.exceptions.UnavailableInvalidChannel #77AADD {
  status_code : str | int
}
class "<color:red>UnknownPackageClobberError</color>" as conda.exceptions.UnknownPackageClobberError #77AADD {
}
class "UnlinkLinkTransaction" as conda.core.link.UnlinkLinkTransaction #FFAABB {
  execute_executor
  nothing_to_do
  prefix_action_groups : dict
  prefix_setups
  transaction_context : dict
  verify_executor
  download_and_extract()
  execute()
  prepare()
  print_transaction_summary()
  verify()
}
class "UnlinkPathAction" as conda.core.path_actions.UnlinkPathAction #FFAABB {
  holding_full_path
  holding_short_path
  link_type
  cleanup()
  execute()
  reverse()
}
class "UnregisterEnvironmentLocationAction" as conda.core.path_actions.UnregisterEnvironmentLocationAction #FFAABB {
  target_full_path
  target_prefix
  transaction_context
  {abstract}cleanup()
  execute()
  {abstract}reverse()
  verify()
}
class "<color:red>UnsatisfiableError</color>" as conda.exceptions.UnsatisfiableError #77AADD {
  unsatisfiable : list
}
class "UpdateHistoryAction" as conda.core.path_actions.UpdateHistoryAction #FFAABB {
  hold_path
  neutered_specs
  remove_specs
  update_specs
  cleanup()
  create_actions(transaction_context, target_prefix, remove_specs, update_specs, neutered_specs)
  execute()
  reverse()
}
class "UpdateModifier" as conda.base.constants.UpdateModifier #44BB99 {
  name
}
class "Url" as conda.common.url.Url #AAAA00 {
  auth
  netloc
  as_dict() -> dict
  from_parse_result(parse_result: ParseResult) -> 'Url'
  replace() -> 'Url'
}
class "Url" as conda.common.url.Url.Url #99DDFF {
  fragment
  hostname
  password
  path
  port
  query
  scheme
  username
}
class "UrlsData" as conda.core.package_cache_data.UrlsData #FFAABB {
  pkgs_dir
  urls_txt_path
  add_url(url)
  get_url(package_path)
}
class "<color:red>ValidationError</color>" as conda.auxlib.exceptions.ValidationError #99DDFF {
}
class "<color:red>ValidationError</color>" as conda.common.configuration.ValidationError #AAAA00 {
  parameter_name
  parameter_value
  source
}
class "ValueEnum" as conda.base.constants.ValueEnum #44BB99 {
  name
}
class "Version" as packaging.version.Version #44BB99 {
  base_version
  dev
  epoch
  is_devrelease
  is_postrelease
  is_prerelease
  local
  major
  micro
  minor
  post
  pre
  public
  release
}
class "VersionOrder" as conda.models.version.VersionOrder #DDDDDD {
  fillvalue : int
  local : list
  norm_version
  version
  startswith(other: object) -> bool
}
class "VersionSpec" as conda.models.version.VersionSpec #DDDDDD {
  matcher_vo : str
  operator_func
  regex
  tup : tuple
  get_matcher(vspec)
  merge(other)
  union(other)
}
class "WIN32_FIND_DATA" as conda.gateways.disk.link.WIN32_FIND_DATA #EEDD88 {
  file_size
}
class "WindowsError" as conda.gateways.disk.link.WindowsError #EEDD88 {
  code
  message
}
class "XonshActivator" as conda.activate.XonshActivator #77AADD {
  command_join : str
  export_var_tmpl : str
  hook_source_path : Path
  path_conversion : staticmethod
  pathsep_join
  run_script_tmpl : str
  script_extension : str
  sep : str
  set_var_tmpl : str
  tempfile_extension : NoneType
  unset_var_tmpl : str
}
class "YamlFileSpec" as conda.env.specs.yaml_file.YamlFileSpec #99DDFF {
  environment
  extensions : set
  filename : NoneType
  msg : NoneType, str
  can_handle()
}
class "YamlRawParameter" as conda.common.configuration.YamlRawParameter #AAAA00 {
  keyflag()
  make_raw_parameters(source, from_map)
  make_raw_parameters_from_file(filepath)
  value(parameter_obj)
  valueflags(parameter_obj)
}
class "ZstdRepoInterface" as conda.gateways.repodata.jlap.interface.ZstdRepoInterface #FFAABB {
}
class "_Action" as conda.core.path_actions._Action #FFAABB {
  verified
  {abstract}cleanup()
  {abstract}execute()
  {abstract}reverse()
  {abstract}verify()
}
class "_Activator" as conda.activate._Activator #77AADD {
  command
  command_join : str
  env_name_or_prefix
  export_var_tmpl : str
  hook_source_path : Path | None
  path_conversion : Callable[[str | Iterable[str] | None], str | tuple[str, ...] | None]
  pathsep_join : str
  run_script_tmpl : str
  script_extension : str
  sep : str
  set_var_tmpl : str
  stack : bool
  tempfile_extension : str | None
  unset_var_tmpl : str
  activate()
  add_export_unset_vars(export_vars, unset_vars)
  build_activate(env_name_or_prefix)
  build_deactivate()
  build_reactivate()
  build_stack(env_name_or_prefix)
  commands()
  deactivate()
  execute()
  get_export_unset_vars(export_metavars)
  get_scripts_export_unset_vars() -> tuple[str, str]
  hook(auto_activate_base: bool | None) -> str
  reactivate()
}
class "_BaseVersion" as packaging.version._BaseVersion #44BB99 {
}
class "_ClauseArray" as conda.common._logic._ClauseArray #AAAA00 {
  append(clause)
  as_array()
  as_list()
  extend(clauses)
  get_clause_count()
  restore_state(saved_state)
  save_state()
}
class "_ClauseList" as conda.common._logic._ClauseList #AAAA00 {
  append
  extend
  as_array()
  as_list()
  get_clause_count()
  restore_state(saved_state)
  save_state()
}
class "_Cygpath" as conda.activate._Cygpath #77AADD {
  RE_DRIVE
  RE_MOUNT
  RE_ROOT
  RE_UNIX
  nt_to_posix(paths: str) -> str
  posix_to_nt(paths: str, prefix: str) -> str
  translate_unix(match: re.Match) -> str
  translation_drive(match: re.Match) -> str
  translation_mount(match: re.Match) -> str
  translation_root(match: re.Match, prefix: str) -> str
}
class "_FeaturesField" as conda.models.records._FeaturesField #DDDDDD {
  box(instance, instance_type, val)
  dump(instance, instance_type, val)
}
class "_GreedySubParsersAction" as conda.cli.conda_argparse._GreedySubParsersAction #BBCC33 {
}
class "_Null" as conda.auxlib._Null #77AADD {
  to_json
}
class "<color:red>_PaddingError</color>" as conda.core.portability._PaddingError #FFAABB {
}
class "_PyCryptoSatSolver" as conda.common._logic._PyCryptoSatSolver #AAAA00 {
  invoke(solver)
  process_solution(solution)
  setup(m, threads)
}
class "_PySatSolver" as conda.common._logic._PySatSolver #AAAA00 {
  invoke(solver)
  process_solution(sat_solution)
  setup(m)
}
class "_PycoSatSolver" as conda.common._logic._PycoSatSolver #AAAA00 {
  invoke(iter_sol)
  process_solution(sat_solution)
  setup(m, limit)
}
class "_Regex" as conda.auxlib.type_coercion._Regex #99DDFF {
  boolean
  none
  numbers
  BIN()
  BOOLEAN_FALSE()
  BOOLEAN_TRUE()
  COMPLEX()
  FLOAT()
  HEX()
  INT()
  NONE()
  OCT()
  convert(value_string)
  convert_number(value_string)
}
class "_SSLContextAdapterMixin" as conda.gateways.connection.adapters.http._SSLContextAdapterMixin #AAAA00 {
  init_poolmanager(connections: int, maxsize: int, block: bool) -> 'PoolManager'
}
class "_SatSolver" as conda.common._logic._SatSolver #AAAA00 {
  add_clause
  add_clauses
  as_list()
  get_clause_count()
  {abstract}invoke(solver)
  {abstract}process_solution(sat_solution)
  restore_state(saved_state)
  run(m)
  save_state()
  {abstract}setup(m)
}
class "_SignatureVerification" as conda.trust.signature_verification._SignatureVerification #77AADD {
  enabled
  key_mgr
  trusted_root
  cache_clear() -> None
  verify(repodata_fn: str, record: PackageRecord)
}
class "_StrMatchMixin" as conda.models.match_spec._StrMatchMixin #DDDDDD {
  exact_value
}
class "_Version" as ._Version #BBCC33 {
  dev
  epoch
  local
  post
  pre
  release
}
class "classproperty" as conda.auxlib.decorators.classproperty #99DDFF {
  setter(setter)
}
class "frozendict" as conda._vendor.frozendict.frozendict #AAAA00 {
  dict_cls : dict
  copy()
  to_json()
}
class "hardlink" as conda.models.enums.LinkType.hardlink #EEDD88 {
  name
  value
}
class "temporary_class" as conda.common.compat.six_with_metaclass.temporary_class #EE8866 {
}
class "time_recorder" as conda.common.io.time_recorder #AAAA00 {
  entry_name : NoneType, str
  module_name : NoneType
  record_file : bytes, str
  start_time : NoneType
  total_call_num : defaultdict
  total_run_time : defaultdict
  log_totals()
}
class "tqdm" as tqdm.auto.tqdm #BBCC33 {
}
class "tqdm" as tqdm.std.tqdm #BBCC33 {
  ascii : NoneType, bool
  bar_format : NoneType, str
  colour : NoneType
  delay : float
  desc : str
  disable : bool
  dynamic_miniters : bool
  dynamic_ncols : NoneType, bool
  format_dict
  fp
  gui : bool
  initial : int
  iterable : NoneType, reversed
  last_print_n : int
  last_print_t
  leave : bool
  lock_args : NoneType
  maxinterval : float, int
  mininterval : float, int
  miniters : NoneType, int
  monitor : NoneType
  monitor_interval : int
  n : int
  ncols : NoneType
  nrows : NoneType
  pos
  postfix : NoneType, str
  smoothing : float, int
  sp
  start_t
  total : NoneType
  unit : str
  unit_divisor : int
  unit_scale : bool
  clear(nolock)
  close()
  display(msg, pos)
  external_write_mode(file, nolock)
  format_interval(t)
  format_meter(n, total, elapsed, ncols, prefix, ascii, unit, unit_scale, rate, bar_format, postfix, unit_divisor, initial, colour)
  format_num(n)
  format_sizeof(num, suffix, divisor)
  get_lock()
  moveto(n)
  pandas()
  refresh(nolock, lock_args)
  reset(total)
  set_description(desc, refresh)
  set_description_str(desc, refresh)
  set_lock(lock)
  set_postfix(ordered_dict, refresh)
  set_postfix_str(s, refresh)
  status_printer(file)
  unpause()
  update(n)
  wrapattr(stream, method, total, bytes)
  write(s, file, end, nolock)
}
class "tqdm_asyncio" as tqdm.asyncio.tqdm_asyncio #BBCC33 {
  iterable_awaitable : bool
  iterable_iterator
  iterable_next
  as_completed(fs)
  gather()
  send()
}
class "tqdm_notebook" as tqdm.notebook.tqdm_notebook #BBCC33 {
  colour
  container
  disp
  displayed : bool
  ncols
  {abstract}clear()
  close()
  display(msg, pos, close, bar_style, check_delay)
  reset(total)
  status_printer(_, total, desc, ncols)
  update(n)
}
conda.CondaExitZero --|> conda.CondaError
conda.CondaMultiError --|> conda.CondaError
conda.activate.CmdExeActivator --|> conda.activate._Activator
conda.activate.CshActivator --|> conda.activate._Activator
conda.activate.FishActivator --|> conda.activate._Activator
conda.activate.JSONFormatMixin --|> conda.activate._Activator
conda.activate.PosixActivator --|> conda.activate._Activator
conda.activate.PowerShellActivator --|> conda.activate._Activator
conda.activate.XonshActivator --|> conda.activate._Activator
conda.auxlib.entity.BooleanField --|> conda.auxlib.entity.Field
conda.auxlib.entity.ComposableField --|> conda.auxlib.entity.Field
conda.auxlib.entity.DateField --|> conda.auxlib.entity.Field
conda.auxlib.entity.EnumField --|> conda.auxlib.entity.Field
conda.auxlib.entity.ImmutableEntity --|> conda.auxlib.entity.Entity
conda.auxlib.entity.IntegerField --|> conda.auxlib.entity.Field
conda.auxlib.entity.ListField --|> conda.auxlib.entity.Field
conda.auxlib.entity.MapField --|> conda.auxlib.entity.Field
conda.auxlib.entity.MutableListField --|> conda.auxlib.entity.ListField
conda.auxlib.entity.NumberField --|> conda.auxlib.entity.Field
conda.auxlib.entity.StringField --|> conda.auxlib.entity.Field
conda.auxlib.exceptions.AssignmentError --|> conda.auxlib.exceptions.AuxlibError
conda.auxlib.exceptions.AuthenticationError --|> conda.auxlib.exceptions.AuxlibError
conda.auxlib.exceptions.InitializationError --|> conda.auxlib.exceptions.AuxlibError
conda.auxlib.exceptions.NotFoundError --|> conda.auxlib.exceptions.AuxlibError
conda.auxlib.exceptions.SenderError --|> conda.auxlib.exceptions.AuxlibError
conda.auxlib.exceptions.ThisShouldNeverHappenError --|> conda.auxlib.exceptions.AuxlibError
conda.auxlib.exceptions.ValidationError --|> conda.auxlib.exceptions.AuxlibError
conda.auxlib.type_coercion.TypeCoercionError --|> conda.auxlib.exceptions.AuxlibError
conda.base.constants.NoticeLevel --|> conda.base.constants.ValueEnum
conda.base.constants.SatSolverChoice --|> conda.base.constants.ValueEnum
conda.base.context.Context --|> conda.common.configuration.Configuration
conda.common._logic._PyCryptoSatSolver --|> conda.common._logic._SatSolver
conda.common._logic._PySatSolver --|> conda.common._logic._SatSolver
conda.common._logic._PycoSatSolver --|> conda.common._logic._SatSolver
conda.common.configuration.ArgParseRawParameter --|> conda.common.configuration.RawParameter
conda.common.configuration.ConfigurationError --|> conda.CondaError
conda.common.configuration.ConfigurationLoadError --|> conda.common.configuration.ConfigurationError
conda.common.configuration.CustomValidationError --|> conda.common.configuration.ValidationError
conda.common.configuration.DefaultValueRawParameter --|> conda.common.configuration.RawParameter
conda.common.configuration.EnvRawParameter --|> conda.common.configuration.RawParameter
conda.common.configuration.InvalidTypeError --|> conda.common.configuration.ValidationError
conda.common.configuration.MapLoadedParameter --|> conda.common.configuration.LoadedParameter
conda.common.configuration.MapParameter --|> conda.common.configuration.Parameter
conda.common.configuration.MultiValidationError --|> conda.CondaMultiError
conda.common.configuration.MultiValidationError --|> conda.common.configuration.ConfigurationError
conda.common.configuration.MultipleKeysError --|> conda.common.configuration.ValidationError
conda.common.configuration.ObjectLoadedParameter --|> conda.common.configuration.LoadedParameter
conda.common.configuration.ObjectParameter --|> conda.common.configuration.Parameter
conda.common.configuration.PrimitiveLoadedParameter --|> conda.common.configuration.LoadedParameter
conda.common.configuration.PrimitiveParameter --|> conda.common.configuration.Parameter
conda.common.configuration.SequenceLoadedParameter --|> conda.common.configuration.LoadedParameter
conda.common.configuration.SequenceParameter --|> conda.common.configuration.Parameter
conda.common.configuration.ValidationError --|> conda.common.configuration.ConfigurationError
conda.common.configuration.YamlRawParameter --|> conda.common.configuration.RawParameter
conda.common.io.SwallowBrokenPipe --|> conda.common.io.ContextDecorator
conda.common.io.time_recorder --|> conda.common.io.ContextDecorator
conda.common.pkg_formats.python.PythonEggInfoDistribution --|> conda.common.pkg_formats.python.PythonDistribution
conda.common.pkg_formats.python.PythonEggLinkDistribution --|> conda.common.pkg_formats.python.PythonEggInfoDistribution
conda.common.pkg_formats.python.PythonInstalledDistribution --|> conda.common.pkg_formats.python.PythonDistribution
conda.core.path_actions.AggregateCompileMultiPycAction --|> conda.core.path_actions.CompileMultiPycAction
conda.core.path_actions.CacheUrlAction --|> conda.core.path_actions.PathAction
conda.core.path_actions.CompileMultiPycAction --|> conda.core.path_actions.MultiPathAction
conda.core.path_actions.CreateInPrefixPathAction --|> conda.core.path_actions.PrefixPathAction
conda.core.path_actions.CreateNonadminAction --|> conda.core.path_actions.CreateInPrefixPathAction
conda.core.path_actions.CreatePrefixRecordAction --|> conda.core.path_actions.CreateInPrefixPathAction
conda.core.path_actions.CreatePythonEntryPointAction --|> conda.core.path_actions.CreateInPrefixPathAction
conda.core.path_actions.ExtractPackageAction --|> conda.core.path_actions.PathAction
conda.core.path_actions.LinkPathAction --|> conda.core.path_actions.CreateInPrefixPathAction
conda.core.path_actions.MakeMenuAction --|> conda.core.path_actions.CreateInPrefixPathAction
conda.core.path_actions.MultiPathAction --|> conda.core.path_actions._Action
conda.core.path_actions.PathAction --|> conda.core.path_actions._Action
conda.core.path_actions.PrefixPathAction --|> conda.core.path_actions.PathAction
conda.core.path_actions.PrefixReplaceLinkAction --|> conda.core.path_actions.LinkPathAction
conda.core.path_actions.RegisterEnvironmentLocationAction --|> conda.core.path_actions.PathAction
conda.core.path_actions.RemoveFromPrefixPathAction --|> conda.core.path_actions.PrefixPathAction
conda.core.path_actions.RemoveLinkedPackageRecordAction --|> conda.core.path_actions.UnlinkPathAction
conda.core.path_actions.RemoveMenuAction --|> conda.core.path_actions.RemoveFromPrefixPathAction
conda.core.path_actions.UnlinkPathAction --|> conda.core.path_actions.RemoveFromPrefixPathAction
conda.core.path_actions.UnregisterEnvironmentLocationAction --|> conda.core.path_actions.PathAction
conda.core.path_actions.UpdateHistoryAction --|> conda.core.path_actions.CreateInPrefixPathAction
conda.exceptions.ActivateHelp --|> conda.exceptions.Help
conda.exceptions.ArgumentError --|> conda.CondaError
conda.exceptions.AuthenticationError --|> conda.CondaError
conda.exceptions.BasicClobberError --|> conda.exceptions.ClobberError
conda.exceptions.BinaryPrefixReplacementError --|> conda.CondaError
conda.exceptions.ChannelError --|> conda.CondaError
conda.exceptions.ChannelNotAllowed --|> conda.exceptions.ChannelError
conda.exceptions.ChecksumMismatchError --|> conda.CondaError
conda.exceptions.ClobberError --|> conda.CondaError
conda.exceptions.CommandNotFoundError --|> conda.CondaError
conda.exceptions.CondaDependencyError --|> conda.CondaError
conda.exceptions.CondaEnvException --|> conda.CondaError
conda.exceptions.CondaEnvironmentError --|> conda.CondaError
conda.exceptions.CondaFileIOError --|> conda.exceptions.CondaIOError
conda.exceptions.CondaHTTPError --|> conda.CondaError
conda.exceptions.CondaHistoryError --|> conda.CondaError
conda.exceptions.CondaIOError --|> conda.CondaError
conda.exceptions.CondaImportError --|> conda.CondaError
conda.exceptions.CondaIndexError --|> conda.CondaError
conda.exceptions.CondaKeyError --|> conda.CondaError
conda.exceptions.CondaMemoryError --|> conda.CondaError
conda.exceptions.CondaOSError --|> conda.CondaError
conda.exceptions.CondaSSLError --|> conda.CondaError
conda.exceptions.CondaSignalInterrupt --|> conda.CondaError
conda.exceptions.CondaSystemExit --|> conda.CondaExitZero
conda.exceptions.CondaUpgradeError --|> conda.CondaError
conda.exceptions.CondaValueError --|> conda.CondaError
conda.exceptions.CondaVerificationError --|> conda.CondaError
conda.exceptions.CorruptedEnvironmentError --|> conda.CondaError
conda.exceptions.CouldntParseError --|> conda.exceptions.ParseError
conda.exceptions.CyclicalDependencyError --|> conda.CondaError
conda.exceptions.DeactivateHelp --|> conda.exceptions.Help
conda.exceptions.DirectoryNotACondaEnvironmentError --|> conda.CondaError
conda.exceptions.DirectoryNotFoundError --|> conda.CondaError
conda.exceptions.DisallowedPackageError --|> conda.CondaError
conda.exceptions.DryRunExit --|> conda.CondaExitZero
conda.exceptions.EncodingError --|> conda.CondaError
conda.exceptions.EnvironmentFileEmpty --|> conda.exceptions.CondaEnvException
conda.exceptions.EnvironmentFileExtensionNotValid --|> conda.exceptions.CondaEnvException
conda.exceptions.EnvironmentFileNotDownloaded --|> conda.CondaError
conda.exceptions.EnvironmentFileNotFound --|> conda.exceptions.CondaEnvException
conda.exceptions.EnvironmentLocationNotFound --|> conda.CondaError
conda.exceptions.EnvironmentNameNotFound --|> conda.CondaError
conda.exceptions.EnvironmentNotWritableError --|> conda.CondaError
conda.exceptions.GenericHelp --|> conda.exceptions.Help
conda.exceptions.Help --|> conda.CondaError
conda.exceptions.InvalidMatchSpec --|> conda.exceptions.InvalidSpec
conda.exceptions.InvalidSpec --|> conda.CondaError
conda.exceptions.InvalidVersionSpec --|> conda.exceptions.InvalidSpec
conda.exceptions.KnownPackageClobberError --|> conda.exceptions.ClobberError
conda.exceptions.LinkError --|> conda.CondaError
conda.exceptions.LockError --|> conda.CondaError
conda.exceptions.NoBaseEnvironmentError --|> conda.CondaError
conda.exceptions.NoSpaceLeftError --|> conda.CondaError
conda.exceptions.NoWritableEnvsDirError --|> conda.CondaError
conda.exceptions.NoWritablePkgsDirError --|> conda.CondaError
conda.exceptions.NotWritableError --|> conda.CondaError
conda.exceptions.OperationNotAllowed --|> conda.CondaError
conda.exceptions.PackageNotInstalledError --|> conda.CondaError
conda.exceptions.PackagesNotFoundError --|> conda.CondaError
conda.exceptions.PaddingError --|> conda.CondaError
conda.exceptions.ParseError --|> conda.CondaError
conda.exceptions.PathNotFoundError --|> conda.CondaError
conda.exceptions.PluginError --|> conda.CondaError
conda.exceptions.ProxyError --|> conda.CondaError
conda.exceptions.RemoveError --|> conda.CondaError
conda.exceptions.ResolvePackageNotFound --|> conda.CondaError
conda.exceptions.SafetyError --|> conda.CondaError
conda.exceptions.SharedLinkPathClobberError --|> conda.exceptions.ClobberError
conda.exceptions.SpecNotFound --|> conda.CondaError
conda.exceptions.SpecsConfigurationConflictError --|> conda.CondaError
conda.exceptions.TooManyArgumentsError --|> conda.exceptions.ArgumentError
conda.exceptions.UnavailableInvalidChannel --|> conda.exceptions.ChannelError
conda.exceptions.UnknownPackageClobberError --|> conda.exceptions.ClobberError
conda.exceptions.UnsatisfiableError --|> conda.CondaError
conda.gateways.connection.adapters.ftp.FTPAdapter --|> requests.adapters.BaseAdapter
conda.gateways.connection.adapters.http.HTTPAdapter --|> conda.gateways.connection.adapters.http._SSLContextAdapterMixin
conda.gateways.connection.adapters.http.HTTPAdapter --|> requests.adapters.HTTPAdapter
conda.gateways.connection.adapters.localfs.LocalFSAdapter --|> requests.adapters.BaseAdapter
conda.gateways.connection.adapters.s3.S3Adapter --|> requests.adapters.BaseAdapter
conda.gateways.connection.session.CondaHttpAuth --|> requests.auth.AuthBase
conda.gateways.connection.session.CondaSession --|> requests.sessions.Session
conda.gateways.connection.session.EnforceUnusedAdapter --|> requests.adapters.BaseAdapter
conda.gateways.repodata.CondaRepoInterface --|> conda.gateways.repodata.RepoInterface
conda.gateways.repodata.RepodataIsEmpty --|> conda.exceptions.UnavailableInvalidChannel
conda.gateways.repodata.jlap.interface.JlapRepoInterface --|> conda.gateways.repodata.RepoInterface
conda.gateways.repodata.jlap.interface.RepodataStateSkipFormat --|> conda.gateways.repodata.RepodataState
conda.gateways.repodata.jlap.interface.ZstdRepoInterface --|> conda.gateways.repodata.jlap.interface.JlapRepoInterface
conda.models.channel.MultiChannel --|> conda.models.channel.Channel
conda.models.dist.Dist --|> conda.auxlib.entity.Entity
conda.models.dist.DistType --|> conda.auxlib.entity.EntityType
conda.models.leased_path_entry.LeasedPathEntry --|> conda.auxlib.entity.Entity
conda.models.match_spec.CaseInsensitiveStrMatch --|> conda.models.match_spec.GlobLowerStrMatch
conda.models.match_spec.ChannelMatch --|> conda.models.match_spec.GlobStrMatch
conda.models.match_spec.ExactLowerStrMatch --|> conda.models.match_spec.ExactStrMatch
conda.models.match_spec.ExactStrMatch --|> conda.models.match_spec.MatchInterface
conda.models.match_spec.ExactStrMatch --|> conda.models.match_spec._StrMatchMixin
conda.models.match_spec.FeatureMatch --|> conda.models.match_spec.MatchInterface
conda.models.match_spec.GlobLowerStrMatch --|> conda.models.match_spec.GlobStrMatch
conda.models.match_spec.GlobStrMatch --|> conda.models.match_spec.MatchInterface
conda.models.match_spec.GlobStrMatch --|> conda.models.match_spec._StrMatchMixin
conda.models.match_spec.SplitStrMatch --|> conda.models.match_spec.MatchInterface
conda.models.package_info.Noarch --|> conda.auxlib.entity.Entity
conda.models.package_info.NoarchField --|> conda.auxlib.entity.EnumField
conda.models.package_info.PackageInfo --|> conda.auxlib.entity.ImmutableEntity
conda.models.package_info.PackageMetadata --|> conda.auxlib.entity.Entity
conda.models.package_info.PreferredEnv --|> conda.auxlib.entity.Entity
conda.models.prefix_graph.GeneralGraph --|> conda.models.prefix_graph.PrefixGraph
conda.models.records.ChannelField --|> conda.auxlib.entity.ComposableField
conda.models.records.FilenameField --|> conda.auxlib.entity.StringField
conda.models.records.Link --|> conda.auxlib.entity.DictSafeMixin
conda.models.records.Link --|> conda.auxlib.entity.Entity
conda.models.records.LinkTypeField --|> conda.auxlib.entity.EnumField
conda.models.records.Md5Field --|> conda.auxlib.entity.StringField
conda.models.records.NoarchField --|> conda.auxlib.entity.EnumField
conda.models.records.PackageCacheRecord --|> conda.models.records.PackageRecord
conda.models.records.PackageRecord --|> conda.auxlib.entity.DictSafeMixin
conda.models.records.PackageRecord --|> conda.auxlib.entity.Entity
conda.models.records.PackageTypeField --|> conda.auxlib.entity.EnumField
conda.models.records.PathData --|> conda.auxlib.entity.Entity
conda.models.records.PathDataV1 --|> conda.models.records.PathData
conda.models.records.PathsData --|> conda.auxlib.entity.Entity
conda.models.records.PrefixRecord --|> conda.models.records.PackageRecord
conda.models.records.SubdirField --|> conda.auxlib.entity.StringField
conda.models.records.TimestampField --|> conda.auxlib.entity.NumberField
conda.models.records._FeaturesField --|> conda.auxlib.entity.ListField
conda.models.version.BuildNumberMatch --|> conda.models.version.BaseSpec
conda.models.version.VersionSpec --|> conda.models.version.BaseSpec
conda.plugins.manager.CondaPluginManager --|> pluggy._manager.PluginManager
conda.plugins.types.ChannelAuthBase --|> conda.plugins.types.ChannelNameMixin
conda.plugins.types.ChannelAuthBase --|> requests.auth.AuthBase
packaging.version.Version --|> packaging.version._BaseVersion
requests.adapters.HTTPAdapter --|> requests.adapters.BaseAdapter
requests.sessions.Session --|> requests.sessions.SessionRedirectMixin
tqdm.asyncio.tqdm_asyncio --|> tqdm.std.tqdm
tqdm.auto.tqdm --|> tqdm.asyncio.tqdm_asyncio
tqdm.auto.tqdm --|> tqdm.notebook.tqdm_notebook
tqdm.auto.tqdm --|> tqdm.std.tqdm
tqdm.notebook.tqdm_notebook --|> tqdm.std.tqdm
tqdm.std.tqdm --|> tqdm.utils.Comparable
tqdm.utils.DisableOnWriteError --|> tqdm.utils.ObjectWrapper
urllib3.poolmanager.PoolManager --|> urllib3._request_methods.RequestMethods
._Version --* packaging.version.Version : _version
boltons.setutils.IndexedSet --* conda.common.configuration.Configuration : _reset_callbacks
boltons.setutils.IndexedSet --* conda.common.configuration.Configuration : _search_path
boltons.setutils.IndexedSet --* conda.core.solve.Solver : channels
boltons.setutils.IndexedSet --* conda.core.solve.SolverStateContainer : solution_precs
conda._vendor.frozendict.frozendict --* conda.auxlib.entity.MapField : _type
conda._vendor.frozendict.frozendict --* conda.common.configuration.DefaultValueRawParameter : _value
conda._vendor.frozendict.frozendict --* conda.common.configuration.MapLoadedParameter : _type
conda._vendor.frozendict.frozendict --* conda.common.configuration.MapParameter : _type
conda._vendor.frozendict.frozendict --* conda.common.configuration.YamlRawParameter : _value
conda._vendor.frozendict.frozendict --* conda.common.pkg_formats.python.PythonDistributionMetadata : SINGLE_USE_KEYS
conda._vendor.frozendict.frozendict --* conda.common.pkg_formats.python.PythonDistributionMetadata : MULTIPLE_USE_KEYS
conda._vendor.frozendict.frozendict --* conda.models.match_spec.MatchSpec : _match_components
conda.auxlib._Null --* conda.auxlib.entity.Field : _default
conda.auxlib.collection.AttrDict --* conda.common.configuration.Configuration : _argparse_args
conda.auxlib.entity.BooleanField --* conda.models.records.PathData : no_link
conda.auxlib.entity.ComposableField --* conda.models.package_info.PackageInfo : channel
conda.auxlib.entity.ComposableField --* conda.models.package_info.PackageInfo : repodata_record
conda.auxlib.entity.ComposableField --* conda.models.package_info.PackageInfo : package_metadata
conda.auxlib.entity.ComposableField --* conda.models.package_info.PackageInfo : paths_data
conda.auxlib.entity.ComposableField --* conda.models.package_info.PackageMetadata : noarch
conda.auxlib.entity.ComposableField --* conda.models.package_info.PackageMetadata : preferred_env
conda.auxlib.entity.ComposableField --* conda.models.records.PrefixRecord : paths_data
conda.auxlib.entity.ComposableField --* conda.models.records.PrefixRecord : link
conda.auxlib.entity.EnumField --* conda.models.leased_path_entry.LeasedPathEntry : leased_path_type
conda.auxlib.entity.EnumField --* conda.models.records.PackageRecord : platform
conda.auxlib.entity.EnumField --* conda.models.records.PathData : file_mode
conda.auxlib.entity.EnumField --* conda.models.records.PathData : path_type
conda.auxlib.entity.IntegerField --* conda.models.dist.Dist : build_number
conda.auxlib.entity.IntegerField --* conda.models.package_info.PackageMetadata : package_metadata_version
conda.auxlib.entity.IntegerField --* conda.models.records.PackageRecord : build_number
conda.auxlib.entity.IntegerField --* conda.models.records.PackageRecord : legacy_bz2_size
conda.auxlib.entity.IntegerField --* conda.models.records.PackageRecord : size
conda.auxlib.entity.IntegerField --* conda.models.records.PathDataV1 : size_in_bytes
conda.auxlib.entity.IntegerField --* conda.models.records.PathsData : paths_version
conda.auxlib.entity.ListField --* conda.models.package_info.Noarch : entry_points
conda.auxlib.entity.ListField --* conda.models.package_info.PreferredEnv : executable_paths
conda.auxlib.entity.ListField --* conda.models.package_info.PreferredEnv : softlink_paths
conda.auxlib.entity.ListField --* conda.models.records.PackageRecord : depends
conda.auxlib.entity.ListField --* conda.models.records.PackageRecord : constrains
conda.auxlib.entity.ListField --* conda.models.records.PathDataV1 : inode_paths
conda.auxlib.entity.ListField --* conda.models.records.PathsData : paths
conda.auxlib.entity.ListField --* conda.models.records.PrefixRecord : files
conda.auxlib.entity.StringField --* conda.models.dist.Dist : channel
conda.auxlib.entity.StringField --* conda.models.dist.Dist : dist_name
conda.auxlib.entity.StringField --* conda.models.dist.Dist : name
conda.auxlib.entity.StringField --* conda.models.dist.Dist : fmt
conda.auxlib.entity.StringField --* conda.models.dist.Dist : version
conda.auxlib.entity.StringField --* conda.models.dist.Dist : build_string
conda.auxlib.entity.StringField --* conda.models.dist.Dist : base_url
conda.auxlib.entity.StringField --* conda.models.dist.Dist : platform
conda.auxlib.entity.StringField --* conda.models.leased_path_entry.LeasedPathEntry : _path
conda.auxlib.entity.StringField --* conda.models.leased_path_entry.LeasedPathEntry : target_path
conda.auxlib.entity.StringField --* conda.models.leased_path_entry.LeasedPathEntry : target_prefix
conda.auxlib.entity.StringField --* conda.models.leased_path_entry.LeasedPathEntry : leased_path
conda.auxlib.entity.StringField --* conda.models.leased_path_entry.LeasedPathEntry : package_name
conda.auxlib.entity.StringField --* conda.models.package_info.PackageInfo : extracted_package_dir
conda.auxlib.entity.StringField --* conda.models.package_info.PackageInfo : package_tarball_full_path
conda.auxlib.entity.StringField --* conda.models.package_info.PackageInfo : url
conda.auxlib.entity.StringField --* conda.models.package_info.PackageInfo : icondata
conda.auxlib.entity.StringField --* conda.models.package_info.PreferredEnv : name
conda.auxlib.entity.StringField --* conda.models.records.Link : source
conda.auxlib.entity.StringField --* conda.models.records.PackageCacheRecord : package_tarball_full_path
conda.auxlib.entity.StringField --* conda.models.records.PackageCacheRecord : extracted_package_dir
conda.auxlib.entity.StringField --* conda.models.records.PackageRecord : name
conda.auxlib.entity.StringField --* conda.models.records.PackageRecord : version
conda.auxlib.entity.StringField --* conda.models.records.PackageRecord : build
conda.auxlib.entity.StringField --* conda.models.records.PackageRecord : md5
conda.auxlib.entity.StringField --* conda.models.records.PackageRecord : legacy_bz2_md5
conda.auxlib.entity.StringField --* conda.models.records.PackageRecord : url
conda.auxlib.entity.StringField --* conda.models.records.PackageRecord : sha256
conda.auxlib.entity.StringField --* conda.models.records.PackageRecord : arch
conda.auxlib.entity.StringField --* conda.models.records.PackageRecord : preferred_env
conda.auxlib.entity.StringField --* conda.models.records.PackageRecord : license
conda.auxlib.entity.StringField --* conda.models.records.PackageRecord : license_family
conda.auxlib.entity.StringField --* conda.models.records.PackageRecord : date
conda.auxlib.entity.StringField --* conda.models.records.PathData : _path
conda.auxlib.entity.StringField --* conda.models.records.PathData : prefix_placeholder
conda.auxlib.entity.StringField --* conda.models.records.PathDataV1 : sha256
conda.auxlib.entity.StringField --* conda.models.records.PathDataV1 : sha256_in_prefix
conda.auxlib.entity.StringField --* conda.models.records.PrefixRecord : package_tarball_full_path
conda.auxlib.entity.StringField --* conda.models.records.PrefixRecord : extracted_package_dir
conda.auxlib.entity.StringField --* conda.models.records.PrefixRecord : requested_spec
conda.auxlib.entity.StringField --* conda.models.records.PrefixRecord : auth
conda.base.constants.NoticeLevel --* conda.notices.types.ChannelNotice : level
conda.common._logic.Clauses --* conda.common.logic.Clauses : _clauses
conda.common._logic._ClauseList --* conda.common._logic._SatSolver : _clauses
conda.common.configuration.Parameter --* conda.plugins.types.CondaSetting : parameter
conda.common.configuration.ParameterLoader --* conda.base.context.Context : add_pip_as_python_dependency
conda.common.configuration.ParameterLoader --* conda.base.context.Context : allow_conda_downgrades
conda.common.configuration.ParameterLoader --* conda.base.context.Context : allow_cycles
conda.common.configuration.ParameterLoader --* conda.base.context.Context : allow_softlinks
conda.common.configuration.ParameterLoader --* conda.base.context.Context : auto_update_conda
conda.common.configuration.ParameterLoader --* conda.base.context.Context : auto_activate_base
conda.common.configuration.ParameterLoader --* conda.base.context.Context : auto_stack
conda.common.configuration.ParameterLoader --* conda.base.context.Context : notify_outdated_conda
conda.common.configuration.ParameterLoader --* conda.base.context.Context : clobber
conda.common.configuration.ParameterLoader --* conda.base.context.Context : changeps1
conda.common.configuration.ParameterLoader --* conda.base.context.Context : env_prompt
conda.common.configuration.ParameterLoader --* conda.base.context.Context : create_default_packages
conda.common.configuration.ParameterLoader --* conda.base.context.Context : register_envs
conda.common.configuration.ParameterLoader --* conda.base.context.Context : default_python
conda.common.configuration.ParameterLoader --* conda.base.context.Context : download_only
conda.common.configuration.ParameterLoader --* conda.base.context.Context : enable_private_envs
conda.common.configuration.ParameterLoader --* conda.base.context.Context : force_32bit
conda.common.configuration.ParameterLoader --* conda.base.context.Context : non_admin_enabled
conda.common.configuration.ParameterLoader --* conda.base.context.Context : pip_interop_enabled
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _default_threads
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _repodata_threads
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _fetch_threads
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _verify_threads
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _execute_threads
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _aggressive_update_packages
conda.common.configuration.ParameterLoader --* conda.base.context.Context : safety_checks
conda.common.configuration.ParameterLoader --* conda.base.context.Context : extra_safety_checks
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _signing_metadata_url_base
conda.common.configuration.ParameterLoader --* conda.base.context.Context : path_conflict
conda.common.configuration.ParameterLoader --* conda.base.context.Context : pinned_packages
conda.common.configuration.ParameterLoader --* conda.base.context.Context : disallowed_packages
conda.common.configuration.ParameterLoader --* conda.base.context.Context : rollback_enabled
conda.common.configuration.ParameterLoader --* conda.base.context.Context : track_features
conda.common.configuration.ParameterLoader --* conda.base.context.Context : use_index_cache
conda.common.configuration.ParameterLoader --* conda.base.context.Context : separate_format_cache
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _root_prefix
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _envs_dirs
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _pkgs_dirs
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _subdir
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _subdirs
conda.common.configuration.ParameterLoader --* conda.base.context.Context : local_repodata_ttl
conda.common.configuration.ParameterLoader --* conda.base.context.Context : ssl_verify
conda.common.configuration.ParameterLoader --* conda.base.context.Context : client_ssl_cert
conda.common.configuration.ParameterLoader --* conda.base.context.Context : client_ssl_cert_key
conda.common.configuration.ParameterLoader --* conda.base.context.Context : proxy_servers
conda.common.configuration.ParameterLoader --* conda.base.context.Context : remote_connect_timeout_secs
conda.common.configuration.ParameterLoader --* conda.base.context.Context : remote_read_timeout_secs
conda.common.configuration.ParameterLoader --* conda.base.context.Context : remote_max_retries
conda.common.configuration.ParameterLoader --* conda.base.context.Context : remote_backoff_factor
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _reporters
conda.common.configuration.ParameterLoader --* conda.base.context.Context : allow_non_channel_urls
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _channel_alias
conda.common.configuration.ParameterLoader --* conda.base.context.Context : channel_priority
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _channels
conda.common.configuration.ParameterLoader --* conda.base.context.Context : channel_settings
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _custom_channels
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _custom_multichannels
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _default_channels
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _migrated_channel_aliases
conda.common.configuration.ParameterLoader --* conda.base.context.Context : migrated_custom_channels
conda.common.configuration.ParameterLoader --* conda.base.context.Context : override_channels_enabled
conda.common.configuration.ParameterLoader --* conda.base.context.Context : show_channel_urls
conda.common.configuration.ParameterLoader --* conda.base.context.Context : use_local
conda.common.configuration.ParameterLoader --* conda.base.context.Context : allowlist_channels
conda.common.configuration.ParameterLoader --* conda.base.context.Context : restore_free_channel
conda.common.configuration.ParameterLoader --* conda.base.context.Context : repodata_fns
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _use_only_tar_bz2
conda.common.configuration.ParameterLoader --* conda.base.context.Context : always_softlink
conda.common.configuration.ParameterLoader --* conda.base.context.Context : always_copy
conda.common.configuration.ParameterLoader --* conda.base.context.Context : always_yes
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _debug
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _trace
conda.common.configuration.ParameterLoader --* conda.base.context.Context : dry_run
conda.common.configuration.ParameterLoader --* conda.base.context.Context : error_upload_url
conda.common.configuration.ParameterLoader --* conda.base.context.Context : force
conda.common.configuration.ParameterLoader --* conda.base.context.Context : json
conda.common.configuration.ParameterLoader --* conda.base.context.Context : offline
conda.common.configuration.ParameterLoader --* conda.base.context.Context : quiet
conda.common.configuration.ParameterLoader --* conda.base.context.Context : ignore_pinned
conda.common.configuration.ParameterLoader --* conda.base.context.Context : report_errors
conda.common.configuration.ParameterLoader --* conda.base.context.Context : shortcuts
conda.common.configuration.ParameterLoader --* conda.base.context.Context : number_channel_notices
conda.common.configuration.ParameterLoader --* conda.base.context.Context : shortcuts_only
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _verbosity
conda.common.configuration.ParameterLoader --* conda.base.context.Context : experimental
conda.common.configuration.ParameterLoader --* conda.base.context.Context : no_lock
conda.common.configuration.ParameterLoader --* conda.base.context.Context : repodata_use_zst
conda.common.configuration.ParameterLoader --* conda.base.context.Context : envvars_force_uppercase
conda.common.configuration.ParameterLoader --* conda.base.context.Context : deps_modifier
conda.common.configuration.ParameterLoader --* conda.base.context.Context : update_modifier
conda.common.configuration.ParameterLoader --* conda.base.context.Context : sat_solver
conda.common.configuration.ParameterLoader --* conda.base.context.Context : solver_ignore_timestamps
conda.common.configuration.ParameterLoader --* conda.base.context.Context : solver
conda.common.configuration.ParameterLoader --* conda.base.context.Context : force_remove
conda.common.configuration.ParameterLoader --* conda.base.context.Context : force_reinstall
conda.common.configuration.ParameterLoader --* conda.base.context.Context : target_prefix_override
conda.common.configuration.ParameterLoader --* conda.base.context.Context : unsatisfiable_hints
conda.common.configuration.ParameterLoader --* conda.base.context.Context : unsatisfiable_hints_check_depth
conda.common.configuration.ParameterLoader --* conda.base.context.Context : bld_path
conda.common.configuration.ParameterLoader --* conda.base.context.Context : anaconda_upload
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _croot
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _conda_build
conda.common.configuration.ParameterLoader --* conda.base.context.Context : no_plugins
conda.common.io.CaptureTarget.STRING --* conda.common.io.Spinner : fh
conda.common.io.CaptureTarget.STRING --* conda.common.io.captured.CapturedText : stderr
conda.common.io.DummyExecutor --* conda.core.link.UnlinkLinkTransaction : verify_executor
conda.common.io.DummyExecutor --* conda.core.link.UnlinkLinkTransaction : execute_executor
conda.common.io.ThreadLimitedThreadPoolExecutor --* conda.core.link.UnlinkLinkTransaction : verify_executor
conda.common.io.ThreadLimitedThreadPoolExecutor --* conda.core.link.UnlinkLinkTransaction : execute_executor
conda.common.pkg_formats.python.PythonDistributionMetadata --* conda.common.pkg_formats.python.PythonDistribution : _metadata
conda.core.package_cache_data.ProgressiveFetchExtract --* conda.core.link.UnlinkLinkTransaction : _pfe
conda.core.package_cache_data.ProgressiveFetchExtract --* conda.core.link.UnlinkLinkTransaction : _pfe
conda.core.package_cache_data.UrlsData --* conda.core.package_cache_data.PackageCacheData : _urls_data
conda.core.subdir_data.PackageRecordList --* conda.core.subdir_data.SubdirData : _package_records
conda.env.env.Dependencies --* conda.env.env.Environment : dependencies
conda.env.env.Environment --* conda.env.specs.yaml_file.YamlFileSpec : _environment
conda.gateways.connection.session.CondaHttpAuth --* conda.gateways.connection.session.CondaSession : auth
conda.gateways.repodata.RepodataState --* conda.gateways.repodata.RepodataCache : state
conda.models.channel.Channel --* conda.gateways.repodata.RepodataFetch : channel
conda.models.package_info.NoarchField --* conda.models.package_info.Noarch : type
conda.models.records.ChannelField --* conda.models.records.PackageRecord : channel
conda.models.records.FilenameField --* conda.models.records.PackageRecord : fn
conda.models.records.LinkTypeField --* conda.models.records.Link : type
conda.models.records.Md5Field --* conda.models.records.PackageCacheRecord : md5
conda.models.records.NoarchField --* conda.models.records.PackageRecord : noarch
conda.models.records.PackageTypeField --* conda.models.records.PackageRecord : package_type
conda.models.records.SubdirField --* conda.models.records.PackageRecord : subdir
conda.models.records.TimestampField --* conda.models.records.PackageRecord : timestamp
conda.models.records._FeaturesField --* conda.models.records.PackageRecord : track_features
conda.models.records._FeaturesField --* conda.models.records.PackageRecord : features
conda.resolve.Resolve --* conda.core.solve.Solver : _r
conda.resolve.Resolve --* conda.core.solve.Solver : _r
conda.testing.CondaCLIFixture --* conda.testing.TmpChannelFixture : conda_cli
conda.testing.CondaCLIFixture --* conda.testing.TmpEnvFixture : conda_cli
conda.testing.PathFactoryFixture --* conda.testing.TmpChannelFixture : path_factory
conda.testing.PathFactoryFixture --* conda.testing.TmpEnvFixture : path_factory
conda.testing.solver_helpers.SimpleEnvironment --* conda.testing.solver_helpers.SolverTests : env
packaging.version.Version --* conda.deprecations.DeprecationHandler : _version_object
packaging.version.Version --* conda.deprecations.DeprecationHandler : _version_object
requests.cookies.RequestsCookieJar --* requests.sessions.Session : cookies
requests.structures.CaseInsensitiveDict --* requests.sessions.Session : headers
tqdm.asyncio.tqdm_asyncio --* conda.common.io.ProgressBar : pbar
tqdm.auto.tqdm --* conda.common.io.ProgressBar : pbar
tqdm.notebook.TqdmHBox --* tqdm.notebook.tqdm_notebook : container
tqdm.std.EMA --* tqdm.std.tqdm : _ema_dn
tqdm.std.EMA --* tqdm.std.tqdm : _ema_dn
tqdm.std.EMA --* tqdm.std.tqdm : _ema_dt
tqdm.std.EMA --* tqdm.std.tqdm : _ema_dt
tqdm.std.EMA --* tqdm.std.tqdm : _ema_miniters
tqdm.std.EMA --* tqdm.std.tqdm : _ema_miniters
urllib3._collections.RecentlyUsedContainer --* urllib3.poolmanager.PoolManager : pools
urllib3.poolmanager.PoolManager --* requests.adapters.HTTPAdapter : poolmanager
urllib3.util.retry.Retry --* requests.adapters.HTTPAdapter : max_retries
urllib3.util.retry.Retry --* requests.adapters.HTTPAdapter : max_retries
conda.auxlib._Null --o conda.core.package_cache_data.PackageCacheData : __is_writable
conda.auxlib._Null --o conda.core.prefix_data.PrefixData : __is_writable
conda.auxlib._Null --o conda.core.solve.Solver : _command
conda.auxlib._Null --o conda.core.solve.SolverStateContainer : update_modifier
conda.auxlib._Null --o conda.core.solve.SolverStateContainer : deps_modifier
conda.auxlib.collection.AttrDict --o conda.auxlib.collection.AttrDict : __dict__
conda.base.constants.DepsModifier --o conda.core.solve.SolverStateContainer : deps_modifier
conda.base.constants.UpdateModifier --o conda.core.solve.SolverStateContainer : update_modifier
conda.core.solve.SolverStateContainer --o conda.core.solve.Solver : ssc
conda.gateways.repodata.CondaRepoInterface --o conda.core.subdir_data.SubdirData : RepoInterface
conda.models.channel.Channel --o conda.core.subdir_data.SubdirData : channel
conda.models.enums.LinkType.hardlink --o conda.core.path_actions.UnlinkPathAction : link_type
tqdm.utils.DisableOnWriteError --o tqdm.std.tqdm : fp
@enduml