#Conda install package dependencies how to
#Conda install package dependencies software

Say package X depends on package Y, but X didn’t set any version constraints for Y. I mentioned that solvers attempt to find a solution that satisfies all package requirements, but that’s under the assumption that package maintainers have their requirements up-to-date.

Depending on the solver configuration, the command could just refuse to create the environment or print a warning message.

Always check the command output for issues. If you have a reasonable set of dependencies, your environment should install just fine, but there are a few factors that might give errors/warnings. Once you specify you create the environment file, you can create the conda virtual environment with the following command: Tl dr Always look for errors when setting up environments, sometimes you might have to pin versions to resolve issues. Keep your dependencies flexible and only pin specific versions when you have to, the more version constraints you add to your environment, the higher the chance of running into situations where the solver is unable to satisfy all constraints. During development, we might experiment with some package but discard it shortly thereafter, the best way to proceed is to remove it from the environment file but if you forget to do so, the comment will be helpful in the future when deciding which dependencies to drop. A good practice is to add a short comment to let other people know (or even your future self!) why you need a package. While you can auto-generate these files, it is best to maintain them manually. # environment name name: my-project dependencies: In conda, you can document your dependencies in a YAML file like this: If there is a package that you cannot install using conda install, you can still use pip install inside the conda environment. You can even install non-Python packages such as R. My recommendation is to use conda (through miniconda), because it can handle more dependencies than pip. Pip and conda are the most widely used package managers for Python both can setup dependencies from a text file. Manually add/remove packages and keep them as flexible as possible (by not pinning specific versions), to ease dependency resolution and to test your project against the latest compatible version available. Tl dr Keep separate files for dev/prod dependencies.

#Conda install package dependencies how to

The next section discusses how to do this. This gives you a chance to simplify dependencies in the production environment. For example, if you are developing a model, you may generate some evaluation charts in a jupyter notebook using matplotlib, but for serving predictions through an API you don’t need any of those. When working on a Data Science project, there might be packages that you only need for development, but that won’t be required in the production environment.

packages needed to train a model) and production (i.e. Tl dr Group your dependencies in development (i.e. To avoid these issues, it is important to be conscious about project dependencies. Some package managers will throw an error, but others might just print a warning message. With large sets of dependencies, it can happen that the solver is unable to find a solution. When packages share dependencies, the package manager has to find versions that satisfy all constraints (this process is known as dependency resolution), doing so is computationally expensive, current package managers use heuristics to find a solution in a reasonable amount of time. For example, at this time of writing scikit-learn requires numpy 1.13.3 or higher. Packages usually have version constraints. When you install a package, your package manager (pip, conda) has to install dependencies for the requested package and dependencies of those dependencies, until all requirements are satisfied. A large set of dependencies and version constraints might lead to failures when resolving the environment. Tl dr Package managers use heuristics to install package versions that are compatible with each other. This post discusses another important subject: dependency management, which relates to properly documenting virtual environments to ease reproducibility and make them reliable when deployed to production.įor a more in-depth description of Python environments, see this other post. However, using virtual environments is just the first step towards developing reproducible data projects. They allow you to create self-contained, isolated Python installations that prevent your projects from clashing with each other and let other people reproduce your setup.

#Conda install package dependencies software

Virtual environments are a must when developing software projects.