tikzplotly 0.2.1__tar.gz → 0.2.3__tar.gz

{tikzplotly-0.2.1/src/tikzplotly.egg-info → tikzplotly-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplotly
-Version: 0.2.1
+Version: 0.2.3
 Summary: Convert plotly figures to LaTeX / TikZ figures
 Author-email: Thomas Saigre <tikzplotly@outlook.fr>
 License: The MIT License (MIT)
@@ -30,11 +30,11 @@ Keywords: plotly,latex,tikz,figure,conversion,graphics
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Multimedia :: Graphics :: Graphics Conversion
@@ -44,6 +44,7 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: plotly
 Requires-Dist: pillow
+Requires-Dist: kaleido
 Provides-Extra: dev
 Requires-Dist: pandas; extra == "dev"
 Dynamic: license-file
@@ -65,7 +66,7 @@ Dynamic: license-file
 
 # Tikzplotly
 
-Convert [plotly](https://plotly.com/python/) figures to TikZ code for inclusion into [PGFPlots](https://www.ctan.org/pkg/pgfplots) ([PGF/TikZ](https://www.ctan.org/pkg/pgf)) figures.
+Convert [Plotly](https://plotly.com/python/) figures to TikZ code for inclusion into [PGFPlots](https://www.ctan.org/pkg/pgfplots) ([PGF/TikZ](https://www.ctan.org/pkg/pgf)) figures.
 
 This results in a ti*k*z code, that can be easily included into your LaTeX document.
 This also allows to easily edit the content of the figure.
@@ -151,9 +152,9 @@ To correctly compile the document, you will need to add the following packages t
 
 ## Note
 
-* This module is in development and new features are added bit by bit, when needed. If you have a feature request, please open an issue with the plotly figure you want to convert and the desired output.
+* This module is in development and new features are added bit by bit, when needed. If you have a feature request, please open an issue with the Plotly figure you want to convert and the desired output.
 You can also submit a pull request with the desired feature !
-* Some feature can result in different output between the plotly figure and the TikZ figure, for instance the size of markers, more details can be found in [the documentation](https://thomas-saigre.github.io/tikzplotly/).
+* Some feature can result in different output between the Plotly figure and the TikZ figure, for instance the size of markers, more details can be found in [the documentation](https://thomas-saigre.github.io/tikzplotly/).
 
 
 ## References

{tikzplotly-0.2.1 → tikzplotly-0.2.3}/README.md

@@ -15,7 +15,7 @@
 
 # Tikzplotly
 
-Convert [plotly](https://plotly.com/python/) figures to TikZ code for inclusion into [PGFPlots](https://www.ctan.org/pkg/pgfplots) ([PGF/TikZ](https://www.ctan.org/pkg/pgf)) figures.
+Convert [Plotly](https://plotly.com/python/) figures to TikZ code for inclusion into [PGFPlots](https://www.ctan.org/pkg/pgfplots) ([PGF/TikZ](https://www.ctan.org/pkg/pgf)) figures.
 
 This results in a ti*k*z code, that can be easily included into your LaTeX document.
 This also allows to easily edit the content of the figure.
@@ -101,9 +101,9 @@ To correctly compile the document, you will need to add the following packages t
 
 ## Note
 
-* This module is in development and new features are added bit by bit, when needed. If you have a feature request, please open an issue with the plotly figure you want to convert and the desired output.
+* This module is in development and new features are added bit by bit, when needed. If you have a feature request, please open an issue with the Plotly figure you want to convert and the desired output.
 You can also submit a pull request with the desired feature !
-* Some feature can result in different output between the plotly figure and the TikZ figure, for instance the size of markers, more details can be found in [the documentation](https://thomas-saigre.github.io/tikzplotly/).
+* Some feature can result in different output between the Plotly figure and the TikZ figure, for instance the size of markers, more details can be found in [the documentation](https://thomas-saigre.github.io/tikzplotly/).
 
 
 ## References

{tikzplotly-0.2.1 → tikzplotly-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tikzplotly"
-version = "0.2.1"
+version = "0.2.3"
 description = "Convert plotly figures to LaTeX / TikZ figures"
 readme = "README.md"
 authors = [{name = "Thomas Saigre", email = "tikzplotly@outlook.fr"}]
@@ -13,11 +13,11 @@ classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Topic :: Multimedia :: Graphics :: Graphics Conversion",
@@ -27,7 +27,8 @@ keywords = ["plotly", "latex", "tikz", "figure", "conversion", "graphics"]
 dependencies = [
     "numpy",
     "plotly",
-    "pillow"
+    "pillow",
+    "kaleido"
 ]
 
 [project.optional-dependencies]
@@ -36,3 +37,10 @@ dev = ["pandas"]
 [project.urls]
 Code = "https://github.com/thomas-saigre/tikzplotly"
 Issues = "https://github.com/thomas-saigre/tikzplotly/issues"
+
+
+[tool.pytest.ini_options]
+filterwarnings = [
+    "ignore:png image has not been reduced.*:UserWarning",
+    "ignore:Text template is not supported yet.:UserWarning",
+]

{tikzplotly-0.2.1 → tikzplotly-0.2.3}/src/tikzplotly/__about__.py

@@ -1,7 +1,7 @@
 """
 Module metadata for tikzplotly.
 """
-__version__ = "0.2.1"
+__version__ = "0.2.3"
 __author__ = "Thomas Saigre"
 __license__ = "MIT"
 __description__ = "Convert plotly figures to TikZ code for inclusion into PGFPlots figures."

{tikzplotly-0.2.1 → tikzplotly-0.2.3}/src/tikzplotly/__init__.py

@@ -7,8 +7,16 @@ functions for generating and saving TikZ code from plotly figures.
 Exports:
     get_tikz_code (Callable): Function to generate TikZ code from a plotly figure.
     save (Callable): Function to save TikZ code to a file.
+    show (Callable): Function to show a figure in the browser, with a button exporting it to TikZ.
+
+Importing the package also registers the ``"tikzplotly"`` Plotly renderer, so that
+``fig.show(renderer="tikzplotly")`` adds the same button.
 """
 from .__about__ import __version__, __author__, __license__, __description__
 from ._save import get_tikz_code, save
+from ._browser import show, TikzBrowserRenderer, register_renderer as _register_renderer
+
+_register_renderer()
 
-__all__ = ["__version__", "__author__", "__license__", "__description__", "get_tikz_code", "save"]
+__all__ = ["__version__", "__author__", "__license__", "__description__", "get_tikz_code", "save",
+           "show", "TikzBrowserRenderer"]

tikzplotly-0.2.3/src/tikzplotly/_browser.py

@@ -0,0 +1,346 @@
+"""Show a figure in the web browser with an "Export to TikZ" button in the mode bar.
+
+Plotly's own browser renderer serves the page once and returns, so the page has no way to
+reach Python afterwards. Here a small local HTTP server keeps running while the page is open:
+clicking the button sends the current view (axis ranges, hidden traces) to that server, which
+calls :func:`get_tikz_code` and writes the result to a file.
+
+Plotly itself is not modified: a renderer named ``"tikzplotly"`` is registered with Plotly's
+renderer API when tikzplotly is imported, and :func:`show` is a shortcut to it.
+"""
+import base64
+import json
+import secrets
+import socketserver
+import threading
+import time
+import webbrowser
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import cast
+
+import numpy as np
+import plotly.graph_objects as go
+import plotly.io as pio
+
+from ._save import get_tikz_code
+
+try:  # private module: guarded so that a Plotly reorganisation cannot break ``import tikzplotly``
+    from plotly.io._base_renderers import ExternalRenderer
+except ImportError:  # pragma: no cover
+    ExternalRenderer = object
+
+RENDERER_NAME = "tikzplotly"
+
+# A hidden browser tab may only run its timers once a minute, so the idle timeout has to be
+# well above 60 s, or a tab left in the background would be considered closed.
+PING_MS = 10_000
+IDLE_TIMEOUT = 150
+# Time left after the page signals it is closing, so that a page reload can reconnect.
+CLOSE_GRACE = 5
+
+# "Export to TikZ" icon: a floppy disk with "TikZ" (glyph outlines of Latin Modern Roman Bold),
+# in a 1000x1000 box. A single path, because Plotly only colours the first path of an icon,
+# and its holes need the evenodd fill rule, set in _POST_SCRIPT.
+TIKZ_ICON_PATH = (
+    "M110 40H760L960 240V890Q960 960 890 960H110Q40 960 40 890V110Q40 40 110 40Z M120 115V885H885V275L725"
+    " 115Z M230 115H690V290Q690 320 660 320H260Q230 320 230 290Z M540 155V280H630V155Z M381 604 374 523H1"
+    "47L140 604H156C159 566 162 539 211 539H237V735H185V750C203 749 241 749 260 749C280 749 318 749 336 7"
+    "50V735H284V539H310C358 539 361 566 365 604ZM491 750V735H471V599L412 602V617C432 617 434 617 434 631V"
+    "735H411V750L452 749ZM475 546C475 532 463 520 449 520C435 520 423 532 423 546C423 561 435 572 449 572"
+    "C463 572 475 561 475 546ZM673 701C673 696 668 696 663 696C655 696 655 696 653 705C648 725 641 741 62"
+    "9 741C626 741 621 740 621 729C621 729 621 723 624 712C625 709 625 705 625 702C625 676 596 669 572 66"
+    "6C584 657 596 645 596 644C619 619 634 610 647 610C648 610 652 610 653 614C639 616 630 628 630 639C63"
+    "0 647 636 654 647 654C657 654 671 647 671 625C671 615 667 598 648 598C629 598 612 611 591 634C577 64"
+    "8 571 653 563 658L596 528C596 527 597 525 597 523C597 516 591 517 586 517L545 519C541 519 534 519 53"
+    "4 529C534 535 541 535 544 535C548 535 554 536 558 536L509 731C508 736 508 737 508 739C508 747 514 75"
+    "3 523 753C530 753 540 749 543 739L558 678C568 680 589 685 589 703C589 705 589 707 588 710C588 713 58"
+    "7 715 587 719C587 739 605 753 627 753C661 753 673 703 673 701ZM865 655H849C846 692 842 733 773 733H7"
+    "26L860 536C863 532 863 532 863 528C863 519 859 519 852 519H679L675 601H691C693 556 716 535 763 535H8"
+    "07L672 733C669 737 669 738 669 742C669 750 673 750 680 750H859Z"
+)
+
+_POST_SCRIPT = """
+(function () {
+  var gd = document.getElementById('{plot_id}');
+  var token = '__TOKEN__';
+
+  function post(path, body) {
+    return fetch('/' + token + path, {method: 'POST', body: JSON.stringify(body || {})});
+  }
+
+  function toast(message, failed) {
+    var el = document.createElement('div');
+    el.textContent = message;
+    el.style.cssText = 'position:fixed;left:16px;bottom:16px;padding:8px 12px;z-index:9999;'
+      + 'border-radius:4px;color:#fff;font:13px sans-serif;background:'
+      + (failed ? '#b3261e' : '#2e7d32');
+    document.body.appendChild(el);
+    setTimeout(function () { el.remove(); }, failed ? 8000 : 3000);
+  }
+
+  // Only the view state is sent: the data stays on the Python side.
+  function viewState() {
+    var axes = {};
+    Object.keys(gd.layout).forEach(function (key) {
+      if (/^[xy]axis\\d*$/.test(key)) {
+        var axis = gd.layout[key];
+        axes[key] = axis.autorange ? null : axis.range;
+      }
+    });
+    return {axes: axes, visible: gd.data.map(function (t) { return t.visible; })};
+  }
+
+  var button = {
+    name: 'exportTikz',
+    title: 'Export to TikZ',
+    icon: {width: 1000, height: 1000, path: '__ICON_PATH__'},
+    click: function () {
+      post('/export', viewState())
+        .then(function (r) { return r.json(); })
+        .then(function (r) {
+          if (r.ok) { toast('Saved ' + r.path); } else { toast(r.error, true); }
+        })
+        .catch(function () { toast('The Python process is no longer running', true); });
+    }
+  };
+
+  var style = document.createElement('style');
+  style.textContent = '.modebar-btn[data-title="Export to TikZ"] path { fill-rule: evenodd; }';
+  document.head.appendChild(style);
+
+  var config = __CONFIG__;
+  config.modeBarButtonsToAdd = (config.modeBarButtonsToAdd || []).concat([button]);
+  Plotly.react(gd, gd.data, gd.layout, config);
+
+  // Immediate ping: after a reload, cancels the "closing" signal sent by the previous page.
+  post('/ping');
+  setInterval(function () { post('/ping'); }, __PING_MS__);
+  window.addEventListener('pagehide', function () {
+    navigator.sendBeacon('/' + token + '/closing');
+  });
+})();
+"""
+
+
+def _decode_arrays(obj):
+    """Turn Plotly's ``{"dtype": ..., "bdata": ...}`` entries back into NumPy arrays.
+
+    Since Plotly 6, ``Figure.to_dict()``, hence the dict a renderer receives, stores NumPy
+    arrays in this base64 form, which the rest of tikzplotly cannot index.
+    """
+    if isinstance(obj, dict):
+        if "bdata" in obj and "dtype" in obj:
+            array = np.frombuffer(base64.b64decode(obj["bdata"]), dtype=obj["dtype"])
+            if "shape" in obj:
+                shape = obj["shape"]
+                if isinstance(shape, str):
+                    shape = [int(n) for n in shape.split(",")]
+                array = array.reshape(shape)
+            return array
+        return {key: _decode_arrays(value) for key, value in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_decode_arrays(value) for value in obj]
+    return obj
+
+
+class _LocalServer(ThreadingHTTPServer):
+    """HTTP server that does not look up its host name.
+
+    ``HTTPServer.server_bind`` calls ``socket.getfqdn``, a reverse DNS lookup that can take
+    several seconds, notably on macOS. The name is not used here.
+    """
+
+    def server_bind(self):
+        socketserver.TCPServer.server_bind(self)
+        self.server_name, self.server_port = self.server_address[:2]    # type: ignore
+
+
+def _free_path(path: Path) -> Path:
+    """Return ``path``, or ``stem_1.ext``, ``stem_2.ext``, ... if it already exists."""
+    candidate, n = path, 0
+    while candidate.exists():
+        n += 1
+        candidate = path.with_name(f"{path.stem}_{n}{path.suffix}")
+    return candidate
+
+
+class TikzBrowserRenderer(ExternalRenderer):    # type: ignore
+    """Plotly renderer opening the figure in the browser with an "Export to TikZ" button.
+
+    Parameters
+    ----------
+    output, optional
+        file written by the button, by default ``"figure.tex"``. If it already exists,
+        ``figure_1.tex``, ``figure_2.tex``, ... are used instead, so no export is overwritten.
+    config, optional
+        Plotly config dict for the page (see ``fig.show(config=...)``), by default None
+    **tikz_options
+        passed on to :func:`get_tikz_code` (``tikz_options``, ``axis_options``, ``decimate``...).
+        Unless ``img_name`` is given, the image of a heatmap is saved next to the ``.tex`` file,
+        with the same name.
+    """
+
+    def __init__(self, output="figure.tex", config=None, **tikz_options):
+        self.output = Path(output)
+        self.config = dict(config or {})
+        self.tikz_options = tikz_options
+        self._lock = threading.Lock()
+
+    def export(self, fig, view=None) -> Path:
+        """Write the TikZ code of ``fig``, as currently displayed in the page, to a free file name.
+
+        Parameters
+        ----------
+        fig
+            Plotly figure, or figure dict as received by a renderer
+        view, optional
+            ``{"axes": {"xaxis": [min, max] or None, ...}, "visible": [...]}`` as sent by the page
+
+        Returns
+        -------
+            path of the written file
+        """
+        view = view or {}
+        fig = go.Figure(_decode_arrays(fig) if isinstance(fig, dict) else fig)  # copy: fig is reused
+        for name, axis_range in (view.get("axes") or {}).items():
+            fig.layout[name].range = axis_range
+        states = view.get("visible") or []
+        if len(states) == len(fig.data):  # get_tikz_code exports hidden traces too
+            fig.data = [trace for trace, state in zip(fig.data, states) if state in (None, True)]
+
+        with self._lock:  # two quick clicks must not pick the same file name
+            path = _free_path(self.output)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            options = {"img_name": str(path.with_suffix(".png")), **self.tikz_options}
+            path.write_text(get_tikz_code(fig, **options), encoding="utf-8")
+        return path
+
+    def start_server(self, fig):
+        """Start serving the page for ``fig`` without opening a browser.
+
+        Returns
+        -------
+            ``(url, thread)``: the page's address, and the thread serving it, which ends once the
+            page has been closed or has not been heard from for ``IDLE_TIMEOUT`` seconds
+        """
+        if not isinstance(fig, dict):
+            fig = go.Figure(fig)  # snapshot: later changes made by the script are not exported
+        fig_dict = fig if isinstance(fig, dict) else fig.to_dict()
+        token = secrets.token_urlsafe(24)
+        script = (_POST_SCRIPT.replace("__TOKEN__", token)
+                  .replace("__CONFIG__", json.dumps(self.config))
+                  .replace("__PING_MS__", str(PING_MS))
+                  .replace("__ICON_PATH__", TIKZ_ICON_PATH))
+        html = pio.to_html(
+            fig_dict, config=self.config, include_plotlyjs=True,
+            include_mathjax="cdn", post_script=script, full_html=True,      # type: ignore[reportArgumentType]
+            default_width="100%", default_height="100%", validate=False,
+        ).encode("utf-8")
+
+        renderer = self
+        state = {}
+
+        class Handler(BaseHTTPRequestHandler):
+            """Serves the page, and answers the requests sent by its script."""
+
+            def _reply(self, status, body, ctype="application/json"):
+                self.send_response(status)
+                self.send_header("Content-Type", ctype)
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+
+            def _host_ok(self):
+                # Rejects DNS rebinding: a remote site reaching this server under its own name.
+                server = cast(ThreadingHTTPServer, self.server)
+                return self.headers.get("Host") == f"127.0.0.1:{server.server_port}"
+
+            def do_GET(self):  # pylint: disable=invalid-name
+                """Serve the page."""
+                if not self._host_ok() or self.path != "/":
+                    self._reply(403, b"{}")
+                    return
+                state["deadline"] = time.monotonic() + IDLE_TIMEOUT
+                self._reply(200, html, "text/html; charset=utf-8")
+
+            def do_POST(self):  # pylint: disable=invalid-name
+                """Handle ``/<token>/ping``, ``/<token>/closing`` and ``/<token>/export``."""
+                raw = self.rfile.read(int(self.headers.get("Content-Length") or 0))
+                prefix = f"/{token}/"
+                if not self._host_ok() or not self.path.startswith(prefix):
+                    self._reply(403, b"{}")
+                    return
+                action = self.path[len(prefix):]
+                if action == "closing":
+                    state["deadline"] = time.monotonic() + CLOSE_GRACE
+                    self._reply(200, b"{}")
+                    return
+                state["deadline"] = time.monotonic() + IDLE_TIMEOUT
+                if action == "ping":
+                    self._reply(200, b"{}")
+                    return
+                if action != "export":
+                    self._reply(404, b"{}")
+                    return
+                try:
+                    path = renderer.export(fig, json.loads(raw or b"{}"))
+                    result = {"ok": True, "path": str(path)}
+                except Exception as exc:  # pylint: disable=broad-exception-caught  # shown in the page
+                    result = {"ok": False, "error": f"{type(exc).__name__}: {exc}"}
+                self._reply(200, json.dumps(result).encode("utf-8"))
+
+            def log_message(self, format, *args):  # pylint: disable=redefined-builtin
+                pass
+
+        server = _LocalServer(("127.0.0.1", 0), Handler)
+        server.timeout = 0.5
+        state["deadline"] = time.monotonic() + IDLE_TIMEOUT  # counted from when the server is ready
+
+        def serve():
+            while time.monotonic() < state["deadline"]:
+                server.handle_request()
+            server.server_close()
+
+        # Not a daemon thread: the script may reach its end while the page is still open,
+        # and the button has to keep working until the page is closed.
+        thread = threading.Thread(target=serve, name="tikzplotly-browser", daemon=False)
+        thread.start()
+        return f"http://127.0.0.1:{server.server_port}/", thread
+
+    def render(self, fig_dict):
+        """Called by Plotly, for ``fig.show(renderer="tikzplotly")``."""
+        url, _ = self.start_server(fig_dict)
+        webbrowser.open(url)
+
+
+def show(fig, output="figure.tex", config=None, **tikz_options):
+    """Show a figure in the web browser, with an "Export to TikZ" button in its mode bar.
+
+    Each click on the button writes the TikZ code of the figure, as currently displayed (zoom,
+    traces hidden from the legend), to ``output``, or to ``output_1.tex``, ``output_2.tex``, ...
+    if that file already exists. The Python process keeps running while the page is open,
+    and stops a few seconds after it is closed.
+
+    Parameters
+    ----------
+    fig
+        Plotly figure
+    output, optional
+        file written by the button, by default ``"figure.tex"``
+    config, optional
+        Plotly config dict for the page, by default None
+    **tikz_options
+        passed on to :func:`get_tikz_code` (``tikz_options``, ``axis_options``, ``decimate``...)
+    """
+    renderer = TikzBrowserRenderer(output, config=config, **tikz_options)
+    url, _ = renderer.start_server(fig)
+    webbrowser.open(url)
+
+
+def register_renderer():
+    """Register the ``"tikzplotly"`` renderer with Plotly, so ``fig.show(renderer="tikzplotly")`` works."""
+    if ExternalRenderer is object:  # pragma: no cover
+        return
+    if RENDERER_NAME not in pio.renderers:
+        pio.renderers[RENDERER_NAME] = TikzBrowserRenderer()

{tikzplotly-0.2.1 → tikzplotly-0.2.3}/src/tikzplotly/_color.py

@@ -30,7 +30,7 @@ def convert_color(color):
         string from plotly color palette, can be one of the following:
         - hex string : "#______"
         - rgb string : "rgb(__, __, __)" with values between 0 and 255
-        - rgba string : "rgba(__, __, __, __)" with values between 0 and 255 and an opacity value between 0 and 1
+        - rgba string : "rgba(__, __, __[, __])" with values between 0 and 255 and an opacity value between 0 and 1 (optional)
         - color name : "red", "green", "blue", "yellow", "orange", "purple", "brown", "black", "gray", "white" or any other color name from
                         https://github.com/plotly/plotly.py/blob/main/templategen/utils/colors.py
 
@@ -45,20 +45,21 @@ def convert_color(color):
     if color is None:
         return None, None, None, 1
     if isinstance(color, numpy.ndarray):
-        warn("Color from data is not supported yet. Returning the default color: blue.")
-        return "blue", "HTML", "0000ff", 1
+        warn("Color from data is not supported yet. Returning no color.")
+        return None, None, None, 1
     if not isinstance(color, str):
-        warn(f"Color {color} type '{color.__class__.__name__}' is not supported yet. Returning the default color: blue.")
-        return "blue", "HTML", "0000ff", 1
+        warn(f"Color {color} type '{color.__class__.__name__}' is not supported yet. Returning no color.")
+        return None, None, None, 1
 
     if color.startswith("#"):
         return color[1:], "HTML", color[1:], 1
 
     if color.startswith("rgba"):
-        sp = color.split("(")[1].split(",")
-        rgb_color = sp[:-1]
-        rgb_color = convert_color(f"rgb({rgb_color[0]},{rgb_color[1]},{rgb_color[2]})")[:-1]
-        return rgb_color + (float(sp[-1][:-1]),)
+        sp = color.split("(")[1].replace(')', '').split(",")
+        rgb_color = [s.strip() for s in sp]
+        r, g, b = int(rgb_color[0]), int(rgb_color[1]), int(rgb_color[2])
+        opacity = float(rgb_color[3]) if len(rgb_color) == 4 else 1.0
+        return hashlib.sha1(f"{r}, {g}, {b}".encode('UTF-8')).hexdigest()[:10], "RGB", rgb_str(r, g, b), opacity
 
     if color.startswith("rgb"):
         color = color[4:-1].replace("[", "{").replace("]", "}")