diff --git a/.github/workflows/CI.yaml b/.github/workflows/CI.yaml new file mode 100644 index 0000000..8cb04b9 --- /dev/null +++ b/.github/workflows/CI.yaml @@ -0,0 +1,159 @@ +# This file is autogenerated by maturin v1.4.0 +# To update, run +# +# maturin generate-ci github --pytest +# +name: CI + +on: + push: + branches: + - main + - master + tags: + - '*' + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + linux: + runs-on: ubuntu-latest + strategy: + matrix: + target: [x86_64, x86, aarch64, armv7] + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-python@v4 + with: + python-version: '3.10' + - name: Build wheels + uses: PyO3/maturin-action@v1 + with: + target: ${{ matrix.target }} + args: --release --out dist --find-interpreter + sccache: 'true' + manylinux: auto + - name: Upload wheels + uses: actions/upload-artifact@v3 + with: + name: wheels + path: dist + - name: pytest + if: ${{ startsWith(matrix.target, 'x86_64') }} + shell: bash + run: | + set -e + pip install resvg_py --find-links dist --force-reinstall + pip install pytest + pytest + - name: pytest + if: ${{ !startsWith(matrix.target, 'x86') && matrix.target != 'ppc64' }} + uses: uraimo/run-on-arch-action@v2.5.0 + with: + arch: ${{ matrix.target }} + distro: ubuntu22.04 + githubToken: ${{ github.token }} + install: | + apt-get update + apt-get install -y --no-install-recommends python3 python3-pip + pip3 install -U pip pytest + run: | + set -e + pip3 install resvg_py --find-links dist --force-reinstall + pytest + + windows: + runs-on: windows-latest + strategy: + matrix: + target: [x64, x86] + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-python@v4 + with: + python-version: '3.10' + architecture: ${{ matrix.target }} + - name: Build wheels + uses: PyO3/maturin-action@v1 + with: + target: ${{ matrix.target }} + args: --release --out dist --find-interpreter + sccache: 'true' + - name: Upload wheels + uses: actions/upload-artifact@v3 + with: + name: wheels + path: dist + - name: pytest + if: ${{ !startsWith(matrix.target, 'aarch64') }} + shell: bash + run: | + set -e + pip install resvg_py --find-links dist --force-reinstall + pip install pytest + pytest + + macos: + runs-on: macos-latest + strategy: + matrix: + target: [x86_64, aarch64] + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-python@v4 + with: + python-version: '3.10' + - name: Build wheels + uses: PyO3/maturin-action@v1 + with: + target: ${{ matrix.target }} + args: --release --out dist --find-interpreter + sccache: 'true' + - name: Upload wheels + uses: actions/upload-artifact@v3 + with: + name: wheels + path: dist + - name: pytest + if: ${{ !startsWith(matrix.target, 'aarch64') }} + shell: bash + run: | + set -e + pip install resvg_py --find-links dist --force-reinstall + pip install pytest + pytest + + sdist: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - name: Build sdist + uses: PyO3/maturin-action@v1 + with: + command: sdist + args: --out dist + - name: Upload sdist + uses: actions/upload-artifact@v3 + with: + name: wheels + path: dist + + release: + name: Release + runs-on: ubuntu-latest + if: "startsWith(github.ref, 'refs/tags/')" + needs: [linux, windows, macos, sdist] + steps: + - uses: actions/download-artifact@v3 + with: + name: wheels + - name: Publish to PyPI + uses: PyO3/maturin-action@v1 + env: + MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }} + with: + command: upload + args: --non-interactive --skip-existing * diff --git a/.gitignore b/.gitignore index a915c8a..e116877 100644 --- a/.gitignore +++ b/.gitignore @@ -1,155 +1,72 @@ -# Byte-compiled / optimized / DLL files -__pycache__/ -*.py[cod] -*$py.class - -# C extensions -*.so - -# Distribution / packaging -.Python -build/ -develop-eggs/ -dist/ -downloads/ -eggs/ -.eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ -wheels/ -share/python-wheels/ -*.egg-info/ -.installed.cfg -*.egg -MANIFEST - -# PyInstaller -# Usually these files are written by a python script from a template -# before PyInstaller builds the exe, so as to inject date/other infos into it. -*.manifest -*.spec - -# Installer logs -pip-log.txt -pip-delete-this-directory.txt - -# Unit test / coverage reports -htmlcov/ -.tox/ -.nox/ -.coverage -.coverage.* -.cache -nosetests.xml -coverage.xml -*.cover -*.py,cover -.hypothesis/ -.pytest_cache/ -cover/ - -# Translations -*.mo -*.pot - -# Django stuff: -*.log -local_settings.py -db.sqlite3 -db.sqlite3-journal - -# Flask stuff: -instance/ -.webassets-cache - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ - -# PyBuilder -.pybuilder/ -target/ - -# Jupyter Notebook -.ipynb_checkpoints - -# IPython -profile_default/ -ipython_config.py - -# pyenv -# For a library or package, you might want to ignore these files since the code is -# intended to run in multiple environments; otherwise, check them in: -# .python-version - -# pipenv -# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. -# However, in case of collaboration, if having platform-specific dependencies or dependencies -# having no cross-platform support, pipenv may install dependencies that don't work, or not -# install all needed dependencies. -#Pipfile.lock - -# poetry -# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. -# This is especially recommended for binary packages to ensure reproducibility, and is more -# commonly ignored for libraries. -# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control -#poetry.lock - -# PEP 582; used by e.g. github.com/David-OConnor/pyflow -__pypackages__/ - -# Celery stuff -celerybeat-schedule -celerybeat.pid - -# SageMath parsed files -*.sage.py - -# Environments -.env -.venv -env/ -venv/ -ENV/ -env.bak/ -venv.bak/ - -# Spyder project settings -.spyderproject -.spyproject - -# Rope project settings -.ropeproject - -# mkdocs documentation -/site - -# mypy -.mypy_cache/ -.dmypy.json -dmypy.json - -# Pyre type checker -.pyre/ - -# pytype static type analyzer -.pytype/ - -# Cython debug symbols -cython_debug/ - -# PyCharm -# JetBrains specific template is maintainted in a separate JetBrains.gitignore that can -# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore -# and can be added to the global gitignore or merged into this file. For a more nuclear -# option (not recommended) you can uncomment the following to ignore the entire idea folder. -#.idea/ - -resvg -resvg.exe \ No newline at end of file +/target + +# Byte-compiled / optimized / DLL files +__pycache__/ +.pytest_cache/ +*.py[cod] + +# C extensions +*.so + +# Distribution / packaging +.Python +.venv/ +env/ +bin/ +build/ +develop-eggs/ +dist/ +eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +include/ +man/ +venv/ +*.egg-info/ +.installed.cfg +*.egg + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt +pip-selfcheck.json + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.cache +nosetests.xml +coverage.xml + +# Translations +*.mo + +# Mr Developer +.mr.developer.cfg +.project +.pydevproject + +# Rope +.ropeproject + +# Django stuff: +*.log +*.pot + +.DS_Store + +# Sphinx documentation +docs/_build/ + +# PyCharm +.idea/ + +# VSCode +.vscode/ + +# Pyenv +.python-version diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..4474e09 --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,705 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "adler" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" + +[[package]] +name = "arrayref" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545" + +[[package]] +name = "arrayvec" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711" + +[[package]] +name = "autocfg" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80" + +[[package]] +name = "base64" +version = "0.21.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" + +[[package]] +name = "base64" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9475866fec1451be56a3c2400fd081ff546538961565ccb5b7142cbd22bc7a51" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" + +[[package]] +name = "bytemuck" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d6d68c57235a3a081186990eca2867354726650f42f7516ca50c28d6281fd15" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "color_quant" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" + +[[package]] +name = "crc32fast" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "data-url" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c297a1c74b71ae29df00c3e22dd9534821d60eb9af5a0192823fa2acea70c2a" + +[[package]] +name = "fdeflate" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f9bfee30e4dedf0ab8b422f03af778d9612b63f502710fc500a334ebe2de645" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "flate2" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "float-cmp" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4" + +[[package]] +name = "fontconfig-parser" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a595cb550439a117696039dfc69830492058211b771a2a165379f2a1a53d84d" +dependencies = [ + "roxmltree", +] + +[[package]] +name = "fontdb" +version = "0.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0299020c3ef3f60f526a4f64ab4a3d4ce116b1acbf24cdd22da0068e5d81dc3" +dependencies = [ + "fontconfig-parser", + "log", + "memmap2", + "slotmap", + "tinyvec", + "ttf-parser", +] + +[[package]] +name = "gif" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80792593675e051cf94a4b111980da2ba60d4a83e43e0048c5693baab3977045" +dependencies = [ + "color_quant", + "weezl", +] + +[[package]] +name = "imagesize" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "029d73f573d8e8d63e6d5020011d3255b28c3ba85d6cf870a07184ed23de9284" + +[[package]] +name = "indoc" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa799dd5ed20a7e349f3b4639aa80d74549c81716d9ec4f994c9b5815598306" + +[[package]] +name = "jpeg-decoder" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f5d4a7da358eff58addd2877a45865158f0d78c911d43a5784ceb7bbf52833b0" + +[[package]] +name = "kurbo" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd85a5776cd9500c2e2059c8c76c3b01528566b7fcbaf8098b55a33fc298849b" +dependencies = [ + "arrayvec", +] + +[[package]] +name = "kurbo" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1618d4ebd923e97d67e7cd363d80aef35fe961005cbbbb3d2dad8bdd1bc63440" +dependencies = [ + "arrayvec", + "smallvec", +] + +[[package]] +name = "libc" +version = "0.2.153" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" + +[[package]] +name = "lock_api" +version = "0.4.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45" +dependencies = [ + "autocfg", + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c" + +[[package]] +name = "memmap2" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe751422e4a8caa417e13c3ea66452215d7d63e19e604f4980461212f3ae1322" +dependencies = [ + "libc", +] + +[[package]] +name = "memoffset" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" +dependencies = [ + "autocfg", +] + +[[package]] +name = "miniz_oxide" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7" +dependencies = [ + "adler", + "simd-adler32", +] + +[[package]] +name = "once_cell" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" + +[[package]] +name = "parking_lot" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-targets", +] + +[[package]] +name = "pico-args" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315" + +[[package]] +name = "png" +version = "0.17.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06e4b0d3d1312775e782c86c91a111aa1f910cbb65e1337f9975b5f9a554b5e1" +dependencies = [ + "bitflags 1.3.2", + "crc32fast", + "fdeflate", + "flate2", + "miniz_oxide", +] + +[[package]] +name = "proc-macro2" +version = "1.0.79" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "pyo3" +version = "0.19.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e681a6cfdc4adcc93b4d3cf993749a4552018ee0a9b65fc0ccfad74352c72a38" +dependencies = [ + "cfg-if", + "indoc", + "libc", + "memoffset", + "parking_lot", + "pyo3-build-config", + "pyo3-ffi", + "pyo3-macros", + "unindent", +] + +[[package]] +name = "pyo3-build-config" +version = "0.19.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "076c73d0bc438f7a4ef6fdd0c3bb4732149136abd952b110ac93e4edb13a6ba5" +dependencies = [ + "once_cell", + "target-lexicon", +] + +[[package]] +name = "pyo3-ffi" +version = "0.19.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e53cee42e77ebe256066ba8aa77eff722b3bb91f3419177cf4cd0f304d3284d9" +dependencies = [ + "libc", + "pyo3-build-config", +] + +[[package]] +name = "pyo3-macros" +version = "0.19.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfeb4c99597e136528c6dd7d5e3de5434d1ceaf487436a3f03b2d56b6fc9efd1" +dependencies = [ + "proc-macro2", + "pyo3-macros-backend", + "quote", + "syn", +] + +[[package]] +name = "pyo3-macros-backend" +version = "0.19.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "947dc12175c254889edc0c02e399476c2f652b4b9ebd123aa655c224de259536" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "quote" +version = "1.0.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "redox_syscall" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +dependencies = [ + "bitflags 1.3.2", +] + +[[package]] +name = "resvg" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "024e40e1ba7313fc315b1720298988c0cd6f8bfe3754b52838aafecebd11355a" +dependencies = [ + "gif", + "jpeg-decoder", + "log", + "pico-args", + "png", + "rgb", + "svgtypes", + "tiny-skia", + "usvg", +] + +[[package]] +name = "resvg_py" +version = "0.1.0" +dependencies = [ + "base64 0.22.0", + "pyo3", + "resvg", + "tiny-skia", + "unescape", + "usvg", +] + +[[package]] +name = "rgb" +version = "0.8.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05aaa8004b64fd573fc9d002f4e632d51ad4f026c2b5ba95fcb6c2f32c2c47d8" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "roxmltree" +version = "0.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3cd14fd5e3b777a7422cca79358c57a8f6e3a703d9ac187448d0daf220c2407f" + +[[package]] +name = "rustybuzz" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0ae5692c5beaad6a9e22830deeed7874eae8a4e3ba4076fb48e12c56856222c" +dependencies = [ + "bitflags 2.5.0", + "bytemuck", + "smallvec", + "ttf-parser", + "unicode-bidi-mirroring", + "unicode-ccc", + "unicode-properties", + "unicode-script", +] + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "simd-adler32" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe" + +[[package]] +name = "simplecss" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a11be7c62927d9427e9f40f3444d5499d868648e2edbc4e2116de69e7ec0e89d" +dependencies = [ + "log", +] + +[[package]] +name = "siphasher" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d" + +[[package]] +name = "slotmap" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbff4acf519f630b3a3ddcfaea6c06b42174d9a44bc70c620e9ed1649d58b82a" +dependencies = [ + "version_check", +] + +[[package]] +name = "smallvec" +version = "1.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" + +[[package]] +name = "strict-num" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731" +dependencies = [ + "float-cmp", +] + +[[package]] +name = "svgtypes" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59d7618f12b51be8171a7cfdda1e7a93f79cbc57c4e7adf89a749cf671125241" +dependencies = [ + "kurbo 0.10.4", + "siphasher", +] + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "target-lexicon" +version = "0.12.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f" + +[[package]] +name = "tiny-skia" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab" +dependencies = [ + "arrayref", + "arrayvec", + "bytemuck", + "cfg-if", + "log", + "png", + "tiny-skia-path", +] + +[[package]] +name = "tiny-skia-path" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93" +dependencies = [ + "arrayref", + "bytemuck", + "strict-num", +] + +[[package]] +name = "tinyvec" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" + +[[package]] +name = "ttf-parser" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17f77d76d837a7830fe1d4f12b7b4ba4192c1888001c7164257e4bc6d21d96b4" + +[[package]] +name = "unescape" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccb97dac3243214f8d8507998906ca3e2e0b900bf9bf4870477f125b82e68f6e" + +[[package]] +name = "unicode-bidi" +version = "0.3.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75" + +[[package]] +name = "unicode-bidi-mirroring" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56d12260fb92d52f9008be7e4bca09f584780eb2266dc8fecc6a192bec561694" + +[[package]] +name = "unicode-ccc" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc2520efa644f8268dce4dcd3050eaa7fc044fca03961e9998ac7e2e92b77cf1" + +[[package]] +name = "unicode-ident" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" + +[[package]] +name = "unicode-properties" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4259d9d4425d9f0661581b804cb85fe66a4c631cadd8f490d1c13a35d5d9291" + +[[package]] +name = "unicode-script" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8d71f5726e5f285a935e9fe8edfd53f0491eb6e9a5774097fdabee7cd8c9cd" + +[[package]] +name = "unicode-vo" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1d386ff53b415b7fe27b50bb44679e2cc4660272694b7b6f3326d8480823a94" + +[[package]] +name = "unindent" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c" + +[[package]] +name = "usvg" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c04150a94f0bfc3b2c15d4e151524d14cd06765fc6641d8b1c59a248360d4474" +dependencies = [ + "base64 0.21.7", + "data-url", + "flate2", + "fontdb", + "imagesize", + "kurbo 0.9.5", + "log", + "pico-args", + "roxmltree", + "rustybuzz", + "simplecss", + "siphasher", + "strict-num", + "svgtypes", + "tiny-skia-path", + "unicode-bidi", + "unicode-script", + "unicode-vo", + "xmlwriter", +] + +[[package]] +name = "version_check" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" + +[[package]] +name = "weezl" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082" + +[[package]] +name = "windows-targets" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" + +[[package]] +name = "windows_i686_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" + +[[package]] +name = "windows_i686_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" + +[[package]] +name = "xmlwriter" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec7a2a501ed189703dba8b08142f057e887dfc4b2cc4db2d343ac6376ba3e0b9" diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..9d132a1 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,18 @@ +[package] +name = "resvg_py" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html +[lib] +name = "resvg_py" +path = "src/rust/lib.rs" +crate-type = ["cdylib"] + +[dependencies] +base64 = "0.22.0" +pyo3 = "0.19.0" +resvg = { version = "0.40.0", features = ["raster-images","text"] } +tiny-skia = "0.11.4" +unescape = "0.1.0" +usvg = "0.40.0" diff --git a/poetry.lock b/poetry.lock new file mode 100644 index 0000000..f8727b2 --- /dev/null +++ b/poetry.lock @@ -0,0 +1,74 @@ +# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand. + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +description = "brain-dead simple config-ini parsing" +optional = false +python-versions = ">=3.7" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "packaging" +version = "24.0" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.7" +files = [ + {file = "packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5"}, + {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"}, +] + +[[package]] +name = "pluggy" +version = "1.4.0" +description = "plugin and hook calling mechanisms for python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pluggy-1.4.0-py3-none-any.whl", hash = "sha256:7db9f7b503d67d1c5b95f59773ebb58a8c1c288129a88665838012cfb07b8981"}, + {file = "pluggy-1.4.0.tar.gz", hash = "sha256:8c85c2876142a764e5b7548e7d9a0e0ddb46f5185161049a79b7e974454223be"}, +] + +[package.extras] +dev = ["pre-commit", "tox"] +testing = ["pytest", "pytest-benchmark"] + +[[package]] +name = "pytest" +version = "8.1.1" +description = "pytest: simple powerful testing with Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pytest-8.1.1-py3-none-any.whl", hash = "sha256:2a8386cfc11fa9d2c50ee7b2a57e7d898ef90470a7a34c4b949ff59662bb78b7"}, + {file = "pytest-8.1.1.tar.gz", hash = "sha256:ac978141a75948948817d360297b7aae0fcb9d6ff6bc9ec6d514b85d5a65c044"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +iniconfig = "*" +packaging = "*" +pluggy = ">=1.4,<2.0" + +[package.extras] +testing = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] + +[metadata] +lock-version = "2.0" +python-versions = "^3.12" +content-hash = "dc8014921a43f17675ce95dc5558a2f12371472649730c844c9bb211c49ff7c7" diff --git a/pyproject.toml b/pyproject.toml index e39666c..4f6208a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "resvg-py" -version = "0.1.0" +version = "0.0.1" description = "" authors = ["baseplate-admin <61817579+baseplate-admin@users.noreply.github.com>"] readme = "README.md" @@ -9,6 +9,22 @@ readme = "README.md" python = "^3.12" +[tool.poetry.group.dev.dependencies] +pytest = "^8.1.1" + [build-system] -requires = ["poetry-core"] -build-backend = "poetry.core.masonry.api" +requires = ["maturin>=1.4,<2.0"] +build-backend = "maturin" + +[project] +name = "resvg_py" +requires-python = ">=3.8" +classifiers = [ + "Programming Language :: Rust", + "Programming Language :: Python :: Implementation :: CPython", + "Programming Language :: Python :: Implementation :: PyPy", +] +dynamic = ["version"] + +[tool.maturin] +features = ["pyo3/extension-module"] diff --git a/resvg_py/__init__.py b/resvg_py/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/resvg_py/downloader.py b/resvg_py/downloader.py deleted file mode 100644 index cb28929..0000000 --- a/resvg_py/downloader.py +++ /dev/null @@ -1,47 +0,0 @@ -import urllib.request -import zipfile -from pathlib import Path -import tempfile -import tarfile - -BASE_DIR = Path(__file__).resolve().parent - -version = "0.40.0" - - -def _skip_if_file_exists(): - for file in BASE_DIR.glob("*"): - if "resvg" in file.name: - return - - -def download_windows(): - _skip_if_file_exists() - - f = urllib.request.urlopen( - f"https://github.com/RazrFalcon/resvg/releases/download/v{version}/resvg-win64.zip", - ) - - with tempfile.NamedTemporaryFile() as fp: - fp.write(f.read()) - - with zipfile.ZipFile(fp, "r") as zip_ref: - zip_ref.extractall(path=BASE_DIR) - - fp.close() - - -def download_linux(): - _skip_if_file_exists() - - f = urllib.request.urlopen( - f"https://github.com/RazrFalcon/resvg/releases/download/v{version}/resvg-linux-x86_64.tar.gz", - ) - - with tempfile.NamedTemporaryFile( - "wb", suffix=".tar.gz", delete_on_close=False - ) as fp: - fp.write(f.read()) - - with tarfile.open(fp.name, "r:gz") as tar: - tar.extractall(path=BASE_DIR) diff --git a/resvg_py/main.py b/resvg_py/main.py deleted file mode 100644 index 6f03c30..0000000 --- a/resvg_py/main.py +++ /dev/null @@ -1,33 +0,0 @@ -import subprocess -from .downloader import download_windows, download_linux -import platform -import tempfile -from pathlib import Path -import os - -BASE_DIR = Path(__file__).resolve().parent - -plt = platform.system().lower() - -if plt == "windows": - download_windows() - binary = Path(BASE_DIR, "resvg.exe") -elif plt == "linux": - download_linux() - binary = Path(BASE_DIR, "resvg") -else: - print("Unidentified system") - - -def main(string: str): - with tempfile.NamedTemporaryFile("w") as input: - input.write(string) - - with tempfile.NamedTemporaryFile() as f: - subprocess.Popen( - [binary, input.name, f.name], - stdin=subprocess.PIPE, - stdout=subprocess.PIPE, - ).wait() - - return f.read() diff --git a/src/python/test.py b/src/python/test.py new file mode 100644 index 0000000..73c448a --- /dev/null +++ b/src/python/test.py @@ -0,0 +1,5 @@ +from resvg_py import svg_to_base64 + +svg = "" +lt = svg_to_base64(svg_string=svg) +print(lt) diff --git a/src/rust/lib.rs b/src/rust/lib.rs new file mode 100644 index 0000000..782fcdd --- /dev/null +++ b/src/rust/lib.rs @@ -0,0 +1,119 @@ +/* +Based on +* https://github.com/RazrFalcon/resvg/blob/master/crates/resvg/src/main.rs +* https://github.com/mrdotb/resvg_nif/blob/master/native/resvg/src/lib.rs +*/ + +use base64::{engine::general_purpose, Engine as _}; +use pyo3::prelude::*; +use resvg; +use resvg::usvg; + +struct Opts { + font_family: Option, + font_size: u32, + serif_family: Option, + sans_serif_family: Option, + cursive_family: Option, + fantasy_family: Option, + monospace_family: Option, + font_files: Vec, + font_dirs: Vec, + skip_system_fonts: bool, +} + +fn load_fonts(options: &mut Opts, fontdb: &mut usvg::fontdb::Database) { + for path in &options.font_files { + if let Err(e) = fontdb.load_font_file(path) { + println!("Failed to load '{}' cause {}.", path.to_string(), e); + } + } + + for path in &options.font_dirs { + fontdb.load_fonts_dir(path); + } + + let take_or = + |family: Option, fallback: &str| family.unwrap_or_else(|| fallback.to_string()); + + fontdb.set_serif_family(take_or(options.serif_family.take(), "Times New Roman")); + fontdb.set_sans_serif_family(take_or(options.sans_serif_family.take(), "Arial")); + fontdb.set_cursive_family(take_or(options.cursive_family.take(), "Comic Sans MS")); + fontdb.set_fantasy_family(take_or(options.fantasy_family.take(), "Impact")); + fontdb.set_monospace_family(take_or(options.monospace_family.take(), "Courier New")); +} + +fn render_svg(tree: &usvg::Tree) -> Result { + let mut pixmap = tiny_skia::Pixmap::new( + tree.size().to_int_size().width(), + tree.size().to_int_size().height(), + ) + .unwrap(); + let ts = tree.view_box().to_transform(tree.size()); + resvg::render(tree, ts, &mut pixmap.as_mut()); + + Ok(pixmap) +} + +fn resvg_magic(mut options: Opts, svg_string: String) -> Result, String> { + let xml_tree = { + let xml_opt = usvg::roxmltree::ParsingOptions { + allow_dtd: true, + ..Default::default() + }; + usvg::roxmltree::Document::parse_with_options(&svg_string, xml_opt) + .map_err(|e| e.to_string()) + } + .unwrap(); + let has_text_nodes = xml_tree + .descendants() + .any(|n| n.has_tag_name(("http://www.w3.org/2000/svg", "text"))); + + let mut fontdb = usvg::fontdb::Database::new(); + if has_text_nodes { + load_fonts(&mut options, &mut fontdb); + } + let tree = { + usvg::Tree::from_xmltree(&xml_tree, &usvg::Options::default(), &fontdb) + .map_err(|e| e.to_string()) + } + .unwrap(); + let img: Vec = render_svg(&tree).unwrap().encode_png().unwrap(); + Ok(img) +} + +#[pyfunction] +fn svg_to_base64( + svg_string: String, + font_family: Option, + serif_family: Option, + sans_serif_family: Option, + cursive_family: Option, + fantasy_family: Option, + monospace_family: Option, + font_files: Option>, + font_dirs: Option>, +) -> PyResult { + //let string = svg_string; + let options = Opts { + font_family: font_family, + font_size: todo!(), + serif_family, + sans_serif_family, + cursive_family, + fantasy_family, + monospace_family, + font_files: font_files.unwrap(), + font_dirs: font_dirs.unwrap(), + skip_system_fonts: todo!(), + }; + let pixmap = resvg_magic(options, String::from(svg_string)).unwrap(); + Ok(general_purpose::STANDARD.encode(&pixmap)) +} + +/// A Python module implemented in Rust. +#[pymodule] +fn resvg_py(_py: Python, m: &PyModule) -> PyResult<()> { + m.add_function(wrap_pyfunction!(svg_to_base64, m)?)?; + Ok(()) +} diff --git a/tests/test_complex_camera.py b/tests/test_complex_camera.py new file mode 100644 index 0000000..3c69612 --- /dev/null +++ b/tests/test_complex_camera.py @@ -0,0 +1,351 @@ +import resvg_py + + +def test_complex_camera(): + svg_string = r""" + + + + + + + digital-camera + + + + digital + + 11 + hardware + photo + digicam + computer + camera + + + + + AJ Ashton + + + + + AJ Ashton + + + + + AJ Ashton + + + + image/svg+xml + + + en + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +""" + + base64 = resvg_py.svg_to_base64(svg_string) + assert ( + base64 + == "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" + ) diff --git a/tests/test_normal_shape.py b/tests/test_normal_shape.py new file mode 100644 index 0000000..6d9c8b8 --- /dev/null +++ b/tests/test_normal_shape.py @@ -0,0 +1,15 @@ +import resvg_py + + +def test_rectangle(): + svg_string = """ + +   + + """ + + base64 = resvg_py.svg_to_base64(svg_string) + assert ( + base64 + == "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" + )