spectrum-barometer 2.2.2__tar.gz → 2.2.5__tar.gz

{spectrum_barometer-2.2.2/spectrum_barometer.egg-info → spectrum_barometer-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spectrum-barometer
-Version: 2.2.2
+Version: 2.2.5
 Summary: Monitor barometric pressure from Spectrum SAX2V1S routers
 Author-email: BobaTeagrl <Unsorted2750@proton.me>
 License: MIT

{spectrum_barometer-2.2.2 → spectrum_barometer-2.2.5}/barometer/background.py

@@ -1,114 +1,148 @@
 """Background monitoring using threading with file-based state"""
 import threading
 import time
+import os
 import logging
+import psutil
 from barometer.paths import get_app_dir
 from datetime import datetime
 from pathlib import Path
 
+
 def get_state_file():
     """Get path to state file"""
     return get_app_dir() / 'monitor.state'
 
+
 def get_interval_file():
     """Get path to interval file"""
     return get_app_dir() / 'monitor.interval'
 
+
 def get_pid_file():
     """Get path to PID file"""
     return get_app_dir() / 'monitor.pid'
 
+
 def get_owner_file():
-    """Get path to owner file"""
+    """Get path to owner file (kept around, not used for access control anymore)"""
     return get_app_dir() / 'monitor.owner'
 
+
+def _all_state_files():
+    return [get_state_file(), get_pid_file(), get_interval_file(), get_owner_file()]
+
+
+def _cleanup_state_files():
+    for f in _all_state_files():
+        f.unlink(missing_ok=True)
+
+
+def _write_pid_record():
+    # store pid and create_time together so a reused pid can't be mistaken 
+    pid = os.getpid()
+    try:
+        create_time = psutil.Process(pid).create_time()
+    except psutil.Error:
+        create_time = None
+    get_pid_file().write_text(f"{pid}:{create_time}")
+    return pid
+
+
+def _read_pid_record():
+    pid_file = get_pid_file()
+    if not pid_file.exists():
+        return None, None
+    try:
+        text = pid_file.read_text().strip()
+        pid_str, _, ct_str = text.partition(':')
+        pid = int(pid_str)
+        create_time = float(ct_str) if ct_str and ct_str != 'None' else None
+        return pid, create_time
+    except (ValueError, OSError):
+        return None, None
+
+
+def _process_still_matches(pid, create_time):
+    # pid alone isn't enough it could've been recycled by a totally different process
+    if pid is None:
+        return False
+    try:
+        proc = psutil.Process(pid)
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        return False
+
+    if create_time is None:
+        return True
+
+    try:
+        return abs(proc.create_time() - create_time) < 1.0
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        return False
+
+
 def is_monitoring():
     """Check if monitoring thread is running"""
-    import os
-    import psutil
-    
     state_file = get_state_file()
-    pid_file = get_pid_file()
-    
-    if not state_file.exists() or not pid_file.exists():
+
+    if not state_file.exists():
         return False
-    
+
     try:
         state = state_file.read_text().strip()
-        pid = int(pid_file.read_text().strip())
-        
-        # Check if state says running AND process exists
-        if state != 'running':
-            return False
-            
-        # Check if the PID is still alive
-        if psutil.pid_exists(pid):
-            return True
-        else:
-            # Stale state files - clean them up
-            state_file.unlink(missing_ok=True)
-            pid_file.unlink(missing_ok=True)
-            get_interval_file().unlink(missing_ok=True)
-            get_owner_file().unlink(missing_ok=True)
-            return False
-    except:
+    except OSError:
         return False
 
-def is_owned_by_current_process():
-    """Check if monitoring is owned by the current process"""
-    import os
-    
-    pid_file = get_pid_file()
-    if not pid_file.exists():
-        return False
-    
-    try:
-        pid = int(pid_file.read_text().strip())
-        return pid == os.getpid()
-    except:
+    if state != 'running':
         return False
 
+    pid, create_time = _read_pid_record()
+
+    if _process_still_matches(pid, create_time):
+        return True
+
+    # stale files left over from a crash - clean up
+    _cleanup_state_files()
+    return False
+
+
+def is_owned_by_current_process():
+    """Kept for backwards compat, not used to gate start/stop anymore"""
+    pid, _ = _read_pid_record()
+    return pid == os.getpid()
+
+
 def get_monitor_info():
     """Get monitoring status"""
-    import os
-    
     interval_file = get_interval_file()
-    pid_file = get_pid_file()
     interval = 300
-    pid = None
-    owned_by_me = False
-    
+
     if interval_file.exists():
         try:
             interval = int(interval_file.read_text().strip())
         except ValueError:
             pass
-    
-    if pid_file.exists():
-        try:
-            pid = int(pid_file.read_text().strip())
-            owned_by_me = (pid == os.getpid())
-        except ValueError:
-            pass
-    
+
     running = is_monitoring()
-    
+    pid, _ = _read_pid_record() if running else (None, None)
+
     return {
         'running': running,
-        'pid': pid if running else None,
+        'pid': pid,
         'interval': interval if running else None,
-        'owned_by_me': owned_by_me if running else False,
     }
 
+
 # Thread management (only exists in the process that started it)
 _monitor_thread = None
 
+
 def _monitor_loop(interval):
     """Internal monitoring loop"""
     from barometer.actions import scrape_single_reading
-    
+
     state_file = get_state_file()
-    
+
     while state_file.exists() and state_file.read_text().strip() == 'running':
         try:
             result = scrape_single_reading()
@@ -118,94 +152,95 @@ def _monitor_loop(interval):
                 logging.error(f"Background scrape failed: {result['message']}")
         except Exception as e:
             logging.error(f"Monitor error: {e}")
-        
+
         # Sleep in small chunks so we can stop quickly
         for _ in range(interval):
             if not state_file.exists() or state_file.read_text().strip() != 'running':
                 break
             time.sleep(1)
-    
-    # Clean up when loop exits
-    state_file.unlink(missing_ok=True)
+
+    _cleanup_state_files()
     logging.info("Background monitoring stopped")
 
+
 def start_monitoring(interval=300):
     """Start monitoring in background thread"""
     global _monitor_thread
-    import os
-    
+
     state_file = get_state_file()
     interval_file = get_interval_file()
-    pid_file = get_pid_file()
-    owner_file = get_owner_file()
-    
+
     # Check if already running (cleans up stale files automatically)
     if is_monitoring():
-        pid = int(pid_file.read_text().strip()) if pid_file.exists() else None
+        pid, _ = _read_pid_record()
         return {
             'success': False,
             'message': 'Monitoring is already running',
             'pid': pid
         }
-    
+
     try:
-        current_pid = os.getpid()
         state_file.write_text('running')
         interval_file.write_text(str(interval))
-        pid_file.write_text(str(current_pid))
-        owner_file.write_text(str(current_pid))
-        
+        current_pid = _write_pid_record()
+
         # Start thread
         _monitor_thread = threading.Thread(
-            target=_monitor_loop, 
-            args=(interval,), 
+            target=_monitor_loop,
+            args=(interval,),
             daemon=True,
             name="BarometerMonitor"
         )
         _monitor_thread.start()
-        
+
         return {
             'success': True,
             'message': f'Monitoring started (interval: {interval}s)',
             'pid': current_pid
         }
     except Exception as e:
-        state_file.unlink(missing_ok=True)
-        pid_file.unlink(missing_ok=True)
-        owner_file.unlink(missing_ok=True)
+        _cleanup_state_files()
         return {
             'success': False,
             'message': f'Failed to start: {e}',
             'pid': None
         }
 
-def stop_monitoring():
-    """Stop monitoring thread (only if owned by this process)"""
+
+def stop_monitoring(wait_seconds=3):
+    """Stop background monitoring. Works from any process - signals the
+    real owner through the state file instead of requiring a pid match."""
     state_file = get_state_file()
-    interval_file = get_interval_file()
-    pid_file = get_pid_file()
-    owner_file = get_owner_file()
-    
+
     if not state_file.exists():
+        _cleanup_state_files()
         return {
             'success': False,
             'message': 'Monitoring is not running'
         }
-    
-    # Only stop if we own it
-    if not is_owned_by_current_process():
+
+    pid, create_time = _read_pid_record()
+
+    if not _process_still_matches(pid, create_time):
+        # owner's already dead/recycled, nothing to signal
+        _cleanup_state_files()
         return {
-            'success': False,
-            'message': 'Monitoring is running in a different process'
+            'success': True,
+            'message': 'Cleared stale monitoring state (the process behind it was no longer running)'
         }
-    
-    # Signal thread to stop and clean up all state files
-    state_file.unlink(missing_ok=True)
-    interval_file.unlink(missing_ok=True)
-    pid_file.unlink(missing_ok=True)
-    owner_file.unlink(missing_ok=True)
-    
+
+    state_file.write_text('stop')
+
+    pid_file = get_pid_file()
+    for _ in range(wait_seconds * 2):
+        if not pid_file.exists():
+            return {
+                'success': True,
+                'message': 'Monitoring stopped'
+            }
+        time.sleep(0.5)
+
     return {
         'success': True,
-        'message': 'Monitoring stopped'
+        'message': 'Stop signal sent - monitoring will halt within a few seconds'
     }

{spectrum_barometer-2.2.2 → spectrum_barometer-2.2.5}/barometer/data.py

@@ -1,42 +1,57 @@
-from barometer.paths import get_data_dir
+from barometer.paths import get_data_dir, get_archive_dir
 import pandas
 from datetime import datetime, timedelta
 import logging
 from barometer.paths import get_logs_dir
 
+
+def _read_and_clean(csv_path):
+    #drop rows with bad timestamps instead of letting them become NaT
+    #and messing up sort order / "latest reading"
+    df = pandas.read_csv(csv_path)
+    df['timestamp'] = pandas.to_datetime(df['timestamp'], format='ISO8601', errors='coerce')
+
+    bad_rows = df['timestamp'].isna().sum()
+    if bad_rows:
+        logging.warning(
+            f"Dropped {bad_rows} row(s) with unparseable/missing timestamp from {csv_path}"
+        )
+        df = df.dropna(subset=['timestamp'])
+
+    return df
+
+
 def load_data(include_archives=False):
     data_file = get_data_dir() / 'readings.csv'
-    
+
     if not data_file.exists():
         return None
-    
+
     dfs = []
-    df = pandas.read_csv(data_file)
-    df['timestamp'] = pandas.to_datetime(df['timestamp'], format='ISO8601')
+    df = _read_and_clean(data_file)
     dfs.append(df)
-    
+
     if include_archives:
         archive_dir = get_archive_dir()
         if archive_dir.exists():
             for csv_file in archive_dir.rglob('*.csv'):
-                df_archive = pandas.read_csv(csv_file)
-                df_archive['timestamp'] = pandas.to_datetime(df_archive['timestamp'], format='ISO8601')
-                dfs.append(df_archive)
-    
+                dfs.append(_read_and_clean(csv_file))
+
     if not dfs:
         return None
-    
+
     combined = pandas.concat(dfs, ignore_index=True)
     combined = combined.sort_values('timestamp').reset_index(drop=True)
     combined = combined.drop_duplicates(subset=['timestamp'], keep='last')
-    
+
     return combined
 
+
 def setup_logging(verbose=False):
     # configure logging
     level = logging.DEBUG if verbose else logging.INFO
     log_file = get_logs_dir() / 'barometer.log'
-    
+
     logging.basicConfig(
         level=level,
         format='%(asctime)s - %(levelname)s - %(message)s',
@@ -44,8 +59,4 @@ def setup_logging(verbose=False):
             logging.FileHandler(log_file),
             logging.StreamHandler()
         ]
-    )
-
-
-
-
+    )

{spectrum_barometer-2.2.2 → spectrum_barometer-2.2.5}/barometer/graphs.py

@@ -12,7 +12,18 @@ from qbstyles import mpl_style
 from pathlib import Path
 
 
-mpl_style(dark=True)
+mpl_style(dark=True, minor_ticks=False)
+
+def _apply_x_axis_format(ax, days):
+    """Show hours if generating one day"""
+    if days == 1:
+        ax.xaxis.set_major_locator(mdates.HourLocator(interval=1))
+        ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
+        
+    else:
+        ax.xaxis.set_major_locator(mdates.AutoDateLocator())
+        ax.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d %H:%M'))
+
 def generate_line_graph(df, output, days):
     """Standard line graph"""
     fig, ax = plt.subplots(figsize=(12, 6))
@@ -25,7 +36,7 @@ def generate_line_graph(df, output, days):
     ax.set_title(f'Barometric Pressure - Last {days} Days', fontsize=14, fontweight='bold')
     ax.grid(True, alpha=0.3)
     ax.legend()
-    ax.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d %H:%M'))
+    _apply_x_axis_format(ax, days)
     plt.xticks(rotation=45)
     plt.tight_layout()
     plt.savefig(output, dpi=150, bbox_inches='tight')
@@ -50,7 +61,7 @@ def generate_smooth_graph(df, output, days, window=12):
     ax.set_title(f'Barometric Pressure with Trend - Last {days} Days', fontsize=14, fontweight='bold')
     ax.grid(True, alpha=0.3)
     ax.legend()
-    ax.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d %H:%M'))
+    _apply_x_axis_format(ax, days)
     plt.xticks(rotation=45)
     plt.tight_layout()
     plt.savefig(output, dpi=150, bbox_inches='tight')
@@ -71,7 +82,7 @@ def generate_area_graph(df, output, days):
     ax.set_title(f'Barometric Pressure Area - Last {days} Days', fontsize=14, fontweight='bold')
     ax.grid(True, alpha=0.3)
     ax.legend()
-    ax.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d %H:%M'))
+    _apply_x_axis_format(ax, days)
     plt.xticks(rotation=45)
     plt.tight_layout()
     plt.savefig(output, dpi=150, bbox_inches='tight')
@@ -160,7 +171,7 @@ def generate_rate_of_change(df, output, days):
     ax.set_ylabel('Pressure Change (hPa/hour)', fontsize=12)
     ax.set_title(f'Rate of Pressure Change - Last {days} Days', fontsize=14, fontweight='bold')
     ax.grid(True, alpha=0.3, axis='y')
-    ax.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d %H:%M'))
+    _apply_x_axis_format(ax, days)
     plt.xticks(rotation=45)
     
     # Legend
@@ -187,8 +198,8 @@ def generate_dashboard(df, output, days):
     ax1.set_title('Pressure Over Time', fontweight='bold')
     ax1.set_ylabel('Pressure (hPa)')
     ax1.grid(True, alpha=0.3)
-    ax1.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d'))
-    
+    ax1.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M' if days == 1 else '%m/%d'))
+
     # 2. Distribution
     ax2 = fig.add_subplot(gs[1, 0])
     ax2.hist(df['pressure_hpa'], bins=20, color='#2E86AB', alpha=0.7, edgecolor='black')
@@ -249,9 +260,9 @@ def generate_dashboard(df, output, days):
 
 def apply_theme(theme: str):
     if theme == "dark":
-        mpl_style(dark=True)
+        mpl_style(dark=True, minor_ticks=False)
     else:
-        mpl_style(dark=False)
+        mpl_style(dark=False, minor_ticks=False)
 
 
 def generate_graph(days=7, output=None, graph_type='line',

{spectrum_barometer-2.2.2 → spectrum_barometer-2.2.5}/barometer_logger.py

@@ -6,6 +6,7 @@ import yaml
 import time
 import re
 import click
+import fcntl
 from io import StringIO
 from datetime import datetime, timedelta
 import os
@@ -88,18 +89,27 @@ class BarometerScraper:
     
     def save_reading(self, pressure):
         # save pressure reading to CSV file
+        # locked so a concurrent scrape and background thread can't interleave writes
         data_file = get_data_dir() / 'readings.csv'
-        
+        timestamp = datetime.now().isoformat()
+
         data = {
-            'timestamp': [datetime.now().isoformat()],
+            'timestamp': [timestamp],
             'pressure_pa': [pressure],
             'pressure_hpa': [pressure / 100]
         }
-        
         df = pandas.DataFrame(data)
-        file_exists = data_file.exists()
-        df.to_csv(data_file, mode='a', header=not file_exists, index=False)
-        
+
+        with open(data_file, 'a', newline='') as f:
+            fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+            try:
+                write_header = f.tell() == 0
+                df.to_csv(f, mode='a', header=write_header, index=False)
+                f.flush()
+                os.fsync(f.fileno())
+            finally:
+                fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+
         return True
 
 
@@ -124,7 +134,7 @@ def cli(ctx, verbose):
 @cli.command()
 def version():
     """Show version information"""
-    click.echo("spectrum-barometer version 2.2.2! (that was fast :3)")
+    click.echo("spectrum-barometer version 2.2.5! (that was fast :3)")
 
 
 @cli.command()

{spectrum_barometer-2.2.2 → spectrum_barometer-2.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spectrum-barometer"
-version = "2.2.2"
+version = "2.2.5"
 description = "Monitor barometric pressure from Spectrum SAX2V1S routers"
 readme = "README.md"
 requires-python = ">=3.8"

{spectrum_barometer-2.2.2 → spectrum_barometer-2.2.5/spectrum_barometer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spectrum-barometer
-Version: 2.2.2
+Version: 2.2.5
 Summary: Monitor barometric pressure from Spectrum SAX2V1S routers
 Author-email: BobaTeagrl <Unsorted2750@proton.me>
 License: MIT

{spectrum_barometer-2.2.2 → spectrum_barometer-2.2.5}/web/routes.py

@@ -24,7 +24,7 @@ def dashboard():
         theme=theme,
         graph_ts=int(time()),
         monitor=monitor_info,
-        can_control_monitor=monitor_info.get('owned_by_me', False) or not monitor_info.get('running', False),
+        can_control_monitor=True, 
         graph_types=['line', 'smooth', 'area', 'daily', 'distribution', 'change', 'dashboard'],
     )
 
@@ -134,18 +134,11 @@ def monitor_start():
 
 @bp.route("/monitor/stop", methods=["POST"])
 def monitor_stop():
-    from barometer.background import is_owned_by_current_process
-    
-    # check if we can stop it
-    if not is_owned_by_current_process():
-        flash("Cannot stop monitoring - it's running in a different process (e.g., CLI). Stop it from where you started it", "error")
-        return redirect(url_for("main.dashboard"))
-    
     result = stop_monitoring()
-    
+
     if result['success']:
         flash(result['message'], "success")
     else:
         flash(result['message'], "error")
-    
+
     return redirect(url_for("main.dashboard"))

{spectrum_barometer-2.2.2 → spectrum_barometer-2.2.5}/web/templates/dashboard.html

@@ -275,7 +275,7 @@
         <nav>
             <a href="{{ url_for('main.dashboard') }}" >Dashboard</a>
             <a href="{{ url_for('main.stats') }}">Statistics</a>
-            <a class="version" href="https://github.com/BobaTeagrl/spectrum-barometer">V 2.2.2 :3</a>
+            <a class="version" href="https://github.com/BobaTeagrl/spectrum-barometer">V 2.2.5 :3</a>
         </nav>
         
         <!-- Flash messages -->

{spectrum_barometer-2.2.2 → spectrum_barometer-2.2.5}/web/templates/stats.html

@@ -69,7 +69,7 @@
         <nav>
             <a href="{{ url_for('main.dashboard') }}">Dashboard</a>
             <a href="{{ url_for('main.stats') }}">Statistics</a>
-            <a class="version" href="https://github.com/BobaTeagrl/spectrum-barometer">V 2.2.2 :3</a>
+            <a class="version" href="https://github.com/BobaTeagrl/spectrum-barometer">V 2.2.5 :3</a>
 
         </nav>