def get_info():
from StringIO import StringIO
from contextlib import contextmanager
from conda.cli import conda_argparse
from conda.cli.main_info import configure_parser
class CapturedText(object):
pass
@contextmanager
def captured():
stdout, stderr = sys.stdout, sys.stderr
sys.stdout = outfile = StringIO()
sys.stderr = errfile = StringIO()
c = CapturedText()
yield c
c.stdout, c.stderr = outfile.getvalue(), errfile.getvalue()
sys.stdout, sys.stderr = stdout, stderr
p = conda_argparse.ArgumentParser()
sub_parsers = p.add_subparsers(metavar='command', dest='cmd')
configure_parser(sub_parsers)
from shlex import split
args = p.parse_args(split("info"))
with captured() as c:
args.func(args, p)
return c.stdout, c.stderr
def get_info():
from conda.cli import conda_argparse
from conda.cli.main_info import configure_parser
from shlex import split
from conda.common.io import captured
p = conda_argparse.ArgumentParser()
sub_parsers = p.add_subparsers(metavar='command', dest='cmd')
configure_parser(sub_parsers)
args = p.parse_args(split("info"))
with captured() as c:
args.func(args, p)
return c.stdout, c.stderr
def get_info():
from conda.cli import conda_argparse
from conda.cli.main_info import configure_parser
from shlex import split
from conda.common.io import captured
p = conda_argparse.ArgumentParser()
sub_parsers = p.add_subparsers(metavar='command', dest='cmd')
configure_parser(sub_parsers)
args = p.parse_args(split("info"))
with captured() as c:
args.func(args, p)
return c.stdout, c.stderr
def main():
if len(sys.argv) > 1:
argv1 = sys.argv[1]
if argv1 in ('..activate', '..deactivate', '..checkenv'):
import conda.cli.activate as activate
activate.main()
return
if argv1 in ('..changeps1'):
import conda.cli.misc as misc
misc.main()
return
if argv1 == 'pip':
sys.exit("""ERROR:
The "conda pip" command has been removed from conda (as of version 1.8) for
the following reasons:
* users get the wrong impression that you *must* use conda pip (instead
of simply pip) when using Anaconda
* there should only be one preferred way to build packages, and that is
the conda build command
* the command did too many things at once, i.e. build a package and
then also install it
* the command is Python centric, whereas conda (from a package management
perspective) is Python agnostic
* packages created with conda pip are not robust, i.e. they will maybe
not work on other people's systems
In short:
* use "conda build" if you want to build a conda package
* use "conda install" if you want to install something
* use "pip" if you want to install something that is on PyPI for which there
isn't a conda package.
""")
if argv1 in ('activate', 'deactivate'):
sys.stderr.write("Error: '%s' is not a conda command.\n" % argv1)
if sys.platform != 'win32':
sys.stderr.write('Did you mean "source %s" ?\n' %
' '.join(sys.argv[1:]))
sys.exit(1)
# for backwards compatibility of conda-api
if sys.argv[1:4] == ['share', '--json', '--prefix']:
import json
from os.path import abspath
from conda.builder.share import old_create_bundle
prefix = sys.argv[4]
path, warnings = old_create_bundle(abspath(prefix))
json.dump(dict(path=path, warnings=warnings),
sys.stdout, indent=2, sort_keys=True)
return
if sys.argv[1:4] == ['clone', '--json', '--prefix']:
import json
from os.path import abspath
from conda.builder.share import old_clone_bundle
prefix, path = sys.argv[4:6]
old_clone_bundle(path, abspath(prefix))
json.dump(dict(warnings=[]), sys.stdout, indent=2)
return
if len(sys.argv) == 1:
sys.argv.append('-h')
import logging
import conda
p = conda_argparse.ArgumentParser(
description='conda is a tool for managing environments and packages.'
)
p.add_argument(
'-V', '--version',
action = 'version',
version = 'conda %s' % conda.__version__,
)
p.add_argument(
"--debug",
action = "store_true",
help = argparse.SUPPRESS,
)
sub_parsers = p.add_subparsers(
metavar = 'command',
dest = 'cmd',
)
main_info.configure_parser(sub_parsers)
main_help.configure_parser(sub_parsers)
main_list.configure_parser(sub_parsers)
main_search.configure_parser(sub_parsers)
main_create.configure_parser(sub_parsers)
main_install.configure_parser(sub_parsers)
main_update.configure_parser(sub_parsers)
main_remove.configure_parser(sub_parsers)
main_config.configure_parser(sub_parsers)
main_init.configure_parser(sub_parsers)
main_clean.configure_parser(sub_parsers)
main_build.configure_parser(sub_parsers)
main_skeleton.configure_parser(sub_parsers)
main_package.configure_parser(sub_parsers)
main_bundle.configure_parser(sub_parsers)
main_index.configure_parser(sub_parsers)
try:
import argcomplete
argcomplete.autocomplete(p)
except ImportError:
pass
except AttributeError:
# On Python 3.3, argcomplete can be an empty namespace package when
# argcomplete is not installed. Not sure why, but this fixes it.
pass
args = p.parse_args()
if args.debug:
logging.basicConfig(level=logging.DEBUG)
if (not main_init.is_initialized() and
'init' not in sys.argv and 'info' not in sys.argv):
sys.exit("Error: conda is not initalized yet, try: conda init")
try:
args.func(args, p)
except RuntimeError as e:
sys.exit("Error: %s" % e)
except Exception as e:
if e.__class__.__name__ not in ('ScannerError', 'ParserError'):
print("""\
An unexpected error has occurred, please consider sending the
following traceback to the conda GitHub issue tracker at:
https://github.com/ContinuumIO/conda/issues
Include the output of the command 'conda info' in your report.
""")
raise # as if we did not catch it
def main():
if len(sys.argv) > 1:
argv1 = sys.argv[1]
if argv1 in ('..activate', '..deactivate', '..activateroot',
'..checkenv'):
import conda.cli.activate as activate
activate.main()
return
if argv1 in ('..changeps1'):
import conda.cli.misc as misc
misc.main()
return
if argv1 == 'pip':
sys.exit("""ERROR:
The "conda pip" command has been removed from conda (as of version 1.8) for
the following reasons:
* users get the wrong impression that you *must* use conda pip (instead
of simply pip) when using Anaconda
* there should only be one preferred way to build packages, and that is
the conda build command
* the command did too many things at once, i.e. build a package and
then also install it
* the command is Python centric, whereas conda (from a package management
perspective) is Python agnostic
* packages created with conda pip are not robust, i.e. they will maybe
not work on other people's systems
In short:
* use "conda build" if you want to build a conda package
* use "conda install" if you want to install something
* use "pip" if you want to install something that is on PyPI for which there
isn't a conda package.
""")
if argv1 in ('activate', 'deactivate'):
sys.stderr.write("Error: '%s' is not a conda command.\n" % argv1)
if sys.platform != 'win32':
sys.stderr.write('Did you mean "source %s" ?\n' %
' '.join(sys.argv[1:]))
sys.exit(1)
# for backwards compatibility of conda-api
if sys.argv[1:4] == ['share', '--json', '--prefix']:
import json
from os.path import abspath
from conda.share import old_create_bundle
prefix = sys.argv[4]
path, warnings = old_create_bundle(abspath(prefix))
json.dump(dict(path=path, warnings=warnings),
sys.stdout,
indent=2,
sort_keys=True)
return
if sys.argv[1:4] == ['clone', '--json', '--prefix']:
import json
from os.path import abspath
from conda.share import old_clone_bundle
prefix, path = sys.argv[4:6]
old_clone_bundle(path, abspath(prefix))
json.dump(dict(warnings=[]), sys.stdout, indent=2)
return
if len(sys.argv) == 1:
sys.argv.append('-h')
import logging
import conda
p = conda_argparse.ArgumentParser(
description='conda is a tool for managing environments and packages.')
p.add_argument(
'-V',
'--version',
action='version',
version='conda %s' % conda.__version__,
)
p.add_argument(
"--debug",
action="store_true",
help=argparse.SUPPRESS,
)
p.add_argument(
"--json",
action="store_true",
help=argparse.SUPPRESS,
)
sub_parsers = p.add_subparsers(
metavar='command',
dest='cmd',
)
main_info.configure_parser(sub_parsers)
main_help.configure_parser(sub_parsers)
main_list.configure_parser(sub_parsers)
main_search.configure_parser(sub_parsers)
main_create.configure_parser(sub_parsers)
main_install.configure_parser(sub_parsers)
main_update.configure_parser(sub_parsers)
main_remove.configure_parser(sub_parsers)
main_run.configure_parser(sub_parsers)
main_config.configure_parser(sub_parsers)
main_init.configure_parser(sub_parsers)
main_clean.configure_parser(sub_parsers)
main_package.configure_parser(sub_parsers)
main_bundle.configure_parser(sub_parsers)
try:
import argcomplete
argcomplete.autocomplete(p)
except ImportError:
pass
except AttributeError:
# On Python 3.3, argcomplete can be an empty namespace package when
# we are in the conda-recipes directory.
pass
args = p.parse_args()
if getattr(args, 'json', False):
# Silence logging info to avoid interfering with JSON output
import logging
for logger in logging.Logger.manager.loggerDict:
if logger not in ('fetch', 'progress'):
logging.getLogger(logger).setLevel(logging.CRITICAL + 1)
if args.debug:
logging.disable(logging.NOTSET)
logging.basicConfig(level=logging.DEBUG)
if (not main_init.is_initialized() and 'init' not in sys.argv
and 'info' not in sys.argv):
if hasattr(args, 'name') and hasattr(args, 'prefix'):
import conda.config as config
if common.get_prefix(args) == config.root_dir:
sys.exit("""\
Error: This installation of conda is not initialized. Use 'conda create -n
envname' to create a conda environment and 'source activate envname' to
activate it.
# Note that pip installing conda is not the recommended way for setting up your
# system. The recommended way for setting up a conda system is by installing
# Miniconda, see: http://repo.continuum.io/miniconda/index.html""")
args_func(args, p)
def main():
if len(sys.argv) > 1:
if sys.argv[1] in ('..activate', '..deactivate', '..checkenv'):
import conda.cli.activate as activate
activate.main()
return
if sys.argv[1] in ('..changeps1'):
import conda.cli.misc as misc
misc.main()
return
if sys.argv[1] == 'pip':
sys.exit("""ERROR:
The "conda pip" command has been removed from conda version 1.8 for the
following reasons:
* users get the wrong impression that you *must* use conda pip (instead
of simply pip) when using Anaconda
* there should only be one preferred way to build packages, and that is
the conda build command
* the command did too many things at once, i.e. build a package and
then also install it
* the command is Python centric, whereas conda (from a package management
perspective) is Python agnostic
* packages created with conda pip are not robust, i.e. they will maybe
not work on other people's systems
In short:
* use "conda build" if you want to build a conda package
* use "conda install" if you want to install something
* use "pip" if you want to install something that is on PyPI for which there
isn't a conda package.
""")
if len(sys.argv) == 1:
sys.argv.append('-h')
import logging
import conda
p = conda_argparse.ArgumentParser(
description='conda is a tool for managing environments and packages.'
)
p.add_argument(
'-V', '--version',
action = 'version',
version = 'conda %s' % conda.__version__,
)
p.add_argument(
"--debug",
action = "store_true",
help = argparse.SUPPRESS,
)
sub_parsers = p.add_subparsers(
metavar = 'command',
dest = 'cmd',
)
main_info.configure_parser(sub_parsers)
main_help.configure_parser(sub_parsers)
main_list.configure_parser(sub_parsers)
main_search.configure_parser(sub_parsers)
main_create.configure_parser(sub_parsers)
main_install.configure_parser(sub_parsers)
main_update.configure_parser(sub_parsers)
main_remove.configure_parser(sub_parsers)
main_config.configure_parser(sub_parsers)
main_clean.configure_parser(sub_parsers)
main_build.configure_parser(sub_parsers)
main_skeleton.configure_parser(sub_parsers)
main_package.configure_parser(sub_parsers)
main_index.configure_parser(sub_parsers)
try:
import argcomplete
argcomplete.autocomplete(p)
except ImportError:
pass
except AttributeError:
# On Python 3.3, argcomplete can be an empty namespace package when
# argcomplete is not installed. Not sure why, but this fixes it.
pass
args = p.parse_args()
if args.debug:
logging.basicConfig(level=logging.DEBUG)
try:
args.func(args, p)
except RuntimeError as e:
sys.exit("Error: %s" % e)
except Exception as e:
if e.__class__.__name__ not in ('ScannerError', 'ParserError'):
print("""\
An unexpected error has occurred, please consider sending the
following traceback to the conda GitHub issue tracker at:
https://github.com/ContinuumIO/conda/issues
Include the output of the command 'conda info' in your report.
""")
raise # as if we did not catch it
def main():
if len(sys.argv) > 1:
argv1 = sys.argv[1]
if argv1 in ('..activate', '..deactivate', '..activateroot', '..checkenv'):
import conda.cli.activate as activate
activate.main()
return
if argv1 in ('..changeps1'):
import conda.cli.misc as misc
misc.main()
return
if argv1 == 'pip':
sys.exit("""ERROR:
The "conda pip" command has been removed from conda (as of version 1.8) for
the following reasons:
* users get the wrong impression that you *must* use conda pip (instead
of simply pip) when using Anaconda
* there should only be one preferred way to build packages, and that is
the conda build command
* the command did too many things at once, i.e. build a package and
then also install it
* the command is Python centric, whereas conda (from a package management
perspective) is Python agnostic
* packages created with conda pip are not robust, i.e. they will maybe
not work on other people's systems
In short:
* use "conda build" if you want to build a conda package
* use "conda install" if you want to install something
* use "pip" if you want to install something that is on PyPI for which there
isn't a conda package.
""")
if argv1 in ('activate', 'deactivate'):
sys.stderr.write("Error: '%s' is not a conda command.\n" % argv1)
if sys.platform != 'win32':
sys.stderr.write('Did you mean "source %s" ?\n' %
' '.join(sys.argv[1:]))
sys.exit(1)
# for backwards compatibility of conda-api
if sys.argv[1:4] == ['share', '--json', '--prefix']:
import json
from os.path import abspath
from conda.share import old_create_bundle
prefix = sys.argv[4]
path, warnings = old_create_bundle(abspath(prefix))
json.dump(dict(path=path, warnings=warnings),
sys.stdout, indent=2, sort_keys=True)
return
if sys.argv[1:4] == ['clone', '--json', '--prefix']:
import json
from os.path import abspath
from conda.share import old_clone_bundle
prefix, path = sys.argv[4:6]
old_clone_bundle(path, abspath(prefix))
json.dump(dict(warnings=[]), sys.stdout, indent=2)
return
if len(sys.argv) == 1:
sys.argv.append('-h')
import logging
import conda
p = conda_argparse.ArgumentParser(
description='conda is a tool for managing environments and packages.'
)
p.add_argument(
'-V', '--version',
action = 'version',
version = 'conda %s' % conda.__version__,
)
p.add_argument(
"--debug",
action = "store_true",
help = argparse.SUPPRESS,
)
p.add_argument(
"--json",
action = "store_true",
help = argparse.SUPPRESS,
)
sub_parsers = p.add_subparsers(
metavar = 'command',
dest = 'cmd',
)
main_info.configure_parser(sub_parsers)
main_help.configure_parser(sub_parsers)
main_list.configure_parser(sub_parsers)
main_search.configure_parser(sub_parsers)
main_create.configure_parser(sub_parsers)
main_install.configure_parser(sub_parsers)
main_update.configure_parser(sub_parsers)
main_remove.configure_parser(sub_parsers)
main_run.configure_parser(sub_parsers)
main_config.configure_parser(sub_parsers)
main_init.configure_parser(sub_parsers)
main_clean.configure_parser(sub_parsers)
main_package.configure_parser(sub_parsers)
main_bundle.configure_parser(sub_parsers)
try:
import argcomplete
argcomplete.autocomplete(p)
except ImportError:
pass
except AttributeError:
# On Python 3.3, argcomplete can be an empty namespace package when
# we are in the conda-recipes directory.
pass
args = p.parse_args()
if getattr(args, 'json', False):
# Silence logging info to avoid interfering with JSON output
import logging
for logger in logging.Logger.manager.loggerDict:
if logger not in ('fetch', 'progress'):
logging.getLogger(logger).setLevel(logging.CRITICAL + 1)
if args.debug:
logging.disable(logging.NOTSET)
logging.basicConfig(level=logging.DEBUG)
if (not main_init.is_initialized() and
'init' not in sys.argv and 'info' not in sys.argv):
sys.exit("""Error: conda is not initialized yet, try: conda init
# Note that initializing conda is not the recommended way for setting up your
# system. The recommended way for setting up a conda system is by installing
# Miniconda, see: http://repo.continuum.io/miniconda/index.html""")
args_func(args, p)
def main():
if len(sys.argv) > 1:
argv1 = sys.argv[1]
if argv1 in ('..activate', '..deactivate', '..activateroot', '..checkenv'):
import conda.cli.activate as activate
activate.main()
return
if argv1 in ('..changeps1'):
import conda.cli.misc as misc
misc.main()
return
if argv1 == 'pip':
sys.exit("""ERROR:
The "conda pip" command has been removed from conda (as of version 1.8) for
the following reasons:
* users get the wrong impression that you *must* use conda pip (instead
of simply pip) when using Anaconda
* there should only be one preferred way to build packages, and that is
the conda build command
* the command did too many things at once, i.e. build a package and
then also install it
* the command is Python centric, whereas conda (from a package management
perspective) is Python agnostic
* packages created with conda pip are not robust, i.e. they will maybe
not work on other people's systems
In short:
* use "conda build" if you want to build a conda package
* use "conda install" if you want to install something
* use "pip" if you want to install something that is on PyPI for which there
isn't a conda package.
""")
if argv1 in ('activate', 'deactivate'):
sys.stderr.write("Error: '%s' is not a conda command.\n" % argv1)
if sys.platform != 'win32':
sys.stderr.write('Did you mean "source %s" ?\n' %
' '.join(sys.argv[1:]))
sys.exit(1)
# for backwards compatibility of conda-api
if sys.argv[1:4] == ['share', '--json', '--prefix']:
import json
from os.path import abspath
from conda.share import old_create_bundle
prefix = sys.argv[4]
path, warnings = old_create_bundle(abspath(prefix))
json.dump(dict(path=path, warnings=warnings),
sys.stdout, indent=2, sort_keys=True)
return
if sys.argv[1:4] == ['clone', '--json', '--prefix']:
import json
from os.path import abspath
from conda.share import old_clone_bundle
prefix, path = sys.argv[4:6]
old_clone_bundle(path, abspath(prefix))
json.dump(dict(warnings=[]), sys.stdout, indent=2)
return
if len(sys.argv) == 1:
sys.argv.append('-h')
import logging
import conda
p = conda_argparse.ArgumentParser(
description='conda is a tool for managing environments and packages.'
)
p.add_argument(
'-V', '--version',
action = 'version',
version = 'conda %s' % conda.__version__,
)
p.add_argument(
"--debug",
action = "store_true",
help = argparse.SUPPRESS,
)
sub_parsers = p.add_subparsers(
metavar = 'command',
dest = 'cmd',
)
main_info.configure_parser(sub_parsers)
main_help.configure_parser(sub_parsers)
main_list.configure_parser(sub_parsers)
main_search.configure_parser(sub_parsers)
main_create.configure_parser(sub_parsers)
main_install.configure_parser(sub_parsers)
main_update.configure_parser(sub_parsers)
main_remove.configure_parser(sub_parsers)
main_config.configure_parser(sub_parsers)
main_init.configure_parser(sub_parsers)
main_clean.configure_parser(sub_parsers)
main_package.configure_parser(sub_parsers)
main_bundle.configure_parser(sub_parsers)
try:
import argcomplete
argcomplete.autocomplete(p)
except ImportError:
pass
except AttributeError:
# On Python 3.3, argcomplete can be an empty namespace package when
# we are in the conda-recipes directory.
pass
args = p.parse_args()
if args.debug:
logging.basicConfig(level=logging.DEBUG)
if (not main_init.is_initialized() and
'init' not in sys.argv and 'info' not in sys.argv):
sys.exit("""Error: conda is not initialized yet, try: conda init
# Note that initializing conda is not the recommended way for setting up your
# system. The recommended way for setting up a conda system is by installing
# Miniconda, see: http://repo.continuum.io/miniconda/index.html""")
try:
args.func(args, p)
except RuntimeError as e:
sys.exit("Error: %s" % e)
except Exception as e:
if e.__class__.__name__ not in ('ScannerError', 'ParserError'):
print("""\
An unexpected error has occurred, please consider sending the
following traceback to the conda GitHub issue tracker at:
https://github.com/conda/conda/issues
Include the output of the command 'conda info' in your report.
""")
raise # as if we did not catch it
def main():
if len(sys.argv) > 1 and sys.argv[1] in ('..activate', '..deactivate', '..changeps1'):
import conda.cli.activate as activate
activate.main()
return
if len(sys.argv) == 1:
sys.argv.append('-h')
import logging
import conda
p = conda_argparse.ArgumentParser(
description='conda is a tool for managing environments and packages.'
)
p.add_argument(
'-V', '--version',
action = 'version',
version = 'conda %s' % conda.__version__,
)
p.add_argument(
"--debug",
action = "store_true",
help = argparse.SUPPRESS,
)
sub_parsers = p.add_subparsers(
metavar = 'command',
dest = 'cmd',
)
main_info.configure_parser(sub_parsers)
main_help.configure_parser(sub_parsers)
main_list.configure_parser(sub_parsers)
main_search.configure_parser(sub_parsers)
main_create.configure_parser(sub_parsers)
main_install.configure_parser(sub_parsers)
main_update.configure_parser(sub_parsers)
main_remove.configure_parser(sub_parsers)
main_package.configure_parser(sub_parsers)
main_pip.configure_parser(sub_parsers)
main_skeleton.configure_parser(sub_parsers)
main_share.configure_parser(sub_parsers)
main_clone.configure_parser(sub_parsers)
main_build.configure_parser(sub_parsers)
main_index.configure_parser(sub_parsers)
main_config.configure_parser(sub_parsers)
args = p.parse_args()
if args.debug:
logging.basicConfig(level=logging.DEBUG)
try:
args.func(args, p)
except RuntimeError as e:
sys.exit(filldedent("Error: %s" % e))
except Exception as e:
if e.__class__.__name__ not in ('ScannerError', 'ParserError'):
print("""\
An unexpected error has occurred, please consider sending the
following traceback to the conda GitHub issue tracker at:
https://github.com/ContinuumIO/conda/issues"
""")
raise # as if we did not catch it
def main():
if len(sys.argv) > 1:
argv1 = sys.argv[1]
if argv1 in ('..activate', '..deactivate', '..activateroot',
'..checkenv'):
import conda.cli.activate as activate
activate.main()
return
if argv1 in ('..changeps1'):
import conda.cli.misc as misc
misc.main()
return
if argv1 in ('activate', 'deactivate'):
sys.stderr.write("Error: '%s' is not a conda command.\n" % argv1)
if sys.platform != 'win32':
sys.stderr.write('Did you mean "source %s" ?\n' %
' '.join(sys.argv[1:]))
sys.exit(1)
# for backwards compatibility of conda-api
if sys.argv[1:4] == ['share', '--json', '--prefix']:
import json
from os.path import abspath
from conda.share import old_create_bundle
prefix = sys.argv[4]
path, warnings = old_create_bundle(abspath(prefix))
json.dump(dict(path=path, warnings=warnings),
sys.stdout,
indent=2,
sort_keys=True)
return
if sys.argv[1:4] == ['clone', '--json', '--prefix']:
import json
from os.path import abspath
from conda.share import old_clone_bundle
prefix, path = sys.argv[4:6]
old_clone_bundle(path, abspath(prefix))
json.dump(dict(warnings=[]), sys.stdout, indent=2)
return
if len(sys.argv) == 1:
sys.argv.append('-h')
import logging
from conda.cli import conda_argparse
import argparse
import conda
p = conda_argparse.ArgumentParser(
description=
'conda is a tool for managing and deploying applications, environments and packages.'
)
p.add_argument('-V',
'--version',
action='version',
version='conda %s' % conda.__version__,
help="Show the conda version number and exit.")
p.add_argument("--debug", action="store_true", help="Show debug output.")
p.add_argument(
"--json",
action="store_true",
help=argparse.SUPPRESS,
)
sub_parsers = p.add_subparsers(
metavar='command',
dest='cmd',
)
from conda.cli import main_info
main_info.configure_parser(sub_parsers)
from conda.cli import main_help
main_help.configure_parser(sub_parsers)
from conda.cli import main_list
main_list.configure_parser(sub_parsers)
from conda.cli import main_search
main_search.configure_parser(sub_parsers)
from conda.cli import main_create
main_create.configure_parser(sub_parsers)
from conda.cli import main_install
main_install.configure_parser(sub_parsers)
from conda.cli import main_update
main_update.configure_parser(sub_parsers)
main_update.configure_parser(sub_parsers, name='upgrade')
from conda.cli import main_remove
main_remove.configure_parser(sub_parsers)
main_remove.configure_parser(sub_parsers, name='uninstall')
from conda.cli import main_run
main_run.configure_parser(sub_parsers)
from conda.cli import main_config
main_config.configure_parser(sub_parsers)
from conda.cli import main_init
main_init.configure_parser(sub_parsers)
from conda.cli import main_clean
main_clean.configure_parser(sub_parsers)
from conda.cli import main_package
main_package.configure_parser(sub_parsers)
from conda.cli import main_bundle
main_bundle.configure_parser(sub_parsers)
from conda.cli.find_commands import find_commands
sub_parsers.completer = lambda prefix, **kwargs: [
i for i in list(sub_parsers.choices) + find_commands()
if i.startswith(prefix)
]
args = p.parse_args()
if getattr(args, 'json', False):
# Silence logging info to avoid interfering with JSON output
for logger in logging.Logger.manager.loggerDict:
if logger not in ('fetch', 'progress'):
logging.getLogger(logger).setLevel(logging.CRITICAL + 1)
if args.debug:
logging.disable(logging.NOTSET)
logging.basicConfig(level=logging.DEBUG)
if (not main_init.is_initialized() and 'init' not in sys.argv
and 'info' not in sys.argv):
if hasattr(args, 'name') and hasattr(args, 'prefix'):
import conda.config as config
from conda.cli import common
if common.get_prefix(args) == config.root_dir:
sys.exit("""\
Error: This installation of conda is not initialized. Use 'conda create -n
envname' to create a conda environment and 'source activate envname' to
activate it.
# Note that pip installing conda is not the recommended way for setting up your
# system. The recommended way for setting up a conda system is by installing
# Miniconda, see: http://repo.continuum.io/miniconda/index.html""")
args_func(args, p)
def main():
if len(sys.argv) > 1:
argv1 = sys.argv[1]
if argv1 in ('..activate', '..deactivate',
'..activateroot', '..checkenv'):
import conda.cli.activate as activate
activate.main()
return
if argv1 in ('..changeps1'):
import conda.cli.misc as misc
misc.main()
return
if argv1 in ('activate', 'deactivate'):
sys.stderr.write("Error: '%s' is not a conda command.\n" % argv1)
if sys.platform != 'win32':
sys.stderr.write('Did you mean "source %s" ?\n' %
' '.join(sys.argv[1:]))
sys.exit(1)
if len(sys.argv) == 1:
sys.argv.append('-h')
import logging
from conda.cli import conda_argparse
import argparse
import conda
p = conda_argparse.ArgumentParser(
description='conda is a tool for managing and deploying applications, environments and packages.'
)
p.add_argument(
'-V', '--version',
action='version',
version='conda %s' % conda.__version__,
help="Show the conda version number and exit."
)
p.add_argument(
"--debug",
action = "store_true",
help = "Show debug output."
)
p.add_argument(
"--json",
action = "store_true",
help = argparse.SUPPRESS,
)
sub_parsers = p.add_subparsers(
metavar = 'command',
dest = 'cmd',
)
from conda.cli import main_info
main_info.configure_parser(sub_parsers)
from conda.cli import main_help
main_help.configure_parser(sub_parsers)
from conda.cli import main_list
main_list.configure_parser(sub_parsers)
from conda.cli import main_search
main_search.configure_parser(sub_parsers)
from conda.cli import main_create
main_create.configure_parser(sub_parsers)
from conda.cli import main_install
main_install.configure_parser(sub_parsers)
from conda.cli import main_update
main_update.configure_parser(sub_parsers)
main_update.configure_parser(sub_parsers, name='upgrade')
from conda.cli import main_remove
main_remove.configure_parser(sub_parsers)
main_remove.configure_parser(sub_parsers, name='uninstall')
from conda.cli import main_run
main_run.configure_parser(sub_parsers)
from conda.cli import main_config
main_config.configure_parser(sub_parsers)
from conda.cli import main_init
main_init.configure_parser(sub_parsers)
from conda.cli import main_clean
main_clean.configure_parser(sub_parsers)
from conda.cli import main_package
main_package.configure_parser(sub_parsers)
from conda.cli import main_bundle
main_bundle.configure_parser(sub_parsers)
from conda.cli.find_commands import find_commands
sub_parsers.completer = lambda prefix, **kwargs: [i for i in
list(sub_parsers.choices) + find_commands() if i.startswith(prefix)]
args = p.parse_args()
if getattr(args, 'json', False):
# Silence logging info to avoid interfering with JSON output
for logger in logging.Logger.manager.loggerDict:
if logger not in ('fetch', 'progress'):
logging.getLogger(logger).setLevel(logging.CRITICAL + 1)
if args.debug:
logging.disable(logging.NOTSET)
logging.basicConfig(level=logging.DEBUG)
args_func(args, p)
def main():
if len(sys.argv) > 1:
argv1 = sys.argv[1]
if argv1 in ('..activate', '..deactivate',
'..activateroot', '..checkenv'):
import conda.cli.activate as activate
activate.main()
return
if argv1 in ('..changeps1'):
import conda.cli.misc as misc
misc.main()
return
if argv1 in ('activate', 'deactivate'):
sys.stderr.write("Error: '%s' is not a conda command.\n" % argv1)
if sys.platform != 'win32':
sys.stderr.write('Did you mean "source %s" ?\n' %
' '.join(sys.argv[1:]))
sys.exit(1)
# for backwards compatibility of conda-api
if sys.argv[1:4] == ['share', '--json', '--prefix']:
import json
from os.path import abspath
from conda.share import old_create_bundle
prefix = sys.argv[4]
path, warnings = old_create_bundle(abspath(prefix))
json.dump(dict(path=path, warnings=warnings),
sys.stdout, indent=2, sort_keys=True)
return
if sys.argv[1:4] == ['clone', '--json', '--prefix']:
import json
from os.path import abspath
from conda.share import old_clone_bundle
prefix, path = sys.argv[4:6]
old_clone_bundle(path, abspath(prefix))
json.dump(dict(warnings=[]), sys.stdout, indent=2)
return
if len(sys.argv) == 1:
sys.argv.append('-h')
import logging
from conda.cli import conda_argparse
import argparse
import conda
p = conda_argparse.ArgumentParser(
description='conda is a tool for managing and deploying applications, environments and packages.'
)
p.add_argument(
'-V', '--version',
action='version',
version='conda %s' % conda.__version__,
help="Show the conda version number and exit."
)
p.add_argument(
"--debug",
action = "store_true",
help = "Show debug output."
)
p.add_argument(
"--json",
action = "store_true",
help = argparse.SUPPRESS,
)
sub_parsers = p.add_subparsers(
metavar = 'command',
dest = 'cmd',
)
from conda.cli import main_info
main_info.configure_parser(sub_parsers)
from conda.cli import main_help
main_help.configure_parser(sub_parsers)
from conda.cli import main_list
main_list.configure_parser(sub_parsers)
from conda.cli import main_search
main_search.configure_parser(sub_parsers)
from conda.cli import main_create
main_create.configure_parser(sub_parsers)
from conda.cli import main_install
main_install.configure_parser(sub_parsers)
from conda.cli import main_update
main_update.configure_parser(sub_parsers)
main_update.configure_parser(sub_parsers, name='upgrade')
from conda.cli import main_remove
main_remove.configure_parser(sub_parsers)
main_remove.configure_parser(sub_parsers, name='uninstall')
from conda.cli import main_run
main_run.configure_parser(sub_parsers)
from conda.cli import main_config
main_config.configure_parser(sub_parsers)
from conda.cli import main_init
main_init.configure_parser(sub_parsers)
from conda.cli import main_clean
main_clean.configure_parser(sub_parsers)
from conda.cli import main_package
main_package.configure_parser(sub_parsers)
from conda.cli import main_bundle
main_bundle.configure_parser(sub_parsers)
from conda.cli.find_commands import find_commands
sub_parsers.completer = lambda prefix, **kwargs: [i for i in
list(sub_parsers.choices) + find_commands() if i.startswith(prefix)]
args = p.parse_args()
if getattr(args, 'json', False):
# Silence logging info to avoid interfering with JSON output
for logger in logging.Logger.manager.loggerDict:
if logger not in ('fetch', 'progress'):
logging.getLogger(logger).setLevel(logging.CRITICAL + 1)
if args.debug:
logging.disable(logging.NOTSET)
logging.basicConfig(level=logging.DEBUG)
if (not main_init.is_initialized() and
'init' not in sys.argv and 'info' not in sys.argv):
if hasattr(args, 'name') and hasattr(args, 'prefix'):
import conda.config as config
from conda.cli import common
if common.get_prefix(args) == config.root_dir:
sys.exit("""\
Error: This installation of conda is not initialized. Use 'conda create -n
envname' to create a conda environment and 'source activate envname' to
activate it.
# Note that pip installing conda is not the recommended way for setting up your
# system. The recommended way for setting up a conda system is by installing
# Miniconda, see: http://repo.continuum.io/miniconda/index.html""")
args_func(args, p)
def main():
if len(sys.argv) > 1:
argv1 = sys.argv[1]
if argv1 in ("..activate", "..deactivate", "..activateroot", "..checkenv"):
import conda.cli.activate as activate
activate.main()
return
if argv1 in ("..changeps1"):
import conda.cli.misc as misc
misc.main()
return
if argv1 == "pip":
sys.exit(
"""ERROR:
The "conda pip" command has been removed from conda (as of version 1.8) for
the following reasons:
* users get the wrong impression that you *must* use conda pip (instead
of simply pip) when using Anaconda
* there should only be one preferred way to build packages, and that is
the conda build command
* the command did too many things at once, i.e. build a package and
then also install it
* the command is Python centric, whereas conda (from a package management
perspective) is Python agnostic
* packages created with conda pip are not robust, i.e. they will maybe
not work on other people's systems
In short:
* use "conda build" if you want to build a conda package
* use "conda install" if you want to install something
* use "pip" if you want to install something that is on PyPI for which there
isn't a conda package.
"""
)
if argv1 in ("activate", "deactivate"):
sys.stderr.write("Error: '%s' is not a conda command.\n" % argv1)
if sys.platform != "win32":
sys.stderr.write('Did you mean "source %s" ?\n' % " ".join(sys.argv[1:]))
sys.exit(1)
# for backwards compatibility of conda-api
if sys.argv[1:4] == ["share", "--json", "--prefix"]:
import json
from os.path import abspath
from conda.share import old_create_bundle
prefix = sys.argv[4]
path, warnings = old_create_bundle(abspath(prefix))
json.dump(dict(path=path, warnings=warnings), sys.stdout, indent=2, sort_keys=True)
return
if sys.argv[1:4] == ["clone", "--json", "--prefix"]:
import json
from os.path import abspath
from conda.share import old_clone_bundle
prefix, path = sys.argv[4:6]
old_clone_bundle(path, abspath(prefix))
json.dump(dict(warnings=[]), sys.stdout, indent=2)
return
if len(sys.argv) == 1:
sys.argv.append("-h")
import logging
from conda.cli import conda_argparse
import argparse
import conda
p = conda_argparse.ArgumentParser(
description="conda is a tool for managing and deploying applications, environments and packages."
)
p.add_argument(
"-V",
"--version",
action="version",
version="conda %s" % conda.__version__,
help="Show the conda version number and exit.",
)
p.add_argument("--debug", action="store_true", help="Show debug output.")
p.add_argument("--json", action="store_true", help=argparse.SUPPRESS)
sub_parsers = p.add_subparsers(metavar="command", dest="cmd")
from conda.cli import main_info
main_info.configure_parser(sub_parsers)
from conda.cli import main_help
main_help.configure_parser(sub_parsers)
from conda.cli import main_list
main_list.configure_parser(sub_parsers)
from conda.cli import main_search
main_search.configure_parser(sub_parsers)
from conda.cli import main_create
main_create.configure_parser(sub_parsers)
from conda.cli import main_install
main_install.configure_parser(sub_parsers)
from conda.cli import main_update
main_update.configure_parser(sub_parsers)
from conda.cli import main_remove
main_remove.configure_parser(sub_parsers)
main_remove.configure_parser(sub_parsers, name="uninstall")
from conda.cli import main_run
main_run.configure_parser(sub_parsers)
from conda.cli import main_config
main_config.configure_parser(sub_parsers)
from conda.cli import main_init
main_init.configure_parser(sub_parsers)
from conda.cli import main_clean
main_clean.configure_parser(sub_parsers)
from conda.cli import main_package
main_package.configure_parser(sub_parsers)
from conda.cli import main_bundle
main_bundle.configure_parser(sub_parsers)
from conda.cli.find_commands import find_commands
sub_parsers.completer = lambda prefix, **kwargs: [
i for i in list(sub_parsers.choices) + find_commands() if i.startswith(prefix)
]
args = p.parse_args()
if getattr(args, "json", False):
# Silence logging info to avoid interfering with JSON output
for logger in logging.Logger.manager.loggerDict:
if logger not in ("fetch", "progress"):
logging.getLogger(logger).setLevel(logging.CRITICAL + 1)
if args.debug:
logging.disable(logging.NOTSET)
logging.basicConfig(level=logging.DEBUG)
if not main_init.is_initialized() and "init" not in sys.argv and "info" not in sys.argv:
if hasattr(args, "name") and hasattr(args, "prefix"):
import conda.config as config
from conda.cli import common
if common.get_prefix(args) == config.root_dir:
sys.exit(
"""\
Error: This installation of conda is not initialized. Use 'conda create -n
envname' to create a conda environment and 'source activate envname' to
activate it.
# Note that pip installing conda is not the recommended way for setting up your
# system. The recommended way for setting up a conda system is by installing
# Miniconda, see: http://repo.continuum.io/miniconda/index.html"""
)
args_func(args, p)