pyvmote 0.1.5__py3-none-any.whl

pyvmote/Graph_generator.py

@@ -0,0 +1,210 @@
+import matplotlib.pyplot as plt
+import mpld3
+from mpld3 import plugins
+import os
+import json
+from scipy.stats import gaussian_kde
+import numpy as np
+import re
+import shutil
+import warnings
+
+class Graph:
+    def __init__(self):
+        warnings.filterwarnings("ignore", category=UserWarning)
+        warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+        self.path = os.path.dirname(os.path.abspath(__file__))
+        self.n_plot = 0
+        self.history_file = os.path.join(self.path, "static", "graph_history.json")
+
+        if not os.path.exists(self.history_file):
+            with open(self.history_file, "w") as f:
+                json.dump([], f)
+
+    def clear_history(self):
+        if os.path.exists(self.history_file):
+            os.remove(self.history_file)
+            with open(self.history_file, "w") as f:
+                json.dump([], f)
+
+    def save_graph_to_history(self, graph_name, graph_type, title):
+        with open(self.history_file, "r") as f:
+            history = json.load(f)
+
+        # Verifica si ya existe un gráfico con ese título
+        for graph in history:
+            if graph["title"] == title:
+                raise ValueError(f"Ya existe un gráfico con el título '{title}'. Usa uno diferente.")
+
+        history.append({"name": graph_name, "type": graph_type, "title": title})
+
+        with open(self.history_file, "w") as f:
+            json.dump(history, f)
+
+    def _sanitize_title(self, title):
+        return re.sub(r'[^a-zA-Z0-9_-]', '_', title.replace(' ', '_'))
+
+    def _prepare_paths(self, title):
+        images_dir = os.path.join(self.path, "static", "images")
+        html_dir = os.path.join(self.path, "static", "html")
+        os.makedirs(images_dir, exist_ok=True)
+        os.makedirs(html_dir, exist_ok=True)
+
+        safe_title = self._sanitize_title(title)
+        image_name = f"{safe_title}.png"
+        html_name = f"{safe_title}.html"
+
+        return images_dir, html_dir, image_name, html_name
+
+    def _finalize_plot(self, fig, image_path, html_path, labels, scatter, plot_type, interactive, title):
+        if interactive:
+            if labels and plot_type in ["line", "scatter", "bar", "density"]:
+                if plot_type == "bar":
+                    for rect, label in zip(scatter, labels):
+                        plugins.connect(fig, plugins.LineLabelTooltip(rect, label))
+                else:
+                    plugins.connect(fig, plugins.PointLabelTooltip(scatter[0], labels=labels))
+
+            mpld3.save_html(fig, html_path)
+            self.save_graph_to_history(os.path.basename(html_path), "html", title)
+            plt.close()
+            return os.path.basename(html_path)
+        else:
+            plt.savefig(image_path, dpi=300, bbox_inches='tight')
+            self.save_graph_to_history(os.path.basename(image_path), "image", title)
+            plt.close()
+            return os.path.basename(image_path)
+
+    def save_as_format(self, fig, title, extension="png"):
+        valid_exts = ["png", "jpg", "jpeg", "svg", "pdf"]
+        if extension not in valid_exts:
+            raise ValueError(f"Formato no soportado: {extension}")
+
+        output_dir = os.path.join(self.path, "static", "images")
+        os.makedirs(output_dir, exist_ok=True)
+        safe_title = self._sanitize_title(title)
+        output_path = os.path.join(output_dir, f"{safe_title}.{extension}")
+        fig.savefig(output_path, dpi=300, bbox_inches='tight')
+        return output_path
+
+    def line_plot(self, x, y, xname="X", yname="Y", title="Line Graph", interactive=True, color='blue', linewidth=2, xlim=None, ylim=None):
+        fig, ax = plt.subplots(figsize=(12, 7))
+        scatter = ax.plot(x, y, marker='o', linestyle='-', color=color, linewidth=linewidth)
+        labels = [f"({xi}, {yi})" for xi, yi in zip(x, y)]
+        ax.set_xlabel(xname)
+        ax.set_ylabel(yname)
+        ax.set_title(title)
+        if xlim: ax.set_xlim(xlim)
+        if ylim: ax.set_ylim(ylim)
+        images_dir, html_dir, image_name, html_name = self._prepare_paths(title)
+        return self._finalize_plot(fig, os.path.join(images_dir, image_name), os.path.join(html_dir, html_name), labels, scatter, "line", interactive, title)
+
+
+    def scatter_plot(self, x, y, xname="X", yname="Y", title="Scatter Plot", interactive=True, color='blue', xlim=None, ylim=None):
+        fig, ax = plt.subplots(figsize=(12, 7))
+        scatter = ax.scatter(x, y, color=color)
+        labels = [f"({xi}, {yi})" for xi, yi in zip(x, y)]
+        ax.set_xlabel(xname)
+        ax.set_ylabel(yname)
+        ax.set_title(title)
+        if xlim: ax.set_xlim(xlim)
+        if ylim: ax.set_ylim(ylim)
+        images_dir, html_dir, image_name, html_name = self._prepare_paths(title)
+        return self._finalize_plot(fig, os.path.join(images_dir, image_name), os.path.join(html_dir, html_name), labels, [scatter], "scatter", interactive, title)
+
+    def bar_plot(self, x, y, xname="X", yname="Y", title="Bar Plot", interactive=True, color='blue', xlim=None, ylim=None):
+        fig, ax = plt.subplots(figsize=(12, 7))
+        scatter = ax.bar(x, y, color=color)
+        labels = [f"({xi}, {yi})" for xi, yi in zip(x, y)]
+        ax.set_xlabel(xname)
+        ax.set_ylabel(yname)
+        ax.set_title(title)
+        if xlim: ax.set_xlim(xlim)
+        if ylim: ax.set_ylim(ylim)
+        images_dir, html_dir, image_name, html_name = self._prepare_paths(title)
+        return self._finalize_plot(fig, os.path.join(images_dir, image_name), os.path.join(html_dir, html_name), labels, scatter, "bar", interactive, title)
+
+    def hist_plot(self, x, xname="Value", yname="Frequency", title="Histogram", bins=20, interactive=True, color='blue', xlim=None, ylim=None):
+        fig, ax = plt.subplots(figsize=(12, 7))
+        scatter = ax.hist(x, bins=bins, edgecolor='black', color=color)
+        ax.set_xlabel(xname)
+        ax.set_ylabel(yname)
+        ax.set_title(title)
+        if xlim: ax.set_xlim(xlim)
+        if ylim: ax.set_ylim(ylim)
+        images_dir, html_dir, image_name, html_name = self._prepare_paths(title)
+        return self._finalize_plot(fig, os.path.join(images_dir, image_name), os.path.join(html_dir, html_name), [], [], "hist", interactive, title)
+
+    def box_plot(self, x, xname="", yname="Value", title="Box Plot", interactive=True):
+        fig, ax = plt.subplots(figsize=(12, 7))
+        scatter = ax.boxplot(x)
+        ax.set_ylabel(yname)
+        ax.set_xlabel(xname)
+        ax.set_title(title)
+        images_dir, html_dir, image_name, html_name = self._prepare_paths(title)
+        return self._finalize_plot(fig, os.path.join(images_dir, image_name), os.path.join(html_dir, html_name), [], [], "box", interactive, title)
+
+    def density_plot(self, x, xname="X", yname="Density", title="Density Plot", interactive=True, color='blue', xlim=None, ylim=None):
+        fig, ax = plt.subplots(figsize=(12, 7))
+        kde = gaussian_kde(x)
+        x_vals = np.linspace(min(x), max(x), 200)
+        y_vals = kde(x_vals)
+        scatter = ax.plot(x_vals, y_vals, color=color)
+        labels = [f"({xi:.2f}, {yi:.2f})" for xi, yi in zip(x_vals, y_vals)]
+        ax.set_xlabel(xname)
+        ax.set_ylabel(yname)
+        ax.set_title(title)
+        if xlim: ax.set_xlim(xlim)
+        if ylim: ax.set_ylim(ylim)
+        images_dir, html_dir, image_name, html_name = self._prepare_paths(title)
+        return self._finalize_plot(fig, os.path.join(images_dir, image_name), os.path.join(html_dir, html_name), labels, scatter, "density", interactive, title)
+    
+    def pie_plot(self, sizes, labels=None, title="Pie Chart", interactive=True, colors=None):
+        fig, ax = plt.subplots(figsize=(8, 8))
+        ax.pie(sizes, labels=labels, autopct='%1.1f%%', startangle=90, colors=colors)
+        ax.set_title(title)
+        images_dir, html_dir, image_name, html_name = self._prepare_paths(title)
+        return self._finalize_plot(fig, os.path.join(images_dir, image_name), os.path.join(html_dir, html_name), [], [], "pie", interactive, title)
+    
+    def cluster_plot(self, data, labels, title="Cluster Plot", interactive=True, cmap='viridis', xlim=None, ylim=None):
+        fig, ax = plt.subplots(figsize=(12, 7))
+        scatter = ax.scatter(data[:, 0], data[:, 1], c=labels, cmap=cmap)
+        ax.set_title(title)
+        ax.set_xlabel("X")
+        ax.set_ylabel("Y")
+        if xlim: ax.set_xlim(xlim)
+        if ylim: ax.set_ylim(ylim)
+        images_dir, html_dir, image_name, html_name = self._prepare_paths(title)
+        return self._finalize_plot(fig, os.path.join(images_dir, image_name), os.path.join(html_dir, html_name), [], [scatter], "cluster", interactive, title)
+
+# 4. Personalización en otros gráficos
+
+    
+    def save_as_format(self, title, extension="png", target_folder="exports"):
+    
+        valid_exts = ["png", "jpg", "jpeg", "svg", "pdf"]
+        if extension not in valid_exts:
+            raise ValueError(f"Formato no soportado: {extension}")
+
+        safe_title = self._sanitize_title(title)
+        original_path = os.path.join(self.path, "static", "images", f"{safe_title}.png")
+    
+        if not os.path.exists(original_path):
+            raise FileNotFoundError(f"No se encontró el gráfico original: {original_path}")
+
+        # Crear carpeta destino si no existe
+        os.makedirs(target_folder, exist_ok=True)
+        output_path = os.path.join(target_folder, f"{safe_title}.{extension}")
+
+        # Si el formato es el mismo, simplemente copiar
+        if extension == "png":
+            shutil.copyfile(original_path, output_path)
+        else:
+            # Leer imagen y volver a guardarla en nuevo formato
+            from PIL import Image
+            with Image.open(original_path) as img:
+                format_map = {"jpg": "JPEG", "jpeg": "JPEG", "png": "PNG", "pdf": "PDF", "svg": "SVG"}
+                img.convert("RGB").save(output_path, format_map[extension.lower()])
+
+        return output_path

pyvmote/Service.py

@@ -0,0 +1,165 @@
+from fastapi import FastAPI, WebSocketDisconnect, WebSocket, Request
+from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+import uvicorn
+import os
+import asyncio
+import threading
+import shutil
+import json 
+
+class Server:
+    def __init__(self):
+        self.port = ""
+        self.app = FastAPI()
+        self.ws_connection = None 
+        self.last_timestamp = 0
+        self.loop = None
+        self.start = False
+        self.init_server()
+    
+    def init_server(self):
+        self.base_path = os.path.dirname(os.path.abspath(__file__))
+        self.image_folder = os.path.join(self.base_path, "static", "images")
+        self.html_folder = os.path.join(self.base_path, "static", "html")
+        self.templates_path = os.path.join(self.base_path, "templates")
+        
+        self.app.mount("/static", StaticFiles(directory=os.path.join(self.base_path, "static")), name="static")
+        
+        self.templates = Jinja2Templates(directory=self.templates_path)
+        
+        self.app.get("/")(self.index)
+        self.app.add_api_route("/preview", self.preview_page)
+        self.app.get("/latest")(self.latest_image)
+        self.app.add_api_route("/rename", self.rename_graph, methods=["POST"])
+        
+        self.app.on_event("startup")(self.startup_event)
+        self.app.websocket("/ws")(self.websocket_endpoint)
+
+    async def startup_event(self):
+        self.loop = asyncio.get_running_loop()
+
+    async def websocket_endpoint(self, websocket: WebSocket):
+        await websocket.accept()
+        self.ws_connection = websocket
+        try:
+            while True:
+                await websocket.receive_text()
+        except WebSocketDisconnect:
+            self.ws_connection = None
+
+    def get_image_files(self):
+        valid_extensions = ('.png', '.jpg', '.jpeg', '.gif', '.bmp')
+        if not os.path.exists(self.image_folder):
+            return []
+        return [f for f in os.listdir(self.image_folder) if f.lower().endswith(valid_extensions)]
+
+    def get_html_files(self):
+        if not os.path.exists(self.html_folder):
+            return []
+        return [f for f in os.listdir(self.html_folder) if f.endswith(".html")]
+
+    def get_latest_graphs(self):
+        images = self.get_image_files()
+        htmls = self.get_html_files()
+        return images, htmls
+
+    async def index(self, request: Request):
+        latest_img, latest_html = self.get_latest_graphs()
+        return self.templates.TemplateResponse("index.html", {"request": request, "latest_img": latest_img[0] if latest_img else None, "latest_html": latest_html[0] if latest_html else None})
+    
+    async def preview_page(self,request: Request):
+        graphs = self.get_ordered_graphs()
+        return self.templates.TemplateResponse("preview.html", {"request": request, "graphs": graphs})
+
+    
+    def show_port(self):
+        print(f"Servidor corriendo en http://localhost:{self.port}")
+
+    def start_server(self, port):
+        self.port = port
+        self.start = True
+        config = uvicorn.Config(self.app, host="0.0.0.0", port=self.port, log_level="warning")
+        self.server = uvicorn.Server(config)
+        self.server_thread = threading.Thread(target=self.server.run, daemon=True)
+        self.server_thread.start()
+        self.show_port()
+
+    def get_ordered_graphs(self):
+        """Lee el historial de gráficos en el orden en que se generaron."""
+        history_file = os.path.join(self.base_path, "static", "graph_history.json")
+    
+        if not os.path.exists(history_file):
+            return []
+    
+        with open(history_file, "r") as f:
+            return json.load(f)
+
+    async def latest_image(self):
+        """
+        Devuelve la lista de gráficos en formato JSON, manteniendo el orden de creación.
+        """
+        graphs = self.get_ordered_graphs()
+        return JSONResponse(content={"graphs": graphs})
+
+    def notify_update(self):
+        if self.ws_connection is not None and self.loop is not None:
+            asyncio.run_coroutine_threadsafe(self.msg_notify_update(), self.loop)
+
+    async def msg_notify_update(self):
+        try:
+            await self.ws_connection.send_text("update")
+        except Exception:
+            self.ws_connection = None
+
+    def stop_server(self):
+        if self.server is not None:
+            self.start = False
+            self.server.should_exit = True
+            self.clear_graphs()
+        if hasattr(self, 'server_thread') and self.server_thread is not None:
+            self.server_thread.join()
+        print("Servidor detenido.")
+
+    def clear_graphs(self):
+        """
+        Borra todo el contenido de la carpeta de imágenes y de gráficos interactivos.
+        """
+        for folder in [self.image_folder, self.html_folder]:
+            if os.path.exists(folder):
+                for filename in os.listdir(folder):
+                    file_path = os.path.join(folder, filename)
+                    try:
+                        if os.path.isfile(file_path) or os.path.islink(file_path):
+                            os.unlink(file_path)
+                        elif os.path.isdir(file_path):
+                            shutil.rmtree(file_path)
+                    except Exception as e:
+                        print(f"No se pudo borrar {file_path}. Motivo: {e}")
+    
+    async def rename_graph(self, request: Request):
+        data = await request.json()
+        old_title = data.get("old_title")
+        new_title = data.get("new_title")
+
+        history_file = os.path.join(self.base_path, "static", "graph_history.json")
+        if not os.path.exists(history_file):
+            return JSONResponse(content={"error": "No hay historial"}, status_code=404)
+
+        with open(history_file, "r") as f:
+            history = json.load(f)
+
+        updated = False
+        for graph in history:
+            if graph["title"] == old_title:
+                graph["title"] = new_title
+                updated = True
+                break
+
+        if updated:
+            with open(history_file, "w") as f:
+                json.dump(history, f)
+            return JSONResponse(content={"message": "Título actualizado"})
+        else:
+            return JSONResponse(content={"error": "Gráfico no encontrado"}, status_code=404)

pyvmote/__init__.py

@@ -0,0 +1,8 @@
+from .pyvmote import Pyvmote
+
+__version__ = "0.1.5"
+
+# Creamos una instancia de Pyvmote para que al importar el paquete se obtenga directamente el objeto
+_instance = Pyvmote()
+import sys
+sys.modules[__name__] = _instance

pyvmote/pyvmote.py

@@ -0,0 +1,70 @@
+from .Graph_generator import Graph
+from .Service import Server
+
+class Pyvmote:
+    def __init__(self):
+        self.gr = Graph()
+        self.sv = Server()
+
+    def start_server(self, puerto):
+        self.sv.start_server(puerto)
+
+    def stop_server(self):
+        self.sv.stop_server()
+        self.gr.clear_history()
+
+    def line_plot(self, x, y, xname="X", yname="Y", title="Line Graph", interactive=True, color='blue', linewidth=2, xlim=None, ylim=None):
+        plot_file = self.gr.line_plot(x, y, xname, yname, title, interactive, color, linewidth, xlim, ylim)
+        if self.sv.start:
+            self.sv.notify_update()
+        return plot_file
+
+    def scatter_plot(self, x, y, xname="X", yname="Y", title="Scatter Plot", interactive=True, color='blue', xlim=None, ylim=None):
+        plot_file = self.gr.scatter_plot(x, y, xname, yname, title, interactive, color, xlim, ylim)
+        if self.sv.start:
+            self.sv.notify_update()
+        return plot_file
+
+    def bar_plot(self, x, y, xname="X", yname="Y", title="Bar Plot", interactive=True, color='blue', xlim=None, ylim=None):
+        plot_file = self.gr.bar_plot(x, y, xname, yname, title, interactive, color, xlim, ylim)
+        if self.sv.start:
+            self.sv.notify_update()
+        return plot_file
+
+    def hist_plot(self, x, xname="Value", yname="Frequency", title="Histogram", bins=20, interactive=True, color='blue', xlim=None, ylim=None):
+        plot_file = self.gr.hist_plot(x, xname, yname, title, bins, interactive, color, xlim, ylim)
+        if self.sv.start:
+            self.sv.notify_update()
+        return plot_file
+
+    def box_plot(self, x, xname="", yname="Value", title="Box Plot", interactive=True):
+        plot_file = self.gr.box_plot(x, xname, yname, title, interactive)
+        if self.sv.start:
+            self.sv.notify_update()
+        return plot_file
+
+    def density_plot(self, x, xname="X", yname="Density", title="Density Plot", interactive=True, color='blue', xlim=None, ylim=None):
+        plot_file = self.gr.density_plot(x, xname, yname, title, interactive, color, xlim, ylim)
+        if self.sv.start:
+            self.sv.notify_update()
+        return plot_file
+    
+    def pie_plot(self, sizes, labels=None, title="Pie Chart", interactive=True, colors=None):
+        plot_file = self.gr.pie_plot(sizes, labels, title, interactive, colors)
+        if self.sv.start:
+            self.sv.notify_update()
+        return plot_file
+    
+    def cluster_plot(self, data, labels, title="Cluster Plot", interactive=True, cmap='viridis', xlim=None, ylim=None):
+        plot_file = self.gr.cluster_plot(data, labels, title, interactive, cmap, xlim, ylim)
+        if self.sv.start:
+            self.sv.notify_update()
+        return plot_file
+
+    def export_graph(self, title, extension="jpg", target_folder="exports"):
+        ruta = self.gr.save_as_format(title, extension, target_folder)
+        print(ruta)
+
+
+
+

pyvmote-0.1.5.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: pyvmote
+Version: 0.1.5
+Summary: Librería para generar gráficos y visualizar imágenes en tiempo real en remoto
+Author: Juan Grima Sanchez
+Author-email: Juan Grima Sanchez <juan.grimasanchez5@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi
+Requires-Dist: uvicorn[standard]
+Requires-Dist: jinja2
+Requires-Dist: matplotlib
+Requires-Dist: mpld3
+Requires-Dist: scipy
+Requires-Dist: numpy
+Dynamic: author
+
+# 📊 PyVmote
+
+**PyVmote** es una librería de Python para la **generación y visualización remota de gráficos**, tanto estáticos como interactivos, usando un servidor FastAPI. Permite visualizar gráficas directamente desde tu navegador incluso cuando trabajas en un entorno remoto (como SSH), gracias a su sistema de forwarding de puertos y WebSocket en tiempo real.
+
+---
+
+## 🚀 Características principales
+
+- 📈 Soporte para múltiples tipos de gráficos:
+  - Line plot
+  - Scatter plot
+  - Bar plot
+  - Histogram
+  - Boxplot
+  - Curvas de densidad (KDE)
+
+- 🌐 Servidor web integrado con FastAPI
+- ⚡ Recarga automática de gráficos mediante WebSocket
+- 🌍 Visualización remota con un simple túnel SSH
+- 🖱️ Soporte para gráficos **interactivos** con `mpld3`
+- 📸 Exportación de gráficos a formatos `png`, `jpg`, `svg`, `pdf`, etc.
+- 🧠 Historial de gráficos generado automáticamente
+
+---
+
+## 🚀 Fujo de trabajo
+- import Pyvmote as p
+- p.start_server(port) port exameple 3000
+- p.line_plot(), p.scatter_plot(), p.box_plot(), p.bar_plot(), p.hist_plot(), p.density_plot() this will generate the graphs in the web server
+- p.export_graph(title, extension, target_folder) title is also the name of the file image, extension = ["png", "jpg", "jpeg", "svg", "pdf"], target_folder = where do you want to save the photo
+- p.stop_server()

pyvmote-0.1.5.dist-info/RECORD

@@ -0,0 +1,8 @@
+pyvmote/Graph_generator.py,sha256=WDeuS0S0Ds6ESUeiaHJ4O2TtIY21BIHZIAKa_6pag0Q,9939
+pyvmote/Service.py,sha256=_a69sXUsuWiNP25m66jitTR7BlYNeXBdEdi6wutS3Gg,6325
+pyvmote/__init__.py,sha256=9Z92pgVaECSzp02o-Ma1qPPkKDeDYd6SpMVFA3d9kKY,221
+pyvmote/pyvmote.py,sha256=CqmZaEM51cXKhvkBYt_LrT7-kXEPFF5gxumN1dvY1xI,2930
+pyvmote-0.1.5.dist-info/METADATA,sha256=Sh1s-TvCx1YRl9T0KZAOYh0-L2uRT6iMIrnkWmB0e04,1953
+pyvmote-0.1.5.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+pyvmote-0.1.5.dist-info/top_level.txt,sha256=ag8OwKUnIP9TDSNWL1zthhFrbe-FfYpjVpQ6b-fSEuk,8
+pyvmote-0.1.5.dist-info/RECORD,,

pyvmote-0.1.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyvmote-0.1.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyvmote