mirror of
https://github.com/python-pillow/Pillow.git
synced 2024-11-10 19:56:47 +03:00
Merge branch 'main' into convert_mode
This commit is contained in:
Andrew Murray
commit
0c6485bee9
|
|
@ -1,9 +1,9 @@
|
|||
skip_commits:
|
||||
files:
|
||||
- ".github/**"
|
||||
- ".github/**/*"
|
||||
- ".gitmodules"
|
||||
- "docs/**"
|
||||
- "wheels/**"
|
||||
- "docs/**/*"
|
||||
- "wheels/**/*"
|
||||
|
||||
version: '{build}'
|
||||
clone_folder: c:\pillow
|
||||
|
|
@ -32,10 +32,10 @@ install:
|
|||
- curl -fsSL -o pillow-test-images.zip https://github.com/python-pillow/test-images/archive/main.zip
|
||||
- 7z x pillow-test-images.zip -oc:\
|
||||
- xcopy /S /Y c:\test-images-main\* c:\pillow\tests\images
|
||||
- curl -fsSL -o nasm-win64.zip https://raw.githubusercontent.com/python-pillow/pillow-depends/main/nasm-2.16.01-win64.zip
|
||||
- curl -fsSL -o nasm-win64.zip https://raw.githubusercontent.com/python-pillow/pillow-depends/main/nasm-2.16.03-win64.zip
|
||||
- 7z x nasm-win64.zip -oc:\
|
||||
- choco install ghostscript --version=10.3.0
|
||||
- path c:\nasm-2.16.01;C:\Program Files\gs\gs10.00.0\bin;%PATH%
|
||||
- choco install ghostscript --version=10.3.1
|
||||
- path c:\nasm-2.16.03;C:\Program Files\gs\gs10.00.0\bin;%PATH%
|
||||
- cd c:\pillow\winbuild\
|
||||
- ps: |
|
||||
c:\python38\python.exe c:\pillow\winbuild\build_prepare.py -v --depends=C:\pillow-depends\
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
cibuildwheel==2.17.0
|
||||
cibuildwheel==2.18.1
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
mypy==1.9.0
|
||||
mypy==1.10.0
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@ BinPackParameters: false
|
|||
BreakBeforeBraces: Attach
|
||||
ColumnLimit: 88
|
||||
DerivePointerAlignment: false
|
||||
IndentGotoLabels: false
|
||||
IndentWidth: 4
|
||||
Language: Cpp
|
||||
PointerAlignment: Right
|
||||
|
|
|
|||
4
.github/workflows/test-cygwin.yml
vendored
4
.github/workflows/test-cygwin.yml
vendored
|
|
@ -55,6 +55,7 @@ jobs:
|
|||
packages: >
|
||||
gcc-g++
|
||||
ghostscript
|
||||
git
|
||||
ImageMagick
|
||||
jpeg
|
||||
libfreetype-devel
|
||||
|
|
@ -132,11 +133,12 @@ jobs:
|
|||
bash.exe .ci/after_success.sh
|
||||
|
||||
- name: Upload coverage
|
||||
uses: codecov/codecov-action@v3.1.5
|
||||
uses: codecov/codecov-action@v4
|
||||
with:
|
||||
file: ./coverage.xml
|
||||
flags: GHA_Cygwin
|
||||
name: Cygwin Python 3.${{ matrix.python-minor-version }}
|
||||
token: ${{ secrets.CODECOV_ORG_TOKEN }}
|
||||
|
||||
success:
|
||||
permissions:
|
||||
|
|
|
|||
20
.github/workflows/test-docker.yml
vendored
20
.github/workflows/test-docker.yml
vendored
|
|
@ -36,32 +36,31 @@ jobs:
|
|||
docker: [
|
||||
# Run slower jobs first to give them a headstart and reduce waiting time
|
||||
ubuntu-22.04-jammy-arm64v8,
|
||||
ubuntu-22.04-jammy-ppc64le,
|
||||
ubuntu-22.04-jammy-s390x,
|
||||
ubuntu-24.04-noble-ppc64le,
|
||||
ubuntu-24.04-noble-s390x,
|
||||
# Then run the remainder
|
||||
alpine,
|
||||
amazon-2-amd64,
|
||||
amazon-2023-amd64,
|
||||
arch,
|
||||
centos-7-amd64,
|
||||
centos-stream-8-amd64,
|
||||
centos-stream-9-amd64,
|
||||
debian-11-bullseye-amd64,
|
||||
debian-12-bookworm-x86,
|
||||
debian-12-bookworm-amd64,
|
||||
fedora-38-amd64,
|
||||
fedora-39-amd64,
|
||||
fedora-40-amd64,
|
||||
gentoo,
|
||||
ubuntu-20.04-focal-amd64,
|
||||
ubuntu-22.04-jammy-amd64,
|
||||
ubuntu-24.04-noble-amd64,
|
||||
]
|
||||
dockerTag: [main]
|
||||
include:
|
||||
- docker: "ubuntu-22.04-jammy-arm64v8"
|
||||
qemu-arch: "aarch64"
|
||||
- docker: "ubuntu-22.04-jammy-ppc64le"
|
||||
- docker: "ubuntu-24.04-noble-ppc64le"
|
||||
qemu-arch: "ppc64le"
|
||||
- docker: "ubuntu-22.04-jammy-s390x"
|
||||
- docker: "ubuntu-24.04-noble-s390x"
|
||||
qemu-arch: "s390x"
|
||||
|
||||
name: ${{ matrix.docker }}
|
||||
|
|
@ -83,8 +82,8 @@ jobs:
|
|||
|
||||
- name: Docker build
|
||||
run: |
|
||||
# The Pillow user in the docker container is UID 1000
|
||||
sudo chown -R 1000 $GITHUB_WORKSPACE
|
||||
# The Pillow user in the docker container is UID 1001
|
||||
sudo chown -R 1001 $GITHUB_WORKSPACE
|
||||
docker run --name pillow_container -v $GITHUB_WORKSPACE:/Pillow pythonpillow/${{ matrix.docker }}:${{ matrix.dockerTag }}
|
||||
sudo chown -R runner $GITHUB_WORKSPACE
|
||||
|
||||
|
|
@ -101,11 +100,12 @@ jobs:
|
|||
MATRIX_DOCKER: ${{ matrix.docker }}
|
||||
|
||||
- name: Upload coverage
|
||||
uses: codecov/codecov-action@v3.1.5
|
||||
uses: codecov/codecov-action@v4
|
||||
with:
|
||||
flags: GHA_Docker
|
||||
name: ${{ matrix.docker }}
|
||||
gcov: true
|
||||
token: ${{ secrets.CODECOV_ORG_TOKEN }}
|
||||
|
||||
success:
|
||||
permissions:
|
||||
|
|
|
|||
3
.github/workflows/test-mingw.yml
vendored
3
.github/workflows/test-mingw.yml
vendored
|
|
@ -85,8 +85,9 @@ jobs:
|
|||
python3 -m pytest -vx --cov PIL --cov Tests --cov-report term --cov-report xml Tests
|
||||
|
||||
- name: Upload coverage
|
||||
uses: codecov/codecov-action@v3.1.5
|
||||
uses: codecov/codecov-action@v4
|
||||
with:
|
||||
file: ./coverage.xml
|
||||
flags: GHA_Windows
|
||||
name: "MSYS2 MinGW"
|
||||
token: ${{ secrets.CODECOV_ORG_TOKEN }}
|
||||
|
|
|
|||
4
.github/workflows/test-valgrind.yml
vendored
4
.github/workflows/test-valgrind.yml
vendored
|
|
@ -50,7 +50,7 @@ jobs:
|
|||
|
||||
- name: Build and Run Valgrind
|
||||
run: |
|
||||
# The Pillow user in the docker container is UID 1000
|
||||
sudo chown -R 1000 $GITHUB_WORKSPACE
|
||||
# The Pillow user in the docker container is UID 1001
|
||||
sudo chown -R 1001 $GITHUB_WORKSPACE
|
||||
docker run --name pillow_container -e "PILLOW_VALGRIND_TEST=true" -v $GITHUB_WORKSPACE:/Pillow pythonpillow/${{ matrix.docker }}:${{ matrix.dockerTag }}
|
||||
sudo chown -R runner $GITHUB_WORKSPACE
|
||||
|
|
|
|||
5
.github/workflows/test-windows.yml
vendored
5
.github/workflows/test-windows.yml
vendored
|
|
@ -86,7 +86,7 @@ jobs:
|
|||
choco install nasm --no-progress
|
||||
echo "C:\Program Files\NASM" >> $env:GITHUB_PATH
|
||||
|
||||
choco install ghostscript --version=10.3.0 --no-progress
|
||||
choco install ghostscript --version=10.3.1 --no-progress
|
||||
echo "C:\Program Files\gs\gs10.00.0\bin" >> $env:GITHUB_PATH
|
||||
|
||||
# Install extra test images
|
||||
|
|
@ -213,11 +213,12 @@ jobs:
|
|||
shell: pwsh
|
||||
|
||||
- name: Upload coverage
|
||||
uses: codecov/codecov-action@v3.1.5
|
||||
uses: codecov/codecov-action@v4
|
||||
with:
|
||||
file: ./coverage.xml
|
||||
flags: GHA_Windows
|
||||
name: ${{ runner.os }} Python ${{ matrix.python-version }}
|
||||
token: ${{ secrets.CODECOV_ORG_TOKEN }}
|
||||
|
||||
success:
|
||||
permissions:
|
||||
|
|
|
|||
7
.github/workflows/test.yml
vendored
7
.github/workflows/test.yml
vendored
|
|
@ -57,9 +57,9 @@ jobs:
|
|||
- python-version: "3.10"
|
||||
PYTHONOPTIMIZE: 2
|
||||
# M1 only available for 3.10+
|
||||
- os: "macos-latest"
|
||||
- os: "macos-13"
|
||||
python-version: "3.9"
|
||||
- os: "macos-latest"
|
||||
- os: "macos-13"
|
||||
python-version: "3.8"
|
||||
exclude:
|
||||
- os: "macos-14"
|
||||
|
|
@ -150,11 +150,12 @@ jobs:
|
|||
.ci/after_success.sh
|
||||
|
||||
- name: Upload coverage
|
||||
uses: codecov/codecov-action@v3.1.5
|
||||
uses: codecov/codecov-action@v4
|
||||
with:
|
||||
flags: ${{ matrix.os == 'ubuntu-latest' && 'GHA_Ubuntu' || 'GHA_macOS' }}
|
||||
name: ${{ matrix.os }} Python ${{ matrix.python-version }}
|
||||
gcov: true
|
||||
token: ${{ secrets.CODECOV_ORG_TOKEN }}
|
||||
|
||||
success:
|
||||
permissions:
|
||||
|
|
|
|||
10
.github/workflows/wheels-dependencies.sh
vendored
10
.github/workflows/wheels-dependencies.sh
vendored
|
|
@ -16,9 +16,9 @@ ARCHIVE_SDIR=pillow-depends-main
|
|||
|
||||
# Package versions for fresh source builds
|
||||
FREETYPE_VERSION=2.13.2
|
||||
HARFBUZZ_VERSION=8.4.0
|
||||
HARFBUZZ_VERSION=8.5.0
|
||||
LIBPNG_VERSION=1.6.43
|
||||
JPEGTURBO_VERSION=3.0.2
|
||||
JPEGTURBO_VERSION=3.0.3
|
||||
OPENJPEG_VERSION=2.5.2
|
||||
XZ_VERSION=5.4.5
|
||||
TIFF_VERSION=4.6.0
|
||||
|
|
@ -33,9 +33,9 @@ if [[ -n "$IS_MACOS" ]] || [[ "$MB_ML_VER" != 2014 ]]; then
|
|||
else
|
||||
ZLIB_VERSION=1.2.8
|
||||
fi
|
||||
LIBWEBP_VERSION=1.3.2
|
||||
LIBWEBP_VERSION=1.4.0
|
||||
BZIP2_VERSION=1.0.8
|
||||
LIBXCB_VERSION=1.16.1
|
||||
LIBXCB_VERSION=1.17.0
|
||||
BROTLI_VERSION=1.1.0
|
||||
|
||||
if [[ -n "$IS_MACOS" ]] && [[ "$CIBW_ARCHS" == "x86_64" ]]; then
|
||||
|
|
@ -70,7 +70,7 @@ function build {
|
|||
fi
|
||||
build_new_zlib
|
||||
|
||||
build_simple xcb-proto 1.16.0 https://xorg.freedesktop.org/archive/individual/proto
|
||||
build_simple xcb-proto 1.17.0 https://xorg.freedesktop.org/archive/individual/proto
|
||||
if [ -n "$IS_MACOS" ]; then
|
||||
build_simple xorgproto 2024.1 https://www.x.org/pub/individual/proto
|
||||
build_simple libXau 1.0.11 https://www.x.org/pub/individual/lib
|
||||
|
|
|
|||
2
.github/workflows/wheels-test.sh
vendored
2
.github/workflows/wheels-test.sh
vendored
|
|
@ -12,7 +12,7 @@ elif [ "${AUDITWHEEL_POLICY::9}" == "musllinux" ]; then
|
|||
else
|
||||
yum install -y fribidi
|
||||
fi
|
||||
if [ "${AUDITWHEEL_POLICY::9}" != "musllinux" ]; then
|
||||
if [ "${AUDITWHEEL_POLICY::9}" != "musllinux" ] && !([[ "$OSTYPE" == "darwin"* ]] && [[ $(python3 --version) == *"3.13."* ]]); then
|
||||
python3 -m pip install numpy
|
||||
fi
|
||||
|
||||
|
|
|
|||
6
.github/workflows/wheels.yml
vendored
6
.github/workflows/wheels.yml
vendored
|
|
@ -46,6 +46,7 @@ jobs:
|
|||
- cp310
|
||||
- cp311
|
||||
- cp312
|
||||
- cp313
|
||||
spec:
|
||||
- manylinux2014
|
||||
- manylinux_2_28
|
||||
|
|
@ -80,6 +81,7 @@ jobs:
|
|||
CIBW_ARCHS: "aarch64"
|
||||
# Likewise, select only one Python version per job to speed this up.
|
||||
CIBW_BUILD: "${{ matrix.python-version }}-${{ matrix.spec == 'musllinux' && 'musllinux' || 'manylinux' }}*"
|
||||
CIBW_PRERELEASE_PYTHONS: True
|
||||
# Extra options for manylinux.
|
||||
CIBW_MANYLINUX_AARCH64_IMAGE: ${{ matrix.spec }}
|
||||
CIBW_MANYLINUX_PYPY_AARCH64_IMAGE: ${{ matrix.spec }}
|
||||
|
|
@ -97,7 +99,7 @@ jobs:
|
|||
matrix:
|
||||
include:
|
||||
- name: "macOS x86_64"
|
||||
os: macos-latest
|
||||
os: macos-13
|
||||
cibw_arch: x86_64
|
||||
macosx_deployment_target: "10.10"
|
||||
- name: "macOS arm64"
|
||||
|
|
@ -133,6 +135,7 @@ jobs:
|
|||
CIBW_BUILD: ${{ matrix.build }}
|
||||
CIBW_MANYLINUX_PYPY_X86_64_IMAGE: ${{ matrix.manylinux }}
|
||||
CIBW_MANYLINUX_X86_64_IMAGE: ${{ matrix.manylinux }}
|
||||
CIBW_PRERELEASE_PYTHONS: True
|
||||
CIBW_SKIP: pp38-*
|
||||
CIBW_TEST_SKIP: cp38-macosx_arm64
|
||||
MACOSX_DEPLOYMENT_TARGET: ${{ matrix.macosx_deployment_target }}
|
||||
|
|
@ -204,6 +207,7 @@ jobs:
|
|||
CIBW_ARCHS: ${{ matrix.cibw_arch }}
|
||||
CIBW_BEFORE_ALL: "{package}\\winbuild\\build\\build_dep_all.cmd"
|
||||
CIBW_CACHE_PATH: "C:\\cibw"
|
||||
CIBW_PRERELEASE_PYTHONS: True
|
||||
CIBW_SKIP: pp38-*
|
||||
CIBW_TEST_SKIP: "*-win_arm64"
|
||||
CIBW_TEST_COMMAND: 'docker run --rm
|
||||
|
|
|
|||
|
|
@ -1,12 +1,12 @@
|
|||
repos:
|
||||
- repo: https://github.com/astral-sh/ruff-pre-commit
|
||||
rev: v0.3.4
|
||||
rev: v0.4.7
|
||||
hooks:
|
||||
- id: ruff
|
||||
args: [--exit-non-zero-on-fix]
|
||||
|
||||
- repo: https://github.com/psf/black-pre-commit-mirror
|
||||
rev: 24.3.0
|
||||
rev: 24.4.2
|
||||
hooks:
|
||||
- id: black
|
||||
|
||||
|
|
@ -23,13 +23,20 @@ repos:
|
|||
- id: remove-tabs
|
||||
exclude: (Makefile$|\.bat$|\.cmake$|\.eps$|\.fits$|\.gd$|\.opt$)
|
||||
|
||||
- repo: https://github.com/pre-commit/mirrors-clang-format
|
||||
rev: v18.1.5
|
||||
hooks:
|
||||
- id: clang-format
|
||||
types: [c]
|
||||
exclude: ^src/thirdparty/
|
||||
|
||||
- repo: https://github.com/pre-commit/pygrep-hooks
|
||||
rev: v1.10.0
|
||||
hooks:
|
||||
- id: rst-backticks
|
||||
|
||||
- repo: https://github.com/pre-commit/pre-commit-hooks
|
||||
rev: v4.5.0
|
||||
rev: v4.6.0
|
||||
hooks:
|
||||
- id: check-executables-have-shebangs
|
||||
- id: check-shebang-scripts-are-executable
|
||||
|
|
@ -43,7 +50,7 @@ repos:
|
|||
exclude: ^.github/.*TEMPLATE|^Tests/(fonts|images)/
|
||||
|
||||
- repo: https://github.com/python-jsonschema/check-jsonschema
|
||||
rev: 0.28.1
|
||||
rev: 0.28.4
|
||||
hooks:
|
||||
- id: check-github-workflows
|
||||
- id: check-readthedocs
|
||||
|
|
@ -55,12 +62,12 @@ repos:
|
|||
- id: sphinx-lint
|
||||
|
||||
- repo: https://github.com/tox-dev/pyproject-fmt
|
||||
rev: 1.7.0
|
||||
rev: 1.8.0
|
||||
hooks:
|
||||
- id: pyproject-fmt
|
||||
|
||||
- repo: https://github.com/abravalheri/validate-pyproject
|
||||
rev: v0.16
|
||||
rev: v0.18
|
||||
hooks:
|
||||
- id: validate-pyproject
|
||||
|
||||
|
|
|
|||
|
|
@ -6,6 +6,10 @@ build:
|
|||
os: ubuntu-22.04
|
||||
tools:
|
||||
python: "3"
|
||||
jobs:
|
||||
post_checkout:
|
||||
- git remote add upstream https://github.com/python-pillow/Pillow.git # For forks
|
||||
- git fetch upstream --tags
|
||||
|
||||
python:
|
||||
install:
|
||||
|
|
|
|||
36
CHANGES.rst
36
CHANGES.rst
|
|
@ -2,6 +2,42 @@
|
|||
Changelog (Pillow)
|
||||
==================
|
||||
|
||||
10.4.0 (unreleased)
|
||||
-------------------
|
||||
|
||||
- Added ImageDraw circle() #8085
|
||||
[void4, hugovk, radarhere]
|
||||
|
||||
- Add mypy target to Makefile #8077
|
||||
[Yay295]
|
||||
|
||||
- Added more modes to Image.MODES #7984
|
||||
[radarhere]
|
||||
|
||||
- Deprecate BGR;15, BGR;16 and BGR;24 modes #7978
|
||||
[radarhere, hugovk]
|
||||
|
||||
- Fix ImagingAccess for I;16N on big-endian #7921
|
||||
[Yay295, radarhere]
|
||||
|
||||
- Support reading P mode TIFF images with padding #7996
|
||||
[radarhere]
|
||||
|
||||
- Deprecate support for libtiff < 4 #7998
|
||||
[radarhere, hugovk]
|
||||
|
||||
- Corrected ImageShow UnixViewer command #7987
|
||||
[radarhere]
|
||||
|
||||
- Use functools.cached_property in ImageStat #7952
|
||||
[nulano, hugovk, radarhere]
|
||||
|
||||
- Add support for reading BITMAPV2INFOHEADER and BITMAPV3INFOHEADER #7956
|
||||
[Cirras, radarhere]
|
||||
|
||||
- Support reading CMYK JPEG2000 images #7947
|
||||
[radarhere]
|
||||
|
||||
10.3.0 (2024-04-01)
|
||||
-------------------
|
||||
|
||||
|
|
|
|||
8
Makefile
8
Makefile
|
|
@ -2,7 +2,6 @@
|
|||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
python3 setup.py clean
|
||||
rm src/PIL/*.so || true
|
||||
rm -r build || true
|
||||
find . -name __pycache__ | xargs rm -r || true
|
||||
|
|
@ -78,8 +77,6 @@ release-test:
|
|||
python3 selftest.py
|
||||
python3 -m pytest Tests
|
||||
python3 -m pip install .
|
||||
-rm dist/*.egg
|
||||
-rmdir dist
|
||||
python3 -m pytest -qq
|
||||
python3 -m check_manifest
|
||||
python3 -m pyroma .
|
||||
|
|
@ -121,3 +118,8 @@ lint-fix:
|
|||
python3 -m black .
|
||||
python3 -c "import ruff" > /dev/null 2>&1 || python3 -m pip install ruff
|
||||
python3 -m ruff --fix .
|
||||
|
||||
.PHONY: mypy
|
||||
mypy:
|
||||
python3 -c "import tox" > /dev/null 2>&1 || python3 -m pip install tox
|
||||
python3 -m tox -e mypy
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ The core image library is designed for fast access to data stored in a few basic
|
|||
## More Information
|
||||
|
||||
- [Documentation](https://pillow.readthedocs.io/)
|
||||
- [Installation](https://pillow.readthedocs.io/en/latest/installation.html)
|
||||
- [Installation](https://pillow.readthedocs.io/en/latest/installation/basic-installation.html)
|
||||
- [Handbook](https://pillow.readthedocs.io/en/latest/handbook/index.html)
|
||||
- [Contribute](https://github.com/python-pillow/Pillow/blob/main/.github/CONTRIBUTING.md)
|
||||
- [Issues](https://github.com/python-pillow/Pillow/issues)
|
||||
|
|
|
|||
20
RELEASING.md
20
RELEASING.md
|
|
@ -20,8 +20,10 @@ Released quarterly on January 2nd, April 1st, July 1st and October 15th.
|
|||
git tag 5.2.0
|
||||
git push --tags
|
||||
```
|
||||
* [ ] Create and upload all [source and binary distributions](https://github.com/python-pillow/Pillow/blob/main/RELEASING.md#source-and-binary-distributions)
|
||||
* [ ] Publish the [release on GitHub](https://github.com/python-pillow/Pillow/releases)
|
||||
* [ ] Check the [GitHub Actions "Wheels" workflow](https://github.com/python-pillow/Pillow/actions/workflows/wheels.yml)
|
||||
has passed, including the "Upload release to PyPI" job. This will have been triggered
|
||||
by the new tag.
|
||||
* [ ] Publish the [release on GitHub](https://github.com/python-pillow/Pillow/releases).
|
||||
* [ ] In compliance with [PEP 440](https://peps.python.org/pep-0440/),
|
||||
increment and append `.dev0` to version identifier in `src/PIL/_version.py` and then:
|
||||
```bash
|
||||
|
|
@ -50,7 +52,9 @@ Released as needed for security, installation or critical bug fixes.
|
|||
```bash
|
||||
make sdist
|
||||
```
|
||||
* [ ] Create and upload all [source and binary distributions](https://github.com/python-pillow/Pillow/blob/main/RELEASING.md#source-and-binary-distributions)
|
||||
* [ ] Check the [GitHub Actions "Wheels" workflow](https://github.com/python-pillow/Pillow/actions/workflows/wheels.yml)
|
||||
has passed, including the "Upload release to PyPI" job. This will have been triggered
|
||||
by the new tag.
|
||||
* [ ] Publish the [release on GitHub](https://github.com/python-pillow/Pillow/releases) and then:
|
||||
```bash
|
||||
git push
|
||||
|
|
@ -72,18 +76,14 @@ Released as needed privately to individual vendors for critical security-related
|
|||
git tag 2.5.3
|
||||
git push origin --tags
|
||||
```
|
||||
* [ ] Create and upload all [source and binary distributions](https://github.com/python-pillow/Pillow/blob/main/RELEASING.md#source-and-binary-distributions)
|
||||
* [ ] Check the [GitHub Actions "Wheels" workflow](https://github.com/python-pillow/Pillow/actions/workflows/wheels.yml)
|
||||
has passed, including the "Upload release to PyPI" job. This will have been triggered
|
||||
by the new tag.
|
||||
* [ ] Publish the [release on GitHub](https://github.com/python-pillow/Pillow/releases) and then:
|
||||
```bash
|
||||
git push origin 2.5.x
|
||||
```
|
||||
|
||||
## Source and Binary Distributions
|
||||
|
||||
* [ ] Check the [GitHub Actions "Wheels" workflow](https://github.com/python-pillow/Pillow/actions/workflows/wheels.yml)
|
||||
has passed, including the "Upload release to PyPI" job. This will have been triggered
|
||||
by the new tag.
|
||||
|
||||
## Publicize Release
|
||||
|
||||
* [ ] Announce release availability via [Mastodon](https://fosstodon.org/@pillow) e.g. https://fosstodon.org/@pillow/110639450470725321
|
||||
|
|
|
|||
|
|
@ -44,6 +44,7 @@ def test_direct() -> None:
|
|||
caccess = im.im.pixel_access(False)
|
||||
access = PyAccess.new(im, False)
|
||||
|
||||
assert access is not None
|
||||
assert caccess[(0, 0)] == access[(0, 0)]
|
||||
|
||||
print(f"Size: {im.width}x{im.height}")
|
||||
|
|
|
|||
|
|
@ -174,12 +174,13 @@ def skip_unless_feature(feature: str) -> pytest.MarkDecorator:
|
|||
def skip_unless_feature_version(
|
||||
feature: str, required: str, reason: str | None = None
|
||||
) -> pytest.MarkDecorator:
|
||||
if not features.check(feature):
|
||||
version = features.version(feature)
|
||||
if version is None:
|
||||
return pytest.mark.skip(f"{feature} not available")
|
||||
if reason is None:
|
||||
reason = f"{feature} is older than {required}"
|
||||
version_required = parse_version(required)
|
||||
version_available = parse_version(features.version(feature))
|
||||
version_available = parse_version(version)
|
||||
return pytest.mark.skipif(version_available < version_required, reason=reason)
|
||||
|
||||
|
||||
|
|
@ -189,12 +190,13 @@ def mark_if_feature_version(
|
|||
version_blacklist: str,
|
||||
reason: str | None = None,
|
||||
) -> pytest.MarkDecorator:
|
||||
if not features.check(feature):
|
||||
version = features.version(feature)
|
||||
if version is None:
|
||||
return pytest.mark.pil_noop_mark()
|
||||
if reason is None:
|
||||
reason = f"{feature} is {version_blacklist}"
|
||||
version_required = parse_version(version_blacklist)
|
||||
version_available = parse_version(features.version(feature))
|
||||
version_available = parse_version(version)
|
||||
if (
|
||||
version_available.major == version_required.major
|
||||
and version_available.minor == version_required.minor
|
||||
|
|
@ -220,16 +222,11 @@ class PillowLeakTestCase:
|
|||
from resource import RUSAGE_SELF, getrusage
|
||||
|
||||
mem = getrusage(RUSAGE_SELF).ru_maxrss
|
||||
if sys.platform == "darwin":
|
||||
# man 2 getrusage:
|
||||
# ru_maxrss
|
||||
# This is the maximum resident set size utilized (in bytes).
|
||||
return mem / 1024 # Kb
|
||||
# linux
|
||||
# man 2 getrusage
|
||||
# ru_maxrss (since Linux 2.6.32)
|
||||
# This is the maximum resident set size used (in kilobytes).
|
||||
return mem # Kb
|
||||
# man 2 getrusage:
|
||||
# ru_maxrss
|
||||
# This is the maximum resident set size utilized
|
||||
# in bytes on macOS, in kilobytes on Linux
|
||||
return mem / 1024 if sys.platform == "darwin" else mem
|
||||
|
||||
def _test_leak(self, core: Callable[[], None]) -> None:
|
||||
start_mem = self._get_mem_usage()
|
||||
|
|
@ -273,7 +270,18 @@ def _cached_hopper(mode: str) -> Image.Image:
|
|||
im = hopper("L")
|
||||
else:
|
||||
im = hopper()
|
||||
return im.convert(mode)
|
||||
if mode.startswith("BGR;"):
|
||||
with pytest.warns(DeprecationWarning):
|
||||
im = im.convert(mode)
|
||||
else:
|
||||
try:
|
||||
im = im.convert(mode)
|
||||
except ImportError:
|
||||
if mode == "LAB":
|
||||
im = Image.open("Tests/images/hopper.Lab.tif")
|
||||
else:
|
||||
raise
|
||||
return im
|
||||
|
||||
|
||||
def djpeg_available() -> bool:
|
||||
|
|
|
|||
BIN
Tests/images/bmp/q/rgb32h52.bmp
Normal file
BIN
Tests/images/bmp/q/rgb32h52.bmp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 32 KiB |
BIN
Tests/images/bmp/q/rgba32h56.bmp
Normal file
BIN
Tests/images/bmp/q/rgba32h56.bmp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 32 KiB |
|
|
@ -12,8 +12,9 @@ from Tests.helper import skip_unless_feature
|
|||
|
||||
if sys.platform.startswith("win32"):
|
||||
pytest.skip("Fuzzer is linux only", allow_module_level=True)
|
||||
if features.check("libjpeg_turbo"):
|
||||
version = packaging.version.parse(features.version("libjpeg_turbo"))
|
||||
libjpeg_turbo_version = features.version("libjpeg_turbo")
|
||||
if libjpeg_turbo_version is not None:
|
||||
version = packaging.version.parse(libjpeg_turbo_version)
|
||||
if version.major == 2 and version.minor == 0:
|
||||
pytestmark = pytest.mark.valgrind_known_error(
|
||||
reason="Known failing with libjpeg_turbo 2.0"
|
||||
|
|
|
|||
|
|
@ -44,6 +44,9 @@ def test_questionable() -> None:
|
|||
"pal8os2sp.bmp",
|
||||
"pal8rletrns.bmp",
|
||||
"rgb32bf-xbgr.bmp",
|
||||
"rgba32.bmp",
|
||||
"rgb32h52.bmp",
|
||||
"rgba32h56.bmp",
|
||||
]
|
||||
for f in get_files("q"):
|
||||
try:
|
||||
|
|
|
|||
|
|
@ -30,13 +30,15 @@ def test_version() -> None:
|
|||
# Check the correctness of the convenience function
|
||||
# and the format of version numbers
|
||||
|
||||
def test(name: str, function: Callable[[str], bool]) -> None:
|
||||
def test(name: str, function: Callable[[str], str | None]) -> None:
|
||||
version = features.version(name)
|
||||
if not features.check(name):
|
||||
assert version is None
|
||||
else:
|
||||
assert function(name) == version
|
||||
if name != "PIL":
|
||||
if name == "zlib" and version is not None:
|
||||
version = version.replace(".zlib-ng", "")
|
||||
assert version is None or re.search(r"\d+(\.\d+)*$", version)
|
||||
|
||||
for module in features.modules:
|
||||
|
|
@ -65,12 +67,16 @@ def test_webp_anim() -> None:
|
|||
|
||||
@skip_unless_feature("libjpeg_turbo")
|
||||
def test_libjpeg_turbo_version() -> None:
|
||||
assert re.search(r"\d+\.\d+\.\d+$", features.version("libjpeg_turbo"))
|
||||
version = features.version("libjpeg_turbo")
|
||||
assert version is not None
|
||||
assert re.search(r"\d+\.\d+\.\d+$", version)
|
||||
|
||||
|
||||
@skip_unless_feature("libimagequant")
|
||||
def test_libimagequant_version() -> None:
|
||||
assert re.search(r"\d+\.\d+\.\d+$", features.version("libimagequant"))
|
||||
version = features.version("libimagequant")
|
||||
assert version is not None
|
||||
assert re.search(r"\d+\.\d+\.\d+$", version)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("feature", features.modules)
|
||||
|
|
@ -118,7 +124,7 @@ def test_unsupported_module() -> None:
|
|||
|
||||
|
||||
@pytest.mark.parametrize("supported_formats", (True, False))
|
||||
def test_pilinfo(supported_formats) -> None:
|
||||
def test_pilinfo(supported_formats: bool) -> None:
|
||||
buf = io.StringIO()
|
||||
features.pilinfo(buf, supported_formats=supported_formats)
|
||||
out = buf.getvalue()
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ from pathlib import Path
|
|||
|
||||
import pytest
|
||||
|
||||
from PIL import BmpImagePlugin, Image
|
||||
from PIL import BmpImagePlugin, Image, _binary
|
||||
|
||||
from .helper import (
|
||||
assert_image_equal,
|
||||
|
|
@ -128,6 +128,29 @@ def test_load_dib() -> None:
|
|||
assert_image_equal_tofile(im, "Tests/images/clipboard_target.png")
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"header_size, path",
|
||||
(
|
||||
(12, "g/pal8os2.bmp"),
|
||||
(40, "g/pal1.bmp"),
|
||||
(52, "q/rgb32h52.bmp"),
|
||||
(56, "q/rgba32h56.bmp"),
|
||||
(64, "q/pal8os2v2.bmp"),
|
||||
(108, "g/pal8v4.bmp"),
|
||||
(124, "g/pal8v5.bmp"),
|
||||
),
|
||||
)
|
||||
def test_dib_header_size(header_size: int, path: str) -> None:
|
||||
image_path = "Tests/images/bmp/" + path
|
||||
with open(image_path, "rb") as fp:
|
||||
data = fp.read()[14:]
|
||||
assert _binary.i32le(data) == header_size
|
||||
|
||||
dib = io.BytesIO(data)
|
||||
with Image.open(dib) as im:
|
||||
im.load()
|
||||
|
||||
|
||||
def test_save_dib(tmp_path: Path) -> None:
|
||||
outfile = str(tmp_path / "temp.dib")
|
||||
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
from __future__ import annotations
|
||||
|
||||
from pathlib import Path
|
||||
from typing import IO
|
||||
|
||||
import pytest
|
||||
|
||||
from PIL import BufrStubImagePlugin, Image
|
||||
from PIL import BufrStubImagePlugin, Image, ImageFile
|
||||
|
||||
from .helper import hopper
|
||||
|
||||
|
|
@ -50,20 +51,20 @@ def test_save(tmp_path: Path) -> None:
|
|||
|
||||
|
||||
def test_handler(tmp_path: Path) -> None:
|
||||
class TestHandler:
|
||||
class TestHandler(ImageFile.StubHandler):
|
||||
opened = False
|
||||
loaded = False
|
||||
saved = False
|
||||
|
||||
def open(self, im) -> None:
|
||||
def open(self, im: ImageFile.StubImageFile) -> None:
|
||||
self.opened = True
|
||||
|
||||
def load(self, im):
|
||||
def load(self, im: ImageFile.StubImageFile) -> Image.Image:
|
||||
self.loaded = True
|
||||
im.fp.close()
|
||||
return Image.new("RGB", (1, 1))
|
||||
|
||||
def save(self, im, fp, filename) -> None:
|
||||
def save(self, im: Image.Image, fp: IO[bytes], filename: str) -> None:
|
||||
self.saved = True
|
||||
|
||||
handler = TestHandler()
|
||||
|
|
|
|||
|
|
@ -336,9 +336,7 @@ def test_readline_psfile(tmp_path: Path) -> None:
|
|||
strings = ["something", "else", "baz", "bif"]
|
||||
|
||||
def _test_readline(t: EpsImagePlugin.PSFile, ending: str) -> None:
|
||||
ending = "Failure with line ending: %s" % (
|
||||
"".join("%s" % ord(s) for s in ending)
|
||||
)
|
||||
ending = f"Failure with line ending: {''.join(str(ord(s)) for s in ending)}"
|
||||
assert t.readline().strip("\r\n") == "something", ending
|
||||
assert t.readline().strip("\r\n") == "else", ending
|
||||
assert t.readline().strip("\r\n") == "baz", ending
|
||||
|
|
|
|||
|
|
@ -1252,10 +1252,11 @@ def test_palette_save_L(tmp_path: Path) -> None:
|
|||
|
||||
im = hopper("P")
|
||||
im_l = Image.frombytes("L", im.size, im.tobytes())
|
||||
palette = bytes(im.getpalette())
|
||||
palette = im.getpalette()
|
||||
assert palette is not None
|
||||
|
||||
out = str(tmp_path / "temp.gif")
|
||||
im_l.save(out, palette=palette)
|
||||
im_l.save(out, palette=bytes(palette))
|
||||
|
||||
with Image.open(out) as reloaded:
|
||||
assert_image_equal(reloaded.convert("RGB"), im.convert("RGB"))
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ from typing import IO
|
|||
|
||||
import pytest
|
||||
|
||||
from PIL import GribStubImagePlugin, Image
|
||||
from PIL import GribStubImagePlugin, Image, ImageFile
|
||||
|
||||
from .helper import hopper
|
||||
|
||||
|
|
@ -51,7 +51,7 @@ def test_save(tmp_path: Path) -> None:
|
|||
|
||||
|
||||
def test_handler(tmp_path: Path) -> None:
|
||||
class TestHandler:
|
||||
class TestHandler(ImageFile.StubHandler):
|
||||
opened = False
|
||||
loaded = False
|
||||
saved = False
|
||||
|
|
|
|||
|
|
@ -1,11 +1,12 @@
|
|||
from __future__ import annotations
|
||||
|
||||
from io import BytesIO
|
||||
from pathlib import Path
|
||||
from typing import IO
|
||||
|
||||
import pytest
|
||||
|
||||
from PIL import Hdf5StubImagePlugin, Image
|
||||
from PIL import Hdf5StubImagePlugin, Image, ImageFile
|
||||
|
||||
TEST_FILE = "Tests/images/hdf5.h5"
|
||||
|
||||
|
|
@ -41,7 +42,7 @@ def test_load() -> None:
|
|||
def test_save() -> None:
|
||||
# Arrange
|
||||
with Image.open(TEST_FILE) as im:
|
||||
dummy_fp = None
|
||||
dummy_fp = BytesIO()
|
||||
dummy_filename = "dummy.filename"
|
||||
|
||||
# Act / Assert: stub cannot save without an implemented handler
|
||||
|
|
@ -52,7 +53,7 @@ def test_save() -> None:
|
|||
|
||||
|
||||
def test_handler(tmp_path: Path) -> None:
|
||||
class TestHandler:
|
||||
class TestHandler(ImageFile.StubHandler):
|
||||
opened = False
|
||||
loaded = False
|
||||
saved = False
|
||||
|
|
|
|||
|
|
@ -70,7 +70,9 @@ class TestFileJpeg:
|
|||
|
||||
def test_sanity(self) -> None:
|
||||
# internal version number
|
||||
assert re.search(r"\d+\.\d+$", features.version_codec("jpg"))
|
||||
version = features.version_codec("jpg")
|
||||
assert version is not None
|
||||
assert re.search(r"\d+\.\d+$", version)
|
||||
|
||||
with Image.open(TEST_FILE) as im:
|
||||
im.load()
|
||||
|
|
@ -152,7 +154,7 @@ class TestFileJpeg:
|
|||
assert k > 0.9
|
||||
|
||||
def test_rgb(self) -> None:
|
||||
def getchannels(im: Image.Image) -> tuple[int, int, int]:
|
||||
def getchannels(im: JpegImagePlugin.JpegImageFile) -> tuple[int, int, int]:
|
||||
return tuple(v[0] for v in im.layer)
|
||||
|
||||
im = hopper()
|
||||
|
|
@ -169,7 +171,7 @@ class TestFileJpeg:
|
|||
[TEST_FILE, "Tests/images/pil_sample_cmyk.jpg"],
|
||||
)
|
||||
def test_dpi(self, test_image_path: str) -> None:
|
||||
def test(xdpi: int, ydpi: int | None = None):
|
||||
def test(xdpi: int, ydpi: int | None = None) -> tuple[int, int] | None:
|
||||
with Image.open(test_image_path) as im:
|
||||
im = self.roundtrip(im, dpi=(xdpi, ydpi or xdpi))
|
||||
return im.info.get("dpi")
|
||||
|
|
@ -441,7 +443,7 @@ class TestFileJpeg:
|
|||
assert_image(im1, im2.mode, im2.size)
|
||||
|
||||
def test_subsampling(self) -> None:
|
||||
def getsampling(im: Image.Image):
|
||||
def getsampling(im: JpegImagePlugin.JpegImageFile):
|
||||
layer = im.layer
|
||||
return layer[0][1:3] + layer[1][1:3] + layer[2][1:3]
|
||||
|
||||
|
|
|
|||
|
|
@ -48,7 +48,9 @@ def roundtrip(im: Image.Image, **options: Any) -> Image.Image:
|
|||
|
||||
def test_sanity() -> None:
|
||||
# Internal version number
|
||||
assert re.search(r"\d+\.\d+\.\d+$", features.version_codec("jpg_2000"))
|
||||
version = features.version_codec("jpg_2000")
|
||||
assert version is not None
|
||||
assert re.search(r"\d+\.\d+\.\d+$", version)
|
||||
|
||||
with Image.open("Tests/images/test-card-lossless.jp2") as im:
|
||||
px = im.load()
|
||||
|
|
@ -289,6 +291,16 @@ def test_rgba(ext: str) -> None:
|
|||
assert im.mode == "RGBA"
|
||||
|
||||
|
||||
@pytest.mark.skipif(
|
||||
not os.path.exists(EXTRA_DIR), reason="Extra image files not installed"
|
||||
)
|
||||
@skip_unless_feature_version("jpg_2000", "2.5.1")
|
||||
def test_cmyk() -> None:
|
||||
with Image.open(f"{EXTRA_DIR}/issue205.jp2") as im:
|
||||
assert im.mode == "CMYK"
|
||||
assert im.getpixel((0, 0)) == (185, 134, 0, 0)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("ext", (".j2k", ".jp2"))
|
||||
def test_16bit_monochrome_has_correct_mode(ext: str) -> None:
|
||||
with Image.open("Tests/images/16bit.cropped" + ext) as im:
|
||||
|
|
|
|||
|
|
@ -52,7 +52,9 @@ class LibTiffTestCase:
|
|||
|
||||
class TestFileLibTiff(LibTiffTestCase):
|
||||
def test_version(self) -> None:
|
||||
assert re.search(r"\d+\.\d+\.\d+$", features.version_codec("libtiff"))
|
||||
version = features.version_codec("libtiff")
|
||||
assert version is not None
|
||||
assert re.search(r"\d+\.\d+\.\d+$", version)
|
||||
|
||||
def test_g4_tiff(self, tmp_path: Path) -> None:
|
||||
"""Test the ordinary file path load path"""
|
||||
|
|
@ -185,7 +187,9 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
assert field in reloaded, f"{field} not in metadata"
|
||||
|
||||
@pytest.mark.valgrind_known_error(reason="Known invalid metadata")
|
||||
def test_additional_metadata(self, tmp_path: Path) -> None:
|
||||
def test_additional_metadata(
|
||||
self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
|
||||
) -> None:
|
||||
# these should not crash. Seriously dummy data, most of it doesn't make
|
||||
# any sense, so we're running up against limits where we're asking
|
||||
# libtiff to do stupid things.
|
||||
|
|
@ -236,13 +240,28 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
del new_ifd[338]
|
||||
|
||||
out = str(tmp_path / "temp.tif")
|
||||
TiffImagePlugin.WRITE_LIBTIFF = True
|
||||
monkeypatch.setattr(TiffImagePlugin, "WRITE_LIBTIFF", True)
|
||||
|
||||
im.save(out, tiffinfo=new_ifd)
|
||||
|
||||
TiffImagePlugin.WRITE_LIBTIFF = False
|
||||
@pytest.mark.parametrize(
|
||||
"libtiff",
|
||||
(
|
||||
pytest.param(
|
||||
True,
|
||||
marks=pytest.mark.skipif(
|
||||
not getattr(Image.core, "libtiff_support_custom_tags", False),
|
||||
reason="Custom tags not supported by older libtiff",
|
||||
),
|
||||
),
|
||||
False,
|
||||
),
|
||||
)
|
||||
def test_custom_metadata(
|
||||
self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path, libtiff: bool
|
||||
) -> None:
|
||||
monkeypatch.setattr(TiffImagePlugin, "WRITE_LIBTIFF", libtiff)
|
||||
|
||||
def test_custom_metadata(self, tmp_path: Path) -> None:
|
||||
class Tc(NamedTuple):
|
||||
value: Any
|
||||
type: int
|
||||
|
|
@ -281,53 +300,43 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
)
|
||||
}
|
||||
|
||||
libtiffs = [False]
|
||||
if Image.core.libtiff_support_custom_tags:
|
||||
libtiffs.append(True)
|
||||
def check_tags(
|
||||
tiffinfo: TiffImagePlugin.ImageFileDirectory_v2 | dict[int, str]
|
||||
) -> None:
|
||||
im = hopper()
|
||||
|
||||
for libtiff in libtiffs:
|
||||
TiffImagePlugin.WRITE_LIBTIFF = libtiff
|
||||
out = str(tmp_path / "temp.tif")
|
||||
im.save(out, tiffinfo=tiffinfo)
|
||||
|
||||
def check_tags(
|
||||
tiffinfo: TiffImagePlugin.ImageFileDirectory_v2 | dict[int, str]
|
||||
) -> None:
|
||||
im = hopper()
|
||||
with Image.open(out) as reloaded:
|
||||
for tag, value in tiffinfo.items():
|
||||
reloaded_value = reloaded.tag_v2[tag]
|
||||
if (
|
||||
isinstance(reloaded_value, TiffImagePlugin.IFDRational)
|
||||
and libtiff
|
||||
):
|
||||
# libtiff does not support real RATIONALS
|
||||
assert round(abs(float(reloaded_value) - float(value)), 7) == 0
|
||||
continue
|
||||
|
||||
out = str(tmp_path / "temp.tif")
|
||||
im.save(out, tiffinfo=tiffinfo)
|
||||
assert reloaded_value == value
|
||||
|
||||
with Image.open(out) as reloaded:
|
||||
for tag, value in tiffinfo.items():
|
||||
reloaded_value = reloaded.tag_v2[tag]
|
||||
if (
|
||||
isinstance(reloaded_value, TiffImagePlugin.IFDRational)
|
||||
and libtiff
|
||||
):
|
||||
# libtiff does not support real RATIONALS
|
||||
assert (
|
||||
round(abs(float(reloaded_value) - float(value)), 7) == 0
|
||||
)
|
||||
continue
|
||||
# Test with types
|
||||
ifd = TiffImagePlugin.ImageFileDirectory_v2()
|
||||
for tag, tagdata in custom.items():
|
||||
ifd[tag] = tagdata.value
|
||||
ifd.tagtype[tag] = tagdata.type
|
||||
check_tags(ifd)
|
||||
|
||||
assert reloaded_value == value
|
||||
|
||||
# Test with types
|
||||
ifd = TiffImagePlugin.ImageFileDirectory_v2()
|
||||
for tag, tagdata in custom.items():
|
||||
ifd[tag] = tagdata.value
|
||||
ifd.tagtype[tag] = tagdata.type
|
||||
check_tags(ifd)
|
||||
|
||||
# Test without types. This only works for some types, int for example are
|
||||
# always encoded as LONG and not SIGNED_LONG.
|
||||
check_tags(
|
||||
{
|
||||
tag: tagdata.value
|
||||
for tag, tagdata in custom.items()
|
||||
if tagdata.supported_by_default
|
||||
}
|
||||
)
|
||||
TiffImagePlugin.WRITE_LIBTIFF = False
|
||||
# Test without types. This only works for some types, int for example are
|
||||
# always encoded as LONG and not SIGNED_LONG.
|
||||
check_tags(
|
||||
{
|
||||
tag: tagdata.value
|
||||
for tag, tagdata in custom.items()
|
||||
if tagdata.supported_by_default
|
||||
}
|
||||
)
|
||||
|
||||
def test_osubfiletype(self, tmp_path: Path) -> None:
|
||||
outfile = str(tmp_path / "temp.tif")
|
||||
|
|
@ -343,24 +352,24 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
# Should not segfault
|
||||
im.save(outfile)
|
||||
|
||||
def test_xmlpacket_tag(self, tmp_path: Path) -> None:
|
||||
TiffImagePlugin.WRITE_LIBTIFF = True
|
||||
def test_xmlpacket_tag(
|
||||
self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
|
||||
) -> None:
|
||||
monkeypatch.setattr(TiffImagePlugin, "WRITE_LIBTIFF", True)
|
||||
|
||||
out = str(tmp_path / "temp.tif")
|
||||
hopper().save(out, tiffinfo={700: b"xmlpacket tag"})
|
||||
TiffImagePlugin.WRITE_LIBTIFF = False
|
||||
|
||||
with Image.open(out) as reloaded:
|
||||
if 700 in reloaded.tag_v2:
|
||||
assert reloaded.tag_v2[700] == b"xmlpacket tag"
|
||||
|
||||
def test_int_dpi(self, tmp_path: Path) -> None:
|
||||
def test_int_dpi(self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
|
||||
# issue #1765
|
||||
im = hopper("RGB")
|
||||
out = str(tmp_path / "temp.tif")
|
||||
TiffImagePlugin.WRITE_LIBTIFF = True
|
||||
monkeypatch.setattr(TiffImagePlugin, "WRITE_LIBTIFF", True)
|
||||
im.save(out, dpi=(72, 72))
|
||||
TiffImagePlugin.WRITE_LIBTIFF = False
|
||||
with Image.open(out) as reloaded:
|
||||
assert reloaded.info["dpi"] == (72.0, 72.0)
|
||||
|
||||
|
|
@ -422,13 +431,13 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
assert "temp.tif" == reread.tag_v2[269]
|
||||
assert "temp.tif" == reread.tag[269][0]
|
||||
|
||||
def test_12bit_rawmode(self) -> None:
|
||||
def test_12bit_rawmode(self, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
"""Are we generating the same interpretation
|
||||
of the image as Imagemagick is?"""
|
||||
TiffImagePlugin.READ_LIBTIFF = True
|
||||
monkeypatch.setattr(TiffImagePlugin, "READ_LIBTIFF", True)
|
||||
with Image.open("Tests/images/12bit.cropped.tif") as im:
|
||||
im.load()
|
||||
TiffImagePlugin.READ_LIBTIFF = False
|
||||
monkeypatch.setattr(TiffImagePlugin, "READ_LIBTIFF", False)
|
||||
# to make the target --
|
||||
# convert 12bit.cropped.tif -depth 16 tmp.tif
|
||||
# convert tmp.tif -evaluate RightShift 4 12in16bit2.tif
|
||||
|
|
@ -514,12 +523,13 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
assert_image_equal_tofile(im, out)
|
||||
|
||||
@pytest.mark.parametrize("im", (hopper("P"), Image.new("P", (1, 1), "#000")))
|
||||
def test_palette_save(self, im: Image.Image, tmp_path: Path) -> None:
|
||||
def test_palette_save(
|
||||
self, im: Image.Image, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
|
||||
) -> None:
|
||||
out = str(tmp_path / "temp.tif")
|
||||
|
||||
TiffImagePlugin.WRITE_LIBTIFF = True
|
||||
monkeypatch.setattr(TiffImagePlugin, "WRITE_LIBTIFF", True)
|
||||
im.save(out)
|
||||
TiffImagePlugin.WRITE_LIBTIFF = False
|
||||
|
||||
with Image.open(out) as reloaded:
|
||||
# colormap/palette tag
|
||||
|
|
@ -548,9 +558,9 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
with pytest.raises(OSError):
|
||||
os.close(fn)
|
||||
|
||||
def test_multipage(self) -> None:
|
||||
def test_multipage(self, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
# issue #862
|
||||
TiffImagePlugin.READ_LIBTIFF = True
|
||||
monkeypatch.setattr(TiffImagePlugin, "READ_LIBTIFF", True)
|
||||
with Image.open("Tests/images/multipage.tiff") as im:
|
||||
# file is a multipage tiff, 10x10 green, 10x10 red, 20x20 blue
|
||||
|
||||
|
|
@ -569,11 +579,9 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
assert im.size == (20, 20)
|
||||
assert im.convert("RGB").getpixel((0, 0)) == (0, 0, 255)
|
||||
|
||||
TiffImagePlugin.READ_LIBTIFF = False
|
||||
|
||||
def test_multipage_nframes(self) -> None:
|
||||
def test_multipage_nframes(self, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
# issue #862
|
||||
TiffImagePlugin.READ_LIBTIFF = True
|
||||
monkeypatch.setattr(TiffImagePlugin, "READ_LIBTIFF", True)
|
||||
with Image.open("Tests/images/multipage.tiff") as im:
|
||||
frames = im.n_frames
|
||||
assert frames == 3
|
||||
|
|
@ -582,10 +590,8 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
# Should not raise ValueError: I/O operation on closed file
|
||||
im.load()
|
||||
|
||||
TiffImagePlugin.READ_LIBTIFF = False
|
||||
|
||||
def test_multipage_seek_backwards(self) -> None:
|
||||
TiffImagePlugin.READ_LIBTIFF = True
|
||||
def test_multipage_seek_backwards(self, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
monkeypatch.setattr(TiffImagePlugin, "READ_LIBTIFF", True)
|
||||
with Image.open("Tests/images/multipage.tiff") as im:
|
||||
im.seek(1)
|
||||
im.load()
|
||||
|
|
@ -593,24 +599,21 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
im.seek(0)
|
||||
assert im.convert("RGB").getpixel((0, 0)) == (0, 128, 0)
|
||||
|
||||
TiffImagePlugin.READ_LIBTIFF = False
|
||||
|
||||
def test__next(self) -> None:
|
||||
TiffImagePlugin.READ_LIBTIFF = True
|
||||
def test__next(self, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
monkeypatch.setattr(TiffImagePlugin, "READ_LIBTIFF", True)
|
||||
with Image.open("Tests/images/hopper.tif") as im:
|
||||
assert not im.tag.next
|
||||
im.load()
|
||||
assert not im.tag.next
|
||||
|
||||
def test_4bit(self) -> None:
|
||||
def test_4bit(self, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
# Arrange
|
||||
test_file = "Tests/images/hopper_gray_4bpp.tif"
|
||||
original = hopper("L")
|
||||
|
||||
# Act
|
||||
TiffImagePlugin.READ_LIBTIFF = True
|
||||
monkeypatch.setattr(TiffImagePlugin, "READ_LIBTIFF", True)
|
||||
with Image.open(test_file) as im:
|
||||
TiffImagePlugin.READ_LIBTIFF = False
|
||||
|
||||
# Assert
|
||||
assert im.size == (128, 128)
|
||||
|
|
@ -650,12 +653,12 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
assert im2.mode == "L"
|
||||
assert_image_equal(im, im2)
|
||||
|
||||
def test_save_bytesio(self) -> None:
|
||||
def test_save_bytesio(self, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
# PR 1011
|
||||
# Test TIFF saving to io.BytesIO() object.
|
||||
|
||||
TiffImagePlugin.WRITE_LIBTIFF = True
|
||||
TiffImagePlugin.READ_LIBTIFF = True
|
||||
monkeypatch.setattr(TiffImagePlugin, "WRITE_LIBTIFF", True)
|
||||
monkeypatch.setattr(TiffImagePlugin, "READ_LIBTIFF", True)
|
||||
|
||||
# Generate test image
|
||||
pilim = hopper()
|
||||
|
|
@ -665,16 +668,14 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
pilim.save(buffer_io, format="tiff", compression=compression)
|
||||
buffer_io.seek(0)
|
||||
|
||||
assert_image_similar_tofile(pilim, buffer_io, 0)
|
||||
with Image.open(buffer_io) as saved_im:
|
||||
assert_image_similar(pilim, saved_im, 0)
|
||||
|
||||
save_bytesio()
|
||||
save_bytesio("raw")
|
||||
save_bytesio("packbits")
|
||||
save_bytesio("tiff_lzw")
|
||||
|
||||
TiffImagePlugin.WRITE_LIBTIFF = False
|
||||
TiffImagePlugin.READ_LIBTIFF = False
|
||||
|
||||
def test_save_ycbcr(self, tmp_path: Path) -> None:
|
||||
im = hopper("YCbCr")
|
||||
outfile = str(tmp_path / "temp.tif")
|
||||
|
|
@ -694,15 +695,16 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
if Image.core.libtiff_support_custom_tags:
|
||||
assert reloaded.tag_v2[34665] == 125456
|
||||
|
||||
def test_crashing_metadata(self, tmp_path: Path) -> None:
|
||||
def test_crashing_metadata(
|
||||
self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
|
||||
) -> None:
|
||||
# issue 1597
|
||||
with Image.open("Tests/images/rdf.tif") as im:
|
||||
out = str(tmp_path / "temp.tif")
|
||||
|
||||
TiffImagePlugin.WRITE_LIBTIFF = True
|
||||
monkeypatch.setattr(TiffImagePlugin, "WRITE_LIBTIFF", True)
|
||||
# this shouldn't crash
|
||||
im.save(out, format="TIFF")
|
||||
TiffImagePlugin.WRITE_LIBTIFF = False
|
||||
|
||||
def test_page_number_x_0(self, tmp_path: Path) -> None:
|
||||
# Issue 973
|
||||
|
|
@ -733,36 +735,41 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
# Should not raise PermissionError.
|
||||
os.remove(tmpfile)
|
||||
|
||||
def test_read_icc(self) -> None:
|
||||
def test_read_icc(self, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
with Image.open("Tests/images/hopper.iccprofile.tif") as img:
|
||||
icc = img.info.get("icc_profile")
|
||||
assert icc is not None
|
||||
TiffImagePlugin.READ_LIBTIFF = True
|
||||
monkeypatch.setattr(TiffImagePlugin, "READ_LIBTIFF", True)
|
||||
with Image.open("Tests/images/hopper.iccprofile.tif") as img:
|
||||
icc_libtiff = img.info.get("icc_profile")
|
||||
assert icc_libtiff is not None
|
||||
TiffImagePlugin.READ_LIBTIFF = False
|
||||
assert icc == icc_libtiff
|
||||
|
||||
def test_write_icc(self, tmp_path: Path) -> None:
|
||||
def check_write(libtiff: bool) -> None:
|
||||
TiffImagePlugin.WRITE_LIBTIFF = libtiff
|
||||
@pytest.mark.parametrize(
|
||||
"libtiff",
|
||||
(
|
||||
pytest.param(
|
||||
True,
|
||||
marks=pytest.mark.skipif(
|
||||
not getattr(Image.core, "libtiff_support_custom_tags", False),
|
||||
reason="Custom tags not supported by older libtiff",
|
||||
),
|
||||
),
|
||||
False,
|
||||
),
|
||||
)
|
||||
def test_write_icc(
|
||||
self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path, libtiff: bool
|
||||
) -> None:
|
||||
monkeypatch.setattr(TiffImagePlugin, "WRITE_LIBTIFF", libtiff)
|
||||
|
||||
with Image.open("Tests/images/hopper.iccprofile.tif") as img:
|
||||
icc_profile = img.info["icc_profile"]
|
||||
with Image.open("Tests/images/hopper.iccprofile.tif") as img:
|
||||
icc_profile = img.info["icc_profile"]
|
||||
|
||||
out = str(tmp_path / "temp.tif")
|
||||
img.save(out, icc_profile=icc_profile)
|
||||
with Image.open(out) as reloaded:
|
||||
assert icc_profile == reloaded.info["icc_profile"]
|
||||
|
||||
libtiffs = []
|
||||
if Image.core.libtiff_support_custom_tags:
|
||||
libtiffs.append(True)
|
||||
libtiffs.append(False)
|
||||
|
||||
for libtiff in libtiffs:
|
||||
check_write(libtiff)
|
||||
out = str(tmp_path / "temp.tif")
|
||||
img.save(out, icc_profile=icc_profile)
|
||||
with Image.open(out) as reloaded:
|
||||
assert icc_profile == reloaded.info["icc_profile"]
|
||||
|
||||
def test_multipage_compression(self) -> None:
|
||||
with Image.open("Tests/images/compression.tif") as im:
|
||||
|
|
@ -840,12 +847,13 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
|
||||
assert_image_equal_tofile(im, "Tests/images/copyleft.png", mode="RGB")
|
||||
|
||||
def test_sampleformat_write(self, tmp_path: Path) -> None:
|
||||
def test_sampleformat_write(
|
||||
self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
|
||||
) -> None:
|
||||
im = Image.new("F", (1, 1))
|
||||
out = str(tmp_path / "temp.tif")
|
||||
TiffImagePlugin.WRITE_LIBTIFF = True
|
||||
monkeypatch.setattr(TiffImagePlugin, "WRITE_LIBTIFF", True)
|
||||
im.save(out)
|
||||
TiffImagePlugin.WRITE_LIBTIFF = False
|
||||
|
||||
with Image.open(out) as reloaded:
|
||||
assert reloaded.mode == "F"
|
||||
|
|
@ -1091,15 +1099,14 @@ class TestFileLibTiff(LibTiffTestCase):
|
|||
with Image.open(out) as im:
|
||||
im.load()
|
||||
|
||||
def test_realloc_overflow(self) -> None:
|
||||
TiffImagePlugin.READ_LIBTIFF = True
|
||||
def test_realloc_overflow(self, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
monkeypatch.setattr(TiffImagePlugin, "READ_LIBTIFF", True)
|
||||
with Image.open("Tests/images/tiff_overflow_rows_per_strip.tif") as im:
|
||||
with pytest.raises(OSError) as e:
|
||||
im.load()
|
||||
|
||||
# Assert that the error code is IMAGING_CODEC_MEMORY
|
||||
assert str(e.value) == "-9"
|
||||
TiffImagePlugin.READ_LIBTIFF = False
|
||||
|
||||
@pytest.mark.parametrize("compression", ("tiff_adobe_deflate", "jpeg"))
|
||||
def test_save_multistrip(self, compression: str, tmp_path: Path) -> None:
|
||||
|
|
|
|||
39
Tests/test_file_mpeg.py
Normal file
39
Tests/test_file_mpeg.py
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
from __future__ import annotations
|
||||
|
||||
from io import BytesIO
|
||||
|
||||
import pytest
|
||||
|
||||
from PIL import Image, MpegImagePlugin
|
||||
|
||||
|
||||
def test_identify() -> None:
|
||||
# Arrange
|
||||
b = BytesIO(b"\x00\x00\x01\xb3\x01\x00\x01")
|
||||
|
||||
# Act
|
||||
with Image.open(b) as im:
|
||||
# Assert
|
||||
assert im.format == "MPEG"
|
||||
|
||||
assert im.mode == "RGB"
|
||||
assert im.size == (16, 1)
|
||||
|
||||
|
||||
def test_invalid_file() -> None:
|
||||
# Arrange
|
||||
invalid_file = "Tests/images/flower.jpg"
|
||||
|
||||
# Act / Assert
|
||||
with pytest.raises(SyntaxError):
|
||||
MpegImagePlugin.MpegImageFile(invalid_file)
|
||||
|
||||
|
||||
def test_load() -> None:
|
||||
# Arrange
|
||||
b = BytesIO(b"\x00\x00\x01\xb3\x01\x00\x01")
|
||||
|
||||
with Image.open(b) as im:
|
||||
# Act / Assert: cannot load
|
||||
with pytest.raises(OSError):
|
||||
im.load()
|
||||
|
|
@ -85,7 +85,9 @@ class TestFilePng:
|
|||
|
||||
def test_sanity(self, tmp_path: Path) -> None:
|
||||
# internal version number
|
||||
assert re.search(r"\d+(\.\d+){1,3}$", features.version_codec("zlib"))
|
||||
version = features.version_codec("zlib")
|
||||
assert version is not None
|
||||
assert re.search(r"\d+(\.\d+){1,3}(\.zlib\-ng)?$", version)
|
||||
|
||||
test_file = str(tmp_path / "temp.png")
|
||||
|
||||
|
|
|
|||
|
|
@ -49,7 +49,9 @@ class TestFileWebp:
|
|||
def test_version(self) -> None:
|
||||
_webp.WebPDecoderVersion()
|
||||
_webp.WebPDecoderBuggyAlpha()
|
||||
assert re.search(r"\d+\.\d+\.\d+$", features.version_module("webp"))
|
||||
version = features.version_module("webp")
|
||||
assert version is not None
|
||||
assert re.search(r"\d+\.\d+\.\d+$", version)
|
||||
|
||||
def test_read_rgb(self) -> None:
|
||||
"""
|
||||
|
|
@ -202,7 +204,9 @@ class TestFileWebp:
|
|||
(0, (0,), (-1, 0, 1, 2), (253, 254, 255, 256)),
|
||||
)
|
||||
@skip_unless_feature("webp_anim")
|
||||
def test_invalid_background(self, background, tmp_path: Path) -> None:
|
||||
def test_invalid_background(
|
||||
self, background: int | tuple[int, ...], tmp_path: Path
|
||||
) -> None:
|
||||
temp_file = str(tmp_path / "temp.webp")
|
||||
im = hopper()
|
||||
with pytest.raises(OSError):
|
||||
|
|
|
|||
|
|
@ -52,8 +52,9 @@ def test_write_animation_L(tmp_path: Path) -> None:
|
|||
assert_image_similar(im, orig.convert("RGBA"), 32.9)
|
||||
|
||||
if is_big_endian():
|
||||
webp = parse_version(features.version_module("webp"))
|
||||
if webp < parse_version("1.2.2"):
|
||||
version = features.version_module("webp")
|
||||
assert version is not None
|
||||
if parse_version(version) < parse_version("1.2.2"):
|
||||
pytest.skip("Fails with libwebp earlier than 1.2.2")
|
||||
orig.seek(orig.n_frames - 1)
|
||||
im.seek(im.n_frames - 1)
|
||||
|
|
@ -68,7 +69,7 @@ def test_write_animation_RGB(tmp_path: Path) -> None:
|
|||
are visually similar to the originals.
|
||||
"""
|
||||
|
||||
def check(temp_file) -> None:
|
||||
def check(temp_file: str) -> None:
|
||||
with Image.open(temp_file) as im:
|
||||
assert im.n_frames == 2
|
||||
|
||||
|
|
@ -78,8 +79,9 @@ def test_write_animation_RGB(tmp_path: Path) -> None:
|
|||
|
||||
# Compare second frame to original
|
||||
if is_big_endian():
|
||||
webp = parse_version(features.version_module("webp"))
|
||||
if webp < parse_version("1.2.2"):
|
||||
version = features.version_module("webp")
|
||||
assert version is not None
|
||||
if parse_version(version) < parse_version("1.2.2"):
|
||||
pytest.skip("Fails with libwebp earlier than 1.2.2")
|
||||
im.seek(1)
|
||||
im.load()
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
from __future__ import annotations
|
||||
|
||||
from pathlib import Path
|
||||
from typing import IO
|
||||
|
||||
import pytest
|
||||
|
||||
from PIL import Image, WmfImagePlugin
|
||||
from PIL import Image, ImageFile, WmfImagePlugin
|
||||
|
||||
from .helper import assert_image_similar_tofile, hopper
|
||||
|
||||
|
|
@ -34,10 +35,13 @@ def test_load() -> None:
|
|||
|
||||
|
||||
def test_register_handler(tmp_path: Path) -> None:
|
||||
class TestHandler:
|
||||
class TestHandler(ImageFile.StubHandler):
|
||||
methodCalled = False
|
||||
|
||||
def save(self, im, fp, filename) -> None:
|
||||
def load(self, im: ImageFile.StubImageFile) -> Image.Image:
|
||||
return Image.new("RGB", (1, 1))
|
||||
|
||||
def save(self, im: Image.Image, fp: IO[bytes], filename: str) -> None:
|
||||
self.methodCalled = True
|
||||
|
||||
handler = TestHandler()
|
||||
|
|
@ -70,7 +74,7 @@ def test_load_set_dpi() -> None:
|
|||
|
||||
|
||||
@pytest.mark.parametrize("ext", (".wmf", ".emf"))
|
||||
def test_save(ext, tmp_path: Path) -> None:
|
||||
def test_save(ext: str, tmp_path: Path) -> None:
|
||||
im = hopper()
|
||||
|
||||
tmpfile = str(tmp_path / ("temp" + ext))
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ class TestTTypeFontLeak(PillowLeakTestCase):
|
|||
iterations = 10
|
||||
mem_limit = 4096 # k
|
||||
|
||||
def _test_font(self, font: ImageFont.FreeTypeFont) -> None:
|
||||
def _test_font(self, font: ImageFont.FreeTypeFont | ImageFont.ImageFont) -> None:
|
||||
im = Image.new("RGB", (255, 255), "white")
|
||||
draw = ImageDraw.ImageDraw(im)
|
||||
self._test_leak(
|
||||
|
|
|
|||
|
|
@ -26,48 +26,30 @@ from PIL import (
|
|||
from .helper import (
|
||||
assert_image_equal,
|
||||
assert_image_equal_tofile,
|
||||
assert_image_similar,
|
||||
assert_image_similar_tofile,
|
||||
assert_not_all_same,
|
||||
hopper,
|
||||
is_big_endian,
|
||||
is_win32,
|
||||
mark_if_feature_version,
|
||||
skip_unless_feature,
|
||||
)
|
||||
|
||||
# name, pixel size
|
||||
image_modes = (
|
||||
("1", 1),
|
||||
("L", 1),
|
||||
("LA", 4),
|
||||
("La", 4),
|
||||
("P", 1),
|
||||
("PA", 4),
|
||||
("F", 4),
|
||||
("I", 4),
|
||||
("I;16", 2),
|
||||
("I;16L", 2),
|
||||
("I;16B", 2),
|
||||
("I;16N", 2),
|
||||
("RGB", 4),
|
||||
("RGBA", 4),
|
||||
("RGBa", 4),
|
||||
("RGBX", 4),
|
||||
("BGR;15", 2),
|
||||
("BGR;16", 2),
|
||||
("BGR;24", 3),
|
||||
("CMYK", 4),
|
||||
("YCbCr", 4),
|
||||
("HSV", 4),
|
||||
("LAB", 4),
|
||||
)
|
||||
|
||||
image_mode_names = [name for name, _ in image_modes]
|
||||
# Deprecation helper
|
||||
def helper_image_new(mode: str, size: tuple[int, int]) -> Image.Image:
|
||||
if mode.startswith("BGR;"):
|
||||
with pytest.warns(DeprecationWarning):
|
||||
return Image.new(mode, size)
|
||||
else:
|
||||
return Image.new(mode, size)
|
||||
|
||||
|
||||
class TestImage:
|
||||
@pytest.mark.parametrize("mode", image_mode_names)
|
||||
@pytest.mark.parametrize("mode", Image.MODES + ["BGR;15", "BGR;16", "BGR;24"])
|
||||
def test_image_modes_success(self, mode: str) -> None:
|
||||
Image.new(mode, (1, 1))
|
||||
helper_image_new(mode, (1, 1))
|
||||
|
||||
@pytest.mark.parametrize("mode", ("", "bad", "very very long"))
|
||||
def test_image_modes_fail(self, mode: str) -> None:
|
||||
|
|
@ -119,10 +101,18 @@ class TestImage:
|
|||
JPGFILE = "Tests/images/hopper.jpg"
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
with Image.open(PNGFILE, formats=123):
|
||||
with Image.open(PNGFILE, formats=123): # type: ignore[arg-type]
|
||||
pass
|
||||
|
||||
for formats in [["JPEG"], ("JPEG",), ["jpeg"], ["Jpeg"], ["jPeG"], ["JpEg"]]:
|
||||
format_list: list[list[str] | tuple[str, ...]] = [
|
||||
["JPEG"],
|
||||
("JPEG",),
|
||||
["jpeg"],
|
||||
["Jpeg"],
|
||||
["jPeG"],
|
||||
["JpEg"],
|
||||
]
|
||||
for formats in format_list:
|
||||
with pytest.raises(UnidentifiedImageError):
|
||||
with Image.open(PNGFILE, formats=formats):
|
||||
pass
|
||||
|
|
@ -158,7 +148,7 @@ class TestImage:
|
|||
|
||||
def test_bad_mode(self) -> None:
|
||||
with pytest.raises(ValueError):
|
||||
with Image.open("filename", "bad mode"):
|
||||
with Image.open("filename", "bad mode"): # type: ignore[arg-type]
|
||||
pass
|
||||
|
||||
def test_stringio(self) -> None:
|
||||
|
|
@ -205,7 +195,8 @@ class TestImage:
|
|||
with tempfile.TemporaryFile() as fp:
|
||||
im.save(fp, "JPEG")
|
||||
fp.seek(0)
|
||||
assert_image_similar_tofile(im, fp, 20)
|
||||
with Image.open(fp) as reloaded:
|
||||
assert_image_similar(im, reloaded, 20)
|
||||
|
||||
def test_unknown_extension(self, tmp_path: Path) -> None:
|
||||
im = hopper()
|
||||
|
|
@ -578,9 +569,11 @@ class TestImage:
|
|||
def test_check_size(self) -> None:
|
||||
# Checking that the _check_size function throws value errors when we want it to
|
||||
with pytest.raises(ValueError):
|
||||
Image.new("RGB", 0) # not a tuple
|
||||
# not a tuple
|
||||
Image.new("RGB", 0) # type: ignore[arg-type]
|
||||
with pytest.raises(ValueError):
|
||||
Image.new("RGB", (0,)) # Tuple too short
|
||||
# tuple too short
|
||||
Image.new("RGB", (0,)) # type: ignore[arg-type]
|
||||
with pytest.raises(ValueError):
|
||||
Image.new("RGB", (-1, -1)) # w,h < 0
|
||||
|
||||
|
|
@ -1107,30 +1100,33 @@ class TestImage:
|
|||
|
||||
|
||||
class TestImageBytes:
|
||||
@pytest.mark.parametrize("mode", image_mode_names)
|
||||
@pytest.mark.parametrize("mode", Image.MODES + ["BGR;15", "BGR;16", "BGR;24"])
|
||||
def test_roundtrip_bytes_constructor(self, mode: str) -> None:
|
||||
im = hopper(mode)
|
||||
source_bytes = im.tobytes()
|
||||
|
||||
reloaded = Image.frombytes(mode, im.size, source_bytes)
|
||||
if mode.startswith("BGR;"):
|
||||
with pytest.warns(DeprecationWarning):
|
||||
reloaded = Image.frombytes(mode, im.size, source_bytes)
|
||||
else:
|
||||
reloaded = Image.frombytes(mode, im.size, source_bytes)
|
||||
assert reloaded.tobytes() == source_bytes
|
||||
|
||||
@pytest.mark.parametrize("mode", image_mode_names)
|
||||
@pytest.mark.parametrize("mode", Image.MODES + ["BGR;15", "BGR;16", "BGR;24"])
|
||||
def test_roundtrip_bytes_method(self, mode: str) -> None:
|
||||
im = hopper(mode)
|
||||
source_bytes = im.tobytes()
|
||||
|
||||
reloaded = Image.new(mode, im.size)
|
||||
reloaded = helper_image_new(mode, im.size)
|
||||
reloaded.frombytes(source_bytes)
|
||||
assert reloaded.tobytes() == source_bytes
|
||||
|
||||
@pytest.mark.parametrize(("mode", "pixelsize"), image_modes)
|
||||
def test_getdata_putdata(self, mode: str, pixelsize: int) -> None:
|
||||
im = Image.new(mode, (2, 2))
|
||||
source_bytes = bytes(range(im.width * im.height * pixelsize))
|
||||
im.frombytes(source_bytes)
|
||||
|
||||
reloaded = Image.new(mode, im.size)
|
||||
@pytest.mark.parametrize("mode", Image.MODES + ["BGR;15", "BGR;16", "BGR;24"])
|
||||
def test_getdata_putdata(self, mode: str) -> None:
|
||||
if is_big_endian() and mode == "BGR;15":
|
||||
pytest.xfail("Known failure of BGR;15 on big-endian")
|
||||
im = hopper(mode)
|
||||
reloaded = helper_image_new(mode, im.size)
|
||||
reloaded.putdata(im.getdata())
|
||||
assert_image_equal(im, reloaded)
|
||||
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ except ImportError:
|
|||
|
||||
|
||||
class AccessTest:
|
||||
# initial value
|
||||
# Initial value
|
||||
_init_cffi_access = Image.USE_CFFI_ACCESS
|
||||
_need_cffi_access = False
|
||||
|
||||
|
|
@ -138,8 +138,8 @@ class TestImageGetPixel(AccessTest):
|
|||
if bands == 1:
|
||||
return 1
|
||||
if mode in ("BGR;15", "BGR;16"):
|
||||
# These modes have less than 8 bits per band
|
||||
# So (1, 2, 3) cannot be roundtripped
|
||||
# These modes have less than 8 bits per band,
|
||||
# so (1, 2, 3) cannot be roundtripped.
|
||||
return (16, 32, 49)
|
||||
return tuple(range(1, bands + 1))
|
||||
|
||||
|
|
@ -151,7 +151,7 @@ class TestImageGetPixel(AccessTest):
|
|||
self.color(mode) if expected_color_int is None else expected_color_int
|
||||
)
|
||||
|
||||
# check putpixel
|
||||
# Check putpixel
|
||||
im = Image.new(mode, (1, 1), None)
|
||||
im.putpixel((0, 0), expected_color)
|
||||
actual_color = im.getpixel((0, 0))
|
||||
|
|
@ -160,7 +160,7 @@ class TestImageGetPixel(AccessTest):
|
|||
f"expected {expected_color} got {actual_color}"
|
||||
)
|
||||
|
||||
# check putpixel negative index
|
||||
# Check putpixel negative index
|
||||
im.putpixel((-1, -1), expected_color)
|
||||
actual_color = im.getpixel((-1, -1))
|
||||
assert actual_color == expected_color, (
|
||||
|
|
@ -168,22 +168,21 @@ class TestImageGetPixel(AccessTest):
|
|||
f"expected {expected_color} got {actual_color}"
|
||||
)
|
||||
|
||||
# Check 0
|
||||
# Check 0x0 image with None initial color
|
||||
im = Image.new(mode, (0, 0), None)
|
||||
assert im.load() is not None
|
||||
|
||||
error = ValueError if self._need_cffi_access else IndexError
|
||||
with pytest.raises(error):
|
||||
im.putpixel((0, 0), expected_color)
|
||||
with pytest.raises(error):
|
||||
im.getpixel((0, 0))
|
||||
# Check 0 negative index
|
||||
# Check negative index
|
||||
with pytest.raises(error):
|
||||
im.putpixel((-1, -1), expected_color)
|
||||
with pytest.raises(error):
|
||||
im.getpixel((-1, -1))
|
||||
|
||||
# check initial color
|
||||
# Check initial color
|
||||
im = Image.new(mode, (1, 1), expected_color)
|
||||
actual_color = im.getpixel((0, 0))
|
||||
assert actual_color == expected_color, (
|
||||
|
|
@ -191,46 +190,30 @@ class TestImageGetPixel(AccessTest):
|
|||
f"expected {expected_color} got {actual_color}"
|
||||
)
|
||||
|
||||
# check initial color negative index
|
||||
# Check initial color negative index
|
||||
actual_color = im.getpixel((-1, -1))
|
||||
assert actual_color == expected_color, (
|
||||
f"initial color failed with negative index for mode {mode}, "
|
||||
f"expected {expected_color} got {actual_color}"
|
||||
)
|
||||
|
||||
# Check 0
|
||||
# Check 0x0 image with initial color
|
||||
im = Image.new(mode, (0, 0), expected_color)
|
||||
with pytest.raises(error):
|
||||
im.getpixel((0, 0))
|
||||
# Check 0 negative index
|
||||
# Check negative index
|
||||
with pytest.raises(error):
|
||||
im.getpixel((-1, -1))
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"mode",
|
||||
(
|
||||
"1",
|
||||
"L",
|
||||
"LA",
|
||||
"I",
|
||||
"I;16",
|
||||
"I;16B",
|
||||
"F",
|
||||
"P",
|
||||
"PA",
|
||||
"BGR;15",
|
||||
"BGR;16",
|
||||
"BGR;24",
|
||||
"RGB",
|
||||
"RGBA",
|
||||
"RGBX",
|
||||
"CMYK",
|
||||
"YCbCr",
|
||||
),
|
||||
)
|
||||
@pytest.mark.parametrize("mode", Image.MODES)
|
||||
def test_basic(self, mode: str) -> None:
|
||||
self.check(mode)
|
||||
|
||||
@pytest.mark.parametrize("mode", ("BGR;15", "BGR;16", "BGR;24"))
|
||||
def test_deprecated(self, mode: str) -> None:
|
||||
with pytest.warns(DeprecationWarning):
|
||||
self.check(mode)
|
||||
|
||||
def test_list(self) -> None:
|
||||
im = hopper()
|
||||
assert im.getpixel([0, 0]) == (20, 20, 70)
|
||||
|
|
@ -238,7 +221,7 @@ class TestImageGetPixel(AccessTest):
|
|||
@pytest.mark.parametrize("mode", ("I;16", "I;16B"))
|
||||
@pytest.mark.parametrize("expected_color", (2**15 - 1, 2**15, 2**15 + 1, 2**16 - 1))
|
||||
def test_signedness(self, mode: str, expected_color: int) -> None:
|
||||
# see https://github.com/python-pillow/Pillow/issues/452
|
||||
# See https://github.com/python-pillow/Pillow/issues/452
|
||||
# pixelaccess is using signed int* instead of uint*
|
||||
self.check(mode, expected_color)
|
||||
|
||||
|
|
@ -276,6 +259,7 @@ class TestCffi(AccessTest):
|
|||
caccess = im.im.pixel_access(False)
|
||||
with pytest.warns(DeprecationWarning):
|
||||
access = PyAccess.new(im, False)
|
||||
assert access is not None
|
||||
|
||||
w, h = im.size
|
||||
for x in range(0, w, 10):
|
||||
|
|
@ -298,13 +282,6 @@ class TestCffi(AccessTest):
|
|||
im = Image.new(mode, (10, 10), 40000)
|
||||
self._test_get_access(im)
|
||||
|
||||
# These don't actually appear to be modes that I can actually make,
|
||||
# as unpack sets them directly into the I mode.
|
||||
# im = Image.new('I;32L', (10, 10), -2**10)
|
||||
# self._test_get_access(im)
|
||||
# im = Image.new('I;32B', (10, 10), 2**10)
|
||||
# self._test_get_access(im)
|
||||
|
||||
def _test_set_access(self, im: Image.Image, color: tuple[int, ...] | float) -> None:
|
||||
"""Are we writing the correct bits into the image?
|
||||
|
||||
|
|
@ -313,6 +290,7 @@ class TestCffi(AccessTest):
|
|||
caccess = im.im.pixel_access(False)
|
||||
with pytest.warns(DeprecationWarning):
|
||||
access = PyAccess.new(im, False)
|
||||
assert access is not None
|
||||
|
||||
w, h = im.size
|
||||
for x in range(0, w, 10):
|
||||
|
|
@ -323,6 +301,8 @@ class TestCffi(AccessTest):
|
|||
# Attempt to set the value on a read-only image
|
||||
with pytest.warns(DeprecationWarning):
|
||||
access = PyAccess.new(im, True)
|
||||
assert access is not None
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
access[(0, 0)] = color
|
||||
|
||||
|
|
@ -336,23 +316,18 @@ class TestCffi(AccessTest):
|
|||
self._test_set_access(hopper("LA"), (128, 128))
|
||||
self._test_set_access(hopper("1"), 255)
|
||||
self._test_set_access(hopper("P"), 128)
|
||||
# self._test_set_access(i, (128, 128)) #PA -- undone how to make
|
||||
self._test_set_access(hopper("PA"), (128, 128))
|
||||
self._test_set_access(hopper("F"), 1024.0)
|
||||
|
||||
for mode in ("I;16", "I;16L", "I;16B", "I;16N", "I"):
|
||||
im = Image.new(mode, (10, 10), 40000)
|
||||
self._test_set_access(im, 45000)
|
||||
|
||||
# im = Image.new('I;32L', (10, 10), -(2**10))
|
||||
# self._test_set_access(im, -(2**13)+1)
|
||||
# im = Image.new('I;32B', (10, 10), 2**10)
|
||||
# self._test_set_access(im, 2**13-1)
|
||||
|
||||
@pytest.mark.filterwarnings("ignore::DeprecationWarning")
|
||||
def test_not_implemented(self) -> None:
|
||||
assert PyAccess.new(hopper("BGR;15")) is None
|
||||
|
||||
# ref https://github.com/python-pillow/Pillow/pull/2009
|
||||
# Ref https://github.com/python-pillow/Pillow/pull/2009
|
||||
def test_reference_counting(self) -> None:
|
||||
size = 10
|
||||
|
||||
|
|
@ -361,7 +336,7 @@ class TestCffi(AccessTest):
|
|||
with pytest.warns(DeprecationWarning):
|
||||
px = Image.new("L", (size, 1), 0).load()
|
||||
for i in range(size):
|
||||
# pixels can contain garbage if image is released
|
||||
# Pixels can contain garbage if image is released
|
||||
assert px[i, 0] == 0
|
||||
|
||||
@pytest.mark.parametrize("mode", ("P", "PA"))
|
||||
|
|
@ -370,6 +345,8 @@ class TestCffi(AccessTest):
|
|||
im = Image.new(mode, (1, 1))
|
||||
with pytest.warns(DeprecationWarning):
|
||||
access = PyAccess.new(im, False)
|
||||
assert access is not None
|
||||
|
||||
access.putpixel((0, 0), color)
|
||||
|
||||
if len(color) == 3:
|
||||
|
|
@ -439,13 +416,14 @@ class TestEmbeddable:
|
|||
from setuptools.command import build_ext
|
||||
|
||||
with open("embed_pil.c", "w", encoding="utf-8") as fh:
|
||||
home = sys.prefix.replace("\\", "\\\\")
|
||||
fh.write(
|
||||
"""
|
||||
f"""
|
||||
#include "Python.h"
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
char *home = "%s";
|
||||
{{
|
||||
char *home = "{home}";
|
||||
wchar_t *whome = Py_DecodeLocale(home, NULL);
|
||||
Py_SetPythonHome(whome);
|
||||
|
||||
|
|
@ -460,9 +438,8 @@ int main(int argc, char* argv[])
|
|||
PyMem_RawFree(whome);
|
||||
|
||||
return 0;
|
||||
}
|
||||
}}
|
||||
"""
|
||||
% sys.prefix.replace("\\", "\\\\")
|
||||
)
|
||||
|
||||
compiler = getattr(build_ext, "new_compiler")()
|
||||
|
|
@ -478,7 +455,7 @@ int main(int argc, char* argv[])
|
|||
env = os.environ.copy()
|
||||
env["PATH"] = sys.prefix + ";" + env["PATH"]
|
||||
|
||||
# do not display the Windows Error Reporting dialog
|
||||
# Do not display the Windows Error Reporting dialog
|
||||
getattr(ctypes, "windll").kernel32.SetErrorMode(0x0002)
|
||||
|
||||
process = subprocess.Popen(["embed_pil.exe"], env=env)
|
||||
|
|
|
|||
|
|
@ -86,11 +86,21 @@ def test_fromarray() -> None:
|
|||
assert test("RGBX") == ("RGBA", (128, 100), True)
|
||||
|
||||
# Test mode is None with no "typestr" in the array interface
|
||||
wrapped = Wrapper(hopper("L"), {"shape": (100, 128)})
|
||||
with pytest.raises(TypeError):
|
||||
wrapped = Wrapper(test("L"), {"shape": (100, 128)})
|
||||
Image.fromarray(wrapped)
|
||||
|
||||
|
||||
def test_fromarray_strides_without_tobytes() -> None:
|
||||
class Wrapper:
|
||||
def __init__(self, arr_params: dict[str, Any]) -> None:
|
||||
self.__array_interface__ = arr_params
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
wrapped = Wrapper({"shape": (1, 1), "strides": (1, 1)})
|
||||
Image.fromarray(wrapped, "L")
|
||||
|
||||
|
||||
def test_fromarray_palette() -> None:
|
||||
# Arrange
|
||||
i = im.convert("L")
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ def test_crop(mode: str) -> None:
|
|||
|
||||
|
||||
def test_wide_crop() -> None:
|
||||
def crop(*bbox: int) -> tuple[int, ...]:
|
||||
def crop(bbox: tuple[int, int, int, int]) -> tuple[int, ...]:
|
||||
i = im.crop(bbox)
|
||||
h = i.histogram()
|
||||
while h and not h[-1]:
|
||||
|
|
@ -27,23 +27,23 @@ def test_wide_crop() -> None:
|
|||
|
||||
im = Image.new("L", (100, 100), 1)
|
||||
|
||||
assert crop(0, 0, 100, 100) == (0, 10000)
|
||||
assert crop(25, 25, 75, 75) == (0, 2500)
|
||||
assert crop((0, 0, 100, 100)) == (0, 10000)
|
||||
assert crop((25, 25, 75, 75)) == (0, 2500)
|
||||
|
||||
# sides
|
||||
assert crop(-25, 0, 25, 50) == (1250, 1250)
|
||||
assert crop(0, -25, 50, 25) == (1250, 1250)
|
||||
assert crop(75, 0, 125, 50) == (1250, 1250)
|
||||
assert crop(0, 75, 50, 125) == (1250, 1250)
|
||||
assert crop((-25, 0, 25, 50)) == (1250, 1250)
|
||||
assert crop((0, -25, 50, 25)) == (1250, 1250)
|
||||
assert crop((75, 0, 125, 50)) == (1250, 1250)
|
||||
assert crop((0, 75, 50, 125)) == (1250, 1250)
|
||||
|
||||
assert crop(-25, 25, 125, 75) == (2500, 5000)
|
||||
assert crop(25, -25, 75, 125) == (2500, 5000)
|
||||
assert crop((-25, 25, 125, 75)) == (2500, 5000)
|
||||
assert crop((25, -25, 75, 125)) == (2500, 5000)
|
||||
|
||||
# corners
|
||||
assert crop(-25, -25, 25, 25) == (1875, 625)
|
||||
assert crop(75, -25, 125, 25) == (1875, 625)
|
||||
assert crop(75, 75, 125, 125) == (1875, 625)
|
||||
assert crop(-25, 75, 25, 125) == (1875, 625)
|
||||
assert crop((-25, -25, 25, 25)) == (1875, 625)
|
||||
assert crop((75, -25, 125, 25)) == (1875, 625)
|
||||
assert crop((75, 75, 125, 125)) == (1875, 625)
|
||||
assert crop((-25, 75, 25, 125)) == (1875, 625)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("box", ((8, 2, 2, 8), (2, 8, 8, 2), (8, 8, 2, 2)))
|
||||
|
|
|
|||
|
|
@ -46,9 +46,9 @@ def test_sanity(filter_to_apply: ImageFilter.Filter, mode: str) -> None:
|
|||
|
||||
@pytest.mark.parametrize("mode", ("L", "I", "RGB", "CMYK"))
|
||||
def test_sanity_error(mode: str) -> None:
|
||||
im = hopper(mode)
|
||||
with pytest.raises(TypeError):
|
||||
im = hopper(mode)
|
||||
im.filter("hello")
|
||||
im.filter("hello") # type: ignore[arg-type]
|
||||
|
||||
|
||||
# crashes on small images
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ def test_sanity() -> None:
|
|||
assert data[0] == (20, 20, 70)
|
||||
|
||||
|
||||
def test_roundtrip() -> None:
|
||||
def test_mode() -> None:
|
||||
def getdata(mode: str) -> tuple[float | tuple[int, ...], int, int]:
|
||||
im = hopper(mode).resize((32, 30), Image.Resampling.NEAREST)
|
||||
data = im.getdata()
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ from .helper import hopper
|
|||
|
||||
|
||||
def test_extrema() -> None:
|
||||
def extrema(mode: str) -> tuple[int, int] | tuple[tuple[int, int], ...]:
|
||||
def extrema(mode: str) -> tuple[float, float] | tuple[tuple[int, int], ...]:
|
||||
return hopper(mode).getextrema()
|
||||
|
||||
assert extrema("1") == (0, 255)
|
||||
|
|
|
|||
|
|
@ -81,7 +81,8 @@ def test_mode_F() -> None:
|
|||
@pytest.mark.parametrize("mode", ("BGR;15", "BGR;16", "BGR;24"))
|
||||
def test_mode_BGR(mode: str) -> None:
|
||||
data = [(16, 32, 49), (32, 32, 98)]
|
||||
im = Image.new(mode, (1, 2))
|
||||
with pytest.warns(DeprecationWarning):
|
||||
im = Image.new(mode, (1, 2))
|
||||
im.putdata(data)
|
||||
|
||||
assert list(im.getdata()) == data
|
||||
|
|
|
|||
|
|
@ -24,8 +24,9 @@ def test_sanity() -> None:
|
|||
def test_libimagequant_quantize() -> None:
|
||||
image = hopper()
|
||||
if is_ppc64le():
|
||||
libimagequant = parse_version(features.version_feature("libimagequant"))
|
||||
if libimagequant < parse_version("4"):
|
||||
version = features.version_feature("libimagequant")
|
||||
assert version is not None
|
||||
if parse_version(version) < parse_version("4"):
|
||||
pytest.skip("Fails with libimagequant earlier than 4.0.0 on ppc64le")
|
||||
converted = image.quantize(100, Image.Quantize.LIBIMAGEQUANT)
|
||||
assert converted.mode == "P"
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ def test_unsupported_modes(mode: str) -> None:
|
|||
def get_image(mode: str) -> Image.Image:
|
||||
mode_info = ImageMode.getmode(mode)
|
||||
if mode_info.basetype == "L":
|
||||
bands = [gradients_image]
|
||||
bands: list[Image.Image] = [gradients_image]
|
||||
for _ in mode_info.bands[1:]:
|
||||
# rotate previous image
|
||||
band = bands[-1].transpose(Image.Transpose.ROTATE_90)
|
||||
|
|
|
|||
|
|
@ -284,7 +284,7 @@ class TestCoreResampleAlphaCorrect:
|
|||
used_colors = {px[x, y][0] for x in range(i.size[0])}
|
||||
assert 256 == len(used_colors), (
|
||||
"All colors should be present in resized image. "
|
||||
f"Only {len(used_colors)} on {y} line."
|
||||
f"Only {len(used_colors)} on line {y}."
|
||||
)
|
||||
|
||||
@pytest.mark.xfail(reason="Current implementation isn't precise enough")
|
||||
|
|
|
|||
|
|
@ -124,8 +124,8 @@ def test_fastpath_translate() -> None:
|
|||
def test_center() -> None:
|
||||
im = hopper()
|
||||
rotate(im, im.mode, 45, center=(0, 0))
|
||||
rotate(im, im.mode, 45, translate=(im.size[0] / 2, 0))
|
||||
rotate(im, im.mode, 45, center=(0, 0), translate=(im.size[0] / 2, 0))
|
||||
rotate(im, im.mode, 45, translate=(im.size[0] // 2, 0))
|
||||
rotate(im, im.mode, 45, center=(0, 0), translate=(im.size[0] // 2, 0))
|
||||
|
||||
|
||||
def test_rotate_no_fill() -> None:
|
||||
|
|
|
|||
|
|
@ -111,7 +111,9 @@ def test_load_first_unless_jpeg() -> None:
|
|||
with Image.open("Tests/images/hopper.jpg") as im:
|
||||
draft = im.draft
|
||||
|
||||
def im_draft(mode: str, size: tuple[int, int]):
|
||||
def im_draft(
|
||||
mode: str, size: tuple[int, int]
|
||||
) -> tuple[str, tuple[int, int, float, float]] | None:
|
||||
result = draft(mode, size)
|
||||
assert result is not None
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ import shutil
|
|||
import sys
|
||||
from io import BytesIO
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
from typing import Any, Literal, cast
|
||||
|
||||
import pytest
|
||||
|
||||
|
|
@ -60,10 +60,13 @@ def test_sanity() -> None:
|
|||
assert list(map(type, v)) == [str, str, str, str]
|
||||
|
||||
# internal version number
|
||||
assert re.search(r"\d+\.\d+(\.\d+)?$", features.version_module("littlecms2"))
|
||||
version = features.version_module("littlecms2")
|
||||
assert version is not None
|
||||
assert re.search(r"\d+\.\d+(\.\d+)?$", version)
|
||||
|
||||
skip_missing()
|
||||
i = ImageCms.profileToProfile(hopper(), SRGB, SRGB)
|
||||
assert i is not None
|
||||
assert_image(i, "RGB", (128, 128))
|
||||
|
||||
i = hopper()
|
||||
|
|
@ -72,23 +75,27 @@ def test_sanity() -> None:
|
|||
|
||||
t = ImageCms.buildTransform(SRGB, SRGB, "RGB", "RGB")
|
||||
i = ImageCms.applyTransform(hopper(), t)
|
||||
assert i is not None
|
||||
assert_image(i, "RGB", (128, 128))
|
||||
|
||||
with hopper() as i:
|
||||
t = ImageCms.buildTransform(SRGB, SRGB, "RGB", "RGB")
|
||||
ImageCms.applyTransform(hopper(), t, inPlace=True)
|
||||
assert i is not None
|
||||
assert_image(i, "RGB", (128, 128))
|
||||
|
||||
p = ImageCms.createProfile("sRGB")
|
||||
o = ImageCms.getOpenProfile(SRGB)
|
||||
t = ImageCms.buildTransformFromOpenProfiles(p, o, "RGB", "RGB")
|
||||
i = ImageCms.applyTransform(hopper(), t)
|
||||
assert i is not None
|
||||
assert_image(i, "RGB", (128, 128))
|
||||
|
||||
t = ImageCms.buildProofTransform(SRGB, SRGB, SRGB, "RGB", "RGB")
|
||||
assert t.inputMode == "RGB"
|
||||
assert t.outputMode == "RGB"
|
||||
i = ImageCms.applyTransform(hopper(), t)
|
||||
assert i is not None
|
||||
assert_image(i, "RGB", (128, 128))
|
||||
|
||||
# test PointTransform convenience API
|
||||
|
|
@ -202,13 +209,13 @@ def test_exceptions() -> None:
|
|||
ImageCms.buildTransform("foo", "bar", "RGB", "RGB")
|
||||
|
||||
with pytest.raises(ImageCms.PyCMSError, match="Invalid type for Profile"):
|
||||
ImageCms.getProfileName(None)
|
||||
ImageCms.getProfileName(None) # type: ignore[arg-type]
|
||||
skip_missing()
|
||||
|
||||
# Python <= 3.9: "an integer is required (got type NoneType)"
|
||||
# Python > 3.9: "'NoneType' object cannot be interpreted as an integer"
|
||||
with pytest.raises(ImageCms.PyCMSError, match="integer"):
|
||||
ImageCms.isIntentSupported(SRGB, None, None)
|
||||
ImageCms.isIntentSupported(SRGB, None, None) # type: ignore[arg-type]
|
||||
|
||||
|
||||
def test_display_profile() -> None:
|
||||
|
|
@ -232,7 +239,7 @@ def test_unsupported_color_space() -> None:
|
|||
"Color space not supported for on-the-fly profile creation (unsupported)"
|
||||
),
|
||||
):
|
||||
ImageCms.createProfile("unsupported")
|
||||
ImageCms.createProfile("unsupported") # type: ignore[arg-type]
|
||||
|
||||
|
||||
def test_invalid_color_temperature() -> None:
|
||||
|
|
@ -240,7 +247,7 @@ def test_invalid_color_temperature() -> None:
|
|||
ImageCms.PyCMSError,
|
||||
match='Color temperature must be numeric, "invalid" not valid',
|
||||
):
|
||||
ImageCms.createProfile("LAB", "invalid")
|
||||
ImageCms.createProfile("LAB", "invalid") # type: ignore[arg-type]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("flag", ("my string", -1))
|
||||
|
|
@ -249,7 +256,7 @@ def test_invalid_flag(flag: str | int) -> None:
|
|||
with pytest.raises(
|
||||
ImageCms.PyCMSError, match="flags must be an integer between 0 and "
|
||||
):
|
||||
ImageCms.profileToProfile(im, "foo", "bar", flags=flag)
|
||||
ImageCms.profileToProfile(im, "foo", "bar", flags=flag) # type: ignore[arg-type]
|
||||
|
||||
|
||||
def test_simple_lab() -> None:
|
||||
|
|
@ -260,7 +267,7 @@ def test_simple_lab() -> None:
|
|||
t = ImageCms.buildTransform(psRGB, pLab, "RGB", "LAB")
|
||||
|
||||
i_lab = ImageCms.applyTransform(i, t)
|
||||
|
||||
assert i_lab is not None
|
||||
assert i_lab.mode == "LAB"
|
||||
|
||||
k = i_lab.getpixel((0, 0))
|
||||
|
|
@ -284,6 +291,7 @@ def test_lab_color() -> None:
|
|||
# Need to add a type mapping for some PIL type to TYPE_Lab_8 in findLCMSType, and
|
||||
# have that mapping work back to a PIL mode (likely RGB).
|
||||
i = ImageCms.applyTransform(hopper(), t)
|
||||
assert i is not None
|
||||
assert_image(i, "LAB", (128, 128))
|
||||
|
||||
# i.save('temp.lab.tif') # visually verified vs PS.
|
||||
|
|
@ -298,6 +306,7 @@ def test_lab_srgb() -> None:
|
|||
|
||||
with Image.open("Tests/images/hopper.Lab.tif") as img:
|
||||
img_srgb = ImageCms.applyTransform(img, t)
|
||||
assert img_srgb is not None
|
||||
|
||||
# img_srgb.save('temp.srgb.tif') # visually verified vs ps.
|
||||
|
||||
|
|
@ -317,11 +326,11 @@ def test_lab_roundtrip() -> None:
|
|||
t2 = ImageCms.buildTransform(pLab, psRGB, "LAB", "RGB")
|
||||
|
||||
i = ImageCms.applyTransform(hopper(), t)
|
||||
|
||||
assert i is not None
|
||||
assert i.info["icc_profile"] == ImageCmsProfile(pLab).tobytes()
|
||||
|
||||
out = ImageCms.applyTransform(i, t2)
|
||||
|
||||
assert out is not None
|
||||
assert_image_similar(hopper(), out, 2)
|
||||
|
||||
|
||||
|
|
@ -343,7 +352,7 @@ def test_extended_information() -> None:
|
|||
p = o.profile
|
||||
|
||||
def assert_truncated_tuple_equal(
|
||||
tup1: tuple[Any, ...], tup2: tuple[Any, ...], digits: int = 10
|
||||
tup1: tuple[Any, ...] | None, tup2: tuple[Any, ...], digits: int = 10
|
||||
) -> None:
|
||||
# Helper function to reduce precision of tuples of floats
|
||||
# recursively and then check equality.
|
||||
|
|
@ -359,6 +368,7 @@ def test_extended_information() -> None:
|
|||
for val in tuple_value
|
||||
)
|
||||
|
||||
assert tup1 is not None
|
||||
assert truncate_tuple(tup1) == truncate_tuple(tup2)
|
||||
|
||||
assert p.attributes == 4294967296
|
||||
|
|
@ -504,22 +514,22 @@ def test_non_ascii_path(tmp_path: Path) -> None:
|
|||
def test_profile_typesafety() -> None:
|
||||
# does not segfault
|
||||
with pytest.raises(TypeError, match="Invalid type for Profile"):
|
||||
ImageCms.ImageCmsProfile(0).tobytes()
|
||||
ImageCms.ImageCmsProfile(0) # type: ignore[arg-type]
|
||||
with pytest.raises(TypeError, match="Invalid type for Profile"):
|
||||
ImageCms.ImageCmsProfile(1).tobytes()
|
||||
ImageCms.ImageCmsProfile(1) # type: ignore[arg-type]
|
||||
|
||||
# also check core function
|
||||
with pytest.raises(TypeError):
|
||||
ImageCms.core.profile_tobytes(0)
|
||||
ImageCms.core.profile_tobytes(0) # type: ignore[arg-type]
|
||||
with pytest.raises(TypeError):
|
||||
ImageCms.core.profile_tobytes(1)
|
||||
ImageCms.core.profile_tobytes(1) # type: ignore[arg-type]
|
||||
|
||||
if not is_pypy():
|
||||
# core profile should not be directly instantiable
|
||||
with pytest.raises(TypeError):
|
||||
ImageCms.core.CmsProfile()
|
||||
with pytest.raises(TypeError):
|
||||
ImageCms.core.CmsProfile(0)
|
||||
ImageCms.core.CmsProfile(0) # type: ignore[call-arg]
|
||||
|
||||
|
||||
@pytest.mark.skipif(is_pypy(), reason="fails on PyPy")
|
||||
|
|
@ -528,7 +538,7 @@ def test_transform_typesafety() -> None:
|
|||
with pytest.raises(TypeError):
|
||||
ImageCms.core.CmsTransform()
|
||||
with pytest.raises(TypeError):
|
||||
ImageCms.core.CmsTransform(0)
|
||||
ImageCms.core.CmsTransform(0) # type: ignore[call-arg]
|
||||
|
||||
|
||||
def assert_aux_channel_preserved(
|
||||
|
|
@ -578,11 +588,13 @@ def assert_aux_channel_preserved(
|
|||
)
|
||||
|
||||
# apply transform
|
||||
result_image: Image.Image | None
|
||||
if transform_in_place:
|
||||
ImageCms.applyTransform(source_image, t, inPlace=True)
|
||||
result_image = source_image
|
||||
else:
|
||||
result_image = ImageCms.applyTransform(source_image, t, inPlace=False)
|
||||
assert result_image is not None
|
||||
result_image_aux = result_image.getchannel(preserved_channel)
|
||||
|
||||
assert_image_equal(source_image_aux, result_image_aux)
|
||||
|
|
@ -628,7 +640,8 @@ def test_auxiliary_channels_isolated() -> None:
|
|||
continue
|
||||
|
||||
# convert with and without AUX data, test colors are equal
|
||||
source_profile = ImageCms.createProfile(src_format[1])
|
||||
src_colorSpace = cast(Literal["LAB", "XYZ", "sRGB"], src_format[1])
|
||||
source_profile = ImageCms.createProfile(src_colorSpace)
|
||||
destination_profile = ImageCms.createProfile(dst_format[1])
|
||||
source_image = src_format[3]
|
||||
test_transform = ImageCms.buildTransform(
|
||||
|
|
@ -639,6 +652,7 @@ def test_auxiliary_channels_isolated() -> None:
|
|||
)
|
||||
|
||||
# test conversion from aux-ful source
|
||||
test_image: Image.Image | None
|
||||
if transform_in_place:
|
||||
test_image = source_image.copy()
|
||||
ImageCms.applyTransform(test_image, test_transform, inPlace=True)
|
||||
|
|
@ -646,6 +660,7 @@ def test_auxiliary_channels_isolated() -> None:
|
|||
test_image = ImageCms.applyTransform(
|
||||
source_image, test_transform, inPlace=False
|
||||
)
|
||||
assert test_image is not None
|
||||
|
||||
# reference conversion from aux-less source
|
||||
reference_transform = ImageCms.buildTransform(
|
||||
|
|
@ -657,7 +672,7 @@ def test_auxiliary_channels_isolated() -> None:
|
|||
reference_image = ImageCms.applyTransform(
|
||||
source_image.convert(src_format[2]), reference_transform
|
||||
)
|
||||
|
||||
assert reference_image is not None
|
||||
assert_image_equal(test_image.convert(dst_format[2]), reference_image)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ from __future__ import annotations
|
|||
|
||||
import contextlib
|
||||
import os.path
|
||||
from typing import Sequence
|
||||
|
||||
import pytest
|
||||
|
||||
|
|
@ -265,6 +266,21 @@ def test_chord_too_fat() -> None:
|
|||
assert_image_equal_tofile(im, "Tests/images/imagedraw_chord_too_fat.png")
|
||||
|
||||
|
||||
@pytest.mark.parametrize("mode", ("RGB", "L"))
|
||||
@pytest.mark.parametrize("xy", ((W / 2, H / 2), [W / 2, H / 2]))
|
||||
def test_circle(mode: str, xy: Sequence[float]) -> None:
|
||||
# Arrange
|
||||
im = Image.new(mode, (W, H))
|
||||
draw = ImageDraw.Draw(im)
|
||||
expected = f"Tests/images/imagedraw_ellipse_{mode}.png"
|
||||
|
||||
# Act
|
||||
draw.circle(xy, 25, fill="green", outline="blue")
|
||||
|
||||
# Assert
|
||||
assert_image_similar_tofile(im, expected, 1)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("mode", ("RGB", "L"))
|
||||
@pytest.mark.parametrize("bbox", BBOX)
|
||||
def test_ellipse(mode: str, bbox: Coords) -> None:
|
||||
|
|
@ -1067,8 +1083,8 @@ def test_line_horizontal() -> None:
|
|||
)
|
||||
|
||||
|
||||
@pytest.mark.xfail(reason="failing test")
|
||||
def test_line_h_s1_w2() -> None:
|
||||
pytest.skip("failing")
|
||||
img, draw = create_base_image_draw((20, 20))
|
||||
draw.line((5, 5, 14, 6), BLACK, 2)
|
||||
assert_image_equal_tofile(
|
||||
|
|
|
|||
|
|
@ -202,6 +202,8 @@ class TestImageFile:
|
|||
|
||||
|
||||
class MockPyDecoder(ImageFile.PyDecoder):
|
||||
last: MockPyDecoder
|
||||
|
||||
def __init__(self, mode: str, *args: Any) -> None:
|
||||
MockPyDecoder.last = self
|
||||
|
||||
|
|
@ -213,6 +215,8 @@ class MockPyDecoder(ImageFile.PyDecoder):
|
|||
|
||||
|
||||
class MockPyEncoder(ImageFile.PyEncoder):
|
||||
last: MockPyEncoder | None
|
||||
|
||||
def __init__(self, mode: str, *args: Any) -> None:
|
||||
MockPyEncoder.last = self
|
||||
|
||||
|
|
@ -315,6 +319,7 @@ class TestPyEncoder(CodecsTest):
|
|||
im, fp, [("MOCK", (xoff, yoff, xoff + xsize, yoff + ysize), 0, "RGB")]
|
||||
)
|
||||
|
||||
assert MockPyEncoder.last
|
||||
assert MockPyEncoder.last.state.xoff == xoff
|
||||
assert MockPyEncoder.last.state.yoff == yoff
|
||||
assert MockPyEncoder.last.state.xsize == xsize
|
||||
|
|
@ -329,6 +334,7 @@ class TestPyEncoder(CodecsTest):
|
|||
fp = BytesIO()
|
||||
ImageFile._save(im, fp, [("MOCK", None, 0, "RGB")])
|
||||
|
||||
assert MockPyEncoder.last
|
||||
assert MockPyEncoder.last.state.xoff == 0
|
||||
assert MockPyEncoder.last.state.yoff == 0
|
||||
assert MockPyEncoder.last.state.xsize == 200
|
||||
|
|
|
|||
|
|
@ -34,7 +34,9 @@ pytestmark = skip_unless_feature("freetype2")
|
|||
|
||||
|
||||
def test_sanity() -> None:
|
||||
assert re.search(r"\d+\.\d+\.\d+$", features.version_module("freetype2"))
|
||||
version = features.version_module("freetype2")
|
||||
assert version is not None
|
||||
assert re.search(r"\d+\.\d+\.\d+$", version)
|
||||
|
||||
|
||||
@pytest.fixture(
|
||||
|
|
@ -547,11 +549,10 @@ def test_find_font(
|
|||
def loadable_font(
|
||||
filepath: str, size: int, index: int, encoding: str, *args: Any
|
||||
):
|
||||
_freeTypeFont = getattr(ImageFont, "_FreeTypeFont")
|
||||
if filepath == path_to_fake:
|
||||
return ImageFont._FreeTypeFont(
|
||||
FONT_PATH, size, index, encoding, *args
|
||||
)
|
||||
return ImageFont._FreeTypeFont(filepath, size, index, encoding, *args)
|
||||
return _freeTypeFont(FONT_PATH, size, index, encoding, *args)
|
||||
return _freeTypeFont(filepath, size, index, encoding, *args)
|
||||
|
||||
m.setattr(ImageFont, "FreeTypeFont", loadable_font)
|
||||
font = ImageFont.truetype(fontname)
|
||||
|
|
@ -630,7 +631,9 @@ def test_complex_font_settings() -> None:
|
|||
|
||||
|
||||
def test_variation_get(font: ImageFont.FreeTypeFont) -> None:
|
||||
freetype = parse_version(features.version_module("freetype2"))
|
||||
version = features.version_module("freetype2")
|
||||
assert version is not None
|
||||
freetype = parse_version(version)
|
||||
if freetype < parse_version("2.9.1"):
|
||||
with pytest.raises(NotImplementedError):
|
||||
font.get_variation_names()
|
||||
|
|
@ -700,7 +703,9 @@ def _check_text(font: ImageFont.FreeTypeFont, path: str, epsilon: float) -> None
|
|||
|
||||
|
||||
def test_variation_set_by_name(font: ImageFont.FreeTypeFont) -> None:
|
||||
freetype = parse_version(features.version_module("freetype2"))
|
||||
version = features.version_module("freetype2")
|
||||
assert version is not None
|
||||
freetype = parse_version(version)
|
||||
if freetype < parse_version("2.9.1"):
|
||||
with pytest.raises(NotImplementedError):
|
||||
font.set_variation_by_name("Bold")
|
||||
|
|
@ -725,7 +730,9 @@ def test_variation_set_by_name(font: ImageFont.FreeTypeFont) -> None:
|
|||
|
||||
|
||||
def test_variation_set_by_axes(font: ImageFont.FreeTypeFont) -> None:
|
||||
freetype = parse_version(features.version_module("freetype2"))
|
||||
version = features.version_module("freetype2")
|
||||
assert version is not None
|
||||
freetype = parse_version(version)
|
||||
if freetype < parse_version("2.9.1"):
|
||||
with pytest.raises(NotImplementedError):
|
||||
font.set_variation_by_axes([100])
|
||||
|
|
|
|||
|
|
@ -4,11 +4,11 @@ from typing import Generator
|
|||
|
||||
import pytest
|
||||
|
||||
from PIL import Image, ImageFilter
|
||||
from PIL import Image, ImageFile, ImageFilter
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def test_images() -> Generator[dict[str, Image.Image], None, None]:
|
||||
def test_images() -> Generator[dict[str, ImageFile.ImageFile], None, None]:
|
||||
ims = {
|
||||
"im": Image.open("Tests/images/hopper.ppm"),
|
||||
"snakes": Image.open("Tests/images/color_snakes.png"),
|
||||
|
|
@ -20,7 +20,7 @@ def test_images() -> Generator[dict[str, Image.Image], None, None]:
|
|||
im.close()
|
||||
|
||||
|
||||
def test_filter_api(test_images: dict[str, Image.Image]) -> None:
|
||||
def test_filter_api(test_images: dict[str, ImageFile.ImageFile]) -> None:
|
||||
im = test_images["im"]
|
||||
|
||||
test_filter = ImageFilter.GaussianBlur(2.0)
|
||||
|
|
@ -34,7 +34,7 @@ def test_filter_api(test_images: dict[str, Image.Image]) -> None:
|
|||
assert i.size == (128, 128)
|
||||
|
||||
|
||||
def test_usm_formats(test_images: dict[str, Image.Image]) -> None:
|
||||
def test_usm_formats(test_images: dict[str, ImageFile.ImageFile]) -> None:
|
||||
im = test_images["im"]
|
||||
|
||||
usm = ImageFilter.UnsharpMask
|
||||
|
|
@ -52,13 +52,12 @@ def test_usm_formats(test_images: dict[str, Image.Image]) -> None:
|
|||
im.convert("YCbCr").filter(usm)
|
||||
|
||||
|
||||
def test_blur_formats(test_images: dict[str, Image.Image]) -> None:
|
||||
def test_blur_formats(test_images: dict[str, ImageFile.ImageFile]) -> None:
|
||||
im = test_images["im"]
|
||||
|
||||
blur = ImageFilter.GaussianBlur
|
||||
with pytest.raises(ValueError):
|
||||
im.convert("1").filter(blur)
|
||||
blur(im.convert("L"))
|
||||
with pytest.raises(ValueError):
|
||||
im.convert("I").filter(blur)
|
||||
with pytest.raises(ValueError):
|
||||
|
|
@ -70,7 +69,7 @@ def test_blur_formats(test_images: dict[str, Image.Image]) -> None:
|
|||
im.convert("YCbCr").filter(blur)
|
||||
|
||||
|
||||
def test_usm_accuracy(test_images: dict[str, Image.Image]) -> None:
|
||||
def test_usm_accuracy(test_images: dict[str, ImageFile.ImageFile]) -> None:
|
||||
snakes = test_images["snakes"]
|
||||
|
||||
src = snakes.convert("RGB")
|
||||
|
|
@ -79,7 +78,7 @@ def test_usm_accuracy(test_images: dict[str, Image.Image]) -> None:
|
|||
assert i.tobytes() == src.tobytes()
|
||||
|
||||
|
||||
def test_blur_accuracy(test_images: dict[str, Image.Image]) -> None:
|
||||
def test_blur_accuracy(test_images: dict[str, ImageFile.ImageFile]) -> None:
|
||||
snakes = test_images["snakes"]
|
||||
|
||||
i = snakes.filter(ImageFilter.GaussianBlur(0.4))
|
||||
|
|
|
|||
|
|
@ -47,7 +47,11 @@ def test_iterator_min_frame() -> None:
|
|||
assert i[index] == next(i)
|
||||
|
||||
|
||||
def _test_multipage_tiff() -> None:
|
||||
@pytest.mark.parametrize(
|
||||
"libtiff", (pytest.param(True, marks=skip_unless_feature("libtiff")), False)
|
||||
)
|
||||
def test_multipage_tiff(monkeypatch: pytest.MonkeyPatch, libtiff: bool) -> None:
|
||||
monkeypatch.setattr(TiffImagePlugin, "READ_LIBTIFF", libtiff)
|
||||
with Image.open("Tests/images/multipage.tiff") as im:
|
||||
for index, frame in enumerate(ImageSequence.Iterator(im)):
|
||||
frame.load()
|
||||
|
|
@ -55,17 +59,6 @@ def _test_multipage_tiff() -> None:
|
|||
frame.convert("RGB")
|
||||
|
||||
|
||||
def test_tiff() -> None:
|
||||
_test_multipage_tiff()
|
||||
|
||||
|
||||
@skip_unless_feature("libtiff")
|
||||
def test_libtiff() -> None:
|
||||
TiffImagePlugin.READ_LIBTIFF = True
|
||||
_test_multipage_tiff()
|
||||
TiffImagePlugin.READ_LIBTIFF = False
|
||||
|
||||
|
||||
def test_consecutive() -> None:
|
||||
with Image.open("Tests/images/multipage.tiff") as im:
|
||||
first_frame = None
|
||||
|
|
|
|||
|
|
@ -25,10 +25,10 @@ def test_sanity() -> None:
|
|||
st.stddev
|
||||
|
||||
with pytest.raises(AttributeError):
|
||||
st.spam()
|
||||
st.spam() # type: ignore[attr-defined]
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
ImageStat.Stat(1)
|
||||
ImageStat.Stat(1) # type: ignore[arg-type]
|
||||
|
||||
|
||||
def test_hopper() -> None:
|
||||
|
|
|
|||
|
|
@ -216,7 +216,10 @@ class TestLibPack:
|
|||
)
|
||||
|
||||
def test_I16(self) -> None:
|
||||
self.assert_pack("I;16N", "I;16N", 2, 0x0201, 0x0403, 0x0605)
|
||||
if sys.byteorder == "little":
|
||||
self.assert_pack("I;16N", "I;16N", 2, 0x0201, 0x0403, 0x0605)
|
||||
else:
|
||||
self.assert_pack("I;16N", "I;16N", 2, 0x0102, 0x0304, 0x0506)
|
||||
|
||||
def test_F_float(self) -> None:
|
||||
self.assert_pack("F", "F;32F", 4, 1.539989614439558e-36, 4.063216068939723e-34)
|
||||
|
|
@ -359,11 +362,14 @@ class TestLibUnpack:
|
|||
)
|
||||
|
||||
def test_BGR(self) -> None:
|
||||
self.assert_unpack("BGR;15", "BGR;15", 3, (8, 131, 0), (24, 0, 8), (41, 131, 8))
|
||||
self.assert_unpack(
|
||||
"BGR;16", "BGR;16", 3, (8, 64, 0), (24, 129, 0), (41, 194, 0)
|
||||
)
|
||||
self.assert_unpack("BGR;24", "BGR;24", 3, (1, 2, 3), (4, 5, 6), (7, 8, 9))
|
||||
with pytest.warns(DeprecationWarning):
|
||||
self.assert_unpack(
|
||||
"BGR;15", "BGR;15", 3, (8, 131, 0), (24, 0, 8), (41, 131, 8)
|
||||
)
|
||||
self.assert_unpack(
|
||||
"BGR;16", "BGR;16", 3, (8, 64, 0), (24, 129, 0), (41, 194, 0)
|
||||
)
|
||||
self.assert_unpack("BGR;24", "BGR;24", 3, (1, 2, 3), (4, 5, 6), (7, 8, 9))
|
||||
|
||||
def test_RGBA(self) -> None:
|
||||
self.assert_unpack("RGBA", "LA", 2, (1, 1, 1, 2), (3, 3, 3, 4), (5, 5, 5, 6))
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ def roundtrip(expected: Image.Image) -> None:
|
|||
@pytest.mark.skipif(not ImageQt.qt_is_installed, reason="Qt bindings are not installed")
|
||||
def test_sanity(tmp_path: Path) -> None:
|
||||
# Segfault test
|
||||
app = QApplication([])
|
||||
app: QApplication | None = QApplication([])
|
||||
ex = Example()
|
||||
assert app # Silence warning
|
||||
assert ex # Silence warning
|
||||
|
|
|
|||
|
|
@ -3,10 +3,12 @@ from __future__ import annotations
|
|||
from fractions import Fraction
|
||||
from pathlib import Path
|
||||
|
||||
from PIL import Image, TiffImagePlugin, features
|
||||
import pytest
|
||||
|
||||
from PIL import Image, TiffImagePlugin
|
||||
from PIL.TiffImagePlugin import IFDRational
|
||||
|
||||
from .helper import hopper
|
||||
from .helper import hopper, skip_unless_feature
|
||||
|
||||
|
||||
def _test_equal(num, denom, target) -> None:
|
||||
|
|
@ -52,18 +54,18 @@ def test_nonetype() -> None:
|
|||
assert xres and yres
|
||||
|
||||
|
||||
def test_ifd_rational_save(tmp_path: Path) -> None:
|
||||
methods = [True]
|
||||
if features.check("libtiff"):
|
||||
methods.append(False)
|
||||
@pytest.mark.parametrize(
|
||||
"libtiff", (pytest.param(True, marks=skip_unless_feature("libtiff")), False)
|
||||
)
|
||||
def test_ifd_rational_save(
|
||||
monkeypatch: pytest.MonkeyPatch, tmp_path: Path, libtiff: bool
|
||||
) -> None:
|
||||
im = hopper()
|
||||
out = str(tmp_path / "temp.tiff")
|
||||
res = IFDRational(301, 1)
|
||||
|
||||
for libtiff in methods:
|
||||
TiffImagePlugin.WRITE_LIBTIFF = libtiff
|
||||
monkeypatch.setattr(TiffImagePlugin, "WRITE_LIBTIFF", libtiff)
|
||||
im.save(out, dpi=(res, res), compression="raw")
|
||||
|
||||
im = hopper()
|
||||
out = str(tmp_path / "temp.tiff")
|
||||
res = IFDRational(301, 1)
|
||||
im.save(out, dpi=(res, res), compression="raw")
|
||||
|
||||
with Image.open(out) as reloaded:
|
||||
assert float(IFDRational(301, 1)) == float(reloaded.tag_v2[282])
|
||||
with Image.open(out) as reloaded:
|
||||
assert float(IFDRational(301, 1)) == float(reloaded.tag_v2[282])
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
# install libimagequant
|
||||
|
||||
archive_name=libimagequant
|
||||
archive_version=4.3.0
|
||||
archive_version=4.3.1
|
||||
|
||||
archive=$archive_name-$archive_version
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/bin/bash
|
||||
# install webp
|
||||
|
||||
archive=libwebp-1.3.2
|
||||
archive=libwebp-1.4.0
|
||||
|
||||
./download-and-extract.sh $archive https://raw.githubusercontent.com/python-pillow/pillow-depends/main/$archive.tar.gz
|
||||
|
||||
|
|
|
|||
|
|
@ -9,9 +9,9 @@ PAPER =
|
|||
BUILDDIR = _build
|
||||
|
||||
# Internal variables.
|
||||
PAPEROPT_a4 = -D latex_paper_size=a4
|
||||
PAPEROPT_letter = -D latex_paper_size=letter
|
||||
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
|
||||
PAPEROPT_a4 = --define latex_paper_size=a4
|
||||
PAPEROPT_letter = --define latex_paper_size=letter
|
||||
ALLSPHINXOPTS = --doctree-dir $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
|
||||
# the i18n builder cannot share the environment and doctrees with the others
|
||||
I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
|
||||
|
||||
|
|
@ -46,47 +46,47 @@ clean:
|
|||
-rm -rf $(BUILDDIR)/*
|
||||
|
||||
install-sphinx:
|
||||
$(PYTHON) -m pip install --quiet furo olefile sphinx sphinx-copybutton sphinx-inline-tabs sphinx-removed-in sphinxext-opengraph
|
||||
$(PYTHON) -m pip install --quiet furo olefile sphinx sphinx-copybutton sphinx-inline-tabs sphinxext-opengraph
|
||||
|
||||
.PHONY: html
|
||||
html:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b html -W --keep-going $(ALLSPHINXOPTS) $(BUILDDIR)/html
|
||||
$(SPHINXBUILD) --builder html --fail-on-warning --keep-going $(ALLSPHINXOPTS) $(BUILDDIR)/html
|
||||
@echo
|
||||
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
|
||||
|
||||
.PHONY: dirhtml
|
||||
dirhtml:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
|
||||
$(SPHINXBUILD) --builder dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
|
||||
@echo
|
||||
@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
|
||||
|
||||
.PHONY: singlehtml
|
||||
singlehtml:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
|
||||
$(SPHINXBUILD) --builder singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
|
||||
@echo
|
||||
@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
|
||||
|
||||
.PHONY: pickle
|
||||
pickle:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
|
||||
$(SPHINXBUILD) --builder pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
|
||||
@echo
|
||||
@echo "Build finished; now you can process the pickle files."
|
||||
|
||||
.PHONY: json
|
||||
json:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
|
||||
$(SPHINXBUILD) --builder json $(ALLSPHINXOPTS) $(BUILDDIR)/json
|
||||
@echo
|
||||
@echo "Build finished; now you can process the JSON files."
|
||||
|
||||
.PHONY: htmlhelp
|
||||
htmlhelp:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
|
||||
$(SPHINXBUILD) --builder htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
|
||||
@echo
|
||||
@echo "Build finished; now you can run HTML Help Workshop with the" \
|
||||
".hhp project file in $(BUILDDIR)/htmlhelp."
|
||||
|
|
@ -94,7 +94,7 @@ htmlhelp:
|
|||
.PHONY: qthelp
|
||||
qthelp:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
|
||||
$(SPHINXBUILD) --builder qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
|
||||
@echo
|
||||
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
|
||||
".qhcp project file in $(BUILDDIR)/qthelp, like this:"
|
||||
|
|
@ -105,7 +105,7 @@ qthelp:
|
|||
.PHONY: devhelp
|
||||
devhelp:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
|
||||
$(SPHINXBUILD) --builder devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
|
||||
@echo
|
||||
@echo "Build finished."
|
||||
@echo "To view the help file:"
|
||||
|
|
@ -116,14 +116,14 @@ devhelp:
|
|||
.PHONY: epub
|
||||
epub:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
|
||||
$(SPHINXBUILD) --builder epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
|
||||
@echo
|
||||
@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
|
||||
|
||||
.PHONY: latex
|
||||
latex:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
|
||||
$(SPHINXBUILD) --builder latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
|
||||
@echo
|
||||
@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
|
||||
@echo "Run \`make' in that directory to run these through (pdf)latex" \
|
||||
|
|
@ -132,7 +132,7 @@ latex:
|
|||
.PHONY: latexpdf
|
||||
latexpdf:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
|
||||
$(SPHINXBUILD) --builder latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
|
||||
@echo "Running LaTeX files through pdflatex..."
|
||||
$(MAKE) -C $(BUILDDIR)/latex all-pdf
|
||||
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
|
||||
|
|
@ -140,21 +140,21 @@ latexpdf:
|
|||
.PHONY: text
|
||||
text:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
|
||||
$(SPHINXBUILD) --builder text $(ALLSPHINXOPTS) $(BUILDDIR)/text
|
||||
@echo
|
||||
@echo "Build finished. The text files are in $(BUILDDIR)/text."
|
||||
|
||||
.PHONY: man
|
||||
man:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
|
||||
$(SPHINXBUILD) --builder man $(ALLSPHINXOPTS) $(BUILDDIR)/man
|
||||
@echo
|
||||
@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
|
||||
|
||||
.PHONY: texinfo
|
||||
texinfo:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
|
||||
$(SPHINXBUILD) --builder texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
|
||||
@echo
|
||||
@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
|
||||
@echo "Run \`make' in that directory to run these through makeinfo" \
|
||||
|
|
@ -163,7 +163,7 @@ texinfo:
|
|||
.PHONY: info
|
||||
info:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
|
||||
$(SPHINXBUILD) --builder texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
|
||||
@echo "Running Texinfo files through makeinfo..."
|
||||
make -C $(BUILDDIR)/texinfo info
|
||||
@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
|
||||
|
|
@ -171,21 +171,21 @@ info:
|
|||
.PHONY: gettext
|
||||
gettext:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
|
||||
$(SPHINXBUILD) --builder gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
|
||||
@echo
|
||||
@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
|
||||
|
||||
.PHONY: changes
|
||||
changes:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
|
||||
$(SPHINXBUILD) --builder changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
|
||||
@echo
|
||||
@echo "The overview file is in $(BUILDDIR)/changes."
|
||||
|
||||
.PHONY: linkcheck
|
||||
linkcheck:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck -j auto
|
||||
$(SPHINXBUILD) --builder linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck -j auto
|
||||
@echo
|
||||
@echo "Link check complete; look for any errors in the above output " \
|
||||
"or in $(BUILDDIR)/linkcheck/output.txt."
|
||||
|
|
@ -193,7 +193,7 @@ linkcheck:
|
|||
.PHONY: doctest
|
||||
doctest:
|
||||
$(MAKE) install-sphinx
|
||||
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
|
||||
$(SPHINXBUILD) --builder doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
|
||||
@echo "Testing of doctests in the sources finished, look at the " \
|
||||
"results in $(BUILDDIR)/doctest/output.txt."
|
||||
|
||||
|
|
|
|||
11
docs/conf.py
11
docs/conf.py
|
|
@ -22,19 +22,19 @@ import PIL
|
|||
# -- General configuration ------------------------------------------------
|
||||
|
||||
# If your documentation needs a minimal Sphinx version, state it here.
|
||||
needs_sphinx = "2.4"
|
||||
needs_sphinx = "7.3"
|
||||
|
||||
# Add any Sphinx extension module names here, as strings. They can be
|
||||
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
|
||||
# ones.
|
||||
extensions = [
|
||||
"dater",
|
||||
"sphinx.ext.autodoc",
|
||||
"sphinx.ext.extlinks",
|
||||
"sphinx.ext.intersphinx",
|
||||
"sphinx.ext.viewcode",
|
||||
"sphinx_copybutton",
|
||||
"sphinx_inline_tabs",
|
||||
"sphinx_removed_in",
|
||||
"sphinxext.opengraph",
|
||||
]
|
||||
|
||||
|
|
@ -121,12 +121,7 @@ nitpicky = True
|
|||
# generating warnings in “nitpicky mode”. Note that type should include the domain name
|
||||
# if present. Example entries would be ('py:func', 'int') or
|
||||
# ('envvar', 'LD_LIBRARY_PATH').
|
||||
nitpick_ignore = [
|
||||
# Sphinx does not understand typing.Literal[-1]
|
||||
# Will be fixed in a future version.
|
||||
# https://github.com/sphinx-doc/sphinx/pull/11904
|
||||
("py:obj", "typing.Literal[-1, 1]"),
|
||||
]
|
||||
# nitpick_ignore = []
|
||||
|
||||
|
||||
# -- Options for HTML output ----------------------------------------------
|
||||
|
|
|
|||
48
docs/dater.py
Normal file
48
docs/dater.py
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
"""
|
||||
Sphinx extension to add timestamps to release notes based on Git versions.
|
||||
|
||||
Based on https://github.com/jaraco/rst.linker, with thanks to Jason R. Coombs.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
import subprocess
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from sphinx.application import Sphinx
|
||||
|
||||
DOC_NAME_REGEX = re.compile(r"releasenotes/\d+\.\d+\.\d+")
|
||||
VERSION_TITLE_REGEX = re.compile(r"^(\d+\.\d+\.\d+)\n-+\n")
|
||||
|
||||
|
||||
def get_date_for(git_version: str) -> str | None:
|
||||
cmd = ["git", "log", "-1", "--format=%ai", git_version]
|
||||
try:
|
||||
out = subprocess.check_output(
|
||||
cmd, stderr=subprocess.DEVNULL, text=True, encoding="utf-8"
|
||||
)
|
||||
except subprocess.CalledProcessError:
|
||||
return None
|
||||
return out.split()[0]
|
||||
|
||||
|
||||
def add_date(app: Sphinx, doc_name: str, source: list[str]) -> None:
|
||||
if DOC_NAME_REGEX.match(doc_name) and (m := VERSION_TITLE_REGEX.match(source[0])):
|
||||
old_title = m.group(1)
|
||||
|
||||
if tag_date := get_date_for(old_title):
|
||||
new_title = f"{old_title} ({tag_date})"
|
||||
else:
|
||||
new_title = f"{old_title} (unreleased)"
|
||||
|
||||
new_underline = "-" * len(new_title)
|
||||
|
||||
result = source[0].replace(m.group(0), f"{new_title}\n{new_underline}\n", 1)
|
||||
source[0] = result
|
||||
|
||||
|
||||
def setup(app: Sphinx) -> dict[str, bool]:
|
||||
app.connect("source-read", add_date)
|
||||
return {"parallel_read_safe": True}
|
||||
|
|
@ -100,6 +100,21 @@ ImageMath eval()
|
|||
``ImageMath.eval()`` has been deprecated. Use :py:meth:`~PIL.ImageMath.lambda_eval` or
|
||||
:py:meth:`~PIL.ImageMath.unsafe_eval` instead.
|
||||
|
||||
BGR;15, BGR 16 and BGR;24
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. deprecated:: 10.4.0
|
||||
|
||||
The experimental BGR;15, BGR;16 and BGR;24 modes have been deprecated.
|
||||
|
||||
Support for LibTIFF earlier than 4
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. deprecated:: 10.4.0
|
||||
|
||||
Support for LibTIFF earlier than version 4 has been deprecated.
|
||||
Upgrade to a newer version of LibTIFF instead.
|
||||
|
||||
Removed features
|
||||
----------------
|
||||
|
||||
|
|
|
|||
|
|
@ -59,9 +59,6 @@ Pillow also provides limited support for a few additional modes, including:
|
|||
* ``I;16L`` (16-bit little endian unsigned integer pixels)
|
||||
* ``I;16B`` (16-bit big endian unsigned integer pixels)
|
||||
* ``I;16N`` (16-bit native endian unsigned integer pixels)
|
||||
* ``BGR;15`` (15-bit reversed true colour)
|
||||
* ``BGR;16`` (16-bit reversed true colour)
|
||||
* ``BGR;24`` (24-bit reversed true colour)
|
||||
|
||||
Premultiplied alpha is where the values for each other channel have been
|
||||
multiplied by the alpha. For example, an RGBA pixel of ``(10, 20, 30, 127)``
|
||||
|
|
@ -147,10 +144,12 @@ pixel, the Python Imaging Library provides different resampling *filters*.
|
|||
.. py:currentmodule:: PIL.Image
|
||||
|
||||
.. data:: Resampling.NEAREST
|
||||
:noindex:
|
||||
|
||||
Pick one nearest pixel from the input image. Ignore all other input pixels.
|
||||
|
||||
.. data:: Resampling.BOX
|
||||
:noindex:
|
||||
|
||||
Each pixel of source image contributes to one pixel of the
|
||||
destination image with identical weights.
|
||||
|
|
@ -161,6 +160,7 @@ pixel, the Python Imaging Library provides different resampling *filters*.
|
|||
.. versionadded:: 3.4.0
|
||||
|
||||
.. data:: Resampling.BILINEAR
|
||||
:noindex:
|
||||
|
||||
For resize calculate the output pixel value using linear interpolation
|
||||
on all pixels that may contribute to the output value.
|
||||
|
|
@ -168,6 +168,7 @@ pixel, the Python Imaging Library provides different resampling *filters*.
|
|||
in the input image is used.
|
||||
|
||||
.. data:: Resampling.HAMMING
|
||||
:noindex:
|
||||
|
||||
Produces a sharper image than :data:`Resampling.BILINEAR`, doesn't have
|
||||
dislocations on local level like with :data:`Resampling.BOX`.
|
||||
|
|
@ -177,6 +178,7 @@ pixel, the Python Imaging Library provides different resampling *filters*.
|
|||
.. versionadded:: 3.4.0
|
||||
|
||||
.. data:: Resampling.BICUBIC
|
||||
:noindex:
|
||||
|
||||
For resize calculate the output pixel value using cubic interpolation
|
||||
on all pixels that may contribute to the output value.
|
||||
|
|
@ -184,6 +186,7 @@ pixel, the Python Imaging Library provides different resampling *filters*.
|
|||
in the input image is used.
|
||||
|
||||
.. data:: Resampling.LANCZOS
|
||||
:noindex:
|
||||
|
||||
Calculate the output pixel value using a high-quality Lanczos filter (a
|
||||
truncated sinc) on all pixels that may contribute to the output value.
|
||||
|
|
|
|||
|
|
@ -1488,7 +1488,9 @@ QOI
|
|||
|
||||
.. versionadded:: 9.5.0
|
||||
|
||||
Pillow identifies and reads images in Quite OK Image format.
|
||||
Pillow reads images in Quite OK Image format using a Python decoder. If you wish to
|
||||
write code specifically for this format, :pypi:`qoi` is an alternative library that
|
||||
uses C to decode the image and interfaces with NumPy.
|
||||
|
||||
SUN
|
||||
^^^
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ Many of Pillow's features require external libraries:
|
|||
|
||||
* **libimagequant** provides improved color quantization
|
||||
|
||||
* Pillow has been tested with libimagequant **2.6-4.3**
|
||||
* Pillow has been tested with libimagequant **2.6-4.3.1**
|
||||
* Libimagequant is licensed GPLv3, which is more restrictive than
|
||||
the Pillow license, therefore we will not be distributing binaries
|
||||
with libimagequant support enabled.
|
||||
|
|
|
|||
|
|
@ -25,23 +25,19 @@ These platforms are built and tested for every change.
|
|||
+----------------------------------+----------------------------+---------------------+
|
||||
| Arch | 3.9 | x86-64 |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| CentOS 7 | 3.9 | x86-64 |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| CentOS Stream 8 | 3.9 | x86-64 |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| CentOS Stream 9 | 3.9 | x86-64 |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| Debian 11 Bullseye | 3.9 | x86-64 |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| Debian 12 Bookworm | 3.11 | x86, x86-64 |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| Fedora 38 | 3.11 | x86-64 |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| Fedora 39 | 3.12 | x86-64 |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| Fedora 40 | 3.12 | x86-64 |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| Gentoo | 3.9 | x86-64 |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| macOS 12 Monterey | 3.8, 3.9 | x86-64 |
|
||||
| macOS 13 Ventura | 3.8, 3.9 | x86-64 |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| macOS 14 Sonoma | 3.10, 3.11, 3.12, 3.13, | arm64 |
|
||||
| | PyPy3 | |
|
||||
|
|
@ -51,7 +47,9 @@ These platforms are built and tested for every change.
|
|||
| Ubuntu Linux 22.04 LTS (Jammy) | 3.8, 3.9, 3.10, 3.11, | x86-64 |
|
||||
| | 3.12, 3.13, PyPy3 | |
|
||||
| +----------------------------+---------------------+
|
||||
| | 3.10 | arm64v8, ppc64le, |
|
||||
| | 3.10 | arm64v8 |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| Ubuntu Linux 24.04 LTS (Noble) | 3.12 | x86-64, ppc64le, |
|
||||
| | | s390x |
|
||||
+----------------------------------+----------------------------+---------------------+
|
||||
| Windows Server 2016 | 3.8 | x86-64 |
|
||||
|
|
@ -81,7 +79,7 @@ These platforms have been reported to work at the versions mentioned.
|
|||
| Operating system | | Tested Python | | Latest tested | | Tested |
|
||||
| | | versions | | Pillow version | | processors |
|
||||
+==================================+============================+==================+==============+
|
||||
| macOS 14 Sonoma | 3.8, 3.9, 3.10, 3.11, 3.12 | 10.2.0 |arm |
|
||||
| macOS 14 Sonoma | 3.8, 3.9, 3.10, 3.11, 3.12 | 10.3.0 |arm |
|
||||
+----------------------------------+----------------------------+------------------+--------------+
|
||||
| macOS 13 Ventura | 3.8, 3.9, 3.10, 3.11 | 10.0.1 |arm |
|
||||
| +----------------------------+------------------+ |
|
||||
|
|
|
|||
|
|
@ -363,6 +363,14 @@ Classes
|
|||
.. autoclass:: PIL.Image.ImagePointHandler
|
||||
.. autoclass:: PIL.Image.ImageTransformHandler
|
||||
|
||||
Protocols
|
||||
---------
|
||||
|
||||
.. autoclass:: SupportsArrayInterface
|
||||
:show-inheritance:
|
||||
.. autoclass:: SupportsGetData
|
||||
:show-inheritance:
|
||||
|
||||
Constants
|
||||
---------
|
||||
|
||||
|
|
@ -416,7 +424,6 @@ See :ref:`concept-filters` for details.
|
|||
.. autoclass:: Resampling
|
||||
:members:
|
||||
:undoc-members:
|
||||
:noindex:
|
||||
|
||||
Dither modes
|
||||
^^^^^^^^^^^^
|
||||
|
|
|
|||
|
|
@ -227,6 +227,18 @@ Methods
|
|||
|
||||
.. versionadded:: 5.3.0
|
||||
|
||||
.. py:method:: ImageDraw.circle(xy, radius, fill=None, outline=None, width=1)
|
||||
|
||||
Draws a circle with a given radius centering on a point.
|
||||
|
||||
.. versionadded:: 10.4.0
|
||||
|
||||
:param xy: The point for the center of the circle, e.g. ``(x, y)``.
|
||||
:param radius: Radius of the circle.
|
||||
:param outline: Color to use for the outline.
|
||||
:param fill: Color to use for the fill.
|
||||
:param width: The line width, in pixels.
|
||||
|
||||
.. py:method:: ImageDraw.ellipse(xy, fill=None, outline=None, width=1)
|
||||
|
||||
Draws an ellipse inside the given bounding box.
|
||||
|
|
|
|||
|
|
@ -57,6 +57,10 @@ Classes
|
|||
:undoc-members:
|
||||
:show-inheritance:
|
||||
|
||||
.. autoclass:: PIL.ImageFile.StubHandler()
|
||||
:members:
|
||||
:show-inheritance:
|
||||
|
||||
.. autoclass:: PIL.ImageFile.StubImageFile()
|
||||
:members:
|
||||
:show-inheritance:
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ Example: Using the :py:mod:`~PIL.ImageMath` module
|
|||
b=im2
|
||||
)
|
||||
|
||||
.. py:function:: lambda_eval(expression, environment)
|
||||
.. py:function:: lambda_eval(expression, options)
|
||||
|
||||
Returns the result of an image function.
|
||||
|
||||
|
|
@ -44,7 +44,7 @@ Example: Using the :py:mod:`~PIL.ImageMath` module
|
|||
:return: An image, an integer value, a floating point value,
|
||||
or a pixel tuple, depending on the expression.
|
||||
|
||||
.. py:function:: unsafe_eval(expression, environment)
|
||||
.. py:function:: unsafe_eval(expression, options)
|
||||
|
||||
Evaluates an image expression.
|
||||
|
||||
|
|
|
|||
|
|
@ -7,67 +7,6 @@
|
|||
The :py:mod:`~PIL.ImageStat` module calculates global statistics for an image, or
|
||||
for a region of an image.
|
||||
|
||||
.. py:class:: Stat(image_or_list, mask=None)
|
||||
|
||||
Calculate statistics for the given image. If a mask is included,
|
||||
only the regions covered by that mask are included in the
|
||||
statistics. You can also pass in a previously calculated histogram.
|
||||
|
||||
:param image: A PIL image, or a precalculated histogram.
|
||||
|
||||
.. note::
|
||||
|
||||
For a PIL image, calculations rely on the
|
||||
:py:meth:`~PIL.Image.Image.histogram` method. The pixel counts are
|
||||
grouped into 256 bins, even if the image has more than 8 bits per
|
||||
channel. So ``I`` and ``F`` mode images have a maximum ``mean``,
|
||||
``median`` and ``rms`` of 255, and cannot have an ``extrema`` maximum
|
||||
of more than 255.
|
||||
|
||||
:param mask: An optional mask.
|
||||
|
||||
.. py:attribute:: extrema
|
||||
|
||||
Min/max values for each band in the image.
|
||||
|
||||
.. note::
|
||||
|
||||
This relies on the :py:meth:`~PIL.Image.Image.histogram` method, and
|
||||
simply returns the low and high bins used. This is correct for
|
||||
images with 8 bits per channel, but fails for other modes such as
|
||||
``I`` or ``F``. Instead, use :py:meth:`~PIL.Image.Image.getextrema` to
|
||||
return per-band extrema for the image. This is more correct and
|
||||
efficient because, for non-8-bit modes, the histogram method uses
|
||||
:py:meth:`~PIL.Image.Image.getextrema` to determine the bins used.
|
||||
|
||||
.. py:attribute:: count
|
||||
|
||||
Total number of pixels for each band in the image.
|
||||
|
||||
.. py:attribute:: sum
|
||||
|
||||
Sum of all pixels for each band in the image.
|
||||
|
||||
.. py:attribute:: sum2
|
||||
|
||||
Squared sum of all pixels for each band in the image.
|
||||
|
||||
.. py:attribute:: mean
|
||||
|
||||
Average (arithmetic mean) pixel level for each band in the image.
|
||||
|
||||
.. py:attribute:: median
|
||||
|
||||
Median pixel level for each band in the image.
|
||||
|
||||
.. py:attribute:: rms
|
||||
|
||||
RMS (root-mean-square) for each band in the image.
|
||||
|
||||
.. py:attribute:: var
|
||||
|
||||
Variance for each band in the image.
|
||||
|
||||
.. py:attribute:: stddev
|
||||
|
||||
Standard deviation for each band in the image.
|
||||
.. autoclass:: Stat
|
||||
:members:
|
||||
:special-members: __init__
|
||||
|
|
|
|||
68
docs/releasenotes/10.4.0.rst
Normal file
68
docs/releasenotes/10.4.0.rst
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
10.4.0
|
||||
------
|
||||
|
||||
Security
|
||||
========
|
||||
|
||||
TODO
|
||||
^^^^
|
||||
|
||||
TODO
|
||||
|
||||
:cve:`YYYY-XXXXX`: TODO
|
||||
^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
TODO
|
||||
|
||||
Backwards Incompatible Changes
|
||||
==============================
|
||||
|
||||
TODO
|
||||
^^^^
|
||||
|
||||
Deprecations
|
||||
============
|
||||
|
||||
BGR;15, BGR 16 and BGR;24
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
The experimental BGR;15, BGR;16 and BGR;24 modes have been deprecated.
|
||||
|
||||
Support for LibTIFF earlier than 4
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
Support for LibTIFF earlier than version 4 has been deprecated.
|
||||
Upgrade to a newer version of LibTIFF instead.
|
||||
|
||||
API Changes
|
||||
===========
|
||||
|
||||
TODO
|
||||
^^^^
|
||||
|
||||
TODO
|
||||
|
||||
API Additions
|
||||
=============
|
||||
|
||||
ImageDraw.circle
|
||||
^^^^^^^^^^^^^^^^
|
||||
|
||||
Added :py:meth:`~PIL.ImageDraw.ImageDraw.circle`. It provides the same functionality as
|
||||
:py:meth:`~PIL.ImageDraw.ImageDraw.ellipse`, but instead of taking a bounding box, it
|
||||
takes a center point and radius.
|
||||
|
||||
TODO
|
||||
^^^^
|
||||
|
||||
TODO
|
||||
|
||||
Other Changes
|
||||
=============
|
||||
|
||||
Python 3.13 beta
|
||||
^^^^^^^^^^^^^^^^
|
||||
|
||||
To help others prepare for Python 3.13, wheels have been built against the 3.13 beta as
|
||||
a preview. This is not official support for Python 3.13, but simply an opportunity for
|
||||
users to test how Pillow works with the beta and report any problems.
|
||||
|
|
@ -14,6 +14,7 @@ expected to be backported to earlier versions.
|
|||
.. toctree::
|
||||
:maxdepth: 2
|
||||
|
||||
10.4.0
|
||||
10.3.0
|
||||
10.2.0
|
||||
10.1.0
|
||||
|
|
|
|||
|
|
@ -42,10 +42,9 @@ dynamic = [
|
|||
docs = [
|
||||
"furo",
|
||||
"olefile",
|
||||
"sphinx>=2.4",
|
||||
"sphinx>=7.3",
|
||||
"sphinx-copybutton",
|
||||
"sphinx-inline-tabs",
|
||||
"sphinx-removed-in",
|
||||
"sphinxext-opengraph",
|
||||
]
|
||||
fpx = [
|
||||
|
|
|
|||
|
|
@ -139,7 +139,9 @@ def testimage() -> None:
|
|||
In 1.1.6, you can use the ImageMath module to do image
|
||||
calculations.
|
||||
|
||||
>>> im = ImageMath.eval("float(im + 20)", im=im.convert("L"))
|
||||
>>> im = ImageMath.lambda_eval( \
|
||||
lambda args: args["float"](args["im"] + 20), im=im.convert("L") \
|
||||
)
|
||||
>>> im.mode, im.size
|
||||
('F', (128, 128))
|
||||
|
||||
|
|
@ -163,9 +165,9 @@ if __name__ == "__main__":
|
|||
print("Running selftest:")
|
||||
status = doctest.testmod(sys.modules[__name__])
|
||||
if status[0]:
|
||||
print("*** %s tests of %d failed." % status)
|
||||
print(f"*** {status[0]} tests of {status[1]} failed.")
|
||||
exit_status = 1
|
||||
else:
|
||||
print("--- %s tests passed." % status[1])
|
||||
print(f"--- {status[1]} tests passed.")
|
||||
|
||||
sys.exit(exit_status)
|
||||
|
|
|
|||
5
setup.py
5
setup.py
|
|
@ -23,8 +23,7 @@ from setuptools.command.build_ext import build_ext
|
|||
def get_version():
|
||||
version_file = "src/PIL/_version.py"
|
||||
with open(version_file, encoding="utf-8") as f:
|
||||
exec(compile(f.read(), version_file, "exec"))
|
||||
return locals()["__version__"]
|
||||
return f.read().split('"')[1]
|
||||
|
||||
|
||||
configuration = {}
|
||||
|
|
@ -1018,7 +1017,7 @@ The headers or library files could not be found for {str(err)},
|
|||
a required dependency when compiling Pillow from source.
|
||||
|
||||
Please see the install instructions at:
|
||||
https://pillow.readthedocs.io/en/latest/installation.html
|
||||
https://pillow.readthedocs.io/en/latest/installation/basic-installation.html
|
||||
|
||||
"""
|
||||
sys.stderr.write(msg)
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@ import os
|
|||
import struct
|
||||
from enum import IntEnum
|
||||
from io import BytesIO
|
||||
from typing import IO
|
||||
|
||||
from . import Image, ImageFile
|
||||
|
||||
|
|
@ -55,7 +56,7 @@ class AlphaEncoding(IntEnum):
|
|||
DXT5 = 7
|
||||
|
||||
|
||||
def unpack_565(i):
|
||||
def unpack_565(i: int) -> tuple[int, int, int]:
|
||||
return ((i >> 11) & 0x1F) << 3, ((i >> 5) & 0x3F) << 2, (i & 0x1F) << 3
|
||||
|
||||
|
||||
|
|
@ -241,7 +242,7 @@ class BLPFormatError(NotImplementedError):
|
|||
pass
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return prefix[:4] in (b"BLP1", b"BLP2")
|
||||
|
||||
|
||||
|
|
@ -253,7 +254,7 @@ class BlpImageFile(ImageFile.ImageFile):
|
|||
format = "BLP"
|
||||
format_description = "Blizzard Mipmap Format"
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
self.magic = self.fp.read(4)
|
||||
|
||||
self.fp.seek(5, os.SEEK_CUR)
|
||||
|
|
@ -284,7 +285,8 @@ class _BLPBaseDecoder(ImageFile.PyDecoder):
|
|||
raise OSError(msg) from e
|
||||
return -1, 0
|
||||
|
||||
def _read_blp_header(self):
|
||||
def _read_blp_header(self) -> None:
|
||||
assert self.fd is not None
|
||||
self.fd.seek(4)
|
||||
(self._blp_compression,) = struct.unpack("<i", self._safe_read(4))
|
||||
|
||||
|
|
@ -303,10 +305,10 @@ class _BLPBaseDecoder(ImageFile.PyDecoder):
|
|||
self._blp_offsets = struct.unpack("<16I", self._safe_read(16 * 4))
|
||||
self._blp_lengths = struct.unpack("<16I", self._safe_read(16 * 4))
|
||||
|
||||
def _safe_read(self, length):
|
||||
def _safe_read(self, length: int) -> bytes:
|
||||
return ImageFile._safe_read(self.fd, length)
|
||||
|
||||
def _read_palette(self):
|
||||
def _read_palette(self) -> list[tuple[int, int, int, int]]:
|
||||
ret = []
|
||||
for i in range(256):
|
||||
try:
|
||||
|
|
@ -333,7 +335,7 @@ class _BLPBaseDecoder(ImageFile.PyDecoder):
|
|||
|
||||
|
||||
class BLP1Decoder(_BLPBaseDecoder):
|
||||
def _load(self):
|
||||
def _load(self) -> None:
|
||||
if self._blp_compression == Format.JPEG:
|
||||
self._decode_jpeg_stream()
|
||||
|
||||
|
|
@ -349,29 +351,30 @@ class BLP1Decoder(_BLPBaseDecoder):
|
|||
msg = f"Unsupported BLP compression {repr(self._blp_encoding)}"
|
||||
raise BLPFormatError(msg)
|
||||
|
||||
def _decode_jpeg_stream(self):
|
||||
def _decode_jpeg_stream(self) -> None:
|
||||
from .JpegImagePlugin import JpegImageFile
|
||||
|
||||
(jpeg_header_size,) = struct.unpack("<I", self._safe_read(4))
|
||||
jpeg_header = self._safe_read(jpeg_header_size)
|
||||
assert self.fd is not None
|
||||
self._safe_read(self._blp_offsets[0] - self.fd.tell()) # What IS this?
|
||||
data = self._safe_read(self._blp_lengths[0])
|
||||
data = jpeg_header + data
|
||||
data = BytesIO(data)
|
||||
image = JpegImageFile(data)
|
||||
image = JpegImageFile(BytesIO(data))
|
||||
Image._decompression_bomb_check(image.size)
|
||||
if image.mode == "CMYK":
|
||||
decoder_name, extents, offset, args = image.tile[0]
|
||||
image.tile = [(decoder_name, extents, offset, (args[0], "CMYK"))]
|
||||
r, g, b = image.convert("RGB").split()
|
||||
image = Image.merge("RGB", (b, g, r))
|
||||
self.set_as_raw(image.tobytes())
|
||||
reversed_image = Image.merge("RGB", (b, g, r))
|
||||
self.set_as_raw(reversed_image.tobytes())
|
||||
|
||||
|
||||
class BLP2Decoder(_BLPBaseDecoder):
|
||||
def _load(self):
|
||||
def _load(self) -> None:
|
||||
palette = self._read_palette()
|
||||
|
||||
assert self.fd is not None
|
||||
self.fd.seek(self._blp_offsets[0])
|
||||
|
||||
if self._blp_compression == 1:
|
||||
|
|
@ -418,7 +421,7 @@ class BLP2Decoder(_BLPBaseDecoder):
|
|||
class BLPEncoder(ImageFile.PyEncoder):
|
||||
_pushes_fd = True
|
||||
|
||||
def _write_palette(self):
|
||||
def _write_palette(self) -> bytes:
|
||||
data = b""
|
||||
palette = self.im.getpalette("RGBA", "RGBA")
|
||||
for i in range(len(palette) // 4):
|
||||
|
|
@ -446,7 +449,7 @@ class BLPEncoder(ImageFile.PyEncoder):
|
|||
return len(data), 0, data
|
||||
|
||||
|
||||
def _save(im, fp, filename):
|
||||
def _save(im: Image.Image, fp: IO[bytes], filename: str) -> None:
|
||||
if im.mode != "P":
|
||||
msg = "Unsupported BLP image mode"
|
||||
raise ValueError(msg)
|
||||
|
|
|
|||
|
|
@ -25,6 +25,7 @@
|
|||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
from typing import IO
|
||||
|
||||
from . import Image, ImageFile, ImagePalette
|
||||
from ._binary import i16le as i16
|
||||
|
|
@ -48,12 +49,12 @@ BIT2MODE = {
|
|||
}
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return prefix[:2] == b"BM"
|
||||
|
||||
|
||||
def _dib_accept(prefix):
|
||||
return i32(prefix) in [12, 40, 64, 108, 124]
|
||||
def _dib_accept(prefix: bytes) -> bool:
|
||||
return i32(prefix) in [12, 40, 52, 56, 64, 108, 124]
|
||||
|
||||
|
||||
# =============================================================================
|
||||
|
|
@ -83,8 +84,9 @@ class BmpImageFile(ImageFile.ImageFile):
|
|||
# read the rest of the bmp header, without its size
|
||||
header_data = ImageFile._safe_read(self.fp, file_info["header_size"] - 4)
|
||||
|
||||
# -------------------------------------------------- IBM OS/2 Bitmap v1
|
||||
# ------------------------------- Windows Bitmap v2, IBM OS/2 Bitmap v1
|
||||
# ----- This format has different offsets because of width/height types
|
||||
# 12: BITMAPCOREHEADER/OS21XBITMAPHEADER
|
||||
if file_info["header_size"] == 12:
|
||||
file_info["width"] = i16(header_data, 0)
|
||||
file_info["height"] = i16(header_data, 2)
|
||||
|
|
@ -93,9 +95,14 @@ class BmpImageFile(ImageFile.ImageFile):
|
|||
file_info["compression"] = self.RAW
|
||||
file_info["palette_padding"] = 3
|
||||
|
||||
# --------------------------------------------- Windows Bitmap v2 to v5
|
||||
# v3, OS/2 v2, v4, v5
|
||||
elif file_info["header_size"] in (40, 64, 108, 124):
|
||||
# --------------------------------------------- Windows Bitmap v3 to v5
|
||||
# 40: BITMAPINFOHEADER
|
||||
# 52: BITMAPV2HEADER
|
||||
# 56: BITMAPV3HEADER
|
||||
# 64: BITMAPCOREHEADER2/OS22XBITMAPHEADER
|
||||
# 108: BITMAPV4HEADER
|
||||
# 124: BITMAPV5HEADER
|
||||
elif file_info["header_size"] in (40, 52, 56, 64, 108, 124):
|
||||
file_info["y_flip"] = header_data[7] == 0xFF
|
||||
file_info["direction"] = 1 if file_info["y_flip"] else -1
|
||||
file_info["width"] = i32(header_data, 0)
|
||||
|
|
@ -117,10 +124,13 @@ class BmpImageFile(ImageFile.ImageFile):
|
|||
file_info["palette_padding"] = 4
|
||||
self.info["dpi"] = tuple(x / 39.3701 for x in file_info["pixels_per_meter"])
|
||||
if file_info["compression"] == self.BITFIELDS:
|
||||
if len(header_data) >= 52:
|
||||
for idx, mask in enumerate(
|
||||
["r_mask", "g_mask", "b_mask", "a_mask"]
|
||||
):
|
||||
masks = ["r_mask", "g_mask", "b_mask"]
|
||||
if len(header_data) >= 48:
|
||||
if len(header_data) >= 52:
|
||||
masks.append("a_mask")
|
||||
else:
|
||||
file_info["a_mask"] = 0x0
|
||||
for idx, mask in enumerate(masks):
|
||||
file_info[mask] = i32(header_data, 36 + idx * 4)
|
||||
else:
|
||||
# 40 byte headers only have the three components in the
|
||||
|
|
@ -132,7 +142,7 @@ class BmpImageFile(ImageFile.ImageFile):
|
|||
# location, but it is listed as a reserved component,
|
||||
# and it is not generally an alpha channel
|
||||
file_info["a_mask"] = 0x0
|
||||
for mask in ["r_mask", "g_mask", "b_mask"]:
|
||||
for mask in masks:
|
||||
file_info[mask] = i32(read(4))
|
||||
file_info["rgb_mask"] = (
|
||||
file_info["r_mask"],
|
||||
|
|
@ -175,9 +185,11 @@ class BmpImageFile(ImageFile.ImageFile):
|
|||
32: [
|
||||
(0xFF0000, 0xFF00, 0xFF, 0x0),
|
||||
(0xFF000000, 0xFF0000, 0xFF00, 0x0),
|
||||
(0xFF000000, 0xFF00, 0xFF, 0x0),
|
||||
(0xFF000000, 0xFF0000, 0xFF00, 0xFF),
|
||||
(0xFF, 0xFF00, 0xFF0000, 0xFF000000),
|
||||
(0xFF0000, 0xFF00, 0xFF, 0xFF000000),
|
||||
(0xFF000000, 0xFF00, 0xFF, 0xFF0000),
|
||||
(0x0, 0x0, 0x0, 0x0),
|
||||
],
|
||||
24: [(0xFF0000, 0xFF00, 0xFF)],
|
||||
|
|
@ -186,9 +198,11 @@ class BmpImageFile(ImageFile.ImageFile):
|
|||
MASK_MODES = {
|
||||
(32, (0xFF0000, 0xFF00, 0xFF, 0x0)): "BGRX",
|
||||
(32, (0xFF000000, 0xFF0000, 0xFF00, 0x0)): "XBGR",
|
||||
(32, (0xFF000000, 0xFF00, 0xFF, 0x0)): "BGXR",
|
||||
(32, (0xFF000000, 0xFF0000, 0xFF00, 0xFF)): "ABGR",
|
||||
(32, (0xFF, 0xFF00, 0xFF0000, 0xFF000000)): "RGBA",
|
||||
(32, (0xFF0000, 0xFF00, 0xFF, 0xFF000000)): "BGRA",
|
||||
(32, (0xFF000000, 0xFF00, 0xFF, 0xFF0000)): "BGAR",
|
||||
(32, (0x0, 0x0, 0x0, 0x0)): "BGRA",
|
||||
(24, (0xFF0000, 0xFF00, 0xFF)): "BGR",
|
||||
(16, (0xF800, 0x7E0, 0x1F)): "BGR;16",
|
||||
|
|
@ -270,7 +284,7 @@ class BmpImageFile(ImageFile.ImageFile):
|
|||
)
|
||||
]
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
"""Open file, check magic number and read header"""
|
||||
# read 14 bytes: magic number, filesize, reserved, header final offset
|
||||
head_data = self.fp.read(14)
|
||||
|
|
@ -363,7 +377,7 @@ class DibImageFile(BmpImageFile):
|
|||
format = "DIB"
|
||||
format_description = "Windows Bitmap"
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
self._bitmap()
|
||||
|
||||
|
||||
|
|
@ -381,11 +395,13 @@ SAVE = {
|
|||
}
|
||||
|
||||
|
||||
def _dib_save(im, fp, filename):
|
||||
def _dib_save(im: Image.Image, fp: IO[bytes], filename: str) -> None:
|
||||
_save(im, fp, filename, False)
|
||||
|
||||
|
||||
def _save(im, fp, filename, bitmap_header=True):
|
||||
def _save(
|
||||
im: Image.Image, fp: IO[bytes], filename: str, bitmap_header: bool = True
|
||||
) -> None:
|
||||
try:
|
||||
rawmode, bits, colors = SAVE[im.mode]
|
||||
except KeyError as e:
|
||||
|
|
|
|||
|
|
@ -10,12 +10,14 @@
|
|||
#
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import IO
|
||||
|
||||
from . import Image, ImageFile
|
||||
|
||||
_handler = None
|
||||
|
||||
|
||||
def register_handler(handler):
|
||||
def register_handler(handler: ImageFile.StubHandler | None) -> None:
|
||||
"""
|
||||
Install application-specific BUFR image handler.
|
||||
|
||||
|
|
@ -29,7 +31,7 @@ def register_handler(handler):
|
|||
# Image adapter
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return prefix[:4] == b"BUFR" or prefix[:4] == b"ZCZC"
|
||||
|
||||
|
||||
|
|
@ -37,7 +39,7 @@ class BufrStubImageFile(ImageFile.StubImageFile):
|
|||
format = "BUFR"
|
||||
format_description = "BUFR"
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
offset = self.fp.tell()
|
||||
|
||||
if not _accept(self.fp.read(4)):
|
||||
|
|
@ -54,11 +56,11 @@ class BufrStubImageFile(ImageFile.StubImageFile):
|
|||
if loader:
|
||||
loader.open(self)
|
||||
|
||||
def _load(self):
|
||||
def _load(self) -> ImageFile.StubHandler | None:
|
||||
return _handler
|
||||
|
||||
|
||||
def _save(im, fp, filename):
|
||||
def _save(im: Image.Image, fp: IO[bytes], filename: str) -> None:
|
||||
if _handler is None or not hasattr(_handler, "save"):
|
||||
msg = "BUFR save handler not installed"
|
||||
raise OSError(msg)
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ from ._binary import i32le as i32
|
|||
# --------------------------------------------------------------------
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return prefix[:4] == b"\0\0\2\0"
|
||||
|
||||
|
||||
|
|
@ -37,7 +37,7 @@ class CurImageFile(BmpImagePlugin.BmpImageFile):
|
|||
format = "CUR"
|
||||
format_description = "Windows Cursor"
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
offset = self.fp.tell()
|
||||
|
||||
# check magic
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ from .PcxImagePlugin import PcxImageFile
|
|||
MAGIC = 0x3ADE68B1 # QUIZ: what's this value, then?
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return len(prefix) >= 4 and i32(prefix) == MAGIC
|
||||
|
||||
|
||||
|
|
@ -42,7 +42,7 @@ class DcxImageFile(PcxImageFile):
|
|||
format_description = "Intel DCX"
|
||||
_close_exclusive_fp_after_loading = False
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
# Header
|
||||
s = self.fp.read(4)
|
||||
if not _accept(s):
|
||||
|
|
@ -58,12 +58,12 @@ class DcxImageFile(PcxImageFile):
|
|||
self._offset.append(offset)
|
||||
|
||||
self._fp = self.fp
|
||||
self.frame = None
|
||||
self.frame = -1
|
||||
self.n_frames = len(self._offset)
|
||||
self.is_animated = self.n_frames > 1
|
||||
self.seek(0)
|
||||
|
||||
def seek(self, frame):
|
||||
def seek(self, frame: int) -> None:
|
||||
if not self._seek_check(frame):
|
||||
return
|
||||
self.frame = frame
|
||||
|
|
@ -71,7 +71,7 @@ class DcxImageFile(PcxImageFile):
|
|||
self.fp.seek(self._offset[frame])
|
||||
PcxImageFile._open(self)
|
||||
|
||||
def tell(self):
|
||||
def tell(self) -> int:
|
||||
return self.frame
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@ import io
|
|||
import struct
|
||||
import sys
|
||||
from enum import IntEnum, IntFlag
|
||||
from typing import IO
|
||||
|
||||
from . import Image, ImageFile, ImagePalette
|
||||
from ._binary import i32le as i32
|
||||
|
|
@ -271,16 +272,16 @@ class D3DFMT(IntEnum):
|
|||
module = sys.modules[__name__]
|
||||
for item in DDSD:
|
||||
assert item.name is not None
|
||||
setattr(module, "DDSD_" + item.name, item.value)
|
||||
setattr(module, f"DDSD_{item.name}", item.value)
|
||||
for item1 in DDSCAPS:
|
||||
assert item1.name is not None
|
||||
setattr(module, "DDSCAPS_" + item1.name, item1.value)
|
||||
setattr(module, f"DDSCAPS_{item1.name}", item1.value)
|
||||
for item2 in DDSCAPS2:
|
||||
assert item2.name is not None
|
||||
setattr(module, "DDSCAPS2_" + item2.name, item2.value)
|
||||
setattr(module, f"DDSCAPS2_{item2.name}", item2.value)
|
||||
for item3 in DDPF:
|
||||
assert item3.name is not None
|
||||
setattr(module, "DDPF_" + item3.name, item3.value)
|
||||
setattr(module, f"DDPF_{item3.name}", item3.value)
|
||||
|
||||
DDS_FOURCC = DDPF.FOURCC
|
||||
DDS_RGB = DDPF.RGB
|
||||
|
|
@ -331,7 +332,7 @@ class DdsImageFile(ImageFile.ImageFile):
|
|||
format = "DDS"
|
||||
format_description = "DirectDraw Surface"
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
if not _accept(self.fp.read(4)):
|
||||
msg = "not a DDS file"
|
||||
raise SyntaxError(msg)
|
||||
|
|
@ -472,7 +473,7 @@ class DdsImageFile(ImageFile.ImageFile):
|
|||
else:
|
||||
self.tile = [ImageFile._Tile("raw", extents, 0, rawmode or self.mode)]
|
||||
|
||||
def load_seek(self, pos):
|
||||
def load_seek(self, pos: int) -> None:
|
||||
pass
|
||||
|
||||
|
||||
|
|
@ -510,7 +511,7 @@ class DdsRgbDecoder(ImageFile.PyDecoder):
|
|||
return -1, 0
|
||||
|
||||
|
||||
def _save(im, fp, filename):
|
||||
def _save(im: Image.Image, fp: IO[bytes], filename: str) -> None:
|
||||
if im.mode not in ("RGB", "RGBA", "L", "LA"):
|
||||
msg = f"cannot write mode {im.mode} as DDS"
|
||||
raise OSError(msg)
|
||||
|
|
@ -562,7 +563,7 @@ def _save(im, fp, filename):
|
|||
)
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return prefix[:4] == b"DDS "
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ gs_binary: str | bool | None = None
|
|||
gs_windows_binary = None
|
||||
|
||||
|
||||
def has_ghostscript():
|
||||
def has_ghostscript() -> bool:
|
||||
global gs_binary, gs_windows_binary
|
||||
if gs_binary is None:
|
||||
if sys.platform.startswith("win"):
|
||||
|
|
@ -178,7 +178,7 @@ class PSFile:
|
|||
self.char = None
|
||||
self.fp.seek(offset, whence)
|
||||
|
||||
def readline(self):
|
||||
def readline(self) -> str:
|
||||
s = [self.char or b""]
|
||||
self.char = None
|
||||
|
||||
|
|
@ -195,7 +195,7 @@ class PSFile:
|
|||
return b"".join(s).decode("latin-1")
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return prefix[:4] == b"%!PS" or (len(prefix) >= 4 and i32(prefix) == 0xC6D3D0C5)
|
||||
|
||||
|
||||
|
|
@ -212,7 +212,7 @@ class EpsImageFile(ImageFile.ImageFile):
|
|||
|
||||
mode_map = {1: "L", 2: "LAB", 3: "RGB", 4: "CMYK"}
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
(length, offset) = self._find_offset(self.fp)
|
||||
|
||||
# go to offset - start of "%!PS"
|
||||
|
|
@ -228,7 +228,7 @@ class EpsImageFile(ImageFile.ImageFile):
|
|||
reading_trailer_comments = False
|
||||
trailer_reached = False
|
||||
|
||||
def check_required_header_comments():
|
||||
def check_required_header_comments() -> None:
|
||||
if "PS-Adobe" not in self.info:
|
||||
msg = 'EPS header missing "%!PS-Adobe" comment'
|
||||
raise SyntaxError(msg)
|
||||
|
|
@ -404,7 +404,7 @@ class EpsImageFile(ImageFile.ImageFile):
|
|||
self.tile = []
|
||||
return Image.Image.load(self)
|
||||
|
||||
def load_seek(self, pos):
|
||||
def load_seek(self, pos: int) -> None:
|
||||
# we can't incrementally load, so force ImageFile.parser to
|
||||
# use our custom load method by defining this method.
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -346,7 +346,7 @@ class Interop(IntEnum):
|
|||
InteropVersion = 2
|
||||
RelatedImageFileFormat = 4096
|
||||
RelatedImageWidth = 4097
|
||||
RleatedImageHeight = 4098
|
||||
RelatedImageHeight = 4098
|
||||
|
||||
|
||||
class IFD(IntEnum):
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ from ._binary import o8
|
|||
# decoder
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return (
|
||||
len(prefix) >= 6
|
||||
and i16(prefix, 4) in [0xAF11, 0xAF12]
|
||||
|
|
@ -123,7 +123,7 @@ class FliImageFile(ImageFile.ImageFile):
|
|||
palette[i] = (r, g, b)
|
||||
i += 1
|
||||
|
||||
def seek(self, frame):
|
||||
def seek(self, frame: int) -> None:
|
||||
if not self._seek_check(frame):
|
||||
return
|
||||
if frame < self.__frame:
|
||||
|
|
@ -132,7 +132,7 @@ class FliImageFile(ImageFile.ImageFile):
|
|||
for f in range(self.__frame + 1, frame + 1):
|
||||
self._seek(f)
|
||||
|
||||
def _seek(self, frame):
|
||||
def _seek(self, frame: int) -> None:
|
||||
if frame == 0:
|
||||
self.__frame = -1
|
||||
self._fp.seek(self.__rewind)
|
||||
|
|
@ -162,7 +162,7 @@ class FliImageFile(ImageFile.ImageFile):
|
|||
|
||||
self.__offset += framesize
|
||||
|
||||
def tell(self):
|
||||
def tell(self) -> int:
|
||||
return self.__frame
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ MODES = {
|
|||
# --------------------------------------------------------------------
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return prefix[:8] == olefile.MAGIC
|
||||
|
||||
|
||||
|
|
@ -70,7 +70,7 @@ class FpxImageFile(ImageFile.ImageFile):
|
|||
|
||||
self._open_index(1)
|
||||
|
||||
def _open_index(self, index=1):
|
||||
def _open_index(self, index: int = 1) -> None:
|
||||
#
|
||||
# get the Image Contents Property Set
|
||||
|
||||
|
|
@ -85,7 +85,7 @@ class FpxImageFile(ImageFile.ImageFile):
|
|||
size = max(self.size)
|
||||
i = 1
|
||||
while size > 64:
|
||||
size = size / 2
|
||||
size = size // 2
|
||||
i += 1
|
||||
self.maxid = i - 1
|
||||
|
||||
|
|
@ -118,7 +118,7 @@ class FpxImageFile(ImageFile.ImageFile):
|
|||
|
||||
self._open_subimage(1, self.maxid)
|
||||
|
||||
def _open_subimage(self, index=1, subimage=0):
|
||||
def _open_subimage(self, index: int = 1, subimage: int = 0) -> None:
|
||||
#
|
||||
# setup tile descriptors for a given subimage
|
||||
|
||||
|
|
@ -237,7 +237,7 @@ class FpxImageFile(ImageFile.ImageFile):
|
|||
|
||||
return ImageFile.ImageFile.load(self)
|
||||
|
||||
def close(self):
|
||||
def close(self) -> None:
|
||||
self.ole.close()
|
||||
super().close()
|
||||
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ class FtexImageFile(ImageFile.ImageFile):
|
|||
format = "FTEX"
|
||||
format_description = "Texture File Format (IW2:EOC)"
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
if not _accept(self.fp.read(4)):
|
||||
msg = "not an FTEX file"
|
||||
raise SyntaxError(msg)
|
||||
|
|
@ -103,11 +103,11 @@ class FtexImageFile(ImageFile.ImageFile):
|
|||
self.fp.close()
|
||||
self.fp = BytesIO(data)
|
||||
|
||||
def load_seek(self, pos):
|
||||
def load_seek(self, pos: int) -> None:
|
||||
pass
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return prefix[:4] == MAGIC
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ from . import Image, ImageFile
|
|||
from ._binary import i32be as i32
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return len(prefix) >= 8 and i32(prefix, 0) >= 20 and i32(prefix, 4) in (1, 2)
|
||||
|
||||
|
||||
|
|
@ -41,7 +41,7 @@ class GbrImageFile(ImageFile.ImageFile):
|
|||
format = "GBR"
|
||||
format_description = "GIMP brush file"
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
header_size = i32(self.fp.read(4))
|
||||
if header_size < 20:
|
||||
msg = "not a GIMP brush"
|
||||
|
|
|
|||
|
|
@ -30,6 +30,8 @@ import math
|
|||
import os
|
||||
import subprocess
|
||||
from enum import IntEnum
|
||||
from functools import cached_property
|
||||
from typing import IO
|
||||
|
||||
from . import (
|
||||
Image,
|
||||
|
|
@ -60,7 +62,7 @@ LOADING_STRATEGY = LoadingStrategy.RGB_AFTER_FIRST
|
|||
# Identify/read GIF files
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return prefix[:6] in [b"GIF87a", b"GIF89a"]
|
||||
|
||||
|
||||
|
|
@ -76,19 +78,19 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
|
||||
global_palette = None
|
||||
|
||||
def data(self):
|
||||
def data(self) -> bytes | None:
|
||||
s = self.fp.read(1)
|
||||
if s and s[0]:
|
||||
return self.fp.read(s[0])
|
||||
return None
|
||||
|
||||
def _is_palette_needed(self, p):
|
||||
def _is_palette_needed(self, p: bytes) -> bool:
|
||||
for i in range(0, len(p), 3):
|
||||
if not (i // 3 == p[i] == p[i + 1] == p[i + 2]):
|
||||
return True
|
||||
return False
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
# Screen
|
||||
s = self.fp.read(13)
|
||||
if not _accept(s):
|
||||
|
|
@ -112,8 +114,7 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
|
||||
self._fp = self.fp # FIXME: hack
|
||||
self.__rewind = self.fp.tell()
|
||||
self._n_frames = None
|
||||
self._is_animated = None
|
||||
self._n_frames: int | None = None
|
||||
self._seek(0) # get ready to read first frame
|
||||
|
||||
@property
|
||||
|
|
@ -128,26 +129,25 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
self.seek(current)
|
||||
return self._n_frames
|
||||
|
||||
@property
|
||||
def is_animated(self):
|
||||
if self._is_animated is None:
|
||||
if self._n_frames is not None:
|
||||
self._is_animated = self._n_frames != 1
|
||||
else:
|
||||
current = self.tell()
|
||||
if current:
|
||||
self._is_animated = True
|
||||
else:
|
||||
try:
|
||||
self._seek(1, False)
|
||||
self._is_animated = True
|
||||
except EOFError:
|
||||
self._is_animated = False
|
||||
@cached_property
|
||||
def is_animated(self) -> bool:
|
||||
if self._n_frames is not None:
|
||||
return self._n_frames != 1
|
||||
|
||||
self.seek(current)
|
||||
return self._is_animated
|
||||
current = self.tell()
|
||||
if current:
|
||||
return True
|
||||
|
||||
def seek(self, frame):
|
||||
try:
|
||||
self._seek(1, False)
|
||||
is_animated = True
|
||||
except EOFError:
|
||||
is_animated = False
|
||||
|
||||
self.seek(current)
|
||||
return is_animated
|
||||
|
||||
def seek(self, frame: int) -> None:
|
||||
if not self._seek_check(frame):
|
||||
return
|
||||
if frame < self.__frame:
|
||||
|
|
@ -337,14 +337,13 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
self._mode = "RGB"
|
||||
self.im = self.im.convert("RGB", Image.Dither.FLOYDSTEINBERG)
|
||||
|
||||
def _rgb(color):
|
||||
def _rgb(color: int) -> tuple[int, int, int]:
|
||||
if self._frame_palette:
|
||||
if color * 3 + 3 > len(self._frame_palette.palette):
|
||||
color = 0
|
||||
color = tuple(self._frame_palette.palette[color * 3 : color * 3 + 3])
|
||||
return tuple(self._frame_palette.palette[color * 3 : color * 3 + 3])
|
||||
else:
|
||||
color = (color, color, color)
|
||||
return color
|
||||
return (color, color, color)
|
||||
|
||||
self.dispose_extent = frame_dispose_extent
|
||||
try:
|
||||
|
|
@ -417,7 +416,7 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
elif k in self.info:
|
||||
del self.info[k]
|
||||
|
||||
def load_prepare(self):
|
||||
def load_prepare(self) -> None:
|
||||
temp_mode = "P" if self._frame_palette else "L"
|
||||
self._prev_im = None
|
||||
if self.__frame == 0:
|
||||
|
|
@ -437,7 +436,7 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
|
||||
super().load_prepare()
|
||||
|
||||
def load_end(self):
|
||||
def load_end(self) -> None:
|
||||
if self.__frame == 0:
|
||||
if self.mode == "P" and LOADING_STRATEGY == LoadingStrategy.RGB_ALWAYS:
|
||||
if self._frame_transparency is not None:
|
||||
|
|
@ -463,7 +462,7 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
else:
|
||||
self.im.paste(frame_im, self.dispose_extent)
|
||||
|
||||
def tell(self):
|
||||
def tell(self) -> int:
|
||||
return self.__frame
|
||||
|
||||
|
||||
|
|
@ -474,7 +473,7 @@ class GifImageFile(ImageFile.ImageFile):
|
|||
RAWMODE = {"1": "L", "L": "L", "P": "P"}
|
||||
|
||||
|
||||
def _normalize_mode(im):
|
||||
def _normalize_mode(im: Image.Image) -> Image.Image:
|
||||
"""
|
||||
Takes an image (or frame), returns an image in a mode that is appropriate
|
||||
for saving in a Gif.
|
||||
|
|
@ -559,7 +558,11 @@ def _normalize_palette(im, palette, info):
|
|||
return im
|
||||
|
||||
|
||||
def _write_single_frame(im, fp, palette):
|
||||
def _write_single_frame(
|
||||
im: Image.Image,
|
||||
fp: IO[bytes],
|
||||
palette: bytes | bytearray | list[int] | ImagePalette.ImagePalette,
|
||||
) -> None:
|
||||
im_out = _normalize_mode(im)
|
||||
for k, v in im_out.info.items():
|
||||
im.encoderinfo.setdefault(k, v)
|
||||
|
|
@ -580,7 +583,9 @@ def _write_single_frame(im, fp, palette):
|
|||
fp.write(b"\0") # end of image data
|
||||
|
||||
|
||||
def _getbbox(base_im, im_frame):
|
||||
def _getbbox(
|
||||
base_im: Image.Image, im_frame: Image.Image
|
||||
) -> tuple[Image.Image, tuple[int, int, int, int]]:
|
||||
if _get_palette_bytes(im_frame) != _get_palette_bytes(base_im):
|
||||
im_frame = im_frame.convert("RGBA")
|
||||
base_im = base_im.convert("RGBA")
|
||||
|
|
@ -710,11 +715,13 @@ def _write_multiple_frames(im, fp, palette):
|
|||
return True
|
||||
|
||||
|
||||
def _save_all(im, fp, filename):
|
||||
def _save_all(im: Image.Image, fp: IO[bytes], filename: str) -> None:
|
||||
_save(im, fp, filename, save_all=True)
|
||||
|
||||
|
||||
def _save(im, fp, filename, save_all=False):
|
||||
def _save(
|
||||
im: Image.Image, fp: IO[bytes], filename: str, save_all: bool = False
|
||||
) -> None:
|
||||
# header
|
||||
if "palette" in im.encoderinfo or "palette" in im.info:
|
||||
palette = im.encoderinfo.get("palette", im.info.get("palette"))
|
||||
|
|
@ -731,7 +738,7 @@ def _save(im, fp, filename, save_all=False):
|
|||
fp.flush()
|
||||
|
||||
|
||||
def get_interlace(im):
|
||||
def get_interlace(im: Image.Image) -> int:
|
||||
interlace = im.encoderinfo.get("interlace", 1)
|
||||
|
||||
# workaround for @PIL153
|
||||
|
|
@ -789,7 +796,7 @@ def _write_local_header(fp, im, offset, flags):
|
|||
fp.write(o8(8)) # bits
|
||||
|
||||
|
||||
def _save_netpbm(im, fp, filename):
|
||||
def _save_netpbm(im: Image.Image, fp: IO[bytes], filename: str) -> None:
|
||||
# Unused by default.
|
||||
# To use, uncomment the register_save call at the end of the file.
|
||||
#
|
||||
|
|
@ -820,6 +827,7 @@ def _save_netpbm(im, fp, filename):
|
|||
)
|
||||
|
||||
# Allow ppmquant to receive SIGPIPE if ppmtogif exits
|
||||
assert quant_proc.stdout is not None
|
||||
quant_proc.stdout.close()
|
||||
|
||||
retcode = quant_proc.wait()
|
||||
|
|
@ -887,7 +895,7 @@ def _get_optimize(im, info):
|
|||
return used_palette_colors
|
||||
|
||||
|
||||
def _get_color_table_size(palette_bytes):
|
||||
def _get_color_table_size(palette_bytes: bytes) -> int:
|
||||
# calculate the palette size for the header
|
||||
if not palette_bytes:
|
||||
return 0
|
||||
|
|
@ -897,7 +905,7 @@ def _get_color_table_size(palette_bytes):
|
|||
return math.ceil(math.log(len(palette_bytes) // 3, 2)) - 1
|
||||
|
||||
|
||||
def _get_header_palette(palette_bytes):
|
||||
def _get_header_palette(palette_bytes: bytes) -> bytes:
|
||||
"""
|
||||
Returns the palette, null padded to the next power of 2 (*3) bytes
|
||||
suitable for direct inclusion in the GIF header
|
||||
|
|
@ -915,7 +923,7 @@ def _get_header_palette(palette_bytes):
|
|||
return palette_bytes
|
||||
|
||||
|
||||
def _get_palette_bytes(im):
|
||||
def _get_palette_bytes(im: Image.Image) -> bytes:
|
||||
"""
|
||||
Gets the palette for inclusion in the gif header
|
||||
|
||||
|
|
@ -1079,7 +1087,7 @@ def getdata(im, offset=(0, 0), **params):
|
|||
class Collector:
|
||||
data = []
|
||||
|
||||
def write(self, data):
|
||||
def write(self, data: bytes) -> None:
|
||||
self.data.append(data)
|
||||
|
||||
im.load() # make sure raster data is available
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ See the GIMP distribution for more information.)
|
|||
from __future__ import annotations
|
||||
|
||||
from math import log, pi, sin, sqrt
|
||||
from typing import IO, Callable
|
||||
|
||||
from ._binary import o8
|
||||
|
||||
|
|
@ -28,7 +29,7 @@ EPSILON = 1e-10
|
|||
"""""" # Enable auto-doc for data member
|
||||
|
||||
|
||||
def linear(middle, pos):
|
||||
def linear(middle: float, pos: float) -> float:
|
||||
if pos <= middle:
|
||||
if middle < EPSILON:
|
||||
return 0.0
|
||||
|
|
@ -43,19 +44,19 @@ def linear(middle, pos):
|
|||
return 0.5 + 0.5 * pos / middle
|
||||
|
||||
|
||||
def curved(middle, pos):
|
||||
def curved(middle: float, pos: float) -> float:
|
||||
return pos ** (log(0.5) / log(max(middle, EPSILON)))
|
||||
|
||||
|
||||
def sine(middle, pos):
|
||||
def sine(middle: float, pos: float) -> float:
|
||||
return (sin((-pi / 2.0) + pi * linear(middle, pos)) + 1.0) / 2.0
|
||||
|
||||
|
||||
def sphere_increasing(middle, pos):
|
||||
def sphere_increasing(middle: float, pos: float) -> float:
|
||||
return sqrt(1.0 - (linear(middle, pos) - 1.0) ** 2)
|
||||
|
||||
|
||||
def sphere_decreasing(middle, pos):
|
||||
def sphere_decreasing(middle: float, pos: float) -> float:
|
||||
return 1.0 - sqrt(1.0 - linear(middle, pos) ** 2)
|
||||
|
||||
|
||||
|
|
@ -64,9 +65,22 @@ SEGMENTS = [linear, curved, sine, sphere_increasing, sphere_decreasing]
|
|||
|
||||
|
||||
class GradientFile:
|
||||
gradient = None
|
||||
gradient: (
|
||||
list[
|
||||
tuple[
|
||||
float,
|
||||
float,
|
||||
float,
|
||||
list[float],
|
||||
list[float],
|
||||
Callable[[float, float], float],
|
||||
]
|
||||
]
|
||||
| None
|
||||
) = None
|
||||
|
||||
def getpalette(self, entries=256):
|
||||
def getpalette(self, entries: int = 256) -> tuple[bytes, str]:
|
||||
assert self.gradient is not None
|
||||
palette = []
|
||||
|
||||
ix = 0
|
||||
|
|
@ -101,7 +115,7 @@ class GradientFile:
|
|||
class GimpGradientFile(GradientFile):
|
||||
"""File handler for GIMP's gradient format."""
|
||||
|
||||
def __init__(self, fp):
|
||||
def __init__(self, fp: IO[bytes]) -> None:
|
||||
if fp.readline()[:13] != b"GIMP Gradient":
|
||||
msg = "not a GIMP gradient file"
|
||||
raise SyntaxError(msg)
|
||||
|
|
@ -114,7 +128,7 @@ class GimpGradientFile(GradientFile):
|
|||
|
||||
count = int(line)
|
||||
|
||||
gradient = []
|
||||
self.gradient = []
|
||||
|
||||
for i in range(count):
|
||||
s = fp.readline().split()
|
||||
|
|
@ -132,6 +146,4 @@ class GimpGradientFile(GradientFile):
|
|||
msg = "cannot handle HSV colour space"
|
||||
raise OSError(msg)
|
||||
|
||||
gradient.append((x0, x1, xm, rgb0, rgb1, segment))
|
||||
|
||||
self.gradient = gradient
|
||||
self.gradient.append((x0, x1, xm, rgb0, rgb1, segment))
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@
|
|||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from typing import IO
|
||||
|
||||
from ._binary import o8
|
||||
|
||||
|
|
@ -25,8 +26,8 @@ class GimpPaletteFile:
|
|||
|
||||
rawmode = "RGB"
|
||||
|
||||
def __init__(self, fp):
|
||||
self.palette = [o8(i) * 3 for i in range(256)]
|
||||
def __init__(self, fp: IO[bytes]) -> None:
|
||||
palette = [o8(i) * 3 for i in range(256)]
|
||||
|
||||
if fp.readline()[:12] != b"GIMP Palette":
|
||||
msg = "not a GIMP palette file"
|
||||
|
|
@ -49,9 +50,9 @@ class GimpPaletteFile:
|
|||
msg = "bad palette entry"
|
||||
raise ValueError(msg)
|
||||
|
||||
self.palette[i] = o8(v[0]) + o8(v[1]) + o8(v[2])
|
||||
palette[i] = o8(v[0]) + o8(v[1]) + o8(v[2])
|
||||
|
||||
self.palette = b"".join(self.palette)
|
||||
self.palette = b"".join(palette)
|
||||
|
||||
def getpalette(self):
|
||||
def getpalette(self) -> tuple[bytes, str]:
|
||||
return self.palette, self.rawmode
|
||||
|
|
|
|||
|
|
@ -10,12 +10,14 @@
|
|||
#
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import IO
|
||||
|
||||
from . import Image, ImageFile
|
||||
|
||||
_handler = None
|
||||
|
||||
|
||||
def register_handler(handler):
|
||||
def register_handler(handler: ImageFile.StubHandler | None) -> None:
|
||||
"""
|
||||
Install application-specific GRIB image handler.
|
||||
|
||||
|
|
@ -29,7 +31,7 @@ def register_handler(handler):
|
|||
# Image adapter
|
||||
|
||||
|
||||
def _accept(prefix):
|
||||
def _accept(prefix: bytes) -> bool:
|
||||
return prefix[:4] == b"GRIB" and prefix[7] == 1
|
||||
|
||||
|
||||
|
|
@ -37,7 +39,7 @@ class GribStubImageFile(ImageFile.StubImageFile):
|
|||
format = "GRIB"
|
||||
format_description = "GRIB"
|
||||
|
||||
def _open(self):
|
||||
def _open(self) -> None:
|
||||
offset = self.fp.tell()
|
||||
|
||||
if not _accept(self.fp.read(8)):
|
||||
|
|
@ -54,11 +56,11 @@ class GribStubImageFile(ImageFile.StubImageFile):
|
|||
if loader:
|
||||
loader.open(self)
|
||||
|
||||
def _load(self):
|
||||
def _load(self) -> ImageFile.StubHandler | None:
|
||||
return _handler
|
||||
|
||||
|
||||
def _save(im, fp, filename):
|
||||
def _save(im: Image.Image, fp: IO[bytes], filename: str) -> None:
|
||||
if _handler is None or not hasattr(_handler, "save"):
|
||||
msg = "GRIB save handler not installed"
|
||||
raise OSError(msg)
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user