Python Packages


Python Packages for Data Science, Web Development, Machine Learning, Code Quality and Security

Python from ActiveState is a part of the ActiveState Platform, which allows you to build Python environments for each of your projects.

The ActiveState Platform catalog includes thousands of the most popular Python packages, imported as source code from the Python Package Index (PyPI), as well as other repositories. 

The ActiveState Platform will automatically build the packages you need, from source (including any linked C or Fortran libraries), and package them for Windows, Mac and Linux in just a few minutes so you can start working on your project right away!

You can install Python by running this code snippet on your command line.

The list below is just a sample of the packages included in our catalog. To explore the complete list head to the ActiveState Platform and start building. It’s free!

Data Science/Big Data/Machine Learning Python Packages

  • pandas (data analysis)
  • NumPy (multi-dimensional arrays)
  • SciPy (algorithms to use with numpy)
  • matplotlib (data visualization)
  • HDF5 (store & manipulate data)
  • PyTables (managing HDF5 datasets)
  • Jupyter (research collaboration)
  • IPython (powerful shell)
  • HDFS (C/C++ wrapper for Hadoop)
  • pymongo (MongoDB driver)
  • SQLAlchemy (Python SQL Toolkit)
  • redis (Redis access libraries)
  • pyMySQL (MySQL connector)
  • scikit-learn (machine learning algorithms)
  • TensorFlow (deep learning with neural networks)*
  • keras (high-level neural networks API)
  • bokeh (data visualization)
  • seaborn (data visualization)
  • dask (data engineering)
  • luigi (data engineering)
  • elasticsearch (data search engine)

Python Packages for Cloud and Web Application Development

  • Django (web framework)
  • flask (web framework – microservices)
  • tornado (web framework and networking)
  • requests (web dev library)
  • AWS SDK (Amazon cloud)
  • google-cloud (Google Cloud)
  • simplejson (json library)
  • Twisted (asynchronous networking)
  • urllib3 (HTTP w/ connection pooling)
  • jinja2 (template engine)
  • s3transfer (AWS S3)

Code Quality/Testing

  • pytest (testing)
  • nose (testing)
  • selenium (testing)
  • flake8 (code quality)
  • coverage (test coverage)

Developer Utilities

  • pytz (time zone library)
  • PyYAML(YAML support)
  • py (code gen, API control, ini file parsing)
  • lxml (processing XML/HTML)
  • cffi (C code interface)

Python Packages for Security

  • cryptography (recipes and primitives)
  • pyOpenSSL (python interface to OpenSSL)
  • passlib (password hashing)
  • requests-oauthlib (Oauth support)
  • ecdsa (cryptographic signature)
  • PyCryptodome (PyCrypto replacement)
  • service_identity (prevents pyOpenSSL man-in-the-middle attacks)

Ready to give it a try? You can install Python 3.9 and our CLI, the State Tool by running the following command:
At a Windows CMD prompt:

powershell -Command “& $([scriptblock]::Create((New-Object Net.WebClient).DownloadString(‘’))) -activate-default ActiveState-Labs/Python-3.9Beta”

For Linux:

sh <(curl -q –activate-default ActiveState-Labs/Python-3.9Beta

Then run –

state install <packagename>


state import <requirements.txt>

Watch a 2 minute video to see how easy it is to get your project running. 

Why Use The ActiveState Platform For Python Package Management?

System-wide installations of Python are still widespread. However, best practices are moving away from global installs which are prone to corruption. Instead, the trend is toward virtual environments that isolate each instance of Python, allowing you to run multiple versions on your local machine without conflicts. This best practice is now an integral part of the ActiveState Platform, which provides you with:

  • Python 3.9 that is automatically installed into a virtual environment
  • Our command line interface (CLI) the State Tool, which allows you to “state install” all the packages your project requires

Rather than a revolution, Python 3.9 from ActiveState is an evolution of the Python ecosystem that offers you a number of features that can make your life as a developer less frustrating and far more productive. For example:

Resolve Dependency Conflicts

There are a few Python package management solutions, that will resolve dependencies for you, ensuring your environments contain only packages that will work together. However, there is currently no way to resolve dependency conflicts other than manually testing out various versions of packages to find a compatible solution. Sometimes the solution is fairly straightforward, but in other cases developers waste time and resources in dependency hell. The ActiveState Platform includes a dependency solver, that not only automatically resolves dependencies for you, but also flags conflicts AND is unique in providing you with a way to solve them. For example:

Solve Dependency Conflicts

While the error message is a bit verbose (for good reason: we’ll soon support multi-language projects, which will need to distinguish conflicts by language), it’s still easy to follow and resolve. Simply following the instructions and changing the version of scipy to be >=0.19.1 (ie., by clicking on the dropdown and selecting a more recent version) would solve this conflict, eliminating dependency hell.

Automatically Build Python from Source Code

Building Python and third-party packages from source code increases security because it ensures:

  • You won’t accidentally install malicious code inserted into the binary version of a package, as might happen with package typosquatting
  • You know the origins of all the components in your open source code, helping secure your open source supply chain

But most developers prefer to install binary versions of packages instead, accepting the security risk because building from source is a pain, especially if you need to support multiple deployment platforms.  That’s why the ActiveState Platform provides:

  • A single, cloud-based build platform for both Windows and Linux
  • Automated building of not only Python code, but also any linked C libraries, as well

So there’s no longer any excuse not to build from source. And best of all, you no longer need to maintain build environments on your local machine.

Python Environment Reproducibility

A requirements.txt or pipfile.lock file goes a long way to helping you consistently reproduce your environment on other systems, but they don’t address all issues, including:

  • Deploying to a different operating system may miss OS-level dependencies
  • Requirements.txt and pipfile.lock files can get out of sync as different developers on a team update their development environment for their own purposes
  • DevOps is often left to resolve multiple conflicting code check-ins, leading to CI/CD environments that differ from development environments

All of which lead to developers wasting time rebuilding environments in order to debug issues.  The ActiveState Platform takes a different approach to ensuring reproducibility by:

  • Automatically building your Python environment for both Windows and Linux
  • Providing a central “source of truth” for the Python runtime environment that both developers and DevOps can pull to build their dev and CI/CD environments
  • Updates to the environment are made centrally, and can be updated locally with a single command.

Centrally managing and deploying your Python and Perl environments means that development and DevOps teams remain in sync, eliminating “works on my machine” issues.

Python Vulnerability Remediation

Developers spend far too much time investigating and remediating open source vulnerabilities to the point where the Mean Time To Resolution (MTTR) is typically measured in weeks. Obviously, everyone would prefer to be able to resolve critical vulnerabilities in a matter of days, if not hours, but our current tooling doesn’t help much beyond notifying you of a vulnerability and perhaps suggesting a solution.  The ActiveState Platform goes a step further in providing you:

  • Notifications
  • Suggestions for upgrading or even downgrading a package to a version that is secure
  • Showing you the ramifications of making the change on the rest of your environment BEFORE you commit to it
  • Automatically rebuilding the environment

Python Vulnerability Remediation

If you’re like most Python developers, you probably maintain multiple tools, build environments and other solutions in order to address the issues that a single tool, the ActiveState Platform can solve today. By adopting the ActiveState Platform, you can:
  • Increase the security of your Python environments
  • Improve the transparency of your open source supply chain
  • Eliminate dependency hell
  • Reduce “works on my machine” issues

Ultimately, developers that are willing to adopt the ActiveState Platform for Python package management will spend less time wrestling with tooling and more time focused on doing what they do best: coding.

*TensorFlow is available on ActivePython 2.7 for Linux and ActivePython 3.5 for Windows and MacOS; the Intel MKL is available on ActivePython 2.7 and 3.5 for Windows and Linux.
Scroll to Top