css-inline 0.21.0__cp310-abi3-win_amd64.whl

css_inline/__init__.py

@@ -0,0 +1,5 @@
+from .css_inline import *
+
+__doc__ = css_inline.__doc__
+if hasattr(css_inline, "__all__"):
+    __all__ = css_inline.__all__

css_inline/__init__.pyi

@@ -0,0 +1,83 @@
+class StylesheetCache:
+    def __init__(self, size: int = 8) -> None: ...
+
+class CSSInliner:
+    def __init__(
+        self,
+        inline_style_tags: bool = True,
+        keep_style_tags: bool = False,
+        keep_link_tags: bool = False,
+        keep_at_rules: bool = False,
+        minify_css: bool = False,
+        base_url: str | None = None,
+        load_remote_stylesheets: bool = True,
+        cache: StylesheetCache | None = None,
+        extra_css: str | None = None,
+        preallocate_node_capacity: int | None = 32,
+        remove_inlined_selectors: bool = False,
+    ) -> None: ...
+    def inline(self, html: str) -> str: ...
+    def inline_fragment(self, html: str, css: str) -> str: ...
+    def inline_many(self, html: list[str]) -> list[str]: ...
+    def inline_many_fragments(self, html: list[str], css: list[str]) -> list[str]: ...
+
+def inline(
+    html: str,
+    inline_style_tags: bool = True,
+    keep_style_tags: bool = False,
+    keep_link_tags: bool = False,
+    keep_at_rules: bool = False,
+    minify_css: bool = False,
+    base_url: str | None = None,
+    load_remote_stylesheets: bool = True,
+    cache: StylesheetCache | None = None,
+    extra_css: str | None = None,
+    preallocate_node_capacity: int | None = 32,
+    remove_inlined_selectors: bool = False,
+) -> str: ...
+def inline_fragment(
+    html: str,
+    css: str,
+    inline_style_tags: bool = True,
+    keep_style_tags: bool = False,
+    keep_link_tags: bool = False,
+    keep_at_rules: bool = False,
+    minify_css: bool = False,
+    base_url: str | None = None,
+    load_remote_stylesheets: bool = True,
+    cache: StylesheetCache | None = None,
+    extra_css: str | None = None,
+    preallocate_node_capacity: int | None = 32,
+    remove_inlined_selectors: bool = False,
+) -> str: ...
+def inline_many(
+    html: list[str],
+    inline_style_tags: bool = True,
+    keep_style_tags: bool = False,
+    keep_link_tags: bool = False,
+    keep_at_rules: bool = False,
+    minify_css: bool = False,
+    base_url: str | None = None,
+    load_remote_stylesheets: bool = True,
+    cache: StylesheetCache | None = None,
+    extra_css: str | None = None,
+    preallocate_node_capacity: int | None = 32,
+    remove_inlined_selectors: bool = False,
+) -> list[str]: ...
+def inline_many_fragments(
+    html: list[str],
+    css: list[str],
+    inline_style_tags: bool = True,
+    keep_style_tags: bool = False,
+    keep_link_tags: bool = False,
+    keep_at_rules: bool = False,
+    minify_css: bool = False,
+    base_url: str | None = None,
+    load_remote_stylesheets: bool = True,
+    cache: StylesheetCache | None = None,
+    extra_css: str | None = None,
+    preallocate_node_capacity: int | None = 32,
+    remove_inlined_selectors: bool = False,
+) -> list[str]: ...
+
+class InlineError(ValueError): ...

css_inline-0.21.0.dist-info/METADATA

@@ -0,0 +1,331 @@
+Metadata-Version: 2.4
+Name: css-inline
+Version: 0.21.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Rust
+License-File: LICENSE
+Summary: High-performance library for inlining CSS into HTML 'style' attributes
+Keywords: css,html,email,stylesheet,inlining
+Author-email: Dmitry Dygalo <dmitry@dygalo.dev>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: homepage, https://github.com/Stranger6667/css-inline/tree/master/bindings/python
+Project-URL: repository, https://github.com/Stranger6667/css-inline
+
+# css_inline
+
+[<img alt="build status" src="https://img.shields.io/github/actions/workflow/status/Stranger6667/css-inline/build.yml?style=flat-square&labelColor=555555&logo=github" height="20">](https://github.com/Stranger6667/css-inline/actions/workflows/build.yml)
+[<img alt="pypi" src="https://img.shields.io/pypi/v/css_inline.svg?style=flat-square" height="20">](https://pypi.org/project/css_inline/)
+[<img alt="versions" src="https://img.shields.io/pypi/pyversions/css_inline.svg?style=flat-square" height="20">](https://pypi.org/project/css_inline/)
+[<img alt="license" src="https://img.shields.io/pypi/l/css_inline.svg?style=flat-square" height="20">](https://opensource.org/licenses/MIT)
+[<img alt="codecov.io" src="https://img.shields.io/codecov/c/gh/Stranger6667/css-inline?logo=codecov&style=flat-square&token=tOzvV4kDY0" height="20">](https://app.codecov.io/github/Stranger6667/css-inline)
+[<img alt="gitter" src="https://img.shields.io/gitter/room/Stranger6667/css-inline?style=flat-square" height="20">](https://gitter.im/Stranger6667/css-inline)
+
+`css_inline` is a high-performance library for inlining CSS into HTML 'style' attributes.
+
+This library is designed for scenarios such as preparing HTML emails or embedding HTML into third-party web pages.
+
+For instance, the library transforms HTML like this:
+
+```html
+<html>
+  <head>
+    <style>h1 { color:blue; }</style>
+  </head>
+  <body>
+    <h1>Big Text</h1>
+  </body>
+</html>
+```
+
+into:
+
+```html
+<html>
+  <head></head>
+  <body>
+    <h1 style="color:blue;">Big Text</h1>
+  </body>
+</html>
+```
+
+- Uses reliable components from Mozilla's Servo project
+- 10-500x faster than alternatives
+- Inlines CSS from `style` and `link` tags
+- Removes `style` and `link` tags
+- Resolves external stylesheets (including local files)
+- Optionally caches external stylesheets
+- Can process multiple documents in parallel
+- Works on Linux, Windows, macOS and in the browser via PyOdide
+- Supports HTML5 & CSS3
+- Tested on CPython 3.10, 3.11, 3.12, 3.13, 3.14 and PyPy 3.11.
+
+## Playground
+
+If you'd like to try `css-inline`, you can check the WebAssembly-powered [playground](https://css-inline.org/) to see the results instantly.
+
+## Installation
+
+Install with `pip`:
+
+```shell
+pip install css_inline
+```
+
+Pre-compiled wheels are available for most popular platforms.
+If not available for your platform, a Rust compiler will be needed to build this package from source. Rust version 1.65 or higher is required.
+
+## Usage
+
+```python
+import css_inline
+
+HTML = """<html>
+<head>
+    <style>h1 { color:blue; }</style>
+</head>
+<body>
+    <h1>Big Text</h1>
+</body>
+</html>"""
+
+inlined = css_inline.inline(HTML)
+# HTML becomes this:
+#
+# <html>
+# <head>
+#    <style>h1 { color:blue; }</style>
+# </head>
+# <body>
+#     <h1 style="color:blue;">Big Text</h1>
+# </body>
+# </html>
+```
+
+Note that `css-inline` automatically adds missing `html` and `body` tags, so the output is a valid HTML document.
+
+Alternatively, you can inline CSS into an HTML fragment. Structural tags (`<html>`, `<head>`, `<body>`) are stripped from the output; only their contents are preserved. Use `inline` if you need to keep the full document structure:
+
+```python
+FRAGMENT = """<main>
+<h1>Hello</h1>
+<section>
+<p>who am i</p>
+</section>
+</main>"""
+
+CSS = """
+p {
+    color: red;
+}
+
+h1 {
+    color: blue;
+}
+"""
+
+inlined = css_inline.inline_fragment(FRAGMENT, CSS)
+# HTML becomes this:
+# <main>
+# <h1 style="color: blue;">Hello</h1>
+# <section>
+# <p style="color: red;">who am i</p>
+# </section>
+# </main>
+```
+
+When there is a need to inline multiple HTML documents simultaneously, `css_inline` offers `inline_many` and `inline_many_fragments` functions.
+This feature allows for concurrent processing of several inputs, significantly improving performance when dealing with a large number of documents.
+
+```python
+import css_inline
+
+css_inline.inline_many(["<...>", "<...>"])
+```
+
+Under the hood, `inline_many`, spawns threads at the Rust layer to handle the parallel processing of inputs.
+This results in faster execution times compared to employing parallel processing techniques at the Python level.
+
+**Note**: To fully benefit from `inline_many`, you should run your application on a multicore machine.
+
+### Configuration
+
+For configuration options use the `CSSInliner` class:
+
+```python
+import css_inline
+
+inliner = css_inline.CSSInliner(keep_style_tags=True)
+inliner.inline("...")
+```
+
+- `inline_style_tags`. Specifies whether to inline CSS from "style" tags. Default: `True`
+- `keep_style_tags`. Specifies whether to keep "style" tags after inlining. Default: `False`
+- `keep_link_tags`. Specifies whether to keep "link" tags after inlining. Default: `False`
+- `keep_at_rules`. Specifies whether to keep "at-rules" (starting with `@`) after inlining. Default: `False`
+- `minify_css`. Specifies whether to remove trailing semicolons and spaces between properties and values. Default: `False`
+- `base_url`. The base URL used to resolve relative URLs. If you'd like to load stylesheets from your filesystem, use the `file://` scheme. Default: `None`
+- `load_remote_stylesheets`. Specifies whether remote stylesheets should be loaded. Default: `True`
+- `cache`. Specifies caching options for external stylesheets (for example, `StylesheetCache(size=5)`). Default: `None`
+- `extra_css`. Extra CSS to be inlined. Default: `None`
+- `preallocate_node_capacity`. **Advanced**. Preallocates capacity for HTML nodes during parsing. This can improve performance when you have an estimate of the number of nodes in your HTML document. Default: `32`
+- `remove_inlined_selectors`. Specifies whether to remove selectors that were successfully inlined from `<style>` blocks. Default: `False`
+- `apply_width_attributes`. Specifies whether to add `width` HTML attributes from CSS `width` properties on supported elements (`table`, `td`, `th`, `img`). Default: `False`
+- `apply_height_attributes`. Specifies whether to add `height` HTML attributes from CSS `height` properties on supported elements (`table`, `td`, `th`, `img`). Default: `False`
+
+You can also skip CSS inlining for an HTML tag by adding the `data-css-inline="ignore"` attribute to it:
+
+```html
+<head>
+  <style>h1 { color:blue; }</style>
+</head>
+<body>
+  <!-- The tag below won't receive additional styles -->
+  <h1 data-css-inline="ignore">Big Text</h1>
+</body>
+```
+
+The `data-css-inline="ignore"` attribute also allows you to skip `link` and `style` tags:
+
+```html
+<head>
+  <!-- Styles below are ignored -->
+  <style data-css-inline="ignore">h1 { color:blue; }</style>
+</head>
+<body>
+  <h1>Big Text</h1>
+</body>
+```
+
+Alternatively, you may keep `style` from being removed by using the `data-css-inline="keep"` attribute.
+This is useful if you want to keep `@media` queries for responsive emails in separate `style` tags.
+Such tags will be kept in the resulting HTML even if the `keep_style_tags` option is set to `false`.
+
+```html
+<head>
+  <!-- Styles below are not removed -->
+  <style data-css-inline="keep">h1 { color:blue; }</style>
+</head>
+<body>
+  <h1>Big Text</h1>
+</body>
+```
+
+Another possibility is to set `keep_at_rules` option to `true`. At-rules cannot be inlined into HTML therefore they
+get removed by default. This is useful if you want to keep at-rules, e.g. `@media` queries for responsive emails in
+separate `style` tags but inline any styles which can be inlined.
+Such tags will be kept in the resulting HTML even if the `keep_style_tags` option is explicitly set to `false`.
+
+```html
+<head>
+  <!-- With keep_at_rules=true "color:blue" will get inlined into <h1> but @media will be kept in <style> -->
+  <style>h1 { color: blue; } @media (max-width: 600px) { h1 { font-size: 18px; } }</style>
+</head>
+<body>
+  <h1>Big Text</h1>
+</body>
+```
+
+If you set the the `minify_css` option to `true`, the inlined styles will be minified by removing trailing semicolons
+and spaces between properties and values.
+
+```html
+<head>
+  <!-- With minify_css=True, the <h1> will have `style="color:blue;font-weight:bold"` -->
+  <style>h1 { color: blue; font-weight: bold; }</style>
+</head>
+<body>
+  <h1>Big Text</h1>
+</body>
+```
+
+If you'd like to load stylesheets from your filesystem, use the `file://` scheme:
+
+```python
+import css_inline
+
+# styles/email is relative to the current directory
+inliner = css_inline.CSSInliner(base_url="file://styles/email/")
+inliner.inline("...")
+```
+
+You can also cache external stylesheets to avoid excessive network requests:
+
+```python
+import css_inline
+
+inliner = css_inline.CSSInliner(
+    cache=css_inline.StylesheetCache(size=5)
+)
+inliner.inline("...")
+```
+
+Caching is disabled by default.
+
+## XHTML compatibility
+
+If you'd like to work around some XHTML compatibility issues like closing empty tags (`<hr>` vs. `<hr/>`), you can use the following snippet that involves `lxml`:
+
+```python
+import css_inline
+from lxml import html, etree
+
+document = "..."  # Your HTML document
+inlined = css_inline.inline(document)
+tree = html.fromstring(inlined)
+inlined = etree.tostring(tree).decode(encoding="utf-8")
+```
+
+## Performance
+
+`css-inline` is powered by efficient tooling from Mozilla's Servo project and significantly outperforms other Python alternatives in terms of speed.
+Most of the time it achieves over a **10x** speed advantage compared to the next fastest alternative.
+
+Here is the performance comparison:
+
+|             | Size    | `css_inline 0.19.0` | `premailer 3.10.0`     | `toronado 0.1.0`        | `inlinestyler 0.2.5`   | `pynliner 0.8.0`        |
+|-------------|---------|---------------------|------------------------|-------------------------|------------------------|-------------------------|
+| Basic       | 230 B   | 4.27 µs             | 85.05 µs (**19.93x**)  | 495.30 µs (**116.05x**) | 1.02 ms (**238.87x**)  | 867.79 µs (**203.32x**) |
+| Realistic-1 | 8.58 KB | 80.59 µs            | 1.03 ms (**12.76x**)   | 11.55 ms (**143.29x**)  | 26.37 ms (**327.21x**) | 11.71 ms (**145.36x**)  |
+| Realistic-2 | 4.3 KB  | 46.88 µs            | 1.44 ms (**30.73x**)   | ERROR                   | 17.71 ms (**377.77x**) | ERROR                   |
+| GitHub page | 1.81 MB | 17.57 ms            | 10.78 s (**613.48x**)  | ERROR                   | ERROR                  | ERROR                   |
+
+The "Basic" case was obtained by benchmarking the example from the Usage section.
+Note that the `toronado`, `inlinestyler`, and `pynliner` libraries encountered errors when used to inline CSS in the last scenarios.
+
+The benchmarking code is available in the `benches/bench.py` file. The benchmarks were conducted using the stable `rustc 1.91`, Python `3.14.2` on Ryzen 9 9950X.
+
+## Comparison with other libraries
+
+Besides performance, `css-inline` differs from other Python libraries for CSS inlining.
+
+- Generally supports more CSS features than other libraries (for example, `toronado` and `pynliner` do not support pseudo-elements);
+- It has fewer configuration options and is not as flexible as `premailer`;
+- Works on fewer platforms than LXML-based libraries (`premailer`, `inlinestyler`, `toronado`, and optionally `pynliner`);
+- Does not have debug logs yet;
+- Supports only HTML 5.
+
+## Further reading
+
+If you want to know how this library was created & how it works internally, you could take a look at these articles:
+
+- [Rust crate](https://dygalo.dev/blog/rust-for-a-pythonista-2/)
+- [Python bindings](https://dygalo.dev/blog/rust-for-a-pythonista-3/)
+
+## License
+
+This project is licensed under the terms of the [MIT license](https://opensource.org/licenses/MIT).
+

css_inline-0.21.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+css_inline/__init__.py,sha256=Idodv4vLn31heDtdkdsRJjLUiFhqZ98AVCXzfNsuGgc,123
+css_inline/__init__.pyi,sha256=oELQofaJ8kiPiqZjmaEZFN1S3DiqyEXp4hNoBNVJPro,2869
+css_inline/css_inline.pyd,sha256=zfRcz97W4OncMdMGO0_-aosLfoo2Vl9zhlwI58E2W3Y,4282880
+css_inline/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+css_inline-0.21.0.dist-info/METADATA,sha256=FiLY8Ixh2pzzg2AEiK401vjnu4kJiZoF5SXcfzpDZoA,13080
+css_inline-0.21.0.dist-info/WHEEL,sha256=OudrOkgSd5TAMiYUmv0po5aZeINNCjLAn4tWEN0V1Jc,96
+css_inline-0.21.0.dist-info/licenses/LICENSE,sha256=dE2b3DgsGRyrpy48m_gfzgxdni8MGnvE8iDDyi_1jCY,1096
+css_inline-0.21.0.dist-info/sboms/css-inline-python.cyclonedx.json,sha256=1hIFuDTwGOyoNF9RPgblPafkbzfNz0r9O4EPH4oVl9c,202140
+css_inline-0.21.0.dist-info/RECORD,,

css_inline-0.21.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.14.0)
+Root-Is-Purelib: false
+Tag: cp310-abi3-win_amd64

css_inline-0.21.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2023 Dmitry Dygalo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.