示例#1
0
文件: main.py 项目: aldanor/conda
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)
示例#2
0
文件: main.py 项目: hihihippp/conda
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.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
        # 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 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/pydata/conda/issues

Include the output of the command 'conda info' in your report.

"""
            )
        raise  # as if we did not catch it
示例#3
0
文件: main.py 项目: westurner/conda
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 and deploying applications, 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_remove.configure_parser(sub_parsers, name='uninstall')
    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)
示例#4
0
文件: main.py 项目: Studiogit/conda
def main():
    if len(sys.argv) > 1:
        argv1 = sys.argv[1]
        if argv1 in ('..activate', '..deactivate', '..checkenv', '..setps1'):
            import conda.cli.activate as activate
            activate.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',
    )

    main_modules = ["info", "help", "list", "search", "create", "install", "update",
                    "remove", "run", "config", "init", "clean", "package", "bundle"]
    modules = ["conda.cli.main_"+suffix for suffix in main_modules]
    for module in modules:
        imported = importlib.import_module(module)
        imported.configure_parser(sub_parsers)
        if "update" in module:
            imported.configure_parser(sub_parsers, name='upgrade')
        if "remove" in module:
            imported.configure_parser(sub_parsers, name='uninstall')

    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)

    from conda.cli import main_init
    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)
示例#5
0
文件: main.py 项目: alexbw/conda
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)
示例#6
0
文件: main.py 项目: nando1/conda
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)
示例#7
0
文件: main.py 项目: jschaf/conda
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