Metadata-Version: 2.4
Name: pip-licenses
Version: 6.0.0a1
Summary: Dump the software license list of Python packages installed with pip.
Author-email: raimon <raimon49@hotmail.com>, "Mr. Walls" <reactive-firewall@users.noreply.github.com>
Maintainer-email: "Mr. Walls" <reactive-firewall@users.noreply.github.com>
License-Expression: MIT
Project-URL: homepage, https://github.com/raimon49/pip-licenses
Project-URL: releasenotes, https://github.com/raimon49/pip-licenses/releases
Project-URL: issues, https://github.com/raimon49/pip-licenses/issues
Keywords: pip,pypi,package,license,check,audit
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3.14
Classifier: Topic :: System :: Systems Administration
Classifier: Topic :: System :: System Shells
Classifier: Typing :: Typed
Requires-Python: >=3.9
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: prettytable>=3.12.0
Requires-Dist: tomli>=2; python_version < "3.11"
Provides-Extra: dev
Requires-Dist: docutils>=0.19; extra == "dev"
Requires-Dist: wheel; extra == "dev"
Requires-Dist: mypy==1.19.1; extra == "dev"
Requires-Dist: pip-tools; extra == "dev"
Requires-Dist: pypandoc; extra == "dev"
Requires-Dist: pytest-cov; extra == "dev"
Requires-Dist: pytest-runner; extra == "dev"
Requires-Dist: ruff; extra == "dev"
Requires-Dist: tomli-w; extra == "dev"
Requires-Dist: virtualenv>=21.1.0; extra == "dev"
Dynamic: license-file

# pip-licenses

[![Build Status](https://github.com/raimon49/pip-licenses/workflows/Python%20package/badge.svg)](https://github.com/raimon49/pip-licenses/actions?query=workflow%3A%22Python+package%22) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pip-licenses.svg)](https://pypi.org/project/pip-licenses/) [![PyPI version](https://badge.fury.io/py/pip-licenses.svg)](https://badge.fury.io/py/pip-licenses) [![GitHub Release](https://img.shields.io/github/release/raimon49/pip-licenses.svg)](https://github.com/raimon49/pip-licenses/releases) [![Codecov](https://codecov.io/gh/raimon49/pip-licenses/branch/master/graph/badge.svg)](https://codecov.io/gh/raimon49/pip-licenses) [![GitHub contributors](https://img.shields.io/github/contributors/raimon49/pip-licenses)](https://github.com/raimon49/pip-licenses/graphs/contributors) [![BSD License](http://img.shields.io/badge/license-MIT-green.svg)](https://github.com/raimon49/pip-licenses/blob/master/LICENSE) [![PyPI - Downloads](https://img.shields.io/pypi/dm/pip-licenses)](https://pypistats.org/packages/pip-licenses)

Dump the software license list of Python packages installed with pip.

## Table of Contents

* [Description](#description)
* [Installation](#installation)
* [Usage](#usage)
* [Command\-Line Options](#command-line-options)
    * [Common options](#common-options)
        * [Option: python](#option-python)
        * [Option: from](#option-from)
        * [Option: order](#option-order)
        * [Option: format](#option-format)
            * [Markdown](#markdown)
            * [reST](#rest)
            * [Confluence](#confluence)
            * [HTML](#html)
            * [JSON](#json)
            * [JSON LicenseFinder](#json-licensefinder)
            * [CSV](#csv)
            * [Plain Vertical](#plain-vertical)
        * [Option: summary](#option-summary)
        * [Option: output\-file](#option-output-file)
        * [Option: ignore\-packages](#option-ignore-packages)
        * [Option: packages](#option-packages)
    * [Format options](#format-options)
        * [Option: with\-system](#option-with-system)
        * [Option: with\-authors](#option-with-authors)
        * [Option: with\-maintainers](#option-with-maintainers)
        * [Option: with\-urls](#option-with-urls)
        * [Option: with\-description](#option-with-description)
        * [Option: no\-version](#option-no-version)
        * [Option: with\-license\-file](#option-with-license-file)
        * [Option: filter\-strings](#option-filter-strings)
        * [Option: filter\-code\-page](#option-filter-code-page)
    * [Verify options](#verify-options)
        * [Option: fail\-on](#option-fail-on)
        * [Option: allow\-only](#option-allow-only)
        * [Option: partial\-match](#option-partial-match)
    * [pyproject.toml support](#pyprojecttoml-support)
    * [More Information](#more-information)
* [Dockerfile](#dockerfile)
* [About UnicodeEncodeError](#about-unicodeencodeerror)
* [License](#license)
    * [Dependencies](#dependencies)
* [Uninstallation](#uninstallation)
* [Contributing](#contributing)

## Description

`pip-licenses` is a CLI tool for checking the software license of installed Python packages with pip.

Implemented with the idea inspired by `composer licenses` command in Composer (a.k.a PHP package management tool).

https://getcomposer.org/doc/03-cli.md#licenses

## Installation

Install it via PyPI using `pip` command.

```bash
# Install or Upgrade to newest available version
$ pip install -U pip-licenses
```

<details>
<summary>Legacy Python Hints</summary>

**Note for Python 3.8 users:** pip-licenses 5.x discontinued support for Python 3.8. If you want to use it with Python 3.8 anyway, install pip-licenses 4.5.x.

```bash
# Using old version for the Python 3.8 environment
$ pip install 'pip-licenses<5.0'

# If upgrading from pip-licenses 3.x, remove PTable
$ pip uninstall -y PTable
```

**Note for Python 3.7 users:** pip-licenses 4.x discontinued support earlier than the Python 3.7 EOL schedule. If you want to use it with Python 3.7, install pip-licenses 3.x.

```bash
# Using old version for the Python 3.7 environment
$ pip install 'pip-licenses<4.0'
```

**Note:** If you are still using Python 2.7, install version less than 2.0. No new features will be provided for version 1.x.

```bash
$ pip install 'pip-licenses<2.0'
```

</details>

## Usage

Simply invoke the command to scan the current environment:

`pip-licenses`

Alternatively execute the command within `virtualenv` (or the legacy `venv`) environment.

```bash
# Install packages in your venv environment
(venv) $ pip install Django pip-licenses

# Check the licenses with your venv environment
(venv) $ pip-licenses
 Name    Version  License
 Django  6.0.6    BSD-3-Clause
 pytz    2026.2   MIT License
```

## Command-Line Options

### Common options

| Option | Argument(s) | Default | Description |
| --- | --- | --- | --- |
| `--python` | path | current interpreter | Python executable whose `sys.path` is searched for packages. |
| `--from` | `meta`, `classifier`, `mixed`, `all` | `mixed` | Source used to look up license information. |
| `--order` | `name`, `license`, `author`, `url`, `count` | `name` | Column used to sort the output. |
| `--format` | `plain`, `plain-vertical`, `markdown`, `rst`, `confluence`, `html`, `json`, `json-license-finder`, `csv` | `plain` | Output format of the report. |
| `--summary` | None (_flag takes no values_) | off | Output a count summary per license instead of a package list. |
| `--output-file` | path | stdout | Write the result to the given file path. |
| `--ignore-packages` | package names | none | Exclude the listed packages from the output. |
| `--packages` | package names | all | Limit the output to the listed packages only. |

#### Option: python

By default, this tools finds the packages from the environment pip-licenses is launched from, by searching in current python's `sys.path` folders. In the case you want to search for packages in an other environment (e.g. if you want to run pip-licenses from its own isolated environment), you can specify a path to a python executable. The packages will be searched for in the given python's `sys.path`, free of pip-licenses dependencies.

```bash
(venv) $ pip-licenses --with-system | grep pip
 pip           26.2     MIT
 pip-licenses  6.0.0    MIT
```

```bash
(venv) $ pip-licenses --python=</path/to/other/env>/bin/python --with-system | grep pip
 pip           26.2     MIT
```

#### Option: from

By default, this tool finds the license from [Trove Classifiers](https://pypi.org/classifiers/) or package Metadata. Some Python packages declare their license only in Trove Classifiers.

(See also): [Set license to MIT in setup.py by alisianoi ・ Pull Request #1058 ・ pypa/setuptools](https://github.com/pypa/setuptools/pull/1058), [PEP 314\#License](https://www.python.org/dev/peps/pep-0314/#license)

For example, even if you check with the `pip show` command, the license is displayed as `UNKNOWN` or simply empty.

```bash
(venv) $ pip show aniso8601
Name: aniso8601
Version: 10.0.1
Summary: A library for parsing ISO 8601 strings.
Home-page: https://codeberg.org/nielsenb-jf/aniso8601
Author: Brandon Nielsen
Author-email: nielsenb@jetfuse.net
License:
Requires:
Required-by:
```

The mixed mode (`--from=mixed`) of this tool works well and looks for licenses.

```bash
(venv) $ pip-licenses --from=mixed --with-system | grep aniso8601
 aniso8601          10.0.1   BSD License
```

In mixed mode, it first tries to look for licenses in the Trove Classifiers. When not found in the Trove Classifiers, the license declared in Metadata is displayed.

If you want to look only in metadata, use `--from=meta`. If you want to look only in Trove Classifiers, use `--from=classifier`.

To list license information from both metadata and classifier, use `--from=all`.

**Note:** If neither can find license information, please check with the `with-authors` and `with-urls` options and contact the software author.

* The `m` keyword is prepared as alias of `meta`.
* The `c` keyword is prepared as alias of `classifier`.
* The `mix` keyword is prepared as alias of `mixed`.
    * Default behavior in this tool

#### Option: order

By default, it is ordered by package name.

If you give arguments to the `--order` option, you can output in other sorted order.

```bash
(venv) $ pip-licenses --order=license
```

#### Option: format

By default, it is output to the `plain` format.

##### Markdown

When executed with the `--format=markdown` option, you can output list in markdown format. The `m` `md` keyword is prepared as alias of `markdown`.

```bash
(venv) $ pip-licenses --format=markdown
| Name   | Version | License      |
|--------|---------|--------------|
| Django | 6.0.6   | BSD-3-Clause |
| pytz   | 2026.2  | MIT License  |
```

When inserted in a markdown document, it is rendered as follows:

| Name   | Version | License      |
|--------|---------|--------------|
| Django | 6.0.6   | BSD-3-Clause |
| pytz   | 2026.2  | MIT License  |

When executed with the `--format=rst` option, you can output list in "[Grid tables](http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#grid-tables)" of reStructuredText format. The `r` `rest` keyword is prepared as alias of `rst`.

```bash
(venv) $ pip-licenses --format=rst
+--------+---------+--------------+
| Name   | Version | License      |
+--------+---------+--------------+
| Django | 6.0.6   | BSD-3-Clause |
+--------+---------+--------------+
| pytz   | 2026.2  | MIT License  |
+--------+---------+--------------+
```

##### Confluence

When executed with the `--format=confluence` option, you can output list in [Confluence (or JIRA) Wiki markup](https://confluence.atlassian.com/doc/confluence-wiki-markup-251003035.html#ConfluenceWikiMarkup-Tables) format. The `c` keyword is prepared as alias of `confluence`.

```bash
(venv) $ pip-licenses --format=confluence
| Name   | Version | License      |
| Django | 6.0.6   | BSD-3-Clause |
| pytz   | 2026.2  | MIT License  |
```

##### HTML

When executed with the `--format=html` option, you can output list in HTML table format. The `h` keyword is prepared as alias of `html`.

```bash
(venv) $ pip-licenses --format=html
<table>
    <thead>
        <tr>
            <th>Name</th>
            <th>Version</th>
            <th>License</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>Django</td>
            <td>6.0.6</td>
            <td>BSD-3-Clause</td>
        </tr>
        <tr>
            <td>pytz</td>
            <td>2026.2</td>
            <td>MIT License</td>
        </tr>
    </tbody>
</table>
```

##### JSON

When executed with the `--format=json` option, you can output list in JSON format easily allowing post-processing. The `j` keyword is prepared as alias of `json`.

```json
[
  {
    "Author": "Django Software Foundation <foundation@djangoproject.com>",
    "License": "BSD-3-Clause",
    "Name": "Django",
    "URL": "https://www.djangoproject.com/",
    "Version": "6.0.6"
  },
  {
    "Author": "Stuart Bishop",
    "License": "MIT License",
    "Name": "pytz",
    "URL": "http://pythonhosted.org/pytz",
    "Version": "2026.2"
  }
]
```

##### JSON LicenseFinder

When executed with the `--format=json-license-finder` option, you can output list in JSON format that is identical to [LicenseFinder](https://github.com/pivotal/LicenseFinder). The `jlf` keyword is prepared as alias of `jlf`.
This makes pip-licenses a drop-in replacement for LicenseFinder.

```json
[
  {
    "licenses": ["BSD-3-Clause"],
    "name": "Django",
    "version": "6.0.6"
  },
  {
    "licenses": ["MIT License"],
    "name": "pytz",
    "version": "2026.2"
  }
]

```

##### CSV

When executed with the `--format=csv` option, you can output list in quoted CSV format. Useful when you want to copy/paste the output to an Excel sheet.

```bash
(venv) $ pip-licenses --format=csv
"Name","Version","License"
"Django","6.0.6","BSD-3-Clause"
"pytz","2026.2","MIT License"
```

##### Plain Vertical

When executed with the `--format=plain-vertical` option, you can output a simple plain vertical output that is similar to Angular CLI's
[--extractLicenses flag](https://angular.io/cli/build#options). This format minimizes rightward drift.

```bash
(venv) $ pip-licenses --format=plain-vertical --with-license-file --no-license-path
pytest
9.1.1
MIT
The MIT License (MIT)

Copyright (c) 2004 Holger Krekel and others

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```

#### Option: summary

When executed with the `--summary` option, you can output a summary of each license.

```bash
(venv) $ pip-licenses --summary --from=classifier --with-system
 Count  License
 2      BSD-3-Clause
 4      MIT
 1      MIT License
```

**Note:** When using this option, only `--order=count` or `--order=license` has an effect for the `--order` option. And using `--with-authors` and `--with-urls` will be ignored.

#### Option: output\-file

When executed with the `--output-file` option, write the result to the path specified by the argument.

```
(venv) $ pip-licenses --format=rst --output-file=/tmp/output.rst
created path: /tmp/output.rst
```

#### Option: ignore-packages

When executed with the `--ignore-packages` option, ignore the package specified by argument from list output.

```bash
(venv) $ pip-licenses --ignore-packages django
 Name  Version  License
 pytz  2026.2   MIT License
```

Package names of arguments can be separated by spaces.

```bash
(venv) $ pip-licenses --with-system --ignore-packages django pip pip-licenses
 Name        Version  License
 prettytable 3.18.0   BSD-3-Clause
 pytz        2026.2   MIT License
 setuptools  83.0.0   MIT
 wcwidth     0.8.2    MIT
```

Packages can also be specified with a version, only ignoring that specific version.

```bash
(venv) $ pip-licenses --with-system --ignore-packages django pytz:2026.2
 Name        Version  License
 prettytable 3.18.0   BSD-3-Clause
 setuptools  83.0.0   MIT
 wcwidth     0.8.2    MIT
```

#### Option: packages

When executed with the `packages` option, look at the package specified by argument from list output.

```bash
(venv) $ pip-licenses --packages django
 Name    Version  License
 Django  6.0.6    BSD-3-Clause
```

Package names of arguments can be separated by spaces.

```bash
(venv) $ pip-licenses --with-system --packages prettytable pytz
 Name         Version  License
 prettytable  3.18.0   BSD-3-Clause
 pytz         2026.2   MIT License
```

### Format options

#### Option: with-system

By default, system packages such as `pip` and `setuptools` are ignored.

And `pip-licenses` and the implicit dependency `prettytable` and `wcwidth` will also be ignored.

If you want to output all including system package, use the `--with-system` option.

```bash
(venv) $ pip-licenses --with-system
 Name          Version  License
 Django        6.0.6    BSD-3-Clause
 pip           26.1.2   MIT
 pip-licenses  5.5.5    MIT
 prettytable   3.18.0   BSD-3-Clause
 pytz          2026.2   MIT License
 setuptools    83.0.0   MIT
 wcwidth       0.8.2    MIT
```

#### Option: with-authors

When executed with the `--with-authors` option, output with author of the package.

```bash
(venv) $ pip-licenses --with-authors
 Name    Version  License       Author
 Django  6.0.6    BSD-3-Clause  Django Software Foundation <foundation@djangoproject.com>
 pytz    2026.2   MIT License   Stuart Bishop
```

#### Option: with-maintainers

When executed with the `--with-maintainers` option, output with maintainer of the package.

**Note:** This option is available for users who want information about the maintainer as well as the author. See [#144](https://github.com/raimon49/pip-licenses/issues/144)

#### Option: with-urls

For packages without Metadata, the license is output as `UNKNOWN`. To get more package information, use the `--with-urls` option.

```bash
(venv) $ pip-licenses --with-urls
 Name    Version  License       URL
 Django  6.0.6    BSD-3-Clause  https://www.djangoproject.com/
 pytz    2026.2   MIT License   http://pythonhosted.org/pytz
```

#### Option: with-description

When executed with the `--with-description` option, output with short description of the package.

```bash
(venv) $ pip-licenses --with-description
 Name    Version  License       Description
 Django  6.0.6    BSD-3-Clause  A high-level Python web framework that encourages rapid development and clean, pragmatic design.
 pytz    2026.2   MIT License   World timezone definitions, modern and historical
```

#### Option: no-version

When executed with the `--no-version` option, output without the version number.

```bash
(venv) $ pip-licenses --no-version
 Name    License
 Django  BSD-3-Clause
 pytz    MIT License
```

#### Option: with-license-file

When executed with the `--with-license-file` option, output the location of the package's license file on disk and the full contents of that file. Due to the length of these fields, this option is best paired with `--format=json`.

If you also want to output the file `NOTICE` distributed under Apache License etc., specify the `--with-notice-file` option additionally.

**Note:** If you want to keep the license file path secret, specify `--no-license-path` option together.

**Note:** When using `--with-license-file` with structured formats like CSV, Markdown, reST, or Confluence, the multi-line license file contents can break the formatting. For documentation workflows (like Sphinx), consider using separate commands:

```bash
# Generate clean RST table for documentation
$ pip-licenses --from=mixed --format=rst --output-file summary.rst

# Generate license file contents in plain-vertical format for inclusion
$ pip-licenses --from=mixed --format=plain-vertical --with-license-file --no-license-path --output-file with_license.txt
```

The RST file can be rendered nicely in Sphinx, while the plain-vertical format preserves the license file contents as monospace text.

#### Option: filter\-strings

Some package data contains Unicode characters which might cause problems for certain output formats (in particular ReST tables). If this filter is enabled, all characters which cannot be encoded with a given code page (see `--filter-code-page`) will be removed from any input strings (e.g. package name, description).

#### Option: filter\-code\-page

If the input strings are filtered (see `--filter-strings`), you can specify the applied code page (default `latin-1`). A list of all available code pages can be found [codecs module document](https://docs.python.org/3/library/codecs.html#standard-encodings).


### Verify options

#### Option: fail\-on

Fail (exit with code 1) on the first occurrence of the licenses of the semicolon-separated list. The license name
matching is case-insensitive.

If `--from=all`, the option will apply to the metadata license field.

```bash
(venv) $ pip-licenses --fail-on="MIT License;BSD License"
```
**Note:** Packages with multiple licenses will fail if at least one license is included in the fail-on list. For example:
```
# keyring library has 2 licenses
$ pip-licenses --package keyring
 Name     Version  License
 keyring  25.7.0   MIT License; Python Software Foundation License

# If just "Python Software Foundation License" is specified, it will fail.
$ pip-licenses --package keyring --fail-on="Python Software Foundation License;"
$ echo $?
1

# Matching is case-insensitive. Following check will fail:
$ pip-licenses --fail-on="mit license"
```

#### Option: allow\-only

Fail (exit with code 1) if none of the package licenses are in the semicolon-separated list. The license name
matching is case-insensitive.

If `--from=all`, the option will apply to the metadata license field.

```bash
(venv) $ pip-licenses --allow-only="MIT License;BSD License"
```
**Note:** Packages with multiple licenses will only be allowed if at least one license is included in the allow-only list. For example:
```
# keyring library has 2 licenses
$ pip-licenses --package keyring
 Name     Version  License
 keyring  25.7.0   MIT License; Python Software Foundation License

# One or both licenses must be specified (order and case does not matter). Following checks will pass:
$ pip-licenses --package keyring --allow-only="MIT License"
$ pip-licenses --package keyring --allow-only="mit License"
$ pip-licenses --package keyring --allow-only="BSD License;MIT License"
$ pip-licenses --package keyring --allow-only="Python Software Foundation License"
$ pip-licenses --package keyring --allow-only="Python Software Foundation License;MIT License"

# If none of the license in the allow list match, the check will fail.
$ pip-licenses --package keyring  --allow-only="BSD License"
$ echo $?
1
```

#### Option: partial\-match

If set, enables partial (substring) matching for `--fail-on` or `--allow-only`. Default is unset (False).

Usage:

```bash
(venv) $ pip-licenses --partial-match --allow-only="MIT License;BSD License"
(venv) $ pip-licenses --partial-match --fail-on="MIT License;BSD License"

```

**Note:** Semantics are the same as with `--fail-on` or `--allow-only`. This only enables substring matching.
```
# keyring library has 2 licenses
$ pip-licenses --package keyring
 Name     Version  License
 keyring  25.7.0   MIT License; Python Software Foundation License

# One or both licenses must be specified (order and case does not matter). Following checks will pass:
$ pip-licenses --package keyring --allow-only="MIT License"
$ pip-licenses --package keyring --allow-only="mit License"
$ pip-licenses --package keyring --allow-only="BSD License;MIT License"
$ pip-licenses --package keyring --allow-only="Python Software Foundation License"
$ pip-licenses --package keyring --allow-only="Python Software Foundation License;MIT License"

# These won't pass, as they're not a full match against one of the licenses
$ pip-licenses --package keyring --allow-only="MIT"
$ echo $?
1
$ pip-licenses --package keyring --allow-only="mit"
$ echo $?
1

# with --partial-match, they pass
$ pip-licenses --package keyring --partial-match --allow-only="MIT"
$ echo $?
0
$ pip-licenses --package keyring --partial-match --allow-only="mit"
$ echo $?
0
```

### pyproject.toml support

All command-line options for `pip-licenses` can be configured using the `pyproject.toml` file under the `[tool.pip-licenses]` section.
The `pyproject.toml` file is searched in the directory where the `pip-licenses` script is executed.
Command-line options specified during execution will override the corresponding options in `pyproject.toml`.

Example `pyproject.toml` configuration:

```toml
[tool.pip-licenses]
from = "classifier"
ignore-packages = [
  "scipy"
]
fail-on = "MIT;"
```

If you run `pip-licenses` without any command-line options, all options will be taken from the `pyproject.toml` file.
For instance, if you run `pip-licenses --from=mixed`, the `from` option will be overridden to `mixed`, while all other options will be sourced from `pyproject.toml`.

### More Information

Other, please make sure to execute the `--help` option.

## Dockerfile

You can check the package license used by your app in the isolated Docker environment.

```bash
# Clone this repository to local
$ git clone https://github.com/raimon49/pip-licenses.git
$ cd pip-licenses

# Create your app's requirements.txt file
# Other ways, pip freeze > docker/requirements.txt
$ echo "Flask" > docker/requirements.txt

# Build docker image
$ docker build . -t myapp-licenses

# Check the package license in container
$ docker run --rm myapp-licenses
 Name          Version  License
 Click         7.0      BSD License
 Flask         1.0.2    BSD License
 Jinja2        2.10     BSD License
 MarkupSafe    1.1.1    BSD License
 Werkzeug      0.15.2   BSD License
 itsdangerous  1.1.0    BSD License

# Check with options
$ docker run --rm myapp-licenses --summary
 Count  License
 4      BSD
 2      BSD-3-Clause

# When you need help
$ docker run --rm myapp-licenses --help
```

**Note:** This Docker image can not check package licenses with C and C++ Extensions. It only works with pure Python package dependencies.

If you want to resolve build environment issues, try using not slim image and more.

```diff
diff --git a/Dockerfile b/Dockerfile
index bfc4edc..81f9264 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,4 +1,4 @@
-FROM python:3.14-slim-trixie
+FROM python:3.14-trixie
```

## About UnicodeEncodeError

If a `UnicodeEncodeError` occurs, check your environment variables `LANG` and `LC_TYPE`. Additionally, you can set `PYTHONIOENCODING` to override the encoding used for `stdout`.

Often occurs in isolated environments such as Docker and tox.

See useful reports:

* [#35](https://github.com/raimon49/pip-licenses/issues/35)
* [#45](https://github.com/raimon49/pip-licenses/issues/45)

## License

[MIT License](https://github.com/raimon49/pip-licenses/blob/master/LICENSE)

### Dependencies

* [prettytable](https://pypi.org/project/prettytable/) by Luke Maurits and maintainer of fork version Jazzband team under the BSD-3-Clause License
    * **Note:** This package implicitly requires [wcwidth](https://pypi.org/project/wcwidth/).

* [tomli](https://pypi.org/project/tomli/) by Taneli Hukkinen under the MIT License

`pip-licenses` has been implemented in the policy to minimize the dependence on external package.

## Uninstallation

Uninstall package and dependent package with `pip` command.

```bash
$ pip uninstall pip-licenses prettytable wcwidth
```

## Contributing

See [contribution guidelines](https://github.com/raimon49/pip-licenses/blob/master/CONTRIBUTING.md).

## CHANGELOG

### pre-6.0.0 (ALPHA WIP)

(SUBJECT TO CHANGE IN NEXT RELEASE)

* Fixed priority logic regression from v5.5.x that lead to non-determinant ordering of multiple-source results, (WIP GHI #309), and possibly resolving? (GHI #330 - needs new testing)
* Fixed multiple regressions in tests due to recent version bumps, closing GHI #337 & GHI #338
* Updated various portions of the README document (WIP), closing GHI #328
* Improved handling of multiple license files in a single package (WIP GHI #71)
* Implemented new flags (WIP GHI #242)
* Fixed multiple false positives including:
  * [CVE-2026-4539 reDoS](https://github.com/advisories/GHSA-5239-wwwm-4pmq)
  * [CVE-2026-44432 Leak](https://github.com/advisories/GHSA-mf9v-mfxr-j63j)
  * [CVE-2026-44431](https://github.com/advisories/GHSA-qccp-gfcp-xxvc)
* Updated testing in CI to resolve python3.9 coverage regresions

### 5.5.5

* Updated cc lines and officially made note of change in maintainers

### 5.5.4

* Expanded typing annotations through-out codebase
* Configured `prek`/`pre-commit` for CI linting and local developer workflows
* Additional configuration following v5.5.2's migration of linters
  * Fine tune ruff to enforce typing and black style opinions (Code style remains PEP-8 aligned)
  * Cleanup/gitignore for ruff
* Fixed a typo in previous changelog

### 5.5.3

* Aligned parsing logic with [PEP 753](https://peps.python.org/pep-0753/)
* Refactored to better leverage f-strings to improve performance slightly
* Fixed various warnings in tests
* Got rid of historical Python 3.5 left-overs

### 5.5.2

* Added support for multi-line allow-only and fail-on arguments
  * Relaxed parsing of most whitespace around semicolon delimiter
* Added simple `SECURITY.md` policy document
* Fixed a duplication behavior in output when a package was found at multiple paths (e.g., symlinks)
* Fixed issue where lowercase license filenames were ignored
* Improved project `Makefile` stability for developers
* Migrated from the linters black and isort to ruff
  * Code style remains PEP-8 aligned, but should be slightly more readable.
  * Linting configuration remains in `pyproject.toml`
* Updated `CONTRIBUTORS.md` guide with related changes

### 5.5.1

* Fixed typographical issue in README examples, closing GHI #209.
* Fixed typographical issue in docstring found by codespell.
* Aligned Project URLs in `pyproject.toml` with [PEP 753](https://peps.python.org/pep-0753/)
* Brought `pyproject.toml` (e.g., packaging metadata) into alignment with [PEP 639](https://peps.python.org/pep-0639/) and related packaging guidance.
  * Improved `MANIFEST.in` to `setuptools-scm` build logic with better filtering, closing GHI #266
* Fixed a regression in linting via `black` by deprecating support for python 3.9, closing GHI #264
  * Applied `black 26.1.0`suggestions to codebase, closing GHI #269

### 5.5.0

* Replace dependency on `tomli` with builtin `tomllib` for Python 3.11
* Added support for `License-Expression` metadata field, see [PEP 639](https://peps.python.org/pep-0639/)
* Added `--from=expression` option
* Breaking change: The `--from=all` output now includes the `License-Expression` value
* Fixed KeyError with `--partial` and `--allow-only` if a license matches multiple allowed licenses.
* Declare support for Python 3.13 and 3.14
* Added RST/Sphinx workflow example for `--with-license-file` option in documentation

### 5.0.0

* Dropped support Python 3.8
* Clarified support for Python 3.12
* Migration pyproject.toml about this package
* Breaking changes
    * Implicitly depends on tomli library since version 4.5.0

### 4.5.1

* Fixes "tomli" to be output only with `--with-system` option

### 4.5.0

* Implement new feature pyproject.toml support

### 4.4.0

* Implement new option `--partial-match`

### 4.3.4

* Maintain to pass test with wcwidth>=0.2.10

### 4.3.3

* Always terminate `--allow-only` and `--fail-on` messages with a newline
* Always terminate files created with `--output-file` with a newline

### 4.3.2

* Better handling extracting URLs from `Project-URL`

### 4.3.1

* Fix to treat package names as normalized as in [PEP 503](https://peps.python.org/pep-0503/) with `--packages` and `--ignore-packages` option

### 4.3.0

* Implement new option `--no-version`

### 4.2.0

* Implement new option `--with-maintainers`
* Implement new option `--python`
* Allow version spec in `--ignore-packages` parameters
* When the `Author` field is `UNKNOWN`, the output is automatically completed from `Author-email`
* When the `home-page` field is `UNKNOWN`, the output is automatically completed from `Project-URL`

### 4.1.0

* Support case-insensitive license name matching around `--fail-on` and `--allow-only` parameters

### 4.0.3

* Escape unicode output (to e.g. `&#123;`) in the html output

### 4.0.2

* Add type annotations and code formatter

### 4.0.1

* Fix "pip-licenses" is missing in output of `pip-licenses --with-system` option

### 4.0.0

* Support for Python 3.11
* Dropped support Python 3.7
* Migrate Docker base image from Alpine to Debian 11-slim
* Breaking changes
    * Does not work with PTable and depends on prettytable
    * Depend on importlib\_metadata rather than pip

### 3.5.5

* Search for path defined in [PEP 639](https://peps.python.org/pep-0639/) with `--with-license-file` option
* Dropped support Python 3.6

### 3.5.4

* Skip directories when detecting license files

### 3.5.3

* Support pip 21.3 or later

### 3.5.2

* Ignore spaces around `--fail-on` and `--allow-only` parameters

### 3.5.1

* Fix the order in which multiple licenses are output

### 3.5.0

* Handle multiple licenses better with options `--fail-on` and `--allow-only`
* Small change in output method for multiple licenses, change the separator from comma to semicolon
    * Up to 3.4.0: `Python Software Foundation License, MIT License`
    * 3.5.0 or later: `Python Software Foundation License; MIT License`

### 3.4.0

* Implement new option `--packages`

### 3.3.1

* Fix license summary refer to `--from` option

### 3.3.0

* Improves the readability of the help command

### 3.2.0

* Implement new option `--from=all`
* Change license notation under [SPDX license identifier](https://spdx.org/licenses/) style

### 3.1.0

* Implement new option for use in continuous integration
    * `--fail-on`
    * `--allow-only`

### 3.0.0

* Dropped support Python 3.5
* Clarified support for Python 3.9
* Migrate package metadata to `setup.cfg`
* Breaking changes
    * Change default behavior to `--from=mixed`

### 2.3.0

* Implement new option for manage unicode characters
    * `--filter-strings`
    * `--filter-code-page`

### 2.2.1

* Fixed the file that is selected when multiple matches are made with `LICENSE*` with run `--with-license-file`

### 2.2.0

* Implement new option `--with-notice-file`
* Added to find British style file name `LICENCE` with run `--with-license-file`

### 2.1.1

* Suppress errors when opening license files

### 2.1.0

* Implement new option `--format=plain-vertical`
* Support for outputting license file named `COPYING *`

### 2.0.1

* Better license file open handling in Python 3

### 2.0.0

* Dropped support Python 2.7
* Breaking changes
    * Removed migration path to obsolete options
        * `--from-classifier`
        * `--format-markdown`
        * `--format-rst`
        * `--format-confluence`
        * `--format-html`
        * `--format-json`
* Implement new option `--no-license-path`

### 1.18.0

* Supports compatibility to work with either PTable or prettytable

### 1.17.0

* Implement new option `--output-file`
* Clarified support for Python 3.8

### 1.16.1

* Add a help text for `--format=json-license-finder` option

### 1.16.0

* Implement new option `--format=json-license-finder`

### 1.15.2

* Read license file works well with Windows

### 1.15.1

* Skip parsing of license file for packages specified with `--ignore-packages` option

### 1.15.0

* Implement new option `--format=csv`

### 1.14.0

* Implement new option `--from=mixed` as a mixed mode

### 1.13.0

* Implement new option `--from=meta`, `from=classifier`
* Dropped support Python 3.4

### 1.12.1

* Fix bug
    * Change warning output to standard error

### 1.12.0

* Supports execution within Docker container
* Warning of deprecated options
* Fix bug
    * Ignore `OSI Approved` string with multiple licenses

### 1.11.0

* Implement new option `--with-license-file`

### 1.10.0

* Implement new option `--with-description`

### 1.9.0

* Implement new option `--summary`

### 1.8.0

* Implement new option `--format-json`
* Dropped support Python 3.3

### 1.7.1

* Fix bug
    * Support pip 10.x

### 1.7.0

* Implement new option `--format-confluence`

### 1.6.1

* Fix bug
    * Support display multiple license with `--from-classifier` option
* Improve document
    * Add section of 'Uninstallation' in README

### 1.6.0

* Implement new option `--format-html`

### 1.5.0

* Implement new option `--format-rst`

### 1.4.0

* Implement new option `--format-markdown`
* Include LICENSE file in distribution package

### 1.3.0

* Implement new option `--ignore-packages`

### 1.2.0

* Implement new option `--from-classifier`

### 1.1.0

* Improve document
    * Add ToC to README document
    * Add a information of dependencies

### 1.0.0

* First stable release version

### 0.2.0
* Implement new option `--order`
    * Default behavior is `--order=name`

### 0.1.0

* First implementation version
    * Support options
        * `--with-system`
        * `--with-authors`
        * `--with-urls`
