pipeline-eds 0.2.13__tar.gz → 0.2.15__tar.gz

{pipeline_eds-0.2.13 → pipeline_eds-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pipeline-eds
-Version: 0.2.13
+Version: 0.2.15
 Summary: The official API pipeline library for mulch-based projects. Key target: Emerson Ovation EDS REST API.
 License: BSD-3
 Author: George Clayton Bennett
@@ -13,7 +13,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: windb
 Requires-Dist: certifi (>=2025.1.31,<2026.0.0)
-Requires-Dist: fastapi (==0.103.0)
+Requires-Dist: fastapi (>=0.116.1,<0.117.0)
+Requires-Dist: matplotlib (>=3.10.6,<4.0.0)
 Requires-Dist: mulch (>=0.2.8,<0.3.0)
 Requires-Dist: mysql-connector-python (>=9.3.0,<10.0.0)
 Requires-Dist: pendulum (>=3.1.0,<4.0.0)

{pipeline_eds-0.2.13 → pipeline_eds-0.2.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pipeline-eds"
-version = "0.2.13"
+version = "0.2.15"
 description = "The official API pipeline library for mulch-based projects. Key target: Emerson Ovation EDS REST API."
 authors = ["George Clayton Bennett <george.bennett@memphistn.gov>"]
 license = "BSD-3"
@@ -39,7 +39,6 @@ pyyaml = ">=6.0.2,<7.0.0"
 certifi = ">=2025.1.31,<2026.0.0"
 schedule = ">=1.2.2,<2.0.0"
 #fastapi = ">=0.115.12,<0.116.0"
-fastapi = "0.103.0"
 pydantic = "1.10.13"
 urllib3 = "^2.4.0"
 plotly = "^6.2.0"
@@ -48,6 +47,8 @@ mulch = "^0.2.8"
 mysql-connector-python = "^9.3.0"
 tzdata = "^2025.2"
 pendulum = "^3.1.0"
+fastapi = "^0.116.1"
+matplotlib = "^3.10.6"
 
 [tool.poetry.extras]
 windb = ["pyodbc"]

{pipeline_eds-0.2.13 → pipeline_eds-0.2.15}/src/pipeline/api/eds.py

@@ -165,7 +165,7 @@ class EdsClient:
     
     @staticmethod
     #def create_tabular_request(session: object, api_url: str, starttime: int, endtime: int, points: list):
-    def create_tabular_request(session, api_url, starttime, endtime, points, step_seconds = 300):
+    def create_tabular_request_(session, api_url, starttime, endtime, points, step_seconds = 300):
         
         data = {
             'period': {
@@ -189,6 +189,51 @@ class EdsClient:
             response = session.post(f"{api_url}/trend/tabular", json=data, verify=False)
             #print(f"response = {response}")
 
+    @staticmethod
+    def create_tabular_request(session, api_url, starttime, endtime, points, step_seconds=300):
+        """
+        Submit a tabular trend request. Returns request id on success, or None if failed.
+        """
+
+        data = {
+            "period": {
+                "from": starttime,
+                "till": endtime,
+            },
+            "step": step_seconds,
+            "items": [
+                {
+                    "pointId": {"iess": p},
+                    "shadePriority": "DEFAULT",
+                    "function": "AVG",
+                }
+                for p in points
+            ],
+        }
+
+        try:
+            res = session.post(f"{api_url}/trend/tabular", json=data, verify=False)
+        except Exception as e:
+            logger.error(f"Request failed to {api_url}/trend/tabular: {e}")
+            return None
+
+        if res.status_code != 200:
+            logger.error(f"Bad status {res.status_code} from server: {res.text}")
+            return None
+
+        try:
+            payload = res.json()
+        except Exception:
+            logger.error(f"Non-JSON response: {res.text}")
+            return None
+
+        req_id = payload.get("id")
+        if not req_id:
+            logger.error(f"No request id in response: {payload}")
+            return None
+
+        return req_id
+
     @staticmethod
     def wait_for_request_execution_session(session, api_url, req_id):
         st = time.time()
@@ -726,7 +771,7 @@ def demo_eds_webplot_point_live():
     gui_fastapi_plotly_live.run_gui(data_buffer)
 
 @log_function_call(level=logging.DEBUG)    
-def load_historic_data(session, iess_list, starttime, endtime):    
+def load_historic_data(session, iess_list, starttime, endtime, step_seconds):    
     
 
     starttime = TimeManager(starttime).as_unix()
@@ -734,11 +779,13 @@ def load_historic_data(session, iess_list, starttime, endtime):
     logger.info(f"starttime = {starttime}")
     logger.info(f"endtime = {endtime}")
 
-    step_seconds = helpers.nice_step(endtime-starttime)
 
     point_list = iess_list
     api_url = str(session.base_url) 
     request_id = EdsClient.create_tabular_request(session, api_url, starttime, endtime, points=point_list, step_seconds=step_seconds)
+    if not request_id:
+        logger.warning(f"Could not create tabular request for points: {point_list}")
+        return []  # or None, depending on how you want the CLI to behave
     EdsClient.wait_for_request_execution_session(session, api_url, request_id)
     results = EdsClient.get_tabular_trend(session, request_id, point_list)
     logger.debug(f"len(results) = {len(results)}")
@@ -951,10 +998,9 @@ if __name__ == "__main__":
         demo_eds_save_graphics_export()
     elif cmd == "license":
         demo_eds_print_license()
-    elif cmd == "access-workspace""":
+    elif cmd == "access-workspace":
         if platform.system().lower() == "windows":
-            # run the Open-FileBrowser command, registered with: git clone https://github.com/city-of-memphis-wastewater/powershell-tools.git ## run `notepad $profile` #noobs 
-            #command = ["Open-FileBrowser", WorkspaceManager.get_cwd()]
+            # at this level it is correct but the get_cwd() command only knows the default workspace.
             command = ["explorer", str(WorkspaceManager.get_cwd())]
             subprocess.call(command) 
     else:

{pipeline_eds-0.2.13 → pipeline_eds-0.2.15}/src/pipeline/cli.py

@@ -20,22 +20,23 @@ from pipeline.env import SecretConfig
 from pipeline.workspace_manager import WorkspaceManager
 
 ### Versioning
+CLI_APP_NAME = "pipeline"
 def print_version(value: bool):
     if value:
         try:
-            typer.secho(f"mulch {MULCH_VERSION}",fg=typer.colors.GREEN, bold=True)
+            typer.secho(f"{CLI_APP_NAME} {PIPELINE_VERSION}",fg=typer.colors.GREEN, bold=True)
         except PackageNotFoundError:
             typer.echo("Version info not found")
         raise typer.Exit()
 try:
-    MULCH_VERSION = version("mulch")
-    __version__ = version("mulch")
+    PIPELINE_VERSION = version(CLI_APP_NAME)
+    __version__ = version(CLI_APP_NAME)
 except PackageNotFoundError:
-    MULCH_VERSION = "unknown"
+    PIPELINE_VERSION = "unknown"
 
 try:
     from importlib.metadata import version
-    __version__ = version("mulch")
+    __version__ = version(CLI_APP_NAME)
 except PackageNotFoundError:
     # fallback if running from source
     try:
@@ -102,7 +103,9 @@ def trend(
     starttime: str = typer.Option(None, "--start", "-s", help="Index from 'mulch order' to choose scaffold source."),
     endtime: str = typer.Option(None, "--end", "-end", help="Reference a known template for workspace organization."),
     zd: str = typer.Option('Maxson', "--zd", "-z", help = "Define the EDS ZD from your secrets file. This must correlate with your idcs point selection(s)."),
-    workspace: str = typer.Option(None,"--workspace","-w", help = "Provide the name of the workspace you want to use, for the secrets.yaml credentials and for the timezone config. If a start time is not provided, the workspace queries can checked for the most recent successful timestamp. ")
+    workspacename: str = typer.Option(None,"--workspace","-w", help = "Provide the name of the workspace you want to use, for the secrets.yaml credentials and for the timezone config. If a start time is not provided, the workspace queries can checked for the most recent successful timestamp. "),
+    print_csv: bool = typer.Option(False,"--print-csv","-p",help = "Print the CSV style for pasting into Excel."),
+    step_seconds: int = typer.Option(None, "--step-seconds", help="You can explicitly provide the delta between datapoints. If not, ~400 data points will be used, based on the nice_step() function.") 
     ):
     """
     Show a curve for a sensor over time.
@@ -112,16 +115,16 @@ def trend(
     from pipeline.api.eds import EdsClient, load_historic_data
     from pipeline import helpers
     from pipeline.plotbuffer import PlotBuffer
-    from pipeline import gui_fastapi_plotly_live
     from pipeline import environment
     from pipeline.workspace_manager import WorkspaceManager
-    ws_dir = WorkspaceManager.ensure_workspace()
+    workspaces_dir = WorkspaceManager.ensure_appdata_workspaces_dir()
 
     # must set up %appdata for pip/x installation. Use mulch or yeoman for this. And have a secrets filler.
-    if workspace is None:
-        WorkspaceManager.identify_default_workspace_name()
-    wm = WorkspaceManager(workspace)
-    secrets_dict = SecretConfig.load_config(secrets_file_path = wm.get_secrets_file_path())
+    if workspacename is None:
+        workspacename = WorkspaceManager.identify_default_workspace_name()
+    wm = WorkspaceManager(workspacename)
+    secrets_file_path = wm.get_secrets_file_path()
+    secrets_dict = SecretConfig.load_config(secrets_file_path)
 
     if zd.lower() == "stiles":
         zd = "WWTF"
@@ -156,22 +159,38 @@ def trend(
         dt_finish = pendulum.parse(endtime, strict=False)
 
     # Should automatically choose time step granularity based on time length; map 
-    
-    results = load_historic_data(session, iess_list, dt_start, dt_finish) 
-    
+    if step_seconds is None:
+        step_seconds = helpers.nice_step(endtime-starttime)
+    results = load_historic_data(session, iess_list, dt_start, dt_finish, step_seconds) 
+    if not results:
+        return 
+
     data_buffer = PlotBuffer()
     for idx, rows in enumerate(results):
         for row in rows:
-            label = f"{row.get('rjn_entityid')} ({row.get('units')})"
+            #label = f"({row.get('units')})"
+            label = iess_list[0]
             ts = helpers.iso(row.get("ts"))
             av = row.get("value")
+            #print(f"{round(av,2)}")
             data_buffer.append(label, ts, av) # needs to be adapted for multiple iess sensor results
-    
+    #print(f"data_buffer = {data_buffer}")
+    #print(f"data_buffer.get_all() = {data_buffer.get_all()}")
     if not environment.matplotlib_enabled():
-        gui_fastapi_plotly_live.run_gui(data_buffer)
+        from pipeline import gui_plotly_static
+        #gui_fastapi_plotly_live.run_gui(data_buffer)
+        gui_plotly_static.show_static(data_buffer)
     else:
         from pipeline import gui_mpl_live
-        gui_mpl_live.run_gui(data_buffer)
+        #gui_mpl_live.run_gui(data_buffer)
+        gui_mpl_live.show_static(data_buffer)
+    
+    if print_csv:
+        print(f"Time,\\{iess_list[0]}\\,")
+        for idx, rows in enumerate(results):
+            for row in rows:
+                print(f"{helpers.iso(row.get('ts'))},{row.get('value')},")
+    
 
 @app.command()
 def list_workspaces():

{pipeline_eds-0.2.13 → pipeline_eds-0.2.15}/src/pipeline/environment.py

@@ -12,11 +12,13 @@ def vercel():
     return False # hard code this
 
 def matplotlib_enabled():
+    #print(f"is_termux() = {is_termux()}")
     if is_termux():
         return False
     else:
         try:
             import matplotlib
+            return True
         except ImportError:
             return False
         

{pipeline_eds-0.2.13 → pipeline_eds-0.2.15}/src/pipeline/gui_fastapi_plotly_live.py

@@ -57,12 +57,32 @@ HTML_TEMPLATE = """
 async def index():
     return HTML_TEMPLATE
 
+
 @app.get("/data", response_class=JSONResponse)
 async def get_data():
+    if plot_buffer is None:
+        print("plot_buffer is None")
+        return {}
     with buffer_lock:
-        data = plot_buffer.get_all()  # Should return { label: {"x": [...], "y": [...]}, ... }
-    return data
-
+        data = plot_buffer.get_all()
+    print("Data in buffer:", data)  # <-- DEBUG
+    fixed_data = {}
+    for label, series in data.items():
+        fixed_data[label] = {
+            "x": [ts + "Z" if not ts.endswith("Z") else ts for ts in series["x"]],
+            "y": series["y"]
+        }
+    return fixed_data
+"""
+@app.get("/data", response_class=JSONResponse)
+async def get_data():
+    return {
+        "Test Series": {
+            "x": ["2025-09-05T15:00:00Z", "2025-09-05T15:05:00Z", "2025-09-05T15:10:00Z"],
+            "y": [1, 3, 2]
+        }
+    }
+"""
 def open_browser(port):
     time.sleep(1)  # Give server a moment to start
     ## Open in a new Chrome window (if installed)
@@ -71,8 +91,14 @@ def open_browser(port):
 
     webbrowser.open(f"http://127.0.0.1:{port}")
 
+#def run_gui(buffer, port=8000):
+#    global plot_buffer
+#    plot_buffer = buffer
+#    threading.Thread(target=open_browser, args=(port,), daemon=True).start()
+#    uvicorn.run("src.pipeline.gui_fastapi_plotly_live:app", host="127.0.0.1", port=port, log_level="info", reload=False)
+
 def run_gui(buffer, port=8000):
     global plot_buffer
-    plot_buffer = buffer
+    plot_buffer = buffer  # set the buffer in this process
     threading.Thread(target=open_browser, args=(port,), daemon=True).start()
-    uvicorn.run("src.pipeline.gui_fastapi_plotly_live:app", host="127.0.0.1", port=port, log_level="info", reload=False)
+    uvicorn.run(app, host="127.0.0.1", port=port, log_level="info", reload=False)  # <- reload=False

{pipeline_eds-0.2.13 → pipeline_eds-0.2.15}/src/pipeline/gui_mpl_live.py

@@ -3,6 +3,8 @@ import time
 import logging
 import matplotlib.pyplot as plt
 import matplotlib.animation as animation
+import matplotlib.dates as mdates
+from datetime import datetime, timedelta
 from pipeline import helpers
 from pipeline.plotbuffer import PlotBuffer  # Adjust import path as needed
 from pipeline.time_manager import TimeManager
@@ -11,28 +13,6 @@ logger = logging.getLogger(__name__)
 
 PADDING_RATIO = 0.25
 
-def compute_padded_bounds(data):
-    all_x_vals = []
-    all_y_vals = []
-
-    for series in data.values():
-        all_x_vals.extend(series["x"])
-        all_y_vals.extend(series["y"])
-
-    if not all_x_vals or not all_y_vals:
-        return (0, 1), (0, 1)
-
-    x_min, x_max = min(all_x_vals), max(all_x_vals)
-    y_min, y_max = min(all_y_vals), max(all_y_vals)
-
-    x_pad = max((x_max - x_min) * PADDING_RATIO, 1.0)
-    y_pad = max((y_max - y_min) * PADDING_RATIO, 1.0)
-
-    padded_x = (x_min - x_pad, x_max + x_pad)
-    padded_y = (y_min - y_pad, y_max + y_pad)
-
-    return padded_x, padded_y
-
 def run_gui(buffer: PlotBuffer, update_interval_ms=1000):
     """
     Runs a matplotlib live updating plot based on the PlotBuffer content.
@@ -45,6 +25,11 @@ def run_gui(buffer: PlotBuffer, update_interval_ms=1000):
     ax.set_title("Live Pipeline Data")
     ax.set_xlabel("Time")
     ax.set_ylabel("Value")
+    # Auto-locate ticks and auto-format dates
+    locator = mdates.AutoDateLocator()
+    formatter = mdates.AutoDateFormatter(locator)
+    ax.xaxis.set_major_locator(locator)
+    ax.xaxis.set_major_formatter(formatter)
 
     lines = {}
     legend_labels = []
@@ -80,11 +65,6 @@ def run_gui(buffer: PlotBuffer, update_interval_ms=1000):
             else:
                 lines[label].set_data(x_vals, y_vals)
 
-        # Adjust axes limits with padding
-        padded_x, padded_y = compute_padded_bounds(data)
-        ax.set_xlim(padded_x)
-        ax.set_ylim(padded_y)
-
         # Format x-axis ticks as human readable time strings
 
         # Tick positions are x values at those indices
@@ -111,3 +91,37 @@ def run_gui(buffer: PlotBuffer, update_interval_ms=1000):
     plt.tight_layout()
     plt.show()
 
+def show_static(buffer: PlotBuffer):
+    """
+    Show a static matplotlib plot of the current PlotBuffer contents,
+    with automatic date formatting based on time span.
+    """
+    plt.style.use('ggplot')
+    fig, ax = plt.subplots(figsize=(10, 6))
+    ax.set_title("Static Pipeline Data")
+    ax.set_xlabel("Time")
+    ax.set_ylabel("Value")
+
+    data = buffer.get_all()
+    if not data:
+        ax.text(0.5, 0.5, "No data to display", ha='center', va='center')
+        plt.show()
+        return
+
+    for label, series in data.items():
+        # Convert strings to datetime objects for better handling
+        x_vals = [TimeManager(ts).as_datetime() for ts in series["x"]]
+        y_vals = series["y"]
+
+        ax.plot(x_vals, y_vals, marker='o', linestyle='-', label=label)
+
+    # Let matplotlib auto-locate ticks and auto-format
+    locator = mdates.AutoDateLocator()
+    formatter = mdates.AutoDateFormatter(locator)
+    ax.xaxis.set_major_locator(locator)
+    ax.xaxis.set_major_formatter(formatter)
+
+    plt.setp(ax.get_xticklabels(), rotation=45, ha='right')
+    ax.legend()
+    plt.tight_layout()
+    plt.show()

pipeline_eds-0.2.15/src/pipeline/gui_plotly_static.py

@@ -0,0 +1,43 @@
+# src/pipeline/gui_plotly_static.py
+
+import plotly.graph_objs as go
+import plotly.offline as pyo
+import webbrowser
+import tempfile
+from threading import Lock
+
+buffer_lock = Lock()  # Optional, if you want thread safety
+
+def show_static(plot_buffer):
+    """
+    Renders the current contents of plot_buffer as a static HTML plot.
+    Does not listen for updates.
+    """
+    if plot_buffer is None:
+        print("plot_buffer is None")
+        return
+
+    with buffer_lock:
+        data = plot_buffer.get_all()
+
+    traces = []
+    for label, series in data.items():
+        traces.append(go.Scatter(
+            x=series["x"],
+            y=series["y"],
+            mode="lines+markers",
+            name=label
+        ))
+
+    layout = go.Layout(
+        title="EDS Data Plot (Static)",
+        margin=dict(t=40)
+    )
+
+    fig = go.Figure(data=traces, layout=layout)
+
+    # Write to a temporary HTML file
+    tmp_file = tempfile.NamedTemporaryFile(suffix=".html", delete=False)
+    pyo.plot(fig, filename=tmp_file.name, auto_open=False)
+    
+    webbrowser.open(f"file://{tmp_file.name}")

{pipeline_eds-0.2.13 → pipeline_eds-0.2.15}/src/pipeline/workspace_manager.py

@@ -2,6 +2,7 @@ import os
 import toml
 import logging
 from pathlib import Path
+import sys
 
 '''
 Goal:
@@ -29,7 +30,14 @@ class WorkspaceManager:
     APP_NAME = "pipeline"
 
     TIMESTAMPS_JSON_FILE_NAME = 'timestamps_success.json'
-    ROOT_DIR = Path(__file__).resolve().parents[2]  # root directory
+
+    # Detect if running in a dev repo vs installed package
+    if getattr(sys, "frozen", False):
+        # Running from a pipx/executable environment
+        ROOT_DIR = None
+    else:
+        # Running from a cloned repo
+        ROOT_DIR = Path(__file__).resolve().parents[2]  # root directory
     
     
     # This climbs out of /src/pipeline/ to find the root.
@@ -62,11 +70,38 @@ class WorkspaceManager:
                                     self.logs_dir,
                                     self.aggregate_dir])
 
-    def get_workspaces_dir(self):
-        return self.ROOT_DIR / self.WORKSPACES_DIR_NAME
+    
+    @classmethod
+    def get_workspaces_dir(cls):
+        """
+        Return workspaces directory depending on environment:
+        - If ROOT_DIR is defined (repo clone), use that
+        - Else use AppData/local platform-specific location
+        """
+        if cls.ROOT_DIR and (cls.ROOT_DIR / cls.WORKSPACES_DIR_NAME).exists():
+            workspaces_dir = cls.ROOT_DIR / cls.WORKSPACES_DIR_NAME
+        else:
+            workspaces_dir = cls.get_appdata_dir() / cls.WORKSPACES_DIR_NAME
+            workspaces_dir.mkdir(parents=True, exist_ok=True)
+            default_file = workspaces_dir / cls.DEFAULT_WORKSPACE_TOML_FILE_NAME
+            if not default_file.exists():
+                # auto-populate default TOML with most recent workspace
+                recent_ws = cls.most_recent_workspace_name() or "default"
+                default_file.write_text(f"[default-workspace]\nworkspace = '{recent_ws}'\n")
+        return workspaces_dir
+    
+    @classmethod
+    def most_recent_workspace_name(cls):
+        workspaces_dir = cls.get_workspaces_dir()
+        all_dirs = [p for p in workspaces_dir.iterdir() if p.is_dir() and not p.name.startswith('.')]
+        if not all_dirs:
+            return None
+        latest = max(all_dirs, key=lambda p: p.stat().st_mtime)
+        return latest.name
 
     def get_workspace_dir(self):
-        return self.get_workspaces_dir() / self.workspace_name
+        # workspace_name is established at instantiation. You want a new name? Initialize a new WorkspaceManager(). It manages one workpspace.
+        return self.get_workspaces_dir() / self.workspace_name 
 
     def get_exports_dir(self):
         return self.workspace_dir / self.EXPORTS_DIR_NAME
@@ -191,13 +226,25 @@ class WorkspaceManager:
         if not default_workspace_path.exists():
             raise FileNotFoundError(f"Default workspace directory not found: {default_workspace_path}")
         return default_workspace_path
+    
+    '''
+    @classmethod
+    def identify_default_workspace_name(cls, workspaces_dir = None):
+        if workspaces_dir is None:
+            workspaces_dir = cls.get_workspaces_dir()
+        default_file = workspaces_dir / cls.DEFAULT_WORKSPACE_TOML_FILE_NAME
+        if not default_file.exists():
+            default_file.write_text("# Default workspace\n")
+        return str(default_file)
+    '''
+    
     @classmethod
-    def identify_default_workspace_name(cls):
+    def identify_default_workspace_name(cls, workspaces_dir = None):
         """
         Class method that reads default-workspace.toml to identify the default-workspace.
         """
-         
-        workspaces_dir = cls.ROOT_DIR / cls.WORKSPACES_DIR_NAME
+        if workspaces_dir is None:
+            workspaces_dir = cls.get_workspaces_dir()
         logging.info(f"workspaces_dir = {workspaces_dir}\n")
         default_toml_path = workspaces_dir / cls.DEFAULT_WORKSPACE_TOML_FILE_NAME
 
@@ -244,16 +291,15 @@ class WorkspaceManager:
         return base / cls.APP_NAME
 
     @classmethod
-    def ensure_workspace(cls) -> Path:
+    def ensure_appdata_workspaces_dir(cls) -> Path:
         """Create workspace folder and default toml if missing."""
-        workspaces_dir = cls.get_appdata_dir() / "workspaces"
+        workspaces_dir = cls.get_appdata_dir() / cls.WORKSPACES_DIR_NAME
         workspaces_dir.mkdir(parents=True, exist_ok=True)
-
+        cls.workspaces_dir = workspaces_dir 
         default_file = workspaces_dir / cls.DEFAULT_WORKSPACE_TOML_FILE_NAME
         if not default_file.exists():
             default_file.write_text("# Default workspace config\n")
         return workspaces_dir
-
     
 def establish_default_workspace():
     workspace_name = WorkspaceManager.identify_default_workspace_name()