Architecture

Conda is a complex system of many components and can be hard to understand for users and developers alike. The following C4 model based architecture diagrams should help in that regard. As a refresher, the C4 model tries to visualize complex software systems at different levels of detail, and explaining the functionality to different types of audience.

Note

These diagrams represent the state of conda at the time when the documentation was automatically build as part of the development process for conda 4.14.0.post12+ea6f585c2 (Aug 10, 2022).

C4 stands for the for levels:

  1. Context

  2. Container

  3. Component

  4. Code

Level 1: Context

This is the overview, 30,000 feet view on conda, to better understand how conda in the center of the diagram interacts with other systems and how users relate to it.

More information about how to interpret this diagram can be found in the C4 model documentation about the System Context diagram.

@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

Level 2: Container

This level is zooming in to conda on a system level, which was in the center of the Level 1 diagram, to show the high-level shape of the software architecture of and the various responsibilities in conda, including major technology choices and communication patterns between the various containers.

More information about how to interpret the following diagrams can be found in the C4 model documentation about the Container diagram.

Channels

The following diagram focuses on the channels container from the level 1 diagram.

@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

The following diagram focuses on the conda container from the level 1 diagram.

@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

Level 3: Component

Yet another zoom-in, in which individual containers from Level 2 are decomposed to show major building blocks in conda and their interactions. Those building blocks are called components in the sense that they each have a higher function and relate to an identifiable responsibility and implementation details.

@startuml packages_conda
set namespaceSeparator none
left to right direction
skinparam nodesep 5
skinparam ranksep 5
package "conda" as conda #aliceblue {
}
package "conda.__main__" as conda.__main__ #aliceblue {
}
package "conda.activate" as conda.activate #aliceblue {
}
package "conda.auxlib" as conda.auxlib #antiquewhite {
}
package "conda.auxlib.collection" as conda.auxlib.collection #antiquewhite {
}
package "conda.auxlib.decorators" as conda.auxlib.decorators #antiquewhite {
}
package "conda.auxlib.entity" as conda.auxlib.entity #antiquewhite {
}
package "conda.auxlib.exceptions" as conda.auxlib.exceptions #antiquewhite {
}
package "conda.auxlib.ish" as conda.auxlib.ish #antiquewhite {
}
package "conda.auxlib.logz" as conda.auxlib.logz #antiquewhite {
}
package "conda.auxlib.packaging" as conda.auxlib.packaging #antiquewhite {
}
package "conda.auxlib.type_coercion" as conda.auxlib.type_coercion #antiquewhite {
}
package "conda.base" as conda.base #aquamarine {
}
package "conda.base.constants" as conda.base.constants #aquamarine {
}
package "conda.base.context" as conda.base.context #aquamarine {
}
package "conda.base.exceptions" as conda.base.exceptions #aquamarine {
}
package "conda.cli" as conda.cli #burlywood {
}
package "conda.cli.common" as conda.cli.common #burlywood {
}
package "conda.cli.conda_argparse" as conda.cli.conda_argparse #burlywood {
}
package "conda.cli.find_commands" as conda.cli.find_commands #burlywood {
}
package "conda.cli.install" as conda.cli.install #burlywood {
}
package "conda.cli.main" as conda.cli.main #burlywood {
}
package "conda.cli.main_clean" as conda.cli.main_clean #burlywood {
}
package "conda.cli.main_compare" as conda.cli.main_compare #burlywood {
}
package "conda.cli.main_config" as conda.cli.main_config #burlywood {
}
package "conda.cli.main_create" as conda.cli.main_create #burlywood {
}
package "conda.cli.main_info" as conda.cli.main_info #burlywood {
}
package "conda.cli.main_init" as conda.cli.main_init #burlywood {
}
package "conda.cli.main_install" as conda.cli.main_install #burlywood {
}
package "conda.cli.main_list" as conda.cli.main_list #burlywood {
}
package "conda.cli.main_notices" as conda.cli.main_notices #burlywood {
}
package "conda.cli.main_package" as conda.cli.main_package #burlywood {
}
package "conda.cli.main_pip" as conda.cli.main_pip #burlywood {
}
package "conda.cli.main_remove" as conda.cli.main_remove #burlywood {
}
package "conda.cli.main_rename" as conda.cli.main_rename #burlywood {
}
package "conda.cli.main_run" as conda.cli.main_run #burlywood {
}
package "conda.cli.main_search" as conda.cli.main_search #burlywood {
}
package "conda.cli.main_update" as conda.cli.main_update #burlywood {
}
package "conda.cli.python_api" as conda.cli.python_api #burlywood {
}
package "conda.common" as conda.common #cadetblue {
}
package "conda.common._logic" as conda.common._logic #cadetblue {
}
package "conda.common._os" as conda.common._os #chartreuse {
}
package "conda.common._os.linux" as conda.common._os.linux #chartreuse {
}
package "conda.common._os.unix" as conda.common._os.unix #chartreuse {
}
package "conda.common._os.windows" as conda.common._os.windows #chartreuse {
}
package "conda.common.configuration" as conda.common.configuration #cadetblue {
}
package "conda.common.constants" as conda.common.constants #cadetblue {
}
package "conda.common.cuda" as conda.common.cuda #cadetblue {
}
package "conda.common.decorators" as conda.common.decorators #cadetblue {
}
package "conda.common.disk" as conda.common.disk #cadetblue {
}
package "conda.common.io" as conda.common.io #cadetblue {
}
package "conda.common.logic" as conda.common.logic #cadetblue {
}
package "conda.common.path" as conda.common.path #cadetblue {
}
package "conda.common.pkg_formats" as conda.common.pkg_formats #chocolate {
}
package "conda.common.pkg_formats.python" as conda.common.pkg_formats.python #chocolate {
}
package "conda.common.serialize" as conda.common.serialize #cadetblue {
}
package "conda.common.signals" as conda.common.signals #cadetblue {
}
package "conda.common.toposort" as conda.common.toposort #cadetblue {
}
package "conda.common.url" as conda.common.url #cadetblue {
}
package "conda.core" as conda.core #coral {
}
package "conda.core.envs_manager" as conda.core.envs_manager #coral {
}
package "conda.core.index" as conda.core.index #coral {
}
package "conda.core.initialize" as conda.core.initialize #coral {
}
package "conda.core.link" as conda.core.link #coral {
}
package "conda.core.package_cache" as conda.core.package_cache #coral {
}
package "conda.core.package_cache_data" as conda.core.package_cache_data #coral {
}
package "conda.core.path_actions" as conda.core.path_actions #coral {
}
package "conda.core.portability" as conda.core.portability #coral {
}
package "conda.core.prefix_data" as conda.core.prefix_data #coral {
}
package "conda.core.solve" as conda.core.solve #coral {
}
package "conda.core.subdir_data" as conda.core.subdir_data #coral {
}
package "conda.exceptions" as conda.exceptions #aliceblue {
}
package "conda.gateways" as conda.gateways #cornflowerblue {
}
package "conda.gateways.anaconda_client" as conda.gateways.anaconda_client #cornflowerblue {
}
package "conda.gateways.connection" as conda.gateways.connection #cyan {
}
package "conda.gateways.connection.adapters" as conda.gateways.connection.adapters #darkgoldenrod {
}
package "conda.gateways.connection.adapters.ftp" as conda.gateways.connection.adapters.ftp #darkgoldenrod {
}
package "conda.gateways.connection.adapters.localfs" as conda.gateways.connection.adapters.localfs #darkgoldenrod {
}
package "conda.gateways.connection.adapters.s3" as conda.gateways.connection.adapters.s3 #darkgoldenrod {
}
package "conda.gateways.connection.download" as conda.gateways.connection.download #cyan {
}
package "conda.gateways.connection.session" as conda.gateways.connection.session #cyan {
}
package "conda.gateways.disk" as conda.gateways.disk #darkseagreen {
}
package "conda.gateways.disk.create" as conda.gateways.disk.create #darkseagreen {
}
package "conda.gateways.disk.delete" as conda.gateways.disk.delete #darkseagreen {
}
package "conda.gateways.disk.link" as conda.gateways.disk.link #darkseagreen {
}
package "conda.gateways.disk.permissions" as conda.gateways.disk.permissions #darkseagreen {
}
package "conda.gateways.disk.read" as conda.gateways.disk.read #darkseagreen {
}
package "conda.gateways.disk.test" as conda.gateways.disk.test #darkseagreen {
}
package "conda.gateways.disk.update" as conda.gateways.disk.update #darkseagreen {
}
package "conda.gateways.logging" as conda.gateways.logging #cornflowerblue {
}
package "conda.gateways.subprocess" as conda.gateways.subprocess #cornflowerblue {
}
package "conda.history" as conda.history #aliceblue {
}
package "conda.instructions" as conda.instructions #aliceblue {
}
package "conda.lock" as conda.lock #aliceblue {
}
package "conda.models" as conda.models #dodgerblue {
}
package "conda.models.channel" as conda.models.channel #dodgerblue {
}
package "conda.models.dist" as conda.models.dist #dodgerblue {
}
package "conda.models.enums" as conda.models.enums #dodgerblue {
}
package "conda.models.leased_path_entry" as conda.models.leased_path_entry #dodgerblue {
}
package "conda.models.match_spec" as conda.models.match_spec #dodgerblue {
}
package "conda.models.package_info" as conda.models.package_info #dodgerblue {
}
package "conda.models.prefix_graph" as conda.models.prefix_graph #dodgerblue {
}
package "conda.models.records" as conda.models.records #dodgerblue {
}
package "conda.models.version" as conda.models.version #dodgerblue {
}
package "conda.notices" as conda.notices #forestgreen {
}
package "conda.notices.cache" as conda.notices.cache #forestgreen {
}
package "conda.notices.core" as conda.notices.core #forestgreen {
}
package "conda.notices.http" as conda.notices.http #forestgreen {
}
package "conda.notices.types" as conda.notices.types #forestgreen {
}
package "conda.notices.views" as conda.notices.views #forestgreen {
}
package "conda.plan" as conda.plan #aliceblue {
}
package "conda.resolve" as conda.resolve #aliceblue {
}
package "conda.testing" as conda.testing #gold {
}
package "conda.testing.cases" as conda.testing.cases #gold {
}
package "conda.testing.decorators" as conda.testing.decorators #gold {
}
package "conda.testing.fixtures" as conda.testing.fixtures #gold {
}
package "conda.testing.gateways" as conda.testing.gateways #hotpink {
}
package "conda.testing.gateways.fixtures" as conda.testing.gateways.fixtures #hotpink {
}
package "conda.testing.helpers" as conda.testing.helpers #gold {
}
package "conda.testing.integration" as conda.testing.integration #gold {
}
package "conda.testing.notices" as conda.testing.notices #mediumspringgreen {
}
package "conda.testing.notices.fixtures" as conda.testing.notices.fixtures #mediumspringgreen {
}
package "conda.testing.notices.helpers" as conda.testing.notices.helpers #mediumspringgreen {
}
package "conda.testing.solver_helpers" as conda.testing.solver_helpers #gold {
}
package "conda.trust" as conda.trust #aliceblue {
}
package "conda.trust.constants" as conda.trust.constants #aliceblue {
}
package "conda.trust.signature_verification" as conda.trust.signature_verification #aliceblue {
}
conda --> conda.auxlib.packaging
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.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.base.context --> conda.common.cuda
conda.cli --> conda.cli.main
conda.cli.conda_argparse --> conda.cli.common
conda.cli.conda_argparse --> conda.cli.find_commands
conda.cli.find_commands --> conda.cli.common
conda.cli.install --> conda.cli.common
conda.cli.install --> conda.cli.common
conda.cli.main --> conda.cli.common
conda.cli.main --> conda.cli.conda_argparse
conda.cli.main_clean --> conda.cli.common
conda.cli.main_compare --> conda.cli.common
conda.cli.main_config --> conda.cli.common
conda.cli.main_config --> conda.cli.common
conda.cli.main_create --> conda.cli.common
conda.cli.main_create --> conda.cli.common
conda.cli.main_create --> conda.cli.install
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_init --> conda.cli.common
conda.cli.main_install --> conda.cli.install
conda.cli.main_list --> conda.cli.common
conda.cli.main_package --> conda.cli.common
conda.cli.main_pip --> conda.cli.main
conda.cli.main_remove --> conda.cli.common
conda.cli.main_remove --> conda.cli.install
conda.cli.main_rename --> conda.cli.common
conda.cli.main_run --> conda.cli.common
conda.cli.main_run --> conda.cli.common
conda.cli.main_search --> conda.cli.common
conda.cli.main_update --> conda.cli.install
conda.cli.python_api --> conda.cli.common
conda.cli.python_api --> conda.cli.conda_argparse
conda.cli.python_api --> conda.cli.main
conda.common._os --> conda.common._os.windows
conda.common.configuration --> conda.common.constants
conda.common.configuration --> conda.common.path
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.url --> conda.common.path
conda.core.envs_manager --> conda.core.prefix_data
conda.core.index --> conda.base.context
conda.core.index --> conda.core.package_cache_data
conda.core.index --> conda.core.prefix_data
conda.core.index --> conda.core.subdir_data
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.exceptions --> conda.auxlib.entity
conda.exceptions --> conda.auxlib.ish
conda.exceptions --> conda.auxlib.logz
conda.exceptions --> conda.auxlib.type_coercion
conda.exceptions --> conda.base.constants
conda.exceptions --> conda.base.context
conda.exceptions --> conda.cli.common
conda.exceptions --> conda.cli.find_commands
conda.exceptions --> conda.cli.main
conda.exceptions --> conda.cli.main_info
conda.exceptions --> conda.common.io
conda.exceptions --> conda.common.signals
conda.exceptions --> conda.common.url
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.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.create --> conda.gateways.subprocess
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.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.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.exceptions
conda.instructions --> conda.gateways.disk.link
conda.lock --> conda.exceptions
conda.lock --> conda.gateways.disk.delete
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.http --> conda.notices.cache
conda.notices.http --> conda.notices.types
conda.notices.views --> conda.notices.types
conda.plan --> conda.base.constants
conda.plan --> conda.base.context
conda.plan --> conda.common.io
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.core.solve
conda.plan --> conda.exceptions
conda.plan --> conda.history
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.prefix_graph
conda.plan --> conda.models.records
conda.plan --> conda.models.version
conda.plan --> conda.resolve
conda.resolve --> conda.auxlib.decorators
conda.resolve --> conda.base.constants
conda.resolve --> conda.base.context
conda.resolve --> conda.common.io
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
conda.testing --> conda.activate
conda.testing --> conda.auxlib.packaging
conda.testing.fixtures --> conda.auxlib.ish
conda.testing.fixtures --> conda.base.context
conda.testing.fixtures --> conda.common.configuration
conda.testing.fixtures --> conda.common.serialize
conda.testing.fixtures --> conda.core.subdir_data
conda.testing.fixtures --> conda.gateways.disk.create
conda.testing.helpers --> conda.testing.gateways
conda.testing.integration --> conda.auxlib.entity
conda.testing.integration --> conda.base.constants
conda.testing.integration --> conda.base.context
conda.testing.integration --> conda.cli.conda_argparse
conda.testing.integration --> conda.cli.main
conda.testing.integration --> conda.common.io
conda.testing.integration --> conda.common.url
conda.testing.integration --> conda.core.package_cache_data
conda.testing.integration --> conda.core.prefix_data
conda.testing.integration --> conda.exceptions
conda.testing.integration --> conda.gateways.disk.create
conda.testing.integration --> conda.gateways.disk.delete
conda.testing.integration --> conda.gateways.disk.link
conda.testing.integration --> conda.gateways.disk.update
conda.testing.integration --> conda.gateways.logging
conda.testing.integration --> conda.models.match_spec
conda.testing.integration --> conda.models.records
conda.testing.notices.fixtures --> conda.base.constants
conda.testing.notices.fixtures --> conda.cli
conda.testing.notices.fixtures --> conda.cli.conda_argparse
conda.testing.notices.helpers --> conda.base.context
conda.testing.notices.helpers --> conda.models.channel
conda.testing.notices.helpers --> conda.notices.core
conda.testing.notices.helpers --> conda.notices.types
conda.trust.signature_verification --> conda.trust.constants
@enduml

More information about how to interpret this diagram can be found in the C4 model documentation about the Component diagram.

Level 4: Code

This part is auto-generated based on the current code and shows how the code is structured and how it interacts. For brevity this ignores a number of subsystems like the public API and exports modules, utility and vendor packages.

More information about how to interpret this diagram can be found in the C4 model documentation about the Code diagram.

@startuml classes_conda
set namespaceSeparator none
left to right direction
skinparam nodesep 5
skinparam ranksep 5
class "six_with_metaclass" as conda.common.compat.six_with_metaclass. #antiquewhite {
}
class "Action" as argparse.Action #grey {
  choices : NoneType
  const : NoneType
  default : NoneType
  dest
  help : NoneType
  metavar : NoneType
  nargs : NoneType
  option_strings
  required : bool
  type : NoneType
}
class "<color:red>ActivateHelp</color>" as conda.exceptions.ActivateHelp #aliceblue {
}
class "AggregateCompileMultiPycAction" as conda.core.path_actions.AggregateCompileMultiPycAction #coral {
}
class "Arch" as conda.models.enums.Arch #dodgerblue {
  name
  from_sys(cls)
}
class "ArgParseRawParameter" as conda.common.configuration.ArgParseRawParameter #cadetblue {
  source : str
  keyflag()
  make_raw_parameters(cls, args_from_argparse)
  value(parameter_obj)
  valueflags(parameter_obj)
}
class "<color:red>ArgumentError</color>" as conda.exceptions.ArgumentError #aliceblue {
  return_code : int
}
class "ArgumentParser" as conda.cli.conda_argparse.ArgumentParser #burlywood {
  description
  error(message)
  print_help()
}
class "ArgumentParser" as argparse.ArgumentParser #grey {
  add_help : bool
  allow_abbrev : bool
  epilog : NoneType
  formatter_class
  fromfile_prefix_chars : NoneType
  prog : NoneType
  usage : NoneType, str
  add_subparsers()
  convert_arg_line_to_args(arg_line)
  error(message)
  exit(status, message)
  format_help()
  format_usage()
  parse_args(args, namespace)
  parse_intermixed_args(args, namespace)
  parse_known_args(args, namespace)
  parse_known_intermixed_args(args, namespace)
  print_help(file)
  print_usage(file)
}
class "<color:red>AssignmentError</color>" as conda.auxlib.exceptions.AssignmentError #antiquewhite {
}
class "AttrDict" as conda.auxlib.collection.AttrDict #antiquewhite {
}
class "AuthBase" as requests.auth.AuthBase #aquamarine {
}
class "AuthBase" as pip._vendor.requests.auth.AuthBase #burlywood {
}
class "<color:red>AuthenticationError</color>" as conda.exceptions.AuthenticationError #aliceblue {
}
class "<color:red>AuthenticationError</color>" as conda.auxlib.exceptions.AuthenticationError #antiquewhite {
}
class "AuxlibError" as conda.auxlib.exceptions.AuxlibError #antiquewhite {
}
class "BaseAdapter" as requests.adapters.BaseAdapter #aquamarine {
  close()
  send(request, stream, timeout, verify, cert, proxies)
}
class "BaseAdapter" as pip._vendor.requests.adapters.BaseAdapter #burlywood {
  close()
  send(request, stream, timeout, verify, cert, proxies)
}
class "BaseSpec" as conda.models.version.BaseSpec #dodgerblue {
  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()
  merge(other)
  operator_match(spec_str)
  regex_match(spec_str)
}
class "BaseTestCase" as conda.testing.cases.BaseTestCase #gold {
  fixture_names : tuple
  auto_injector_fixture(request)
}
class "<color:red>BasicClobberError</color>" as conda.exceptions.BasicClobberError #aliceblue {
}
class "<color:red>BinaryPrefixReplacementError</color>" as conda.exceptions.BinaryPrefixReplacementError #aliceblue {
}
class "BooleanField" as conda.auxlib.entity.BooleanField #antiquewhite {
  box(instance, instance_type, val)
}
class "BufferedRWPair" as _io.BufferedRWPair #grey {
  close()
  detach()
  fileno()
  flush()
  isatty()
  peek()
  read()
  read1()
  readable()
  readinto()
  readinto1()
  readline()
  readlines()
  seek()
  seekable()
  tell()
  truncate()
  writable()
  write()
  writelines()
}
class "BufferedReader" as _io.BufferedReader #grey {
  close()
  detach()
  fileno()
  flush()
  isatty()
  peek()
  read()
  read1()
  readable()
  readinto()
  readinto1()
  readline()
  readlines()
  seek()
  seekable()
  tell()
  truncate()
  writable()
  write()
  writelines()
}
class "BufferedWriter" as _io.BufferedWriter #grey {
  close()
  detach()
  fileno()
  flush()
  isatty()
  read()
  read1()
  readable()
  readinto()
  readinto1()
  readline()
  readlines()
  seek()
  seekable()
  tell()
  truncate()
  writable()
  write()
  writelines()
}
class "BuildNumberMatch" as conda.models.version.BuildNumberMatch #dodgerblue {
  exact_value
  matcher_vo
  operator_func
  regex
  get_matcher(vspec)
  merge(other)
  union(other)
}
class "BuildPyCommand" as conda.auxlib.packaging.BuildPyCommand #antiquewhite {
  run()
}
class "CacheUrlAction" as conda.core.path_actions.CacheUrlAction #coral {
  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 #darkseagreen {
}
class "CaptureTarget" as conda.common.io.CaptureTarget #cadetblue {
  name
}
class "CapturedText" as conda.common.io.captured.CapturedText #cadetblue {
  stderr : NoneType
  stdout
}
class "CaseInsensitiveDict" as requests.structures.CaseInsensitiveDict #aquamarine {
  copy()
  lower_items()
}
class "CaseInsensitiveDict" as pip._vendor.requests.structures.CaseInsensitiveDict #burlywood {
  copy()
  lower_items()
}
class "CaseInsensitiveStrMatch" as conda.models.match_spec.CaseInsensitiveStrMatch #dodgerblue {
  match(other)
}
class "Channel" as conda.models.channel.Channel #dodgerblue {
  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 "<color:red>ChannelError</color>" as conda.exceptions.ChannelError #aliceblue {
}
class "ChannelField" as conda.models.records.ChannelField #dodgerblue {
  dump(instance, instance_type, val)
}
class "ChannelMatch" as conda.models.match_spec.ChannelMatch #dodgerblue {
  match(other)
}
class "<color:red>ChannelNotAllowed</color>" as conda.exceptions.ChannelNotAllowed #aliceblue {
}
class "ChannelNotice" as conda.notices.types.ChannelNotice #forestgreen {
  channel_name : Optional[str]
  created_at : Optional[datetime]
  expired_at : Optional[datetime]
  id : Optional[str]
  interval : Optional[int]
  level
  message : Optional[str]
}
class "ChannelNoticeResponse" as conda.notices.types.ChannelNoticeResponse #forestgreen {
  json_data : Optional[dict]
  name : str
  notices
  url : str
  get_cache_key(cls: str, url: Path, cache_dir) -> Path
}
class "ChannelPriority" as conda.base.constants.ChannelPriority #aquamarine {
  DISABLED : str
  FLEXIBLE : str
  STRICT : str
}
class "ChannelPriorityMeta" as conda.base.constants.ChannelPriorityMeta #aquamarine {
}
class "ChannelType" as conda.models.channel.ChannelType #dodgerblue {
}
class "<color:red>ChecksumMismatchError</color>" as conda.exceptions.ChecksumMismatchError #aliceblue {
}
class "Clauses" as conda.common._logic.Clauses #cadetblue {
  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 #cadetblue {
  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 #aliceblue {
  path_conflict
}
class "CmdExeActivator" as conda.activate.CmdExeActivator #aliceblue {
  command_join : str
  export_var_tmpl : str
  hook_source_path : NoneType
  path_conversion
  pathsep_join
  run_script_tmpl : str
  script_extension : str
  sep : str
  set_var_tmpl : str
  tempfile_extension : str
  unset_var_tmpl : str
}
class "Collection" as _collections_abc.Collection #grey {
}
class "Command" as distutils.cmd.Command #grey {
  distribution
  finalized : int
  force : NoneType
  help : int
  sub_commands : list
  verbose
  announce(msg, level)
  copy_file(infile, outfile, preserve_mode, preserve_times, link, level)
  copy_tree(infile, outfile, preserve_mode, preserve_times, preserve_symlinks, level)
  debug_print(msg)
  dump_options(header, indent)
  ensure_dirname(option)
  ensure_filename(option)
  ensure_finalized()
  ensure_string(option, default)
  ensure_string_list(option)
  execute(func, args, msg, level)
  finalize_options()
  get_command_name()
  get_finalized_command(command, create)
  get_sub_commands()
  initialize_options()
  make_archive(base_name, format, root_dir, base_dir, owner, group)
  make_file(infiles, outfile, func, args, exec_msg, skip_msg, level)
  mkpath(name, mode)
  move_file(src, dst, level)
  reinitialize_command(command, reinit_subcommands)
  run()
  run_command(command)
  set_undefined_options(src_cmd)
  spawn(cmd, search_path, level)
  warn(msg)
}
class "<color:red>CommandNotFoundError</color>" as conda.exceptions.CommandNotFoundError #aliceblue {
}
class "Commands" as conda.cli.python_api.Commands #burlywood {
  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 #gold {
  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 conda._vendor.tqdm.utils.Comparable #chartreuse {
}
class "CompileMultiPycAction" as conda.core.path_actions.CompileMultiPycAction #coral {
  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
  cleanup()
  create_actions(cls, transaction_context, package_info, target_prefix, requested_link_type, file_link_actions)
  execute()
  reverse()
  verify()
}
class "ComposableField" as conda.auxlib.entity.ComposableField #antiquewhite {
  box(instance, instance_type, val)
  dump(instance, instance_type, val)
}
class "<color:red>CondaDependencyError</color>" as conda.exceptions.CondaDependencyError #aliceblue {
}
class "<color:red>CondaEnvException</color>" as conda.exceptions.CondaEnvException #aliceblue {
}
class "<color:red>CondaEnvironmentError</color>" as conda.exceptions.CondaEnvironmentError #aliceblue {
}
class "<color:red>CondaError</color>" as conda.CondaError #aliceblue {
  message
  reportable : bool
  return_code : int
  dump_map()
}
class "<color:red>CondaExitZero</color>" as conda.CondaExitZero #aliceblue {
  return_code : int
}
class "<color:red>CondaFileIOError</color>" as conda.exceptions.CondaFileIOError #aliceblue {
  filepath
}
class "<color:red>CondaHTTPError</color>" as conda.exceptions.CondaHTTPError #aliceblue {
}
class "<color:red>CondaHistoryError</color>" as conda.exceptions.CondaHistoryError #aliceblue {
}
class "<color:red>CondaHistoryWarning</color>" as conda.history.CondaHistoryWarning #aliceblue {
}
class "CondaHttpAuth" as conda.gateways.connection.session.CondaHttpAuth #cyan {
  add_binstar_token(url)
  handle_407(response)
}
class "<color:red>CondaIOError</color>" as conda.exceptions.CondaIOError #aliceblue {
}
class "<color:red>CondaImportError</color>" as conda.exceptions.CondaImportError #aliceblue {
}
class "<color:red>CondaIndexError</color>" as conda.exceptions.CondaIndexError #aliceblue {
}
class "<color:red>CondaKeyError</color>" as conda.exceptions.CondaKeyError #aliceblue {
  key
  msg
}
class "<color:red>CondaMemoryError</color>" as conda.exceptions.CondaMemoryError #aliceblue {
}
class "<color:red>CondaMultiError</color>" as conda.CondaMultiError #aliceblue {
  errors
  contains(exception_class)
  dump_map()
}
class "<color:red>CondaOSError</color>" as conda.exceptions.CondaOSError #aliceblue {
}
class "<color:red>CondaSSLError</color>" as conda.exceptions.CondaSSLError #aliceblue {
}
class "CondaSession" as conda.gateways.connection.session.CondaSession #cyan {
  auth
  cert : tuple
  verify
}
class "CondaSessionType" as conda.gateways.connection.session.CondaSessionType #cyan {
}
class "<color:red>CondaSignalInterrupt</color>" as conda.exceptions.CondaSignalInterrupt #aliceblue {
}
class "<color:red>CondaSystemExit</color>" as conda.exceptions.CondaSystemExit #aliceblue {
}
class "<color:red>CondaUpgradeError</color>" as conda.exceptions.CondaUpgradeError #aliceblue {
}
class "<color:red>CondaValueError</color>" as conda.exceptions.CondaValueError #aliceblue {
}
class "<color:red>CondaVerificationError</color>" as conda.exceptions.CondaVerificationError #aliceblue {
}
class "Condition" as threading.Condition #grey {
  acquire
  notifyAll
  release
  notify(n)
  notify_all()
  wait(timeout)
  wait_for(predicate, timeout)
}
class "Configuration" as conda.common.configuration.Configuration #cadetblue {
  raw_data
  check_source(source)
  collect_all()
  describe_parameter(parameter_name)
  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 #cadetblue {
}
class "<color:red>ConfigurationLoadError</color>" as conda.common.configuration.ConfigurationLoadError #cadetblue {
}
class "ConfigurationObject" as conda.common.configuration.ConfigurationObject #cadetblue {
}
class "ConfigurationType" as conda.common.configuration.ConfigurationType #cadetblue {
}
class "Container" as _collections_abc.Container #grey {
}
class "Context" as conda.base.context.Context #aquamarine {
  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
  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
  conda_private
  config_files
  create_default_packages
  croot
  debug
  default_prefix
  default_python
  default_threads
  deps_modifier
  dev
  dev : bool
  disallowed_packages
  download_only
  dry_run
  enable_private_envs
  env_prompt
  envs_dirs
  error_upload_url
  execute_threads
  experimental_solver
  extra_safety_checks
  force
  force_32bit
  force_reinstall
  force_remove
  ignore_pinned
  json
  local_build_root
  local_repodata_ttl
  migrated_channel_aliases
  migrated_custom_channels
  non_admin_enabled
  notify_outdated_conda
  number_channel_notices
  offline
  override_channels_enabled
  path_conflict
  pinned_packages
  pip_interop_enabled
  pkgs_dirs
  platform
  prefix_specified
  proxy_servers
  quiet
  remote_backoff_factor
  remote_connect_timeout_secs
  remote_max_retries
  remote_read_timeout_secs
  repodata_fns
  repodata_threads
  report_errors
  restore_free_channel
  rollback_enabled
  root_dir
  root_writable
  safety_checks
  sat_solver
  separate_format_cache
  shlvl
  shortcuts
  show_channel_urls
  signing_metadata_url_base
  solver_ignore_timestamps
  ssl_verify
  subdir
  subdirs
  target_prefix
  target_prefix_override
  track_features
  unsatisfiable_hints
  unsatisfiable_hints_check_depth
  update_modifier
  use_index_cache
  use_local
  use_only_tar_bz2
  verbosity
  verify_threads
  channel_alias()
  cpu_flags()
  cuda_version()
  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()
  requests_version()
  root_prefix()
  trash_dir()
  user_agent()
}
class "ContextDecorator" as conda.common.io.ContextDecorator #cadetblue {
}
class "ContextStack" as conda.base.context.ContextStack #aquamarine {
  apply()
  pop()
  push(search_path, argparse_args)
  replace(search_path, argparse_args)
}
class "ContextStackObject" as conda.base.context.ContextStackObject #aquamarine {
  argparse_args : NoneType
  search_path : tuple
  apply()
  set_value(search_path, argparse_args)
}
class "CookieJar" as http.cookiejar.CookieJar #grey {
  domain_re
  dots_re
  magic_re
  non_word_re
  quote_re
  strict_domain_re
  add_cookie_header(request)
  clear(domain, path, name)
  clear_expired_cookies()
  clear_session_cookies()
  extract_cookies(response, request)
  make_cookies(response, request)
  set_cookie(cookie)
  set_cookie_if_ok(cookie, request)
  set_policy(policy)
}
class "CookiePolicy" as http.cookiejar.CookiePolicy #grey {
  domain_return_ok(domain, request)
  path_return_ok(path, request)
  return_ok(cookie, request)
  set_ok(cookie, request)
}
class "<color:red>CorruptedEnvironmentError</color>" as conda.exceptions.CorruptedEnvironmentError #aliceblue {
}
class "<color:red>CouldntParseError</color>" as conda.exceptions.CouldntParseError #aliceblue {
  reason
}
class "CreateInPrefixPathAction" as conda.core.path_actions.CreateInPrefixPathAction #coral {
  package_info
  source_full_path
  source_prefix
  source_short_path
  cleanup()
  verify()
}
class "CreateNonadminAction" as conda.core.path_actions.CreateNonadminAction #coral {
  create_actions(cls, transaction_context, package_info, target_prefix, requested_link_type)
  execute()
  reverse()
}
class "CreatePrefixRecordAction" as conda.core.path_actions.CreatePrefixRecordAction #coral {
  all_link_path_actions : list
  prefix_record
  requested_link_type
  requested_spec
  create_actions(cls, 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 #coral {
  func
  module
  prefix_path_data
  create_actions(cls, transaction_context, package_info, target_prefix, requested_link_type)
  execute()
  reverse()
}
class "CshActivator" as conda.activate.CshActivator #aliceblue {
  command_join : str
  export_var_tmpl : str
  hook_source_path
  path_conversion
  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 #cadetblue {
}
class "<color:red>CyclicalDependencyError</color>" as conda.exceptions.CyclicalDependencyError #aliceblue {
}
class "DateField" as conda.auxlib.entity.DateField #antiquewhite {
  box(instance, instance_type, val)
  dump(instance, instance_type, val)
}
class "<color:red>DeactivateHelp</color>" as conda.exceptions.DeactivateHelp #aliceblue {
}
class "DefaultCookiePolicy" as http.cookiejar.DefaultCookiePolicy #grey {
  DomainLiberal : int
  DomainRFC2965Match : int
  DomainStrict : int
  DomainStrictNoDots : int
  DomainStrictNonDomain : int
  hide_cookie2 : bool
  netscape : bool
  rfc2109_as_netscape : NoneType
  rfc2965 : bool
  strict_domain : bool
  strict_ns_domain : int
  strict_ns_set_initial_dollar : bool
  strict_ns_set_path : bool
  strict_ns_unverifiable : bool
  strict_rfc2965_unverifiable : bool
  allowed_domains()
  blocked_domains()
  domain_return_ok(domain, request)
  is_blocked(domain)
  is_not_allowed(domain)
  path_return_ok(path, request)
  return_ok(cookie, request)
  return_ok_domain(cookie, request)
  return_ok_expires(cookie, request)
  return_ok_port(cookie, request)
  return_ok_secure(cookie, request)
  return_ok_verifiability(cookie, request)
  return_ok_version(cookie, request)
  set_allowed_domains(allowed_domains)
  set_blocked_domains(blocked_domains)
  set_ok(cookie, request)
  set_ok_domain(cookie, request)
  set_ok_name(cookie, request)
  set_ok_path(cookie, request)
  set_ok_port(cookie, request)
  set_ok_verifiability(cookie, request)
  set_ok_version(cookie, request)
}
class "DefaultValueRawParameter" as conda.common.configuration.DefaultValueRawParameter #cadetblue {
  keyflag()
  value(parameter_obj)
  valueflags(parameter_obj)
}
class "DeltaSecondsFormatter" as conda.common.io.DeltaSecondsFormatter #cadetblue {
  prev_time
  format(record)
}
class "DepsModifier" as conda.base.constants.DepsModifier #aquamarine {
  name
}
class "DictSafeMixin" as conda.auxlib.entity.DictSafeMixin #antiquewhite {
  copy()
  get(item, default)
  items()
  setdefault(key, default_value)
  update(E)
}
class "DirectoryLock" as conda.lock.DirectoryLock #aliceblue {
  directory_path : bytes, str
  lock_file_glob_str
  lock_file_path
  retries : int
}
class "<color:red>DirectoryNotACondaEnvironmentError</color>" as conda.exceptions.DirectoryNotACondaEnvironmentError #aliceblue {
}
class "<color:red>DirectoryNotFoundError</color>" as conda.exceptions.DirectoryNotFoundError #aliceblue {
}
class "DisableOnWriteError" as conda._vendor.tqdm.utils.DisableOnWriteError #chartreuse {
  disable_on_exception(tqdm_instance, func)
}
class "<color:red>DisallowedPackageError</color>" as conda.exceptions.DisallowedPackageError #aliceblue {
}
class "Dist" as conda.models.dist.Dist #dodgerblue {
  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(cls, string, channel_override)
  from_url(cls, 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 "DistType" as conda.models.dist.DistType #dodgerblue {
}
class "<color:red>DryRunExit</color>" as conda.exceptions.DryRunExit #aliceblue {
}
class "DummyArgs" as conda.testing.notices.helpers.DummyArgs #mediumspringgreen {
  no_ansi_colors : bool
}
class "DummyExecutor" as conda.common.io.DummyExecutor #cadetblue {
  map(func)
  shutdown(wait)
  submit(fn)
}
class "DumpEncoder" as conda.auxlib.logz.DumpEncoder #antiquewhite {
  default(obj)
}
class "EMA" as conda._vendor.tqdm.std.EMA #chartreuse {
  alpha : float
  calls : int
  last : int
}
class "ERROR" as conda.common._os.windows.ERROR #chartreuse {
  name
}
class "<color:red>EncodingError</color>" as conda.exceptions.EncodingError #aliceblue {
}
class "EnforceUnusedAdapter" as conda.gateways.connection.session.EnforceUnusedAdapter #cyan {
  close()
  send(request)
}
class "Entity" as conda.auxlib.entity.Entity #antiquewhite {
  dump()
  from_json(cls, json_str)
  from_objects(cls)
  json(indent, separators)
  load(cls, data_dict)
  pretty_json(indent, separators)
  validate()
}
class "EntityEncoder" as conda.auxlib.entity.EntityEncoder #antiquewhite {
  default(obj)
}
class "EntityType" as conda.auxlib.entity.EntityType #antiquewhite {
  fields
}
class "Enum" as enum.Enum #grey {
  name()
  value()
}
class "EnumField" as conda.auxlib.entity.EnumField #antiquewhite {
  box(instance, instance_type, val)
  dump(instance, instance_type, val)
}
class "EnumMeta" as enum.EnumMeta #grey {
}
class "EnvAppDirs" as conda.gateways.anaconda_client.EnvAppDirs #cornflowerblue {
  appauthor
  appname
  root_path
  site_data_dir
  user_cache_dir
  user_data_dir
  user_log_dir
}
class "EnvRawParameter" as conda.common.configuration.EnvRawParameter #cadetblue {
  source : str
  keyflag()
  make_raw_parameters(cls, appname)
  value(parameter_obj)
  valueflags(parameter_obj)
}
class "<color:red>EnvironmentFileEmpty</color>" as conda.exceptions.EnvironmentFileEmpty #aliceblue {
  filename
}
class "<color:red>EnvironmentFileExtensionNotValid</color>" as conda.exceptions.EnvironmentFileExtensionNotValid #aliceblue {
  filename
}
class "<color:red>EnvironmentFileNotDownloaded</color>" as conda.exceptions.EnvironmentFileNotDownloaded #aliceblue {
  packagename
  username
}
class "<color:red>EnvironmentFileNotFound</color>" as conda.exceptions.EnvironmentFileNotFound #aliceblue {
  filename
}
class "<color:red>EnvironmentLocationNotFound</color>" as conda.exceptions.EnvironmentLocationNotFound #aliceblue {
}
class "<color:red>EnvironmentNameNotFound</color>" as conda.exceptions.EnvironmentNameNotFound #aliceblue {
}
class "<color:red>EnvironmentNotWritableError</color>" as conda.exceptions.EnvironmentNotWritableError #aliceblue {
}
class "Evaluator" as conda.common.pkg_formats.python.Evaluator #chocolate {
  operations : dict
  evaluate(expr, context)
}
class "Event" as threading.Event #grey {
  isSet
  clear()
  is_set()
  set()
  wait(timeout)
}
class "ExactLowerStrMatch" as conda.models.match_spec.ExactLowerStrMatch #dodgerblue {
  match(other)
}
class "ExactStrMatch" as conda.models.match_spec.ExactStrMatch #dodgerblue {
  match(other)
}
class "ExceptionHandler" as conda.exceptions.ExceptionHandler #aliceblue {
  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 "Executor" as concurrent.futures._base.Executor #grey {
  map(fn)
  shutdown(wait)
  submit()
}
class "ExperimentalSolverChoice" as conda.base.constants.ExperimentalSolverChoice #aquamarine {
  name
}
class "ExtendConstAction" as conda.cli.conda_argparse.ExtendConstAction #burlywood {
}
class "ExtractPackageAction" as conda.core.path_actions.ExtractPackageAction #coral {
  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 "FTP" as ftplib.FTP #grey {
  af
  debug
  debugging
  debugging : int
  encoding : str
  file : NoneType
  file : NoneType
  host : str
  host : str
  lastresp
  maxline : int
  passiveserver
  passiveserver : int
  port : int
  port : int
  sock : NoneType
  sock : NoneType
  source_address : NoneType
  timeout : object, int
  welcome
  welcome : NoneType
  abort()
  acct(password)
  close()
  connect(host, port, timeout, source_address)
  cwd(dirname)
  delete(filename)
  dir()
  getline()
  getmultiline()
  getresp()
  getwelcome()
  login(user, passwd, acct)
  makepasv()
  makeport()
  mkd(dirname)
  mlsd(path, facts)
  nlst()
  ntransfercmd(cmd, rest)
  putcmd(line)
  putline(line)
  pwd()
  quit()
  rename(fromname, toname)
  retrbinary(cmd, callback, blocksize, rest)
  retrlines(cmd, callback)
  rmd(dirname)
  sanitize(s)
  sendcmd(cmd)
  sendeprt(host, port)
  sendport(host, port)
  set_debuglevel(level)
  set_pasv(val)
  size(filename)
  storbinary(cmd, fp, blocksize, callback, rest)
  storlines(cmd, fp, callback)
  transfercmd(cmd, rest)
  voidcmd(cmd)
  voidresp()
}
class "FTPAdapter" as conda.gateways.connection.adapters.ftp.FTPAdapter #darkgoldenrod {
  conn
  func_table : dict
  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 #dodgerblue {
  exact_value
  match(other)
}
class "Field" as conda.auxlib.entity.Field #antiquewhite {
  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 "FileList" as distutils.filelist.FileList #grey {
  allfiles : NoneType, list
  files : list
  append(item)
  debug_print(msg)
  exclude_pattern(pattern, anchor, prefix, is_regex)
  extend(items)
  findall(dir)
  include_pattern(pattern, anchor, prefix, is_regex)
  process_template_line(line)
  remove_duplicates()
  set_allfiles(allfiles)
  sort()
}
class "FileLock" as conda.lock.FileLock #aliceblue {
  lock_file_glob_str
  lock_file_path
  path_to_lock : bytes, str
  retries : int
}
class "FileMode" as conda.models.enums.FileMode #dodgerblue {
  name
}
class "FilenameField" as conda.models.records.FilenameField #dodgerblue {
}
class "Filter" as logging.Filter #grey {
  name : str
  nlen
  filter(record)
}
class "Filterer" as logging.Filterer #grey {
  filters : list
  addFilter(filter)
  filter(record)
  removeFilter(filter)
}
class "FishActivator" as conda.activate.FishActivator #aliceblue {
  command_join : str
  export_var_tmpl : str
  hook_source_path
  path_conversion
  pathsep_join
  run_script_tmpl : str
  script_extension : str
  sep : str
  set_var_tmpl : str
  tempfile_extension : NoneType
  unset_var_tmpl : str
}
class "Formatter" as logging.Formatter #grey {
  converter
  datefmt : NoneType
  default_msec_format : str
  default_time_format : str
  format(record)
  formatException(ei)
  formatMessage(record)
  formatStack(stack_info)
  formatTime(record, datefmt)
  usesTime()
}
class "GeneralGraph" as conda.models.prefix_graph.GeneralGraph #dodgerblue {
  graph_by_name
  specs_by_name
  breadth_first_search_by_name(root_spec, target_spec)
}
class "<color:red>GenericHelp</color>" as conda.exceptions.GenericHelp #aliceblue {
}
class "GlobLowerStrMatch" as conda.models.match_spec.GlobLowerStrMatch #dodgerblue {
}
class "GlobStrMatch" as conda.models.match_spec.GlobStrMatch #dodgerblue {
  exact_value
  matches_all
  match(other)
}
class "Handler" as logging.Handler #grey {
  formatter : NoneType
  level : int
  lock
  name
  acquire()
  close()
  createLock()
  emit(record)
  flush()
  format(record)
  get_name()
  handle(record)
  handleError(record)
  release()
  setFormatter(fmt)
  setLevel(level)
  set_name(name)
}
class "<color:red>Help</color>" as conda.exceptions.Help #aliceblue {
}
class "HelpFormatter" as argparse.HelpFormatter #grey {
  add_argument(action)
  add_arguments(actions)
  add_text(text)
  add_usage(usage, actions, groups, prefix)
  end_section()
  format_help()
  start_section(heading)
}
class "History" as conda.history.History #aliceblue {
  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()
  print_log()
  update()
  write_changes(last_state, current_state)
  write_specs(remove_specs, update_specs, neutered_specs)
}
class "IOBase" as io.IOBase #grey {
}
class "ImmutableEntity" as conda.auxlib.entity.ImmutableEntity #antiquewhite {
}
class "IndexedSet" as conda._vendor.boltons.setutils.IndexedSet #chocolate {
  dead_indices : list
  item_index_map : dict
  item_list : list
  add(item)
  clear()
  count(val)
  difference()
  difference_update()
  discard(item)
  from_iterable(cls, 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 #antiquewhite {
}
class "IntEnum" as enum.IntEnum #grey {
}
class "IntegerField" as conda.auxlib.entity.IntegerField #antiquewhite {
}
class "<color:red>InvalidElementTypeError</color>" as conda.common.configuration.InvalidElementTypeError #cadetblue {
}
class "<color:red>InvalidMatchSpec</color>" as conda.exceptions.InvalidMatchSpec #aliceblue {
}
class "<color:red>InvalidSpec</color>" as conda.exceptions.InvalidSpec #aliceblue {
}
class "<color:red>InvalidTypeError</color>" as conda.common.configuration.InvalidTypeError #cadetblue {
  valid_types
  wrong_type
}
class "<color:red>InvalidVersionSpec</color>" as conda.exceptions.InvalidVersionSpec #aliceblue {
}
class "Iterable" as _collections_abc.Iterable #grey {
}
class "JSONEncoder" as json.encoder.JSONEncoder #grey {
  allow_nan : bool
  check_circular : bool
  default : NoneType
  ensure_ascii : bool
  indent : NoneType
  item_separator : str
  item_separator : str
  key_separator
  key_separator : str
  skipkeys : bool
  sort_keys : bool
  default(o)
  encode(o)
  iterencode(o, _one_shot)
}
class "JSONFormatMixin" as conda.activate.JSONFormatMixin #aliceblue {
  command_join : list
  pathsep_join : list
  tempfile_extension : NoneType
  get_scripts_export_unset_vars()
}
class "<color:red>KnownPackageClobberError</color>" as conda.exceptions.KnownPackageClobberError #aliceblue {
}
class "LeasedPathEntry" as conda.models.leased_path_entry.LeasedPathEntry #dodgerblue {
  leased_path
  leased_path_type
  package_name
  target_path
  target_prefix
}
class "LeasedPathType" as conda.models.enums.LeasedPathType #dodgerblue {
  name
}
class "Link" as conda.models.records.Link #dodgerblue {
  source
  type
}
class "<color:red>LinkError</color>" as conda.exceptions.LinkError #aliceblue {
}
class "LinkPathAction" as conda.core.path_actions.LinkPathAction #coral {
  link_type
  prefix_path_data : NoneType
  source_path_data
  create_directory_actions(cls, transaction_context, package_info, target_prefix, requested_link_type, file_link_actions)
  create_file_link_actions(cls, transaction_context, package_info, target_prefix, requested_link_type)
  create_python_entry_point_windows_exe_action(cls, transaction_context, package_info, target_prefix, requested_link_type, entry_point_def)
  execute()
  reverse()
  verify()
}
class "LinkType" as conda.models.enums.LinkType #dodgerblue {
  name
}
class "LinkTypeField" as conda.models.records.LinkTypeField #dodgerblue {
  box(instance, instance_type, val)
}
class "ListField" as conda.auxlib.entity.ListField #antiquewhite {
  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 #cadetblue {
  key_flag
  value
  value_flags
  collect_errors(instance, typed_value, source)
  expand()
  merge(matches)
  typify(source)
}
class "LocalFSAdapter" as conda.gateways.connection.adapters.localfs.LocalFSAdapter #darkgoldenrod {
  close()
  send(request, stream, timeout, verify, cert, proxies)
}
class "<color:red>LockError</color>" as conda.exceptions.LockError #aliceblue {
}
class "MakeMenuAction" as conda.core.path_actions.MakeMenuAction #coral {
  create_actions(cls, transaction_context, package_info, target_prefix, requested_link_type)
  execute()
  reverse()
}
class "MapField" as conda.auxlib.entity.MapField #antiquewhite {
  box(instance, instance_type, val)
}
class "MapLoadedParameter" as conda.common.configuration.MapLoadedParameter #cadetblue {
  collect_errors(instance, typed_value, source)
  merge(matches)
}
class "MapParameter" as conda.common.configuration.MapParameter #cadetblue {
  get_all_matches(name, names, instance)
  load(name, match)
}
class "Mapping" as _collections_abc.Mapping #grey {
  get(key, default)
  items()
  keys()
  values()
}
class "MatchInterface" as conda.models.match_spec.MatchInterface #dodgerblue {
  exact_value
  raw_value
  match(other)
  matches(value)
  merge(other)
  union(other)
}
class "MatchSpec" as conda.models.match_spec.MatchSpec #dodgerblue {
  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(cls, dist_str)
  get(field_name, default)
  get_exact_value(field_name)
  get_raw_value(field_name)
  match(rec)
  merge(cls, match_specs, union)
  union(cls, match_specs)
}
class "MatchSpecType" as conda.models.match_spec.MatchSpecType #dodgerblue {
}
class "Md5Field" as conda.models.records.Md5Field #dodgerblue {
}
class "<color:red>MetadataWarning</color>" as conda.common.pkg_formats.python.MetadataWarning #chocolate {
}
class "Minio" as conda.testing.gateways.fixtures.minio_s3_server.Minio #coral {
  name : str
  port : int
  server_url
  populate_bucket(endpoint, bucket_name, channel_dir)
}
class "MockResponse" as conda.testing.notices.helpers.MockResponse #mediumspringgreen {
  json_data
  raise_exc : bool
  status_code
  json()
}
class "MultiChannel" as conda.models.channel.MultiChannel #dodgerblue {
  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 #coral {
  target_full_paths
  verified
  cleanup()
  execute()
  reverse()
  verify()
}
class "<color:red>MultiValidationError</color>" as conda.common.configuration.MultiValidationError #cadetblue {
}
class "<color:red>MultipleKeysError</color>" as conda.common.configuration.MultipleKeysError #cadetblue {
  keys
  source
}
class "MutableListField" as conda.auxlib.entity.MutableListField #antiquewhite {
}
class "MutableMapping" as _collections_abc.MutableMapping #grey {
  clear()
  pop(key, default)
  popitem()
  setdefault(key, default)
  update()
}
class "MutableSet" as _collections_abc.MutableSet #grey {
  add(value)
  clear()
  discard(value)
  pop()
  remove(value)
}
class "NamedTuple" as typing.NamedTuple #grey {
}
class "<color:red>NoBaseEnvironmentError</color>" as conda.exceptions.NoBaseEnvironmentError #aliceblue {
}
class "<color:red>NoSpaceLeftError</color>" as conda.exceptions.NoSpaceLeftError #aliceblue {
}
class "<color:red>NoWritableEnvsDirError</color>" as conda.exceptions.NoWritableEnvsDirError #aliceblue {
}
class "<color:red>NoWritablePkgsDirError</color>" as conda.exceptions.NoWritablePkgsDirError #aliceblue {
}
class "Noarch" as conda.models.package_info.Noarch #dodgerblue {
  entry_points
  type
}
class "NoarchField" as conda.models.package_info.NoarchField #dodgerblue {
  box(instance, instance_type, val)
}
class "NoarchField" as conda.models.records.NoarchField #dodgerblue {
  box(instance, instance_type, val)
}
class "NoarchType" as conda.models.enums.NoarchType #dodgerblue {
  name
  coerce(val)
}
class "<color:red>NotFoundError</color>" as conda.auxlib.exceptions.NotFoundError #antiquewhite {
}
class "<color:red>NotWritableError</color>" as conda.exceptions.NotWritableError #aliceblue {
  errno
}
class "NoticeLevel" as conda.base.constants.NoticeLevel #aquamarine {
  name
}
class "NullCountAction" as conda.cli.conda_argparse.NullCountAction #burlywood {
}
class "NullHandler" as conda.auxlib.NullHandler #aliceblue {
  emit(record)
}
class "NumberField" as conda.auxlib.entity.NumberField #antiquewhite {
}
class "ObjectLoadedParameter" as conda.common.configuration.ObjectLoadedParameter #cadetblue {
  collect_errors(instance, typed_value, source)
  merge(matches)
}
class "ObjectParameter" as conda.common.configuration.ObjectParameter #cadetblue {
  get_all_matches(name, names, instance)
  load(name, match)
}
class "ObjectWrapper" as conda._vendor.tqdm.utils.ObjectWrapper #chartreuse {
  wrapper_getattr(name)
  wrapper_setattr(name, value)
}
class "<color:red>OperationNotAllowed</color>" as conda.exceptions.OperationNotAllowed #aliceblue {
}
class "OrderedDict" as collections.OrderedDict #grey {
  move_to_end(key, last)
}
class "PackageCacheData" as conda.core.package_cache_data.PackageCacheData #coral {
  is_writable
  pkgs_dir
  all_caches_writable_first(cls, pkgs_dirs)
  clear(cls)
  first_writable(cls, pkgs_dirs)
  get(package_ref, default)
  get_all_extracted_entries(cls)
  get_entry_to_link(cls, package_ref)
  insert(package_cache_record)
  iter_records()
  itervalues()
  load()
  query(package_ref_or_match_spec)
  query_all(cls, package_ref_or_match_spec, pkgs_dirs)
  read_only_caches(cls, pkgs_dirs)
  reload()
  remove(package_ref, default)
  tarball_file_in_cache(cls, tarball_path, md5sum, exclude_caches)
  tarball_file_in_this_cache(tarball_path, md5sum)
  values()
  writable_caches(cls, pkgs_dirs)
}
class "PackageCacheRecord" as conda.models.records.PackageCacheRecord #dodgerblue {
  extracted_package_dir
  is_extracted
  is_fetched
  md5
  package_tarball_full_path
  tarball_basename
}
class "PackageCacheType" as conda.core.package_cache_data.PackageCacheType #coral {
}
class "PackageInfo" as conda.models.package_info.PackageInfo #dodgerblue {
  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 #dodgerblue {
  noarch
  package_metadata_version
  preferred_env
}
class "<color:red>PackageNotInstalledError</color>" as conda.exceptions.PackageNotInstalledError #aliceblue {
}
class "PackageRecord" as conda.models.records.PackageRecord #dodgerblue {
  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_signature_status
  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 "PackageType" as conda.models.enums.PackageType #dodgerblue {
  name
  conda_package_types()
  unmanageable_package_types()
}
class "PackageTypeField" as conda.models.records.PackageTypeField #dodgerblue {
}
class "<color:red>PackagesNotFoundError</color>" as conda.exceptions.PackagesNotFoundError #aliceblue {
}
class "<color:red>PaddingError</color>" as conda.exceptions.PaddingError #aliceblue {
}
class "Parameter" as conda.common.configuration.Parameter #cadetblue {
  default
  get_all_matches(name, names, instance)
  load(name, match)
  typify(name, source, value)
}
class "ParameterFlag" as conda.common.configuration.ParameterFlag #cadetblue {
  name
  from_name(cls, name)
  from_string(cls, string)
  from_value(cls, value)
}
class "ParameterLoader" as conda.common.configuration.ParameterLoader #cadetblue {
  aliases : tuple
  name
  names
  type
  raw_parameters_from_single_source(name, names, raw_parameters)
}
class "<color:red>ParseError</color>" as conda.exceptions.ParseError #aliceblue {
}
class "Path" as pathlib.Path #grey {
  absolute()
  chmod(mode)
  cwd(cls)
  exists()
  expanduser()
  glob(pattern)
  group()
  home(cls)
  is_block_device()
  is_char_device()
  is_dir()
  is_fifo()
  is_file()
  is_mount()
  is_socket()
  is_symlink()
  iterdir()
  lchmod(mode)
  lstat()
  mkdir(mode, parents, exist_ok)
  open(mode, buffering, encoding, errors, newline)
  owner()
  read_bytes()
  read_text(encoding, errors)
  rename(target)
  replace(target)
  resolve(strict)
  rglob(pattern)
  rmdir()
  samefile(other_path)
  stat()
  symlink_to(target, target_is_directory)
  touch(mode, exist_ok)
  unlink()
  write_bytes(data)
  write_text(data, encoding, errors)
}
class "PathAction" as conda.core.path_actions.PathAction #coral {
  target_full_path
  verified
  cleanup()
  execute()
  reverse()
  verify()
}
class "PathConflict" as conda.base.constants.PathConflict #aquamarine {
  name
}
class "PathData" as conda.models.records.PathData #dodgerblue {
  file_mode
  no_link
  path
  path_type
  prefix_placeholder
}
class "PathDataV1" as conda.models.records.PathDataV1 #dodgerblue {
  inode_paths
  sha256
  sha256_in_prefix
  size_in_bytes
}
class "<color:red>PathNotFoundError</color>" as conda.exceptions.PathNotFoundError #aliceblue {
}
class "PathType" as conda.models.enums.PathType #dodgerblue {
  name
  basic_types()
}
class "PathsData" as conda.models.records.PathsData #dodgerblue {
  paths
  paths_version
}
class "PercentStyle" as logging.PercentStyle #grey {
  asctime_format : str
  asctime_search : str
  default_format : str
  format(record)
  usesTime()
}
class "Platform" as conda.models.enums.Platform #dodgerblue {
  name
  from_sys(cls)
}
class "PosixActivator" as conda.activate.PosixActivator #aliceblue {
  command_join : str
  export_var_tmpl : str
  hook_source_path
  path_conversion
  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 #aliceblue {
  command_join : str
  export_var_tmpl : str
  hook_source_path
  path_conversion
  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 #dodgerblue {
  executable_paths
  name
  softlink_paths
}
class "PrefixData" as conda.core.prefix_data.PrefixData #coral {
  is_writable
  prefix_path
  all_subdir_urls()
  get(package_name, default)
  get_environment_env_vars()
  insert(prefix_record)
  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 #coral {
}
class "PrefixGraph" as conda.models.prefix_graph.PrefixGraph #dodgerblue {
  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 #coral {
  target_full_path
  target_prefix
  target_short_path
  target_short_paths
  transaction_context
}
class "PrefixRecord" as conda.models.records.PrefixRecord #dodgerblue {
  auth
  extracted_package_dir
  files
  link
  package_tarball_full_path
  paths_data
  requested_spec
}
class "PrefixReplaceLinkAction" as conda.core.path_actions.PrefixReplaceLinkAction #coral {
  file_mode
  intermediate_path : NoneType
  prefix_path_data
  prefix_placeholder
  execute()
  verify()
}
class "PrimitiveLoadedParameter" as conda.common.configuration.PrimitiveLoadedParameter #cadetblue {
  merge(matches)
}
class "PrimitiveParameter" as conda.common.configuration.PrimitiveParameter #cadetblue {
  load(name, match)
}
class "ProgressBar" as conda.common.io.ProgressBar #cadetblue {
  description
  enabled : bool
  json : bool
  pbar
  close()
  finish()
  update_to(fraction)
}
class "ProgressFileWrapper" as conda.gateways.disk.create.ProgressFileWrapper #darkseagreen {
  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 #coral {
  cache_actions
  extract_actions
  link_precs
  paired_actions
  execute()
  make_actions_for_record(pref_or_spec)
  prepare()
}
class "<color:red>ProxyError</color>" as conda.exceptions.ProxyError #aliceblue {
}
class "PurePath" as pathlib.PurePath #grey {
  anchor
  drive : property
  name
  parent
  parents
  parts
  root : property
  stem
  suffix
  suffixes
  as_posix()
  as_uri()
  is_absolute()
  is_reserved()
  joinpath()
  match(path_pattern)
  relative_to()
  with_name(name)
  with_suffix(suffix)
}
class "PythonDistribution" as conda.common.pkg_formats.python.PythonDistribution #chocolate {
  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()
  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 #chocolate {
  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 #chocolate {
  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 #chocolate {
  is_manageable : bool
}
class "PythonInstalledDistribution" as conda.common.pkg_formats.python.PythonInstalledDistribution #chocolate {
  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 #darkseagreen {
  get_print_name()
  get_substitute_name()
}
class "RLock" as _thread.RLock #grey {
  acquire()
  release()
}
class "RawIOBase" as io.RawIOBase #grey {
}
class "RawParameter" as conda.common.configuration.RawParameter #cadetblue {
  key
  source
  keyflag()
  make_raw_parameters(cls, source, from_map)
  value(parameter_obj)
  valueflags(parameter_obj)
}
class "RegisterEnvironmentLocationAction" as conda.core.path_actions.RegisterEnvironmentLocationAction #coral {
  target_full_path
  target_prefix
  transaction_context
  cleanup()
  execute()
  reverse()
  verify()
}
class "<color:red>RemoveError</color>" as conda.exceptions.RemoveError #aliceblue {
}
class "RemoveFromPrefixPathAction" as conda.core.path_actions.RemoveFromPrefixPathAction #coral {
  linked_package_data
  verify()
}
class "RemoveLinkedPackageRecordAction" as conda.core.path_actions.RemoveLinkedPackageRecordAction #coral {
  execute()
  reverse()
}
class "RemoveMenuAction" as conda.core.path_actions.RemoveMenuAction #coral {
  cleanup()
  create_actions(cls, transaction_context, linked_package_data, target_prefix)
  execute()
  reverse()
}
class "RequestsCookieJar" as requests.cookies.RequestsCookieJar #aquamarine {
  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 "RequestsCookieJar" as pip._vendor.requests.cookies.RequestsCookieJar #burlywood {
  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 "Resolve" as conda.resolve.Resolve #aliceblue {
  channels : tuple
  groups
  index
  ms_depends_ : dict
  trackers
  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)
  environment_is_consistent(installed)
  find_conflicts(specs, specs_to_add, history_specs)
  find_matches(spec)
  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)
  push_MatchSpec(C, spec)
  remove(specs, installed)
  remove_specs(specs, installed)
  restore_bad(pkgs, preserve)
  solve(specs, returnall, _remove, specs_to_add, history_specs, should_retry_solve)
  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 #aliceblue {
  bad_deps : tuple
}
class "<color:red>Response304ContentUnchanged</color>" as conda.core.subdir_data.Response304ContentUnchanged #coral {
}
class "Result" as conda.core.initialize.Result #coral {
  MODIFIED : str
  NEEDS_SUDO : str
  NO_CHANGE : str
}
class "S3Adapter" as conda.gateways.connection.adapters.s3.S3Adapter #darkgoldenrod {
  close()
  send(request, stream, timeout, verify, cert, proxies)
}
class "SDistCommand" as conda.auxlib.packaging.SDistCommand #antiquewhite {
  make_release_tree(base_dir, files)
}
class "SECURITY_ATTRIBUTES" as conda.gateways.disk.link.SECURITY_ATTRIBUTES #darkseagreen {
}
class "STRING" as conda.common.io.CaptureTarget.STRING #cadetblue {
  name
  value
}
class "SW" as conda.common._os.windows.SW #chartreuse {
  name
}
class "SafetyChecks" as conda.base.constants.SafetyChecks #aquamarine {
  name
}
class "<color:red>SafetyError</color>" as conda.exceptions.SafetyError #aliceblue {
}
class "SatSolverChoice" as conda.base.constants.SatSolverChoice #aquamarine {
  name
}
class "Semaphore" as threading.Semaphore #grey {
  acquire(blocking, timeout)
  release()
}
class "<color:red>SenderError</color>" as conda.auxlib.exceptions.SenderError #antiquewhite {
}
class "SequenceLoadedParameter" as conda.common.configuration.SequenceLoadedParameter #cadetblue {
  collect_errors(instance, typed_value, source)
  merge(matches)
}
class "SequenceParameter" as conda.common.configuration.SequenceParameter #cadetblue {
  string_delimiter : str
  get_all_matches(name, names, instance)
  load(name, match)
}
class "Session" as requests.sessions.Session #aquamarine {
  adapters
  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 "Session" as pip._vendor.requests.sessions.Session #burlywood {
  adapters
  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 #aquamarine {
  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 "SessionRedirectMixin" as pip._vendor.requests.sessions.SessionRedirectMixin #burlywood {
  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 "Set" as _collections_abc.Set #grey {
  isdisjoint(other)
}
class "<color:red>SharedLinkPathClobberError</color>" as conda.exceptions.SharedLinkPathClobberError #aliceblue {
}
class "ShellExecuteInfo" as conda.common._os.windows.ShellExecuteInfo #chartreuse {
  cbSize
}
class "SimpleEnvironment" as conda.testing.solver_helpers.SimpleEnvironment #gold {
  REPO_DATA_KEYS : tuple
  installed_packages : list
  repo_packages
  subdirs : tuple
  install()
  remove()
  solver(add, remove)
  solver_transaction(add, remove, as_specs)
}
class "SimpleQueue" as _queue.SimpleQueue #grey {
  empty()
  get()
  get_nowait()
  put()
  put_nowait()
  qsize()
}
class "SingleStrArgCachingType" as conda.models.version.SingleStrArgCachingType #dodgerblue {
}
class "Sized" as _collections_abc.Sized #grey {
}
class "SocketIO" as socket.SocketIO #grey {
  mode
  name
  close()
  fileno()
  readable()
  readinto(b)
  seekable()
  writable()
  write(b)
}
class "Solver" as conda.core.solve.Solver #coral {
  channels
  neutered_specs : tuple
  prefix
  specs_to_add : frozenset, tuple, set
  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)
  solve_for_transaction(update_modifier, deps_modifier, prune, ignore_pinned, force_remove, force_reinstall, should_retry_solve)
}
class "SolverStateContainer" as conda.core.solve.SolverStateContainer #coral {
  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 : tuple
  specs_map
  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 #gold {
  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 #aliceblue {
}
class "<color:red>SpecsConfigurationConflictError</color>" as conda.exceptions.SpecsConfigurationConflictError #aliceblue {
}
class "Spinner" as conda.common.io.Spinner #cadetblue {
  enabled : bool
  fail_message : str
  fh
  json : bool
  message
  show_spin : bool
  spinner_cycle
  start()
  stop()
}
class "SplitStrMatch" as conda.models.match_spec.SplitStrMatch #dodgerblue {
  exact_value
  match(other)
}
class "Starter" as conda.testing.gateways.fixtures.minio_s3_server.Starter #coral {
  args : list
  pattern : str
  terminate_on_interrupt : bool
  timeout : int
  startup_check(port)
}
class "StdStreamHandler" as conda.gateways.logging.StdStreamHandler #cornflowerblue {
  sys_stream
  terminator : str
  terminator : str
  emit(record)
}
class "StreamHandler" as logging.StreamHandler #grey {
  name : str
  stream : NoneType
  terminator : str
  emit(record)
  flush()
  setStream(stream)
}
class "StreamRecoder" as codecs.StreamRecoder #grey {
  data_encoding
  data_encoding : str
  decode
  encode
  errors : str
  file_encoding : NoneType
  file_encoding : str
  reader
  stream
  writer
  read(size)
  readline(size)
  readlines(sizehint)
  reset()
  seek(offset, whence)
  write(data)
  writelines(list)
}
class "StringField" as conda.auxlib.entity.StringField #antiquewhite {
  box(instance, instance_type, val)
}
class "StringIO" as _io.StringIO #grey {
  old_write
  release_conn
  write
  close()
  detach()
  fileno()
  flush()
  getvalue()
  isatty()
  read()
  readable()
  readline()
  readlines()
  seek()
  seekable()
  tell()
  truncate()
  writable()
  write()
  writelines()
}
class "Structure" as _ctypes.Structure #grey {
}
class "SubdirData" as conda.core.subdir_data.SubdirData #coral {
  cache_path_base
  cache_path_json
  cache_path_pickle
  channel
  repodata_fn : str
  url_w_credentials : NoneType
  url_w_repodata_fn
  url_w_subdir : NoneType
  clear_cached_local_channel_data(cls)
  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 #coral {
}
class "SubdirField" as conda.models.records.SubdirField #dodgerblue {
}
class "SwallowBrokenPipe" as conda.common.io.SwallowBrokenPipe #cadetblue {
}
class "TemporaryDirectory" as conda.gateways.disk.create.TemporaryDirectory #darkseagreen {
  name
  name : NoneType
  cleanup(_warn, _warnings)
}
class "TestCase" as unittest.case.TestCase #grey {
  assertAlmostEquals
  assertEquals
  assertNotAlmostEquals
  assertNotEquals
  assertNotRegexpMatches
  assertRaisesRegexp
  assertRegexpMatches
  assert_
  failIf
  failIfAlmostEqual
  failIfEqual
  failUnless
  failUnlessAlmostEqual
  failUnlessEqual
  failUnlessRaises
  failureException : AssertionError
  longMessage : bool
  maxDiff : int
  addCleanup()
  addTypeEqualityFunc(typeobj, function)
  assertAlmostEqual(first, second, places, msg, delta)
  assertCountEqual(first, second, msg)
  assertDictContainsSubset(subset, dictionary, msg)
  assertDictEqual(d1, d2, msg)
  assertEqual(first, second, msg)
  assertFalse(expr, msg)
  assertGreater(a, b, msg)
  assertGreaterEqual(a, b, msg)
  assertIn(member, container, msg)
  assertIs(expr1, expr2, msg)
  assertIsInstance(obj, cls, msg)
  assertIsNone(obj, msg)
  assertIsNot(expr1, expr2, msg)
  assertIsNotNone(obj, msg)
  assertLess(a, b, msg)
  assertLessEqual(a, b, msg)
  assertListEqual(list1, list2, msg)
  assertLogs(logger, level)
  assertMultiLineEqual(first, second, msg)
  assertNotAlmostEqual(first, second, places, msg, delta)
  assertNotEqual(first, second, msg)
  assertNotIn(member, container, msg)
  assertNotIsInstance(obj, cls, msg)
  assertNotRegex(text, unexpected_regex, msg)
  assertRaises(expected_exception)
  assertRaisesRegex(expected_exception, expected_regex)
  assertRegex(text, expected_regex, msg)
  assertSequenceEqual(seq1, seq2, msg, seq_type)
  assertSetEqual(set1, set2, msg)
  assertTrue(expr, msg)
  assertTupleEqual(tuple1, tuple2, msg)
  assertWarns(expected_warning)
  assertWarnsRegex(expected_warning, expected_regex)
  countTestCases()
  debug()
  defaultTestResult()
  doCleanups()
  fail(msg)
  id()
  run(result)
  setUp()
  setUpClass(cls)
  shortDescription()
  skipTest(reason)
  subTest(msg)
  tearDown()
  tearDownClass(cls)
}
class "TextIOWrapper" as _io.TextIOWrapper #grey {
  close()
  detach()
  fileno()
  flush()
  isatty()
  read()
  readable()
  readline()
  readlines()
  reconfigure()
  seek()
  seekable()
  tell()
  truncate()
  writable()
  write()
  writelines()
}
class "<color:red>ThisShouldNeverHappenError</color>" as conda.auxlib.exceptions.ThisShouldNeverHappenError #antiquewhite {
}
class "Thread" as threading.Thread #grey {
  daemon
  daemon : bool
  ident
  name
  name
  getName()
  isAlive()
  isDaemon()
  is_alive()
  join(timeout)
  run()
  setDaemon(daemonic)
  setName(name)
  start()
}
class "ThreadLimitedThreadPoolExecutor" as conda.common.io.ThreadLimitedThreadPoolExecutor #cadetblue {
  submit(fn)
}
class "ThreadPoolExecutor" as concurrent.futures.thread.ThreadPoolExecutor #grey {
  shutdown(wait)
  submit()
}
class "<color:red>TimeoutException</color>" as conda.common.io.timeout.TimeoutException #cadetblue {
}
class "TimestampField" as conda.models.records.TimestampField #dodgerblue {
  box(instance, instance_type, val)
  dump(instance, instance_type, val)
}
class "TmpDownload" as conda.gateways.connection.download.TmpDownload #cyan {
  tmp_dir : NoneType
  url
  verbose : bool
}
class "TokenURLFilter" as conda.gateways.logging.TokenURLFilter #cornflowerblue {
  TOKEN_REPLACE
  TOKEN_URL_PATTERN
  filter(record)
}
class "<color:red>TooManyArgumentsError</color>" as conda.exceptions.TooManyArgumentsError #aliceblue {
  expected
  offending_arguments
  optional_message : str
  received
}
class "<color:red>TypeCoercionError</color>" as conda.auxlib.type_coercion.TypeCoercionError #antiquewhite {
  value
}
class "<color:red>UnavailableInvalidChannel</color>" as conda.exceptions.UnavailableInvalidChannel #aliceblue {
}
class "<color:red>UnknownPackageClobberError</color>" as conda.exceptions.UnknownPackageClobberError #aliceblue {
}
class "UnlinkLinkTransaction" as conda.core.link.UnlinkLinkTransaction #coral {
  execute_executor
  nothing_to_do
  prefix_action_groups
  prefix_setups
  transaction_context : dict
  verify_executor
  download_and_extract()
  execute()
  prepare()
  print_transaction_summary()
  verify()
}
class "UnlinkPathAction" as conda.core.path_actions.UnlinkPathAction #coral {
  holding_full_path
  holding_short_path
  link_type
  cleanup()
  execute()
  reverse()
}
class "UnregisterEnvironmentLocationAction" as conda.core.path_actions.UnregisterEnvironmentLocationAction #coral {
  target_full_path
  target_prefix
  transaction_context
  cleanup()
  execute()
  reverse()
  verify()
}
class "<color:red>UnsatisfiableError</color>" as conda.exceptions.UnsatisfiableError #aliceblue {
  unsatisfiable : list
}
class "UpdateHistoryAction" as conda.core.path_actions.UpdateHistoryAction #coral {
  hold_path
  neutered_specs
  remove_specs
  update_specs
  cleanup()
  create_actions(cls, transaction_context, target_prefix, remove_specs, update_specs, neutered_specs)
  execute()
  reverse()
}
class "UpdateModifier" as conda.base.constants.UpdateModifier #aquamarine {
  name
}
class "Url" as conda.common.url.Url #cadetblue {
  auth
  netloc
  as_dict() -> dict
  from_parse_result(cls: ParseResult, parse_result) -> 
  replace() -> 
}
class "Url" as conda.common.url.Url.Url #cornflowerblue {
  fragment
  hostname
  password
  path
  port
  query
  scheme
  username
}
class "UrlsData" as conda.core.package_cache_data.UrlsData #coral {
  pkgs_dir
  urls_txt_path
  add_url(url)
  get_url(package_path)
}
class "<color:red>ValidationError</color>" as conda.auxlib.exceptions.ValidationError #antiquewhite {
}
class "<color:red>ValidationError</color>" as conda.common.configuration.ValidationError #cadetblue {
  parameter_name
  parameter_value
  source
}
class "ValueEnum" as conda.base.constants.ValueEnum #aquamarine {
  name
}
class "VersionOrder" as conda.models.version.VersionOrder #dodgerblue {
  fillvalue : int
  local : list
  norm_version
  version
  startswith(other)
}
class "VersionSpec" as conda.models.version.VersionSpec #dodgerblue {
  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 #darkseagreen {
  file_size
}
class "WeakSet" as _weakrefset.WeakSet #grey {
  data : set
  add(item)
  clear()
  copy()
  difference(other)
  difference_update(other)
  discard(item)
  intersection(other)
  intersection_update(other)
  isdisjoint(other)
  issubset(other)
  issuperset(other)
  pop()
  remove(item)
  symmetric_difference(other)
  symmetric_difference_update(other)
  union(other)
  update(other)
}
class "WindowsError" as conda.gateways.disk.link.WindowsError #darkseagreen {
  code
  message
}
class "XonshActivator" as conda.activate.XonshActivator #aliceblue {
  command_join : str
  export_var_tmpl : str
  hook_source_path
  pathsep_join
  run_script_tmpl : str
  script_extension : str
  sep : str
  set_var_tmpl : str
  tempfile_extension : NoneType
  unset_var_tmpl : str
  path_conversion(paths)
}
class "YamlRawParameter" as conda.common.configuration.YamlRawParameter #cadetblue {
  keyflag()
  make_raw_parameters(cls, source, from_map)
  make_raw_parameters_from_file(cls, filepath)
  value(parameter_obj)
  valueflags(parameter_obj)
}
class "_Accessor" as pathlib._Accessor #grey {
}
class "_ActionsContainer" as argparse._ActionsContainer #grey {
  argument_default
  conflict_handler
  description
  prefix_chars
  add_argument()
  add_argument_group()
  add_mutually_exclusive_group()
  get_default(dest)
  register(registry_name, value, object)
  set_defaults()
}
class "_Activator" as conda.activate._Activator #aliceblue {
  command
  command_join : NoneType
  env_name_or_prefix
  environ : dict
  export_var_tmpl : NoneType
  hook_source_path : NoneType
  path_conversion : NoneType
  pathsep_join : NoneType
  run_script_tmpl : NoneType
  script_extension : NoneType
  sep : NoneType
  set_var_tmpl : NoneType
  stack : bool
  tempfile_extension : NoneType
  unset_var_tmpl : NoneType
  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()
  hook(auto_activate_base)
  reactivate()
}
class "_ArgumentGroup" as argparse._ArgumentGroup #grey {
  title : NoneType
}
class "_AttributeHolder" as argparse._AttributeHolder #grey {
}
class "_BufferedIOBase" as _io._BufferedIOBase #grey {
  close()
  detach()
  fileno()
  flush()
  isatty()
  read()
  read1()
  readable()
  readinto()
  readinto1()
  readline()
  readlines()
  seek()
  seekable()
  tell()
  truncate()
  writable()
  write()
  writelines()
}
class "_ClauseArray" as conda.common._logic._ClauseArray #cadetblue {
  append(clause)
  as_array()
  as_list()
  extend(clauses)
  get_clause_count()
  restore_state(saved_state)
  save_state()
}
class "_ClauseList" as conda.common._logic._ClauseList #cadetblue {
  append
  extend
  as_array()
  as_list()
  get_clause_count()
  restore_state(saved_state)
  save_state()
}
class "_CountAction" as argparse._CountAction #grey {
}
class "_FeaturesField" as conda.models.records._FeaturesField #dodgerblue {
  box(instance, instance_type, val)
  dump(instance, instance_type, val)
}
class "_IOBase" as _io._IOBase #grey {
  close()
  fileno()
  flush()
  isatty()
  readable()
  readline()
  readlines()
  seek()
  seekable()
  tell()
  truncate()
  writable()
  writelines()
}
class "_NormalAccessor" as pathlib._NormalAccessor #grey {
  chmod
  lchmod
  listdir
  lstat
  mkdir
  open
  rename
  replace
  rmdir
  scandir
  stat
  symlink
  unlink
  utime
  readlink(path)
}
class "_Null" as conda.auxlib._Null #aliceblue {
  to_json
}
class "_Outcome" as unittest.case._Outcome #grey {
  errors : list
  expectedFailure : NoneType
  expecting_failure : bool
  result : NoneType
  result_supports_subtests : bool
  skipped : list
  success : bool
  testPartExecutor(test_case, isTest)
}
class "<color:red>_PaddingError</color>" as conda.core.portability._PaddingError #coral {
}
class "_PyCryptoSatSolver" as conda.common._logic._PyCryptoSatSolver #cadetblue {
  invoke(solver)
  process_solution(solution)
  setup(m, threads)
}
class "_PySatSolver" as conda.common._logic._PySatSolver #cadetblue {
  invoke(solver)
  process_solution(sat_solution)
  setup(m)
}
class "_PySimpleQueue" as queue._PySimpleQueue #grey {
  empty()
  get(block, timeout)
  get_nowait()
  put(item, block, timeout)
  put_nowait(item)
  qsize()
}
class "_PycoSatSolver" as conda.common._logic._PycoSatSolver #cadetblue {
  invoke(iter_sol)
  process_solution(sat_solution)
  setup(m, limit)
}
class "_RLock" as threading._RLock #grey {
  acquire(blocking, timeout)
  release()
}
class "_RawIOBase" as _io._RawIOBase #grey {
  close()
  fileno()
  flush()
  isatty()
  read()
  readable()
  readall()
  readinto()
  readline()
  readlines()
  seek()
  seekable()
  tell()
  truncate()
  writable()
  write()
  writelines()
}
class "_Regex" as conda.auxlib.type_coercion._Regex #antiquewhite {
  boolean
  none
  numbers
  BIN()
  BOOLEAN_FALSE()
  BOOLEAN_TRUE()
  COMPLEX()
  FLOAT()
  HEX()
  INT()
  NONE()
  OCT()
  convert(value_string)
  convert_number(value_string)
}
class "_SatSolver" as conda.common._logic._SatSolver #cadetblue {
  add_clause
  add_clauses
  as_list()
  get_clause_count()
  invoke(solver)
  process_solution(sat_solution)
  restore_state(saved_state)
  run(m)
  save_state()
  setup(m)
}
class "_Section" as argparse.HelpFormatter._Section #grey {
  formatter
  heading : NoneType
  items : list
  parent
  format_help()
}
class "_SignatureVerification" as conda.trust.signature_verification._SignatureVerification #aliceblue {
  enabled
  key_mgr
  session
  trusted_root
}
class "_StrMatchMixin" as conda.models.match_spec._StrMatchMixin #dodgerblue {
  exact_value
}
class "_SubTest" as unittest.case._SubTest #grey {
  failureException
  params
  test_case
  id()
  runTest()
  shortDescription()
}
class "_TextIOBase" as _io._TextIOBase #grey {
  close()
  detach()
  fileno()
  flush()
  isatty()
  read()
  readable()
  readline()
  readlines()
  seek()
  seekable()
  tell()
  truncate()
  writable()
  write()
  writelines()
}
class "array" as array.array #grey {
  append()
  buffer_info()
  byteswap()
  count()
  extend()
  frombytes()
  fromfile()
  fromlist()
  fromstring()
  fromunicode()
  index()
  insert()
  pop()
  remove()
  reverse()
  tobytes()
  tofile()
  tolist()
  tostring()
  tounicode()
}
class "build_py" as distutils.command.build_py.build_py #grey {
  boolean_options : list
  build_lib : NoneType
  compile : int
  data_files : list
  description : str
  force : NoneType
  negative_opt : dict
  optimize : int
  package : NoneType
  package_data : NoneType
  package_dir : NoneType, dict
  packages
  py_modules : NoneType
  user_options : list
  build_module(module, module_file, package)
  build_modules()
  build_package_data()
  build_packages()
  byte_compile(files)
  check_module(module, module_file)
  check_package(package, package_dir)
  finalize_options()
  find_all_modules()
  find_data_files(package, src_dir)
  find_modules()
  find_package_modules(package, package_dir)
  get_data_files()
  get_module_outfile(build_dir, package, module)
  get_outputs(include_bytecode)
  get_package_dir(package)
  get_source_files()
  initialize_options()
  run()
}
class "classproperty" as conda.auxlib.decorators.classproperty #antiquewhite {
  setter(setter)
}
class "cycle" as itertools.cycle #grey {
}
class "date" as datetime.date #grey {
  day
  month
  year
  ctime()
  fromisoformat(cls, date_string)
  fromordinal(cls, n)
  fromtimestamp(cls, t)
  isocalendar()
  isoformat()
  isoweekday()
  replace(year, month, day)
  strftime(fmt)
  timetuple()
  today(cls)
  toordinal()
  weekday()
}
class "datetime" as datetime.datetime #grey {
  fold
  hour
  microsecond
  minute
  second
  tzinfo
  astimezone(tz)
  combine(cls, date, time, tzinfo)
  ctime()
  date()
  dst()
  fromisoformat(cls, date_string)
  fromtimestamp(cls, t, tz)
  isoformat(sep, timespec)
  now(cls, tz)
  replace(year, month, day, hour, minute, second, microsecond, tzinfo)
  strptime(cls, date_string, format)
  time()
  timestamp()
  timetuple()
  timetz()
  tzname()
  utcfromtimestamp(cls, t)
  utcnow(cls)
  utcoffset()
  utctimetuple()
}
class "defaultdict" as collections.defaultdict #grey {
  default_factory : NoneType
}
class "deque" as collections.deque #grey {
  iterable : list
  maxlen : int
  append(x)
  appendleft(x)
  clear()
  copy()
  count(x)
  extend(iterable)
  extendleft(iterable)
  index(x, start, end)
  insert(x, i)
  pop()
  popleft()
  remove(value)
  reverse()
  rotate(n)
}
class "family" as _socket.socket.family #grey {
}
class "frozendict" as conda._vendor.frozendict.frozendict #cyan {
  dict_cls : dict
  copy()
  to_json()
}
class "hardlink" as conda.models.enums.LinkType.hardlink #darkgoldenrod {
  name
  value
}
class "lock" as threading.lock #grey {
  acquire(blocking, timeout)
  locked()
  release()
}
class "partial" as _functools.functools.partial #grey {
  args : tuple
  func
  keywords : dict
}
class "partial" as functools.partial #grey {
  args : tuple
  func
  keywords : dict
}
class "sdist" as distutils.command.sdist.sdist #grey {
  READMES : tuple
  archive_files : NoneType, list
  boolean_options : list
  description : str
  dist_dir : NoneType, str
  filelist
  force_manifest : int
  formats : list
  group : NoneType
  help_options : list
  keep_temp : int
  manifest : str, NoneType
  manifest_only : int
  metadata_check : int
  negative_opt : dict
  owner : NoneType
  prune : int
  sub_commands : list
  template : NoneType, str
  use_defaults : int
  user_options : list
  add_defaults()
  check_metadata()
  checking_metadata()
  finalize_options()
  get_archive_files()
  get_file_list()
  initialize_options()
  make_distribution()
  make_release_tree(base_dir, files)
  prune_file_list()
  read_manifest()
  read_template()
  run()
  write_manifest()
}
class "socket" as socket.socket #grey {
  family
  type
  accept()
  close()
  detach()
  dup()
  get_inheritable()
  makefile(mode, buffering)
  sendfile(file, offset, count)
  set_inheritable(inheritable)
}
class "socket" as _socket.socket #grey {
  bind()
  close()
  connect()
  connect_ex()
  detach()
  fileno()
  getblocking()
  getpeername()
  getsockname()
  getsockopt()
  gettimeout()
  listen()
  recv()
  recv_into()
  recvfrom()
  recvfrom_into()
  recvmsg()
  recvmsg_into()
  send()
  sendall()
  sendmsg()
  sendmsg_afalg()
  sendto()
  setblocking()
  setsockopt()
  settimeout()
  shutdown()
}
class "time_recorder" as conda.common.io.time_recorder #cadetblue {
  entry_name : NoneType, str
  module_name : NoneType
  record_file : bytes, str
  start_time
  start_time : NoneType
  total_call_num
  total_run_time
  log_totals(cls)
}
class "tqdm" as conda._vendor.tqdm.std.tqdm #chartreuse {
  ascii : NoneType, bool
  bar_format : str, NoneType
  colour : NoneType
  delay : int
  desc : str
  disable : bool
  dynamic_miniters : bool
  dynamic_ncols : NoneType, bool
  format_dict
  fp
  gui : bool
  initial : int
  iterable : NoneType
  last_print_n : int
  last_print_t
  leave : bool
  lock_args : NoneType
  maxinterval : int, float
  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(cls, 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(cls)
  moveto(n)
  pandas(cls)
  refresh(nolock, lock_args)
  reset(total)
  set_description(desc, refresh)
  set_description_str(desc, refresh)
  set_lock(cls, lock)
  set_postfix(ordered_dict, refresh)
  set_postfix_str(s, refresh)
  status_printer(file)
  unpause()
  update(n)
  wrapattr(cls, stream, method, total, bytes)
  write(cls, s, file, end, nolock)
}
_collections_abc.Collection --|> _collections_abc.Container
_collections_abc.Collection --|> _collections_abc.Iterable
_collections_abc.Collection --|> _collections_abc.Sized
_collections_abc.Mapping --|> _collections_abc.Collection
_collections_abc.MutableMapping --|> _collections_abc.Mapping
_collections_abc.MutableSet --|> _collections_abc.Set
_collections_abc.Set --|> _collections_abc.Collection
_io.BufferedRWPair --|> _io._BufferedIOBase
_io.BufferedReader --|> _io._BufferedIOBase
_io.BufferedWriter --|> _io._BufferedIOBase
_io.StringIO --|> _io._TextIOBase
_io.TextIOWrapper --|> _io._TextIOBase
_io._BufferedIOBase --|> _io._IOBase
_io._RawIOBase --|> _io._IOBase
_io._TextIOBase --|> _io._IOBase
argparse.Action --|> argparse._AttributeHolder
argparse.ArgumentParser --|> argparse._ActionsContainer
argparse.ArgumentParser --|> argparse._AttributeHolder
argparse._ArgumentGroup --|> argparse._ActionsContainer
argparse._CountAction --|> argparse.Action
concurrent.futures.thread.ThreadPoolExecutor --|> concurrent.futures._base.Executor
conda.CondaExitZero --|> conda.CondaError
conda.CondaMultiError --|> conda.CondaError
conda._vendor.boltons.setutils.IndexedSet --|> _collections_abc.MutableSet
conda._vendor.frozendict.frozendict --|> _collections_abc.Mapping
conda._vendor.tqdm.std.tqdm --|> conda._vendor.tqdm.utils.Comparable
conda._vendor.tqdm.utils.DisableOnWriteError --|> conda._vendor.tqdm.utils.ObjectWrapper
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.NullHandler --|> logging.Handler
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.EntityEncoder --|> json.encoder.JSONEncoder
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.logz.DumpEncoder --|> json.encoder.JSONEncoder
conda.auxlib.packaging.BuildPyCommand --|> distutils.command.build_py.build_py
conda.auxlib.packaging.SDistCommand --|> distutils.command.sdist.sdist
conda.auxlib.type_coercion.TypeCoercionError --|> conda.auxlib.exceptions.AuxlibError
conda.base.constants.ChannelPriorityMeta --|> enum.EnumMeta
conda.base.constants.DepsModifier --|> enum.Enum
conda.base.constants.ExperimentalSolverChoice --|> conda.base.constants.ValueEnum
conda.base.constants.NoticeLevel --|> conda.base.constants.ValueEnum
conda.base.constants.PathConflict --|> enum.Enum
conda.base.constants.SafetyChecks --|> enum.Enum
conda.base.constants.SatSolverChoice --|> conda.base.constants.ValueEnum
conda.base.constants.UpdateModifier --|> enum.Enum
conda.base.constants.ValueEnum --|> enum.Enum
conda.base.context.Context --|> conda.common.configuration.Configuration
conda.cli.conda_argparse.ArgumentParser --|> argparse.ArgumentParser
conda.cli.conda_argparse.ExtendConstAction --|> argparse.Action
conda.cli.conda_argparse.NullCountAction --|> argparse._CountAction
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._os.windows.ERROR --|> enum.IntEnum
conda.common._os.windows.SW --|> enum.IntEnum
conda.common._os.windows.ShellExecuteInfo --|> _ctypes.Structure
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.InvalidElementTypeError --|> conda.common.configuration.InvalidTypeError
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.ParameterFlag --|> enum.Enum
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.CaptureTarget --|> enum.Enum
conda.common.io.CaptureTarget.STRING --|> enum.Enum
conda.common.io.DeltaSecondsFormatter --|> logging.Formatter
conda.common.io.DummyExecutor --|> concurrent.futures._base.Executor
conda.common.io.SwallowBrokenPipe --|> conda.common.io.ContextDecorator
conda.common.io.ThreadLimitedThreadPoolExecutor --|> concurrent.futures.thread.ThreadPoolExecutor
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.common.url.Url --|> conda.common.url.Url.Url
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.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.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 --|> pip._vendor.requests.adapters.BaseAdapter
conda.gateways.connection.adapters.ftp.FTPAdapter --|> requests.adapters.BaseAdapter
conda.gateways.connection.adapters.localfs.LocalFSAdapter --|> pip._vendor.requests.adapters.BaseAdapter
conda.gateways.connection.adapters.localfs.LocalFSAdapter --|> requests.adapters.BaseAdapter
conda.gateways.connection.adapters.s3.S3Adapter --|> pip._vendor.requests.adapters.BaseAdapter
conda.gateways.connection.adapters.s3.S3Adapter --|> requests.adapters.BaseAdapter
conda.gateways.connection.session.CondaHttpAuth --|> pip._vendor.requests.auth.AuthBase
conda.gateways.connection.session.CondaHttpAuth --|> requests.auth.AuthBase
conda.gateways.connection.session.CondaSession --|> pip._vendor.requests.sessions.Session
conda.gateways.connection.session.CondaSession --|> requests.sessions.Session
conda.gateways.connection.session.EnforceUnusedAdapter --|> pip._vendor.requests.adapters.BaseAdapter
conda.gateways.connection.session.EnforceUnusedAdapter --|> requests.adapters.BaseAdapter
conda.gateways.disk.link.REPARSE_DATA_BUFFER --|> _ctypes.Structure
conda.gateways.disk.link.SECURITY_ATTRIBUTES --|> _ctypes.Structure
conda.gateways.disk.link.WIN32_FIND_DATA --|> _ctypes.Structure
conda.gateways.logging.StdStreamHandler --|> logging.StreamHandler
conda.gateways.logging.TokenURLFilter --|> logging.Filter
conda.lock.DirectoryLock --|> conda.lock.FileLock
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.enums.Arch --|> enum.Enum
conda.models.enums.FileMode --|> enum.Enum
conda.models.enums.LeasedPathType --|> enum.Enum
conda.models.enums.LinkType --|> enum.Enum
conda.models.enums.LinkType.hardlink --|> enum.Enum
conda.models.enums.NoarchType --|> enum.Enum
conda.models.enums.PackageType --|> enum.Enum
conda.models.enums.PathType --|> enum.Enum
conda.models.enums.Platform --|> enum.Enum
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.notices.types.ChannelNotice --|> typing.NamedTuple
conda.notices.types.ChannelNoticeResponse --|> typing.NamedTuple
conda.testing.cases.BaseTestCase --|> unittest.case.TestCase
datetime.datetime --|> datetime.date
distutils.command.build_py.build_py --|> distutils.cmd.Command
distutils.command.sdist.sdist --|> distutils.cmd.Command
enum.IntEnum --|> enum.Enum
http.cookiejar.DefaultCookiePolicy --|> http.cookiejar.CookiePolicy
io.IOBase --|> _io._IOBase
io.RawIOBase --|> _io._RawIOBase
io.RawIOBase --|> io.IOBase
logging.Handler --|> logging.Filterer
logging.StreamHandler --|> logging.Handler
pathlib.Path --|> pathlib.PurePath
pathlib._NormalAccessor --|> pathlib._Accessor
pip._vendor.requests.cookies.RequestsCookieJar --|> _collections_abc.MutableMapping
pip._vendor.requests.cookies.RequestsCookieJar --|> http.cookiejar.CookieJar
pip._vendor.requests.sessions.Session --|> pip._vendor.requests.sessions.SessionRedirectMixin
pip._vendor.requests.structures.CaseInsensitiveDict --|> _collections_abc.MutableMapping
requests.cookies.RequestsCookieJar --|> _collections_abc.MutableMapping
requests.cookies.RequestsCookieJar --|> http.cookiejar.CookieJar
requests.sessions.Session --|> requests.sessions.SessionRedirectMixin
requests.structures.CaseInsensitiveDict --|> _collections_abc.MutableMapping
socket.SocketIO --|> io.RawIOBase
socket.socket --|> _socket.socket
unittest.case._SubTest --|> unittest.case.TestCase
_functools.functools.partial --* conda.gateways.logging.TokenURLFilter : TOKEN_REPLACE
_io.BufferedRWPair --* ftplib.FTP : file
_io.BufferedReader --* ftplib.FTP : file
_io.BufferedWriter --* ftplib.FTP : file
_io.StringIO --* conda.common.io.Spinner : fh
_io.StringIO --* conda.common.io.captured.CapturedText : stdout
_io.StringIO --* conda.common.io.captured.CapturedText : stderr
_io.StringIO --* conda.common.io.captured.CapturedText : stderr
_io.StringIO --* logging.StreamHandler : stream
_io.StringIO --* threading.Thread : _stderr
_io.TextIOWrapper --* conda.common.io.Spinner : fh
_io.TextIOWrapper --* ftplib.FTP : file
_io.TextIOWrapper --* logging.StreamHandler : stream
_io.TextIOWrapper --* threading.Thread : _stderr
_queue.SimpleQueue --* concurrent.futures.thread.ThreadPoolExecutor : _work_queue
_socket.socket.family --* ftplib.FTP : af
_thread.RLock --* http.cookiejar.CookieJar : _cookies_lock
_thread.RLock --* logging.Handler : lock
_thread.RLock --* pip._vendor.requests.cookies.RequestsCookieJar : _cookies_lock
_thread.RLock --* requests.cookies.RequestsCookieJar : _cookies_lock
_thread.RLock --* threading.Condition : _lock
_weakrefset.WeakSet --* conda._vendor.tqdm.std.tqdm : _instances
argparse.HelpFormatter --* argparse.ArgumentParser : formatter_class
argparse.HelpFormatter._Section --* argparse.HelpFormatter : _root_section
argparse.HelpFormatter._Section --* argparse.HelpFormatter : _current_section
argparse.HelpFormatter._Section --* argparse.HelpFormatter : _current_section
argparse._ArgumentGroup --* argparse.ArgumentParser : _positionals
argparse._ArgumentGroup --* argparse.ArgumentParser : _optionals
argparse._ArgumentGroup --* argparse.ArgumentParser : _subparsers
argparse._ArgumentGroup --* argparse.ArgumentParser : _subparsers
array.array --* conda.common._logic._ClauseArray : _clause_array
codecs.StreamRecoder --* conda.common.io.Spinner : fh
collections.OrderedDict --* conda.auxlib.entity.Entity : __fields__
collections.OrderedDict --* conda.common.configuration.Configuration : raw_data
collections.OrderedDict --* conda.common.pkg_formats.python.PythonDistributionMetadata : _data
collections.OrderedDict --* conda.core.link.UnlinkLinkTransaction : prefix_setups
collections.OrderedDict --* conda.core.link.UnlinkLinkTransaction : prefix_action_groups
collections.OrderedDict --* conda.core.package_cache_data.ProgressiveFetchExtract : paired_actions
collections.OrderedDict --* conda.core.solve.SolverStateContainer : specs_map
collections.OrderedDict --* conda.core.solve.SolverStateContainer : specs_map
collections.OrderedDict --* conda.models.prefix_graph.GeneralGraph : graph_by_name
collections.OrderedDict --* conda.models.prefix_graph.PrefixGraph : graph
collections.OrderedDict --* pip._vendor.requests.sessions.Session : adapters
collections.OrderedDict --* pip._vendor.requests.structures.CaseInsensitiveDict : _store
collections.OrderedDict --* requests.sessions.Session : adapters
collections.OrderedDict --* requests.structures.CaseInsensitiveDict : _store
collections.defaultdict --* conda.common.configuration.Configuration : _validation_errors
collections.defaultdict --* conda.common.io.time_recorder : total_call_num
collections.defaultdict --* conda.common.io.time_recorder : total_run_time
collections.defaultdict --* conda.core.subdir_data.SubdirData : _names_index
collections.defaultdict --* conda.core.subdir_data.SubdirData : _names_index
collections.defaultdict --* conda.core.subdir_data.SubdirData : _track_features_index
collections.defaultdict --* conda.core.subdir_data.SubdirData : _track_features_index
collections.defaultdict --* conda.models.prefix_graph.GeneralGraph : specs_by_name
collections.defaultdict --* conda.resolve.Resolve : trackers
collections.deque --* queue._PySimpleQueue : _queue
collections.deque --* threading.Condition : _waiters
conda._vendor.boltons.setutils.IndexedSet --* conda.common.configuration.Configuration : _reset_callbacks
conda._vendor.boltons.setutils.IndexedSet --* conda.common.configuration.Configuration : _search_path
conda._vendor.boltons.setutils.IndexedSet --* conda.core.solve.Solver : channels
conda._vendor.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._vendor.tqdm.std.EMA --* conda._vendor.tqdm.std.tqdm : _ema_dn
conda._vendor.tqdm.std.EMA --* conda._vendor.tqdm.std.tqdm : _ema_dn
conda._vendor.tqdm.std.EMA --* conda._vendor.tqdm.std.tqdm : _ema_dt
conda._vendor.tqdm.std.EMA --* conda._vendor.tqdm.std.tqdm : _ema_dt
conda._vendor.tqdm.std.EMA --* conda._vendor.tqdm.std.tqdm : _ema_miniters
conda._vendor.tqdm.std.EMA --* conda._vendor.tqdm.std.tqdm : _ema_miniters
conda._vendor.tqdm.std.tqdm --* conda.common.io.ProgressBar : pbar
conda._vendor.tqdm.utils.DisableOnWriteError --* conda._vendor.tqdm.std.tqdm : fp
conda.auxlib._Null --* conda.auxlib.entity.Field : _default
conda.auxlib._Null --* conda.auxlib.entity.Field : _default
conda.auxlib._Null --* conda.core.package_cache_data.PackageCacheData : __is_writable
conda.auxlib._Null --* conda.core.prefix_data.PrefixData : __is_writable
conda.auxlib._Null --* conda.core.solve.Solver : _command
conda.auxlib._Null --* conda.core.solve.SolverStateContainer : update_modifier
conda.auxlib._Null --* conda.core.solve.SolverStateContainer : deps_modifier
conda.auxlib.collection.AttrDict --* conda.auxlib.collection.AttrDict : __dict__
conda.auxlib.collection.AttrDict --* conda.common.configuration.Configuration : _argparse_args
conda.auxlib.collection.AttrDict --* conda.common.configuration.Configuration : _argparse_args
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 : metadata_signature_status
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.DepsModifier --* conda.core.solve.SolverStateContainer : deps_modifier
conda.base.constants.NoticeLevel --* conda.notices.types.ChannelNotice : level
conda.base.constants.UpdateModifier --* conda.core.solve.SolverStateContainer : update_modifier
conda.common._logic.Clauses --* conda.common.logic.Clauses : _clauses
conda.common._logic._ClauseList --* conda.common._logic._SatSolver : _clauses
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 : 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 : _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 : add_anaconda_token
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 : _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 : dev
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 : _verbosity
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 : experimental_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.io.CaptureTarget.STRING --* conda.common.io.Spinner : fh
conda.common.io.CaptureTarget.STRING --* conda.common.io.captured.CapturedText : stdout
conda.common.io.CaptureTarget.STRING --* conda.common.io.captured.CapturedText : stderr
conda.common.io.CaptureTarget.STRING --* logging.StreamHandler : stream
conda.common.io.CaptureTarget.STRING --* threading.Thread : _stderr
conda.common.io.DummyExecutor --* conda.core.link.UnlinkLinkTransaction : execute_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.solve.SolverStateContainer --* conda.core.solve.Solver : ssc
conda.gateways.connection.session.CondaHttpAuth --* conda.gateways.connection.session.CondaSession : auth
conda.models.channel.Channel --* conda.core.subdir_data.SubdirData : channel
conda.models.enums.LinkType.hardlink --* conda.core.path_actions.UnlinkPathAction : link_type
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.solver_helpers.SimpleEnvironment --* conda.testing.solver_helpers.SolverTests : env
datetime.datetime --* conda.auxlib.entity.DateField : _type
distutils.filelist.FileList --* distutils.command.sdist.sdist : filelist
ftplib.FTP --* conda.gateways.connection.adapters.ftp.FTPAdapter : conn
functools.partial --* conda.gateways.logging.TokenURLFilter : TOKEN_REPLACE
http.cookiejar.DefaultCookiePolicy --* http.cookiejar.CookieJar : _policy
itertools.cycle --* conda.common.io.Spinner : spinner_cycle
logging.PercentStyle --* logging.Formatter : _style
pathlib.Path --* conda.testing.solver_helpers.SimpleEnvironment : _path
pathlib.Path --* conda.testing.solver_helpers.SimpleEnvironment : _prefix_path
pathlib.Path --* conda.testing.solver_helpers.SimpleEnvironment : _channels_path
pathlib._NormalAccessor --* pathlib.Path : _accessor
pip._vendor.requests.cookies.RequestsCookieJar --* pip._vendor.requests.sessions.Session : cookies
pip._vendor.requests.structures.CaseInsensitiveDict --* pip._vendor.requests.sessions.Session : headers
queue._PySimpleQueue --* concurrent.futures.thread.ThreadPoolExecutor : _work_queue
requests.cookies.RequestsCookieJar --* requests.sessions.Session : cookies
requests.structures.CaseInsensitiveDict --* requests.sessions.Session : headers
socket.SocketIO --* ftplib.FTP : file
socket.socket --* ftplib.FTP : sock
threading.Condition --* threading.Event : _cond
threading.Condition --* threading.Semaphore : _cond
threading.Event --* conda.common.io.Spinner : _stop_running
threading.Event --* threading.Thread : _started
threading.Semaphore --* queue._PySimpleQueue : _count
threading.Thread --* conda.common.io.Spinner : _spinner_thread
threading._RLock --* http.cookiejar.CookieJar : _cookies_lock
threading._RLock --* logging.Handler : lock
threading._RLock --* pip._vendor.requests.cookies.RequestsCookieJar : _cookies_lock
threading._RLock --* requests.cookies.RequestsCookieJar : _cookies_lock
threading._RLock --* threading.Condition : _lock
threading.lock --* concurrent.futures.thread.ThreadPoolExecutor : _shutdown_lock
threading.lock --* conda.common.io.DummyExecutor : _shutdownLock
unittest.case._Outcome --* unittest.case.TestCase : _outcome
unittest.case._SubTest --* unittest.case.TestCase : _subtest
unittest.case._SubTest --* unittest.case.TestCase : _subtest
@enduml