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 0.0.0.dev0+placeholder (Jul 17, 2023).
C4 stands for the for levels:
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.
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.
Conda
The following diagram focuses on the conda container from the level 1 diagram.
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.
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
class "ABC" as abc.ABC #grey {
}
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
format_usage()
}
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 #gold {
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
epilog : str
error(message)
parse_args(args, namespace)
print_help()
}
class "ArgumentParser" as argparse.ArgumentParser #grey {
add_help : bool
allow_abbrev : bool
epilog : NoneType
exit_on_error : bool
formatter_class
fromfile_prefix_chars : NoneType
prog : NoneType
usage : str, NoneType
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 #coral {
}
class "AuthBase" as pip._vendor.requests.auth.AuthBase #cornflowerblue {
}
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 #coral {
close()
send(request, stream, timeout, verify, cert, proxies)
}
class "BaseAdapter" as pip._vendor.requests.adapters.BaseAdapter #cornflowerblue {
close()
send(request, stream, timeout, verify, cert, proxies)
}
class "BaseSpec" as conda.models.version.BaseSpec #gold {
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 #burlywood {
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 #gold {
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 #cyan {
stderr : NoneType
stdout
}
class "CaseInsensitiveDict" as requests.structures.CaseInsensitiveDict #coral {
copy()
lower_items()
}
class "CaseInsensitiveDict" as pip._vendor.requests.structures.CaseInsensitiveDict #cornflowerblue {
copy()
lower_items()
}
class "CaseInsensitiveStrMatch" as conda.models.match_spec.CaseInsensitiveStrMatch #gold {
match(other)
}
class "Channel" as conda.models.channel.Channel #gold {
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 #gold {
dump(instance, instance_type, val)
}
class "ChannelMatch" as conda.models.match_spec.ChannelMatch #gold {
match(other)
}
class "<color:red>ChannelNotAllowed</color>" as conda.exceptions.ChannelNotAllowed #aliceblue {
}
class "ChannelNotice" as conda.notices.types.ChannelNotice #hotpink {
channel_name
created_at
expired_at
id
interval
level
message
}
class "ChannelNoticeResponse" as conda.notices.types.ChannelNoticeResponse #hotpink {
json_data
name : str
notices
url : str
get_cache_key(cls: str, url: Path, cache_dir) -> Path
}
class "ChannelNoticeResultSet" as conda.notices.types.ChannelNoticeResultSet #hotpink {
channel_notices : Sequence[ChannelNotice]
total_number_channel_notices : int
viewed_channel_notices : int
}
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 #gold {
}
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 : staticmethod
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 #burlywood {
CLEAN : str
COMPARE : str
CONFIG : str
CREATE : str
INFO : str
INSTALL : str
LIST : str
REMOVE : str
RUN : str
SEARCH : str
UPDATE : str
}
class "Comparable" as tqdm.utils.Comparable #darkgoldenrod {
}
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 "CondaCLIFixture" as conda.testing.CondaCLIFixture #aliceblue {
capsys
}
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 "CondaPluginManager" as conda.plugins.manager.CondaPluginManager #mediumspringgreen {
get_cached_solver_backend
get_cached_solver_backend : NoneType
get_hook_results(name: str) -> list
get_solver_backend(name: str) -> type[Solver]
load_entrypoints(group: str, name) -> int
load_plugins() -> list[str]
}
class "CondaRepoInterface" as conda.gateways.repodata.CondaRepoInterface #cornflowerblue {
repodata(state: RepodataState) ->
}
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 "CondaSolver" as conda.plugins.types.CondaSolver #mediumspringgreen {
backend : type[Solver]
name : str
}
class "CondaSpecs" as conda.plugins.hookspec.CondaSpecs #mediumspringgreen {
conda_solvers() -> Iterable[CondaSolver]
conda_subcommands() -> Iterable[CondaSubcommand]
conda_virtual_packages() -> Iterable[CondaVirtualPackage]
}
class "CondaSubcommand" as conda.plugins.types.CondaSubcommand #mediumspringgreen {
action : Callable[[list[str]], int | None]
name : str
summary : str
}
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 "CondaVirtualPackage" as conda.plugins.types.CondaVirtualPackage #mediumspringgreen {
build
name : str
version
}
class "Condition" as threading.Condition #grey {
acquire
release
notify(n)
notifyAll()
notify_all()
wait(timeout)
wait_for(predicate, timeout)
}
class "Configuration" as conda.common.configuration.Configuration #cadetblue {
raw_data : dict
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
channel_settings
channels
client_ssl_cert
client_ssl_cert_key
clobber
conda_build
conda_build_local_paths
conda_build_local_urls
conda_exe
conda_exe_vars_dict
conda_prefix
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
experimental_solver
extra_safety_checks
fetch_threads
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
plugin_manager
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
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 : staticmethod
pathsep_join
run_script_tmpl : str
script_extension : str
sep : str
set_var_tmpl : str
tempfile_extension : NoneType
unset_var_tmpl : str
}
class "<color:red>CustomValidationError</color>" as conda.common.configuration.CustomValidationError #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
secure_protocols : tuple
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 "DeprecatedAction" as conda.cli.conda_argparse.DeprecatedAction #burlywood {
}
class "<color:red>DeprecatedError</color>" as conda.deprecations.DeprecatedError #aliceblue {
}
class "DeprecationHandler" as conda.deprecations.DeprecationHandler #aliceblue {
argument(deprecate_in: str, remove_in: str, argument: str) -> Callable[Callable, Callable]
constant(deprecate_in: str, remove_in: str, constant: str, value: Any) ->
module(deprecate_in: str, remove_in: str) ->
topic(deprecate_in: str, remove_in: str) ->
}
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 tqdm.utils.DisableOnWriteError #darkgoldenrod {
disable_on_exception(tqdm_instance, func)
}
class "<color:red>DisallowedPackageError</color>" as conda.exceptions.DisallowedPackageError #aliceblue {
}
class "Dist" as conda.models.dist.Dist #gold {
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 #gold {
}
class "<color:red>DryRunExit</color>" as conda.exceptions.DryRunExit #aliceblue {
}
class "DummyArgs" as conda.testing.notices.helpers.DummyArgs #chartreuse {
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 tqdm.std.EMA #darkgoldenrod {
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 {
clear()
isSet()
is_set()
set()
wait(timeout)
}
class "ExactLowerStrMatch" as conda.models.match_spec.ExactLowerStrMatch #gold {
match(other)
}
class "ExactStrMatch" as conda.models.match_spec.ExactStrMatch #gold {
match(other)
}
class "ExceptionHandler" as conda.exception_handler.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 "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 : bool
port : int
port : int
sock : NoneType
sock : NoneType
source_address : NoneType
timeout : object, int
trust_server_pasv_ipv4_address : bool
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 #gold {
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 : list, NoneType
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 #gold {
name
}
class "FilenameField" as conda.models.records.FilenameField #gold {
}
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 : staticmethod
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 #gold {
graph_by_name : dict
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 #gold {
}
class "GlobStrMatch" as conda.models.match_spec.GlobStrMatch #gold {
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 "HashWriter" as conda.gateways.repodata.jlap.fetch.HashWriter #forestgreen {
backing
hasher
close()
write(b: bytes)
}
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() -> list[tuple[str, set[str], list[str]]]
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 #darkseagreen {
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>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 "JLAP" as conda.gateways.repodata.jlap.core.JLAP #forestgreen {
body
last
penultimate
add(line: str)
from_lines(cls: Iterable[bytes], lines: bytes, iv, pos, verify)
from_path(cls, path, verify)
terminate()
write(path: Path)
}
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>Jlap304NotModified</color>" as conda.gateways.repodata.jlap.fetch.Jlap304NotModified #forestgreen {
}
class "<color:red>JlapPatchNotFound</color>" as conda.gateways.repodata.jlap.fetch.JlapPatchNotFound #forestgreen {
}
class "JlapRepoInterface" as conda.gateways.repodata.jlap.interface.JlapRepoInterface #forestgreen {
repodata(state) ->
repodata_parsed(state) ->
}
class "<color:red>JlapSkipZst</color>" as conda.gateways.repodata.jlap.fetch.JlapSkipZst #forestgreen {
}
class "<color:red>KnownPackageClobberError</color>" as conda.exceptions.KnownPackageClobberError #aliceblue {
}
class "LeasedPathEntry" as conda.models.leased_path_entry.LeasedPathEntry #gold {
leased_path
leased_path_type
package_name
target_path
target_prefix
}
class "LeasedPathType" as conda.models.enums.LeasedPathType #gold {
name
}
class "Link" as conda.models.records.Link #gold {
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 #gold {
name
}
class "LinkTypeField" as conda.models.records.LinkTypeField #gold {
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 "Logger" as logging.Logger #grey {
disabled : bool
emittedNoHandlerWarning : bool
handlers : list
level : int
manager
name
parent : NoneType
propagate : bool
addHandler(hdlr)
callHandlers(record)
critical(msg)
debug(msg)
error(msg)
exception(msg)
fatal(msg)
findCaller(stack_info, stacklevel)
getChild(suffix)
getEffectiveLevel()
handle(record)
hasHandlers()
info(msg)
isEnabledFor(level)
log(level, msg)
makeRecord(name, level, fn, lno, msg, args, exc_info, func, extra, sinfo)
removeHandler(hdlr)
setLevel(level)
warn(msg)
warning(msg)
}
class "MakeMenuAction" as conda.core.path_actions.MakeMenuAction #coral {
create_actions(cls, transaction_context, package_info, target_prefix, requested_link_type)
execute()
reverse()
}
class "Manager" as logging.Manager #grey {
disable
disable : int
emittedNoHandlerWarning : bool
logRecordFactory : NoneType
loggerClass : NoneType
loggerDict : dict
root
getLogger(name)
setLogRecordFactory(factory)
setLoggerClass(klass)
}
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(parameters: Sequence[MapLoadedParameter]) -> MapLoadedParameter
}
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 #gold {
exact_value
raw_value
match(other)
matches(value)
merge(other)
union(other)
}
class "MatchSpec" as conda.models.match_spec.MatchSpec #gold {
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 #gold {
}
class "Md5Field" as conda.models.records.Md5Field #gold {
}
class "<color:red>MetadataWarning</color>" as conda.common.pkg_formats.python.MetadataWarning #chocolate {
}
class "Minio" as conda.testing.gateways.fixtures.minio_s3_server.Minio #dodgerblue {
name : str
port : int
server_url
populate_bucket(endpoint, bucket_name, channel_dir)
}
class "MockResponse" as conda.testing.notices.helpers.MockResponse #chartreuse {
json_data
raise_exc : bool
status_code
json()
}
class "MultiChannel" as conda.models.channel.MultiChannel #gold {
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 "MutableSequence" as _collections_abc.MutableSequence #grey {
append(value)
clear()
extend(values)
insert(index, value)
pop(index)
remove(value)
reverse()
}
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 #gold {
entry_points
type
}
class "NoarchField" as conda.models.package_info.NoarchField #gold {
box(instance, instance_type, val)
}
class "NoarchField" as conda.models.records.NoarchField #gold {
box(instance, instance_type, val)
}
class "NoarchType" as conda.models.enums.NoarchType #gold {
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(parameters: Sequence[ObjectLoadedParameter]) -> ObjectLoadedParameter
}
class "ObjectParameter" as conda.common.configuration.ObjectParameter #cadetblue {
get_all_matches(name, names, instance)
load(name, match)
}
class "ObjectWrapper" as tqdm.utils.ObjectWrapper #darkgoldenrod {
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 #gold {
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 #gold {
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 #gold {
noarch
package_metadata_version
preferred_env
}
class "<color:red>PackageNotInstalledError</color>" as conda.exceptions.PackageNotInstalledError #aliceblue {
}
class "PackageRecord" as conda.models.records.PackageRecord #gold {
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 "PackageRecordList" as conda.core.subdir_data.PackageRecordList #coral {
}
class "PackageType" as conda.models.enums.PackageType #gold {
name
conda_package_types()
unmanageable_package_types()
}
class "PackageTypeField" as conda.models.records.PackageTypeField #gold {
}
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()
hardlink_to(target)
home(cls)
is_block_device()
is_char_device()
is_dir()
is_fifo()
is_file()
is_mount()
is_socket()
is_symlink()
iterdir()
lchmod(mode)
link_to(target)
lstat()
mkdir(mode, parents, exist_ok)
open(mode, buffering, encoding, errors, newline)
owner()
read_bytes()
read_text(encoding, errors)
readlink()
rename(target)
replace(target)
resolve(strict)
rglob(pattern)
rmdir()
samefile(other_path)
stat()
symlink_to(target, target_is_directory)
touch(mode, exist_ok)
unlink(missing_ok)
write_bytes(data)
write_text(data, encoding, errors, newline)
}
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 #gold {
file_mode
no_link
path
path_type
prefix_placeholder
}
class "PathDataV1" as conda.models.records.PathDataV1 #gold {
inode_paths
sha256
sha256_in_prefix
size_in_bytes
}
class "PathFactoryFixture" as conda.testing.PathFactoryFixture #aliceblue {
tmp_path
}
class "<color:red>PathNotFoundError</color>" as conda.exceptions.PathNotFoundError #aliceblue {
}
class "PathType" as conda.models.enums.PathType #gold {
name
basic_types()
}
class "PathsData" as conda.models.records.PathsData #gold {
paths
paths_version
}
class "PendingDeprecationAction" as conda.cli.conda_argparse.PendingDeprecationAction #burlywood {
}
class "PercentStyle" as logging.PercentStyle #grey {
asctime_format : str
asctime_search : str
default_format : str
validation_pattern
format(record)
usesTime()
validate()
}
class "Platform" as conda.models.enums.Platform #gold {
name
from_sys(cls)
}
class "<color:red>PluginError</color>" as conda.exceptions.PluginError #aliceblue {
}
class "PluginManager" as pluggy._manager.PluginManager #forestgreen {
hook
project_name
trace
add_hookcall_monitoring(before, after)
add_hookspecs(module_or_class)
check_pending()
enable_tracing()
get_canonical_name(plugin)
get_hookcallers(plugin)
get_name(plugin)
get_plugin(name)
get_plugins()
has_plugin(name)
is_blocked(name)
is_registered(plugin)
list_name_plugin()
list_plugin_distinfo()
load_setuptools_entrypoints(group, name)
parse_hookimpl_opts(plugin, name)
parse_hookspec_opts(module_or_class, name)
register(plugin, name)
set_blocked(name)
subset_hook_caller(name, remove_plugins)
unregister(plugin, name)
}
class "PosixActivator" as conda.activate.PosixActivator #aliceblue {
command_join : str
export_var_tmpl : str
hook_source_path
path_conversion : staticmethod
pathsep_join
run_script_tmpl : str
script_extension : str
sep : str
set_var_tmpl : str
tempfile_extension : NoneType
unset_var_tmpl : str
}
class "PowerShellActivator" as conda.activate.PowerShellActivator #aliceblue {
command_join : str
export_var_tmpl : str
hook_source_path
path_conversion : staticmethod
pathsep_join
run_script_tmpl : str
script_extension : str
sep : str
set_var_tmpl : str
tempfile_extension : NoneType
unset_var_tmpl : str
}
class "PreferredEnv" as conda.models.package_info.PreferredEnv #gold {
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 #gold {
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 #gold {
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()
get_lock(cls)
refresh()
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 : dict
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_relative_to()
is_reserved()
joinpath()
match(path_pattern)
relative_to()
with_name(name)
with_stem(stem)
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 "RepoInterface" as conda.gateways.repodata.RepoInterface #cornflowerblue {
repodata(state: dict) -> str
}
class "RepodataCache" as conda.gateways.repodata.RepodataCache #cornflowerblue {
cache_dir
cache_path_json
cache_path_state
name : str
repodata_fn
state
load() -> str
load_state()
refresh(refresh_ns)
replace(temp_path: Path)
save(data: str)
stale()
timeout()
}
class "RepodataFetch" as conda.gateways.repodata.RepodataFetch #cornflowerblue {
cache_path_base
cache_path_base
cache_path_json
cache_path_state
channel
channel
repo_cache
repo_interface_cls
repo_interface_cls
repodata_fn : str
repodata_fn : str
url_w_credentials
url_w_credentials : str
url_w_repodata_fn
url_w_subdir
url_w_subdir : str
fetch_latest() -> tuple[dict | str, RepodataState]
fetch_latest_parsed() -> tuple[dict, RepodataState]
fetch_latest_path() -> tuple[Path, RepodataState]
read_cache() -> tuple[str, RepodataState]
}
class "<color:red>RepodataIsEmpty</color>" as conda.gateways.repodata.RepodataIsEmpty #cornflowerblue {
}
class "<color:red>RepodataOnDisk</color>" as conda.gateways.repodata.RepodataOnDisk #cornflowerblue {
}
class "RepodataState" as conda.gateways.repodata.RepodataState #cornflowerblue {
cache_control
cache_path_json
cache_path_state
etag
mod
repodata_fn : str
clear_has_format(format: str)
has_format(format: str) -> tuple[bool, datetime.datetime | None]
load()
save()
set_has_format(format: str, value: bool)
should_check_format(format: str) -> bool
}
class "RequestsCookieJar" as requests.cookies.RequestsCookieJar #coral {
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 #cornflowerblue {
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 : dict
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: dict[str, PackageRecord]) -> list[PackageRecord]
environment_is_consistent(installed)
find_conflicts(specs, specs_to_add, history_specs)
find_matches(spec: MatchSpec) -> tuple[PackageRecord]
find_matches_with_strict(ms, strict_channel_priority)
gen_clauses()
generate_feature_count(C)
generate_feature_metric(C)
generate_install_count(C, specs)
generate_package_count(C, missing)
generate_removal_count(C, specs)
generate_spec_constraints(C, specs)
generate_update_count(C, specs)
generate_version_metrics(C, specs, include0)
get_conflicting_specs(specs, explicit_specs)
get_pkgs(ms, emptyok)
get_reduced_index(explicit_specs, sort_by_exactness, exit_on_conflict)
install(specs, installed, update_deps, returnall)
install_specs(specs, installed, update_deps)
invalid_chains(spec, filter, optional)
match_any(mss, prec)
ms_depends(prec: PackageRecord) -> list[MatchSpec]
push_MatchSpec(C, spec)
remove(specs, installed)
remove_specs(specs, installed)
restore_bad(pkgs, preserve)
solve(specs: list, returnall: bool, _remove, specs_to_add, history_specs, should_retry_solve) -> list[PackageRecord]
to_feature_metric_id(prec_dist_str, feat)
to_sat_name(val)
valid(spec_or_prec, filter, optional)
valid2(spec_or_prec, filter_out, optional)
verify_specs(specs)
version_key(prec, vtype)
}
class "<color:red>ResolvePackageNotFound</color>" as conda.exceptions.ResolvePackageNotFound #aliceblue {
bad_deps : tuple
}
class "<color:red>Response304ContentUnchanged</color>" as conda.gateways.repodata.Response304ContentUnchanged #cornflowerblue {
}
class "Result" as conda.core.initialize.Result #coral {
MODIFIED : str
NEEDS_SUDO : str
NO_CHANGE : str
}
class "Reversible" as _collections_abc.Reversible #grey {
}
class "RootLogger" as logging.RootLogger #grey {
disable : int
disabled : bool
handlers : list
level : int
propagate : bool
}
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 #cyan {
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(n)
}
class "<color:red>SenderError</color>" as conda.auxlib.exceptions.SenderError #antiquewhite {
}
class "Sequence" as _collections_abc.Sequence #grey {
count(value)
index(value, start, stop)
}
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 #coral {
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 #cornflowerblue {
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 #coral {
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 #cornflowerblue {
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 #burlywood {
REPO_DATA_KEYS : tuple
installed_packages : list
repo_packages
subdirs
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 #gold {
}
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 : set, frozenset, tuple
specs_to_add_names : frozenset
specs_to_remove : frozenset
ssc
subdirs : tuple
determine_constricting_specs(spec, solution_precs)
get_constrained_packages(pre_packages, post_packages, index_keys)
get_request_package_in_solution(solution_precs, specs_map)
solve_final_state(update_modifier, deps_modifier, prune, ignore_pinned, force_remove, should_retry_solve)
solve_for_diff(update_modifier, deps_modifier, prune, ignore_pinned, force_remove, force_reinstall, should_retry_solve)
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 : dict
update_modifier
pinned_specs()
prefix_data()
set_repository_metadata(index, r)
specs_from_history_map()
track_features_specs()
working_state_reset()
}
class "SolverTests" as conda.testing.solver_helpers.SolverTests #burlywood {
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 #gold {
exact_value
match(other)
}
class "Starter" as conda.testing.gateways.fixtures.minio_s3_server.Starter #dodgerblue {
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 {
RepoInterface
cache_path_base
cache_path_json
cache_path_pickle
cache_path_state
channel
repo_cache
repo_fetch
repodata_fn : str
url_w_credentials : str
url_w_repodata_fn
url_w_subdir
clear_cached_local_channel_data(cls, exclude_file)
iter_records()
load()
query(package_ref_or_match_spec)
query_all(package_ref_or_match_spec, channels, subdirs, repodata_fn)
reload()
}
class "SubdirDataType" as conda.core.subdir_data.SubdirDataType #coral {
}
class "SubdirField" as conda.models.records.SubdirField #gold {
}
class "SwallowBrokenPipe" as conda.common.io.SwallowBrokenPipe #cadetblue {
}
class "TagTracerSub" as pluggy._tracing.TagTracerSub #forestgreen {
root
tags
get(name)
}
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
addClassCleanup()
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)
assertNoLogs(logger, level)
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()
doClassCleanups(cls)
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
native_id
getName()
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 #cyan {
}
class "TimestampField" as conda.models.records.TimestampField #gold {
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 "TmpEnvFixture" as conda.testing.TmpEnvFixture #aliceblue {
conda_cli
path_factory
}
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 "TqdmHBox" as tqdm.notebook.TqdmHBox #darkgoldenrod {
pbar
}
class "Tuple" as typing.Tuple #grey {
}
class "<color:red>TypeCoercionError</color>" as conda.auxlib.type_coercion.TypeCoercionError #antiquewhite {
value
}
class "<color:red>UnavailableInvalidChannel</color>" as conda.exceptions.UnavailableInvalidChannel #aliceblue {
status_code
status_code
}
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 : dict
prefix_setups
transaction_context : dict
verify_executor
download_and_extract()
execute()
prepare()
print_transaction_summary()
verify()
}
class "UnlinkPathAction" as conda.core.path_actions.UnlinkPathAction #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 #gold {
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 "UserDict" as collections.UserDict #grey {
data : dict
copy()
fromkeys(cls, iterable, value)
}
class "UserList" as collections.UserList #grey {
data : list
append(item)
clear()
copy()
count(item)
extend(other)
index(item)
insert(i, item)
pop(i)
remove(item)
reverse()
sort()
}
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 "Version" as packaging.version.Version #hotpink {
base_version
dev
epoch
is_devrelease
is_postrelease
is_prerelease
local
major
micro
minor
post
pre
public
release
}
class "VersionOrder" as conda.models.version.VersionOrder #gold {
fillvalue : int
local : list
norm_version
version
startswith(other)
}
class "VersionSpec" as conda.models.version.VersionSpec #gold {
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
path_conversion : staticmethod
pathsep_join
run_script_tmpl : str
script_extension : str
sep : str
set_var_tmpl : str
tempfile_extension : NoneType
unset_var_tmpl : str
}
class "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 : str
env_name_or_prefix
environ : dict
export_var_tmpl : str
hook_source_path : str
path_conversion : Callable[str | Iterable[str] | None, str | tuple[str, ...] | None]
pathsep_join : str
run_script_tmpl : str
script_extension : str
sep : str
set_var_tmpl : str
stack : bool
tempfile_extension
unset_var_tmpl : str
activate()
add_export_unset_vars(export_vars, unset_vars)
build_activate(env_name_or_prefix)
build_deactivate()
build_reactivate()
build_stack(env_name_or_prefix)
commands()
deactivate()
execute()
get_export_unset_vars(export_metavars)
get_scripts_export_unset_vars()
hook(auto_activate_base)
reactivate()
}
class "_ArgumentGroup" as argparse._ArgumentGroup #grey {
title : NoneType
}
class "_AttributeHolder" as argparse._AttributeHolder #grey {
}
class "_BaseVersion" as packaging.version._BaseVersion #hotpink {
}
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 #gold {
box(instance, instance_type, val)
dump(instance, instance_type, val)
}
class "_HookRelay" as pluggy._hooks._HookRelay #forestgreen {
}
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
expanduser : staticmethod
getcwd
link
listdir
mkdir
open
readlink
realpath : staticmethod
rename
replace
rmdir
scandir
stat
symlink
unlink
group(path)
owner(path)
touch(path, mode, exist_ok)
}
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 #chocolate {
enabled
key_mgr
session
trusted_root
}
class "_StoreAction" as argparse._StoreAction #grey {
}
class "_StrMatchMixin" as conda.models.match_spec._StrMatchMixin #gold {
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 "_Version" as packaging.version._Version #hotpink {
dev
epoch
local
post
pre
release
}
class "array" as array.array #grey {
append()
buffer_info()
byteswap()
count()
extend()
frombytes()
fromfile()
fromlist()
fromunicode()
index()
insert()
pop()
remove()
reverse()
tobytes()
tofile()
tolist()
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 : dict, NoneType
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()
fromisocalendar(cls, year, week, day)
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 #mediumspringgreen {
dict_cls : dict
copy()
to_json()
}
class "hardlink" as conda.models.enums.LinkType.hardlink #aliceblue {
name
value
}
class "lock" as threading.lock #grey {
acquire(blocking, timeout)
locked()
release()
}
class "partial" as functools.partial #grey {
args : tuple
func
keywords : dict
}
class "partial" as _functools.functools.partial #grey {
args : tuple
func
keywords : dict
}
class "sdist" as distutils.command.sdist.sdist #grey {
READMES : tuple
archive_files : list, NoneType
boolean_options : list
description : str
dist_dir : NoneType, str
filelist
force_manifest : int
formats : list
group : NoneType
help_options : list
keep_temp : int
manifest : NoneType, str
manifest_only : int
metadata_check : int
negative_opt : dict
owner : NoneType
prune : int
sub_commands : list
template : str, NoneType
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 "temporary_class" as conda.common.compat.six_with_metaclass.temporary_class #antiquewhite {
}
class "time_recorder" as conda.common.io.time_recorder #cadetblue {
entry_name : str, NoneType
module_name : NoneType
record_file : bytes, str
start_time
start_time : NoneType
total_call_num
total_run_time
log_totals(cls)
}
class "tqdm" as tqdm.auto.tqdm #darkgoldenrod {
}
class "tqdm" as tqdm.std.tqdm #darkgoldenrod {
ascii : bool, NoneType
bar_format : NoneType, str
colour : NoneType
delay : int
desc : str
disable : bool
dynamic_miniters : bool
dynamic_ncols : NoneType, bool
format_dict
fp
gui : bool
initial : int
iterable : reversed, NoneType
last_print_n : int
last_print_t
leave : bool
lock_args : NoneType
maxinterval : int, float
mininterval : float, int
miniters : int, NoneType
monitor : NoneType
monitor_interval : int
n : int
ncols : NoneType
nrows : NoneType
pos
postfix : str, NoneType
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)
}
class "tqdm_asyncio" as tqdm.asyncio.tqdm_asyncio #darkgoldenrod {
iterable_awaitable : bool
iterable_iterator
iterable_next
as_completed(cls, fs)
gather(cls)
send()
}
class "tqdm_notebook" as tqdm.notebook.tqdm_notebook #darkgoldenrod {
colour
colour
container
disp
displayed : bool
ncols
clear()
close()
display(msg, pos, close, bar_style, check_delay)
reset(total)
status_printer(_, total, desc, ncols)
update(n)
}
_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.MutableSequence --|> _collections_abc.Sequence
_collections_abc.MutableSet --|> _collections_abc.Set
_collections_abc.Reversible --|> _collections_abc.Iterable
_collections_abc.Sequence --|> _collections_abc.Collection
_collections_abc.Sequence --|> _collections_abc.Reversible
_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
argparse._StoreAction --|> argparse.Action
collections.UserDict --|> _collections_abc.MutableMapping
collections.UserList --|> _collections_abc.MutableSequence
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.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.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.DeprecatedAction --|> argparse._StoreAction
conda.cli.conda_argparse.ExtendConstAction --|> argparse.Action
conda.cli.conda_argparse.NullCountAction --|> argparse._CountAction
conda.cli.conda_argparse.PendingDeprecationAction --|> argparse._StoreAction
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.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.core.subdir_data.PackageRecordList --|> collections.UserList
conda.exceptions.ActivateHelp --|> conda.exceptions.Help
conda.exceptions.ArgumentError --|> conda.CondaError
conda.exceptions.AuthenticationError --|> conda.CondaError
conda.exceptions.BasicClobberError --|> conda.exceptions.ClobberError
conda.exceptions.BinaryPrefixReplacementError --|> conda.CondaError
conda.exceptions.ChannelError --|> conda.CondaError
conda.exceptions.ChannelNotAllowed --|> conda.exceptions.ChannelError
conda.exceptions.ChecksumMismatchError --|> conda.CondaError
conda.exceptions.ClobberError --|> conda.CondaError
conda.exceptions.CommandNotFoundError --|> conda.CondaError
conda.exceptions.CondaDependencyError --|> conda.CondaError
conda.exceptions.CondaEnvException --|> conda.CondaError
conda.exceptions.CondaEnvironmentError --|> conda.CondaError
conda.exceptions.CondaFileIOError --|> conda.exceptions.CondaIOError
conda.exceptions.CondaHTTPError --|> conda.CondaError
conda.exceptions.CondaHistoryError --|> conda.CondaError
conda.exceptions.CondaIOError --|> conda.CondaError
conda.exceptions.CondaImportError --|> conda.CondaError
conda.exceptions.CondaIndexError --|> conda.CondaError
conda.exceptions.CondaKeyError --|> conda.CondaError
conda.exceptions.CondaMemoryError --|> conda.CondaError
conda.exceptions.CondaOSError --|> conda.CondaError
conda.exceptions.CondaSSLError --|> conda.CondaError
conda.exceptions.CondaSignalInterrupt --|> conda.CondaError
conda.exceptions.CondaSystemExit --|> conda.CondaExitZero
conda.exceptions.CondaUpgradeError --|> conda.CondaError
conda.exceptions.CondaValueError --|> conda.CondaError
conda.exceptions.CondaVerificationError --|> conda.CondaError
conda.exceptions.CorruptedEnvironmentError --|> conda.CondaError
conda.exceptions.CouldntParseError --|> conda.exceptions.ParseError
conda.exceptions.CyclicalDependencyError --|> conda.CondaError
conda.exceptions.DeactivateHelp --|> conda.exceptions.Help
conda.exceptions.DirectoryNotACondaEnvironmentError --|> conda.CondaError
conda.exceptions.DirectoryNotFoundError --|> conda.CondaError
conda.exceptions.DisallowedPackageError --|> conda.CondaError
conda.exceptions.DryRunExit --|> conda.CondaExitZero
conda.exceptions.EncodingError --|> conda.CondaError
conda.exceptions.EnvironmentFileEmpty --|> conda.exceptions.CondaEnvException
conda.exceptions.EnvironmentFileExtensionNotValid --|> conda.exceptions.CondaEnvException
conda.exceptions.EnvironmentFileNotDownloaded --|> conda.CondaError
conda.exceptions.EnvironmentFileNotFound --|> conda.exceptions.CondaEnvException
conda.exceptions.EnvironmentLocationNotFound --|> conda.CondaError
conda.exceptions.EnvironmentNameNotFound --|> conda.CondaError
conda.exceptions.EnvironmentNotWritableError --|> conda.CondaError
conda.exceptions.GenericHelp --|> conda.exceptions.Help
conda.exceptions.Help --|> conda.CondaError
conda.exceptions.InvalidMatchSpec --|> conda.exceptions.InvalidSpec
conda.exceptions.InvalidSpec --|> conda.CondaError
conda.exceptions.InvalidVersionSpec --|> conda.exceptions.InvalidSpec
conda.exceptions.KnownPackageClobberError --|> conda.exceptions.ClobberError
conda.exceptions.LinkError --|> conda.CondaError
conda.exceptions.LockError --|> conda.CondaError
conda.exceptions.NoBaseEnvironmentError --|> conda.CondaError
conda.exceptions.NoSpaceLeftError --|> conda.CondaError
conda.exceptions.NoWritableEnvsDirError --|> conda.CondaError
conda.exceptions.NoWritablePkgsDirError --|> conda.CondaError
conda.exceptions.NotWritableError --|> conda.CondaError
conda.exceptions.OperationNotAllowed --|> conda.CondaError
conda.exceptions.PackageNotInstalledError --|> conda.CondaError
conda.exceptions.PackagesNotFoundError --|> conda.CondaError
conda.exceptions.PaddingError --|> conda.CondaError
conda.exceptions.ParseError --|> conda.CondaError
conda.exceptions.PathNotFoundError --|> conda.CondaError
conda.exceptions.PluginError --|> conda.CondaError
conda.exceptions.ProxyError --|> conda.CondaError
conda.exceptions.RemoveError --|> conda.CondaError
conda.exceptions.ResolvePackageNotFound --|> conda.CondaError
conda.exceptions.SafetyError --|> conda.CondaError
conda.exceptions.SharedLinkPathClobberError --|> conda.exceptions.ClobberError
conda.exceptions.SpecNotFound --|> conda.CondaError
conda.exceptions.SpecsConfigurationConflictError --|> conda.CondaError
conda.exceptions.TooManyArgumentsError --|> conda.exceptions.ArgumentError
conda.exceptions.UnavailableInvalidChannel --|> conda.exceptions.ChannelError
conda.exceptions.UnknownPackageClobberError --|> conda.exceptions.ClobberError
conda.exceptions.UnsatisfiableError --|> conda.CondaError
conda.gateways.connection.adapters.ftp.FTPAdapter --|> 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.gateways.repodata.CondaRepoInterface --|> conda.gateways.repodata.RepoInterface
conda.gateways.repodata.RepoInterface --|> abc.ABC
conda.gateways.repodata.RepodataIsEmpty --|> conda.exceptions.UnavailableInvalidChannel
conda.gateways.repodata.RepodataState --|> collections.UserDict
conda.gateways.repodata.jlap.core.JLAP --|> collections.UserList
conda.gateways.repodata.jlap.fetch.HashWriter --|> io.RawIOBase
conda.gateways.repodata.jlap.interface.JlapRepoInterface --|> conda.gateways.repodata.RepoInterface
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.notices.types.ChannelNoticeResultSet --|> typing.NamedTuple
conda.plugins.manager.CondaPluginManager --|> pluggy._manager.PluginManager
conda.plugins.types.CondaSolver --|> typing.NamedTuple
conda.plugins.types.CondaSubcommand --|> typing.NamedTuple
conda.plugins.types.CondaVirtualPackage --|> 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.Logger --|> logging.Filterer
logging.RootLogger --|> logging.Logger
logging.StreamHandler --|> logging.Handler
packaging.version.Version --|> packaging.version._BaseVersion
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
tqdm.asyncio.tqdm_asyncio --|> tqdm.std.tqdm
tqdm.auto.tqdm --|> tqdm.asyncio.tqdm_asyncio
tqdm.auto.tqdm --|> tqdm.notebook.tqdm_notebook
tqdm.auto.tqdm --|> tqdm.std.tqdm
tqdm.notebook.tqdm_notebook --|> tqdm.std.tqdm
tqdm.std.tqdm --|> tqdm.utils.Comparable
tqdm.utils.DisableOnWriteError --|> tqdm.utils.ObjectWrapper
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 --* 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 --* 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 : _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.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 : _fetch_threads
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _verify_threads
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _execute_threads
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _aggressive_update_packages
conda.common.configuration.ParameterLoader --* conda.base.context.Context : safety_checks
conda.common.configuration.ParameterLoader --* conda.base.context.Context : extra_safety_checks
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _signing_metadata_url_base
conda.common.configuration.ParameterLoader --* conda.base.context.Context : path_conflict
conda.common.configuration.ParameterLoader --* conda.base.context.Context : pinned_packages
conda.common.configuration.ParameterLoader --* conda.base.context.Context : disallowed_packages
conda.common.configuration.ParameterLoader --* conda.base.context.Context : rollback_enabled
conda.common.configuration.ParameterLoader --* conda.base.context.Context : track_features
conda.common.configuration.ParameterLoader --* conda.base.context.Context : use_index_cache
conda.common.configuration.ParameterLoader --* conda.base.context.Context : separate_format_cache
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _root_prefix
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _envs_dirs
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _pkgs_dirs
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _subdir
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _subdirs
conda.common.configuration.ParameterLoader --* conda.base.context.Context : local_repodata_ttl
conda.common.configuration.ParameterLoader --* conda.base.context.Context : ssl_verify
conda.common.configuration.ParameterLoader --* conda.base.context.Context : client_ssl_cert
conda.common.configuration.ParameterLoader --* conda.base.context.Context : client_ssl_cert_key
conda.common.configuration.ParameterLoader --* conda.base.context.Context : proxy_servers
conda.common.configuration.ParameterLoader --* conda.base.context.Context : remote_connect_timeout_secs
conda.common.configuration.ParameterLoader --* conda.base.context.Context : remote_read_timeout_secs
conda.common.configuration.ParameterLoader --* conda.base.context.Context : remote_max_retries
conda.common.configuration.ParameterLoader --* conda.base.context.Context : remote_backoff_factor
conda.common.configuration.ParameterLoader --* conda.base.context.Context : 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 : channel_settings
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _custom_channels
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _custom_multichannels
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _default_channels
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _migrated_channel_aliases
conda.common.configuration.ParameterLoader --* conda.base.context.Context : migrated_custom_channels
conda.common.configuration.ParameterLoader --* conda.base.context.Context : override_channels_enabled
conda.common.configuration.ParameterLoader --* conda.base.context.Context : show_channel_urls
conda.common.configuration.ParameterLoader --* conda.base.context.Context : use_local
conda.common.configuration.ParameterLoader --* conda.base.context.Context : allowlist_channels
conda.common.configuration.ParameterLoader --* conda.base.context.Context : restore_free_channel
conda.common.configuration.ParameterLoader --* conda.base.context.Context : repodata_fns
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _use_only_tar_bz2
conda.common.configuration.ParameterLoader --* conda.base.context.Context : always_softlink
conda.common.configuration.ParameterLoader --* conda.base.context.Context : always_copy
conda.common.configuration.ParameterLoader --* conda.base.context.Context : always_yes
conda.common.configuration.ParameterLoader --* conda.base.context.Context : debug
conda.common.configuration.ParameterLoader --* conda.base.context.Context : 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 : experimental
conda.common.configuration.ParameterLoader --* conda.base.context.Context : deps_modifier
conda.common.configuration.ParameterLoader --* conda.base.context.Context : update_modifier
conda.common.configuration.ParameterLoader --* conda.base.context.Context : sat_solver
conda.common.configuration.ParameterLoader --* conda.base.context.Context : solver_ignore_timestamps
conda.common.configuration.ParameterLoader --* conda.base.context.Context : solver
conda.common.configuration.ParameterLoader --* conda.base.context.Context : force_remove
conda.common.configuration.ParameterLoader --* conda.base.context.Context : force_reinstall
conda.common.configuration.ParameterLoader --* conda.base.context.Context : target_prefix_override
conda.common.configuration.ParameterLoader --* conda.base.context.Context : unsatisfiable_hints
conda.common.configuration.ParameterLoader --* conda.base.context.Context : unsatisfiable_hints_check_depth
conda.common.configuration.ParameterLoader --* conda.base.context.Context : bld_path
conda.common.configuration.ParameterLoader --* conda.base.context.Context : anaconda_upload
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _croot
conda.common.configuration.ParameterLoader --* conda.base.context.Context : _conda_build
conda.common.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 : verify_executor
conda.common.io.DummyExecutor --* conda.core.link.UnlinkLinkTransaction : execute_executor
conda.common.io.ThreadLimitedThreadPoolExecutor --* conda.core.link.UnlinkLinkTransaction : verify_executor
conda.common.io.ThreadLimitedThreadPoolExecutor --* conda.core.link.UnlinkLinkTransaction : execute_executor
conda.common.pkg_formats.python.PythonDistributionMetadata --* conda.common.pkg_formats.python.PythonDistribution : _metadata
conda.core.package_cache_data.ProgressiveFetchExtract --* conda.core.link.UnlinkLinkTransaction : _pfe
conda.core.package_cache_data.ProgressiveFetchExtract --* conda.core.link.UnlinkLinkTransaction : _pfe
conda.core.package_cache_data.UrlsData --* conda.core.package_cache_data.PackageCacheData : _urls_data
conda.core.solve.SolverStateContainer --* conda.core.solve.Solver : ssc
conda.core.subdir_data.PackageRecordList --* conda.core.subdir_data.SubdirData : _package_records
conda.gateways.connection.session.CondaHttpAuth --* conda.gateways.connection.session.CondaSession : auth
conda.gateways.repodata.CondaRepoInterface --* conda.core.subdir_data.SubdirData : RepoInterface
conda.gateways.repodata.RepodataState --* conda.gateways.repodata.RepodataCache : state
conda.models.channel.Channel --* conda.core.subdir_data.SubdirData : channel
conda.models.channel.Channel --* conda.gateways.repodata.RepodataFetch : channel
conda.models.channel.Channel --* conda.gateways.repodata.RepodataFetch : 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.CondaCLIFixture --* conda.testing.TmpEnvFixture : conda_cli
conda.testing.PathFactoryFixture --* conda.testing.TmpEnvFixture : path_factory
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.Logger --* conda.gateways.repodata.jlap.interface.JlapRepoInterface : _log
logging.Logger --* conda.gateways.repodata.jlap.interface.JlapRepoInterface : _stderrlog
logging.Manager --* logging.Logger : manager
logging.PercentStyle --* logging.Formatter : _style
logging.RootLogger --* conda.gateways.repodata.jlap.interface.JlapRepoInterface : _log
logging.RootLogger --* conda.gateways.repodata.jlap.interface.JlapRepoInterface : _stderrlog
packaging.version.Version --* conda.deprecations.DeprecationHandler : _version
packaging.version.Version --* conda.deprecations.DeprecationHandler : _version
packaging.version.Version --* conda.deprecations.DeprecationHandler : _version
packaging.version._Version --* packaging.version.Version : _version
pathlib.Path --* conda.gateways.repodata.RepodataCache : cache_dir
pathlib.Path --* conda.gateways.repodata.RepodataFetch : cache_path_base
pathlib.Path --* conda.gateways.repodata.RepodataFetch : cache_path_base
pathlib.Path --* conda.gateways.repodata.RepodataState : cache_path_json
pathlib.Path --* conda.gateways.repodata.RepodataState : cache_path_state
pathlib.Path --* conda.gateways.repodata.jlap.interface.JlapRepoInterface : _cache_path_json
pathlib.Path --* conda.gateways.repodata.jlap.interface.JlapRepoInterface : _cache_path_state
pathlib.Path --* conda.testing.PathFactoryFixture : tmp_path
pathlib.Path --* conda.testing.solver_helpers.SimpleEnvironment : _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
pluggy._hooks._HookRelay --* pluggy._manager.PluginManager : hook
pluggy._tracing.TagTracerSub --* pluggy._manager.PluginManager : trace
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 --* concurrent.futures.thread.ThreadPoolExecutor : _idle_semaphore
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
tqdm.asyncio.tqdm_asyncio --* conda.common.io.ProgressBar : pbar
tqdm.auto.tqdm --* conda.common.io.ProgressBar : pbar
tqdm.notebook.TqdmHBox --* tqdm.notebook.tqdm_notebook : container
tqdm.std.EMA --* tqdm.std.tqdm : _ema_dn
tqdm.std.EMA --* tqdm.std.tqdm : _ema_dn
tqdm.std.EMA --* tqdm.std.tqdm : _ema_dt
tqdm.std.EMA --* tqdm.std.tqdm : _ema_dt
tqdm.std.EMA --* tqdm.std.tqdm : _ema_miniters
tqdm.std.EMA --* tqdm.std.tqdm : _ema_miniters
tqdm.utils.DisableOnWriteError --* tqdm.std.tqdm : fp
typing.Tuple --* packaging.version.Version : _key
unittest.case._Outcome --* unittest.case.TestCase : _outcome
unittest.case._SubTest --* unittest.case.TestCase : _subtest
unittest.case._SubTest --* unittest.case.TestCase : _subtest
@enduml](../_images/plantuml-23d16c8929a89c1833688a8f353631024a370ee5.svg)