network-check-tool 0.0.1__tar.gz

network_check_tool-0.0.1/LICENSE

@@ -0,0 +1,6 @@
+MIT License
+
+Copyright (c) 2025 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+...

network_check_tool-0.0.1/network_checker/__init__.py

@@ -0,0 +1,3 @@
+"""Network Checker - A network monitoring tool with ping tracking and dashboard visualization."""
+
+__version__ = "0.0.1"

network_check_tool-0.0.1/network_checker/app.py

@@ -0,0 +1,28 @@
+from flask import Flask
+from flask_cors import CORS
+from .models import db
+from .config.config import config
+from .views.dashboard import dashboard_bp
+import os
+
+
+def create_app(config_name=None):
+    """Application factory pattern"""
+    if config_name is None:
+        config_name = os.environ.get('FLASK_ENV', 'development')
+    
+    app = Flask(__name__)
+    app.config.from_object(config[config_name])
+    
+    # Initialize extensions
+    db.init_app(app)
+    CORS(app)
+    
+    # Register blueprints
+    app.register_blueprint(dashboard_bp)
+    
+    # Create database tables
+    with app.app_context():
+        db.create_all()
+    
+    return app

network_check_tool-0.0.1/network_checker/cli.py

@@ -0,0 +1,145 @@
+import click
+import os
+from .app import create_app
+from .services import SchedulerService
+from .config.config import Config
+
+
+@click.group()
+def cli():
+    """Network Checker CLI - Monitor network hosts with ping"""
+    pass
+
+
+@cli.command('run-server')
+@click.option('--host', '-h', default='0.0.0.0', help='Host to bind to')
+@click.option('--port', '-p', default=9991, help='Port to bind to')
+@click.option('--debug', is_flag=True, help='Enable debug mode')
+def run_server(host, port, debug):
+    """Run the Flask web application"""
+    app = create_app('development' if debug else 'production')
+    app.run(host=host, port=port, debug=debug)
+
+
+@cli.command()
+@click.argument('hosts', nargs=-1, required=True)
+@click.option('--interval', '-i', default=60, help='Ping interval in seconds')
+def start_monitoring(hosts, interval):
+    """Start monitoring specified hosts"""
+    app = create_app()
+    
+    with app.app_context():
+        scheduler = SchedulerService()
+        
+        try:
+            scheduler.start()
+            click.echo(f"Starting ping monitoring for: {', '.join(hosts)}")
+            click.echo(f"Ping interval: {interval} seconds")
+            
+            for host in hosts:
+                scheduler.add_ping_job(host, interval)
+                click.echo(f"Added ping job for {host}")
+            
+            click.echo("Monitoring started. Press Ctrl+C to stop.")
+            
+            # Keep the process running
+            import time
+            while True:
+                time.sleep(1)
+                
+        except KeyboardInterrupt:
+            click.echo("\nStopping monitoring...")
+            scheduler.shutdown()
+            click.echo("Monitoring stopped.")
+        except Exception as e:
+            click.echo(f"Error: {e}")
+            scheduler.shutdown()
+
+
+@cli.command()
+@click.argument('host')
+@click.option('--count', '-c', default=4, help='Number of pings to send')
+def ping(host, count):
+    """Send ping to a specific host"""
+    app = create_app()
+    
+    with app.app_context():
+        from .services import PingService
+        ping_service = PingService()
+        
+        click.echo(f"Pinging {host} {count} times...")
+        
+        for i in range(count):
+            result = ping_service.ping_and_save(host)
+            
+            if result.packet_loss:
+                click.echo(f"Ping {i+1}: Request timeout ({result.error_message})")
+            else:
+                click.echo(f"Ping {i+1}: {result.response_time:.2f}ms")
+            
+            if i < count - 1:
+                import time
+                time.sleep(1)
+
+
+@cli.command()
+@click.option('--host', help='Filter by host')
+@click.option('--limit', '-l', default=10, help='Number of recent results to show')
+def status(host, limit):
+    """Show recent ping status"""
+    app = create_app()
+    
+    with app.app_context():
+        from .models import PingResult
+        from sqlalchemy import desc
+        
+        query = PingResult.query
+        
+        if host:
+            query = query.filter(PingResult.target_host == host)
+        
+        results = query.order_by(desc(PingResult.timestamp)).limit(limit).all()
+        
+        if not results:
+            click.echo("No ping results found.")
+            return
+        
+        click.echo(f"Recent ping results{'for ' + host if host else ''}:")
+        click.echo("-" * 70)
+        click.echo(f"{'Host':<20} {'Time':<20} {'Response':<12} {'Status'}")
+        click.echo("-" * 70)
+        
+        for result in results:
+            status_str = "FAIL" if result.packet_loss else "OK"
+            response_str = f"{result.response_time:.2f}ms" if result.response_time else "timeout"
+            time_str = result.timestamp.strftime("%Y-%m-%d %H:%M:%S")
+            
+            click.echo(f"{result.target_host:<20} {time_str:<20} {response_str:<12} {status_str}")
+
+
+@cli.command()
+def init():
+    """Initialize the database"""
+    app = create_app()
+    
+    with app.app_context():
+        from .models import db
+        db.create_all()
+        click.echo("Database initialized successfully.")
+
+
+@cli.command()
+@click.confirmation_option(prompt='Are you sure you want to clear all ping data?')
+def clear():
+    """Clear all ping data from the database"""
+    app = create_app()
+    
+    with app.app_context():
+        from .models import db, PingResult
+        db.session.query(PingResult).delete()
+        db.session.commit()
+        click.echo("All ping data cleared.")
+
+
+if __name__ == '__main__':
+    cli()

network_check_tool-0.0.1/network_checker/config/config.py

@@ -0,0 +1,42 @@
+import os
+from pathlib import Path
+
+class Config:
+    SECRET_KEY = os.environ.get('SECRET_KEY') or 'dev-secret-key'
+    
+    # Database configuration
+    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or 'sqlite:///network_checker.db'
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
+    
+    # Ping configuration
+    PING_TIMEOUT = float(os.environ.get('PING_TIMEOUT', '4.0'))
+    DEFAULT_PING_INTERVAL = int(os.environ.get('DEFAULT_PING_INTERVAL', '60'))
+    
+    # Default hosts to monitor
+    DEFAULT_HOSTS = os.environ.get('DEFAULT_HOSTS', 'google.com,cloudflare.com').split(',')
+    
+    # Application directory
+    APP_DIR = Path(__file__).parent.parent
+    INSTANCE_PATH = APP_DIR.parent / 'instance'
+    
+    @staticmethod
+    def init_app(app):
+        """Initialize application with configuration"""
+        # Ensure instance directory exists
+        Config.INSTANCE_PATH.mkdir(exist_ok=True)
+
+
+class DevelopmentConfig(Config):
+    DEBUG = True
+    SQLALCHEMY_ECHO = True
+
+
+class ProductionConfig(Config):
+    DEBUG = False
+
+
+config = {
+    'development': DevelopmentConfig,
+    'production': ProductionConfig,
+    'default': DevelopmentConfig
+}

network_check_tool-0.0.1/network_checker/models/__init__.py

@@ -0,0 +1,3 @@
+from .ping_result import db, PingResult
+
+__all__ = ['db', 'PingResult']

network_check_tool-0.0.1/network_checker/models/ping_result.py

@@ -0,0 +1,28 @@
+from datetime import datetime
+from flask_sqlalchemy import SQLAlchemy
+
+db = SQLAlchemy()
+
+
+class PingResult(db.Model):
+    __tablename__ = 'ping_results'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    target_host = db.Column(db.String(255), nullable=False, index=True)
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow, nullable=False, index=True)
+    response_time = db.Column(db.Float, nullable=True)
+    packet_loss = db.Column(db.Boolean, default=False, nullable=False)
+    error_message = db.Column(db.Text, nullable=True)
+    
+    def __repr__(self):
+        return f'<PingResult {self.target_host} at {self.timestamp}>'
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'target_host': self.target_host,
+            'timestamp': self.timestamp.isoformat(),
+            'response_time': self.response_time,
+            'packet_loss': self.packet_loss,
+            'error_message': self.error_message
+        }

network_check_tool-0.0.1/network_checker/services/__init__.py

@@ -0,0 +1,4 @@
+from .ping_service import PingService
+from .scheduler_service import SchedulerService
+
+__all__ = ['PingService', 'SchedulerService']

network_check_tool-0.0.1/network_checker/services/ping_service.py

@@ -0,0 +1,57 @@
+import ping3
+from datetime import datetime
+from typing import Dict, Optional
+from ..models import db, PingResult
+
+
+class PingService:
+    def __init__(self, timeout: float = 4.0):
+        self.timeout = timeout
+        ping3.EXCEPTIONS = True
+    
+    def ping_host(self, host: str) -> Dict:
+        try:
+            response_time = ping3.ping(host, timeout=self.timeout)
+            
+            if response_time is None:
+                return {
+                    'host': host,
+                    'timestamp': datetime.utcnow(),
+                    'response_time': None,
+                    'packet_loss': True,
+                    'error_message': 'Request timeout'
+                }
+            else:
+                return {
+                    'host': host,
+                    'timestamp': datetime.utcnow(),
+                    'response_time': response_time * 1000,  # Convert to milliseconds
+                    'packet_loss': False,
+                    'error_message': None
+                }
+                
+        except Exception as e:
+            return {
+                'host': host,
+                'timestamp': datetime.utcnow(),
+                'response_time': None,
+                'packet_loss': True,
+                'error_message': str(e)
+            }
+    
+    def save_ping_result(self, result: Dict) -> PingResult:
+        ping_result = PingResult(
+            target_host=result['host'],
+            timestamp=result['timestamp'],
+            response_time=result['response_time'],
+            packet_loss=result['packet_loss'],
+            error_message=result['error_message']
+        )
+        
+        db.session.add(ping_result)
+        db.session.commit()
+        return ping_result
+    
+    def ping_and_save(self, host: str) -> PingResult:
+        result = self.ping_host(host)
+        return self.save_ping_result(result)

network_check_tool-0.0.1/network_checker/services/scheduler_service.py

@@ -0,0 +1,94 @@
+from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
+from apscheduler.executors.pool import ThreadPoolExecutor
+from typing import List, Optional
+import logging
+from .ping_service import PingService
+
+
+class SchedulerService:
+    def __init__(self, database_url: str = 'sqlite:///network_checker.db'):
+        jobstores = {
+            'default': SQLAlchemyJobStore(url=database_url)
+        }
+        
+        executors = {
+            'default': ThreadPoolExecutor(20)
+        }
+        
+        job_defaults = {
+            'coalesce': False,
+            'max_instances': 3
+        }
+        
+        self.scheduler = BackgroundScheduler(
+            jobstores=jobstores,
+            executors=executors,
+            job_defaults=job_defaults
+        )
+        
+        self.ping_service = PingService()
+        self.is_running = False
+        
+        # Configure logging
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+    
+    def start(self):
+        if not self.is_running:
+            self.scheduler.start()
+            self.is_running = True
+            self.logger.info("Scheduler started")
+    
+    def shutdown(self):
+        if self.is_running:
+            self.scheduler.shutdown()
+            self.is_running = False
+            self.logger.info("Scheduler stopped")
+    
+    def add_ping_job(self, host: str, interval: int = 60, job_id: Optional[str] = None):
+        if job_id is None:
+            job_id = f"ping_{host}"
+        
+        self.scheduler.add_job(
+            func=self._ping_job,
+            trigger='interval',
+            seconds=interval,
+            id=job_id,
+            args=[host],
+            replace_existing=True
+        )
+        
+        self.logger.info(f"Added ping job for {host} with {interval}s interval")
+    
+    def remove_ping_job(self, job_id: str):
+        try:
+            self.scheduler.remove_job(job_id)
+            self.logger.info(f"Removed ping job: {job_id}")
+        except Exception as e:
+            self.logger.error(f"Failed to remove job {job_id}: {e}")
+    
+    def add_multiple_ping_jobs(self, hosts: List[str], interval: int = 60):
+        for host in hosts:
+            self.add_ping_job(host, interval)
+    
+    def list_jobs(self):
+        return self.scheduler.get_jobs()
+    
+    def _ping_job(self, host: str):
+        try:
+            result = self.ping_service.ping_and_save(host)
+            self.logger.debug(f"Ping result for {host}: {result.response_time}ms, packet_loss: {result.packet_loss}")
+        except Exception as e:
+            self.logger.error(f"Error pinging {host}: {e}")
+    
+    def get_job_status(self, job_id: str):
+        job = self.scheduler.get_job(job_id)
+        if job:
+            return {
+                'id': job.id,
+                'name': str(job.func),
+                'next_run_time': job.next_run_time.isoformat() if job.next_run_time else None,
+                'trigger': str(job.trigger)
+            }
+        return None

network_check_tool-0.0.1/network_checker/templates/dashboard.html

@@ -0,0 +1,276 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Network Checker Dashboard</title>
+    <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            margin: 0;
+            padding: 20px;
+            background-color: #f5f5f5;
+        }
+        
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        
+        .header {
+            background: white;
+            padding: 20px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            margin-bottom: 20px;
+        }
+        
+        .controls {
+            display: flex;
+            gap: 15px;
+            margin-bottom: 20px;
+            align-items: center;
+        }
+        
+        select, button {
+            padding: 8px 12px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            font-size: 14px;
+        }
+        
+        button {
+            background-color: #007bff;
+            color: white;
+            border: none;
+            cursor: pointer;
+        }
+        
+        button:hover {
+            background-color: #0056b3;
+        }
+        
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+            margin-bottom: 20px;
+        }
+        
+        .stat-card {
+            background: white;
+            padding: 20px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            text-align: center;
+        }
+        
+        .stat-value {
+            font-size: 2em;
+            font-weight: bold;
+            color: #007bff;
+        }
+        
+        .stat-label {
+            color: #666;
+            margin-top: 5px;
+        }
+        
+        .chart-container {
+            background: white;
+            padding: 20px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            margin-bottom: 20px;
+        }
+        
+        .loading {
+            text-align: center;
+            padding: 50px;
+            color: #666;
+        }
+        
+        .error {
+            background-color: #f8d7da;
+            color: #721c24;
+            padding: 15px;
+            border-radius: 4px;
+            margin-bottom: 20px;
+        }
+        
+        .success {
+            background-color: #d4edda;
+            color: #155724;
+            padding: 15px;
+            border-radius: 4px;
+            margin-bottom: 20px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>Network Checker Dashboard</h1>
+            <p>Monitor ping responses and packet loss for your network hosts</p>
+        </div>
+        
+        <div class="controls">
+            <label for="hostSelect">Host:</label>
+            <select id="hostSelect">
+                <option value="">Select a host...</option>
+            </select>
+            
+            <label for="timeRange">Time Range:</label>
+            <select id="timeRange">
+                <option value="1">Last 1 hour</option>
+                <option value="6">Last 6 hours</option>
+                <option value="24" selected>Last 24 hours</option>
+                <option value="72">Last 3 days</option>
+                <option value="168">Last week</option>
+            </select>
+            
+            <button onclick="refreshData()">Refresh</button>
+        </div>
+        
+        <div id="statsContainer" class="stats-grid" style="display: none;">
+            <div class="stat-card">
+                <div class="stat-value" id="totalPings">-</div>
+                <div class="stat-label">Total Pings</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="successRate">-</div>
+                <div class="stat-label">Success Rate</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="avgResponseTime">-</div>
+                <div class="stat-label">Avg Response Time</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="packetLossRate">-</div>
+                <div class="stat-label">Packet Loss Rate</div>
+            </div>
+        </div>
+        
+        <div class="chart-container">
+            <div id="chartContainer">
+                <div class="loading">
+                    Select a host to view ping data
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let currentHost = '';
+        let currentTimeRange = 24;
+        
+        // Load hosts on page load
+        loadHosts();
+        
+        // Event listeners
+        document.getElementById('hostSelect').addEventListener('change', function() {
+            currentHost = this.value;
+            if (currentHost) {
+                loadData();
+            } else {
+                document.getElementById('statsContainer').style.display = 'none';
+                document.getElementById('chartContainer').innerHTML = '<div class="loading">Select a host to view ping data</div>';
+            }
+        });
+        
+        document.getElementById('timeRange').addEventListener('change', function() {
+            currentTimeRange = parseInt(this.value);
+            if (currentHost) {
+                loadData();
+            }
+        });
+        
+        function loadHosts() {
+            fetch('/api/hosts')
+                .then(response => response.json())
+                .then(data => {
+                    const select = document.getElementById('hostSelect');
+                    select.innerHTML = '<option value="">Select a host...</option>';
+                    
+                    data.forEach(host => {
+                        const option = document.createElement('option');
+                        option.value = host;
+                        option.textContent = host;
+                        select.appendChild(option);
+                    });
+                })
+                .catch(error => {
+                    console.error('Error loading hosts:', error);
+                    showError('Failed to load hosts');
+                });
+        }
+        
+        function loadData() {
+            if (!currentHost) return;
+            
+            document.getElementById('chartContainer').innerHTML = '<div class="loading">Loading...</div>';
+            
+            // Load statistics
+            fetch(`/api/stats?host=${currentHost}&hours=${currentTimeRange}`)
+                .then(response => response.json())
+                .then(data => {
+                    updateStats(data);
+                })
+                .catch(error => {
+                    console.error('Error loading stats:', error);
+                });
+            
+            // Load chart
+            fetch(`/api/ping_chart?host=${currentHost}&hours=${currentTimeRange}`)
+                .then(response => response.json())
+                .then(data => {
+                    if (data.error) {
+                        document.getElementById('chartContainer').innerHTML = `<div class="error">${data.error}</div>`;
+                    } else {
+                        Plotly.newPlot('chartContainer', data.data, data.layout, {responsive: true});
+                    }
+                })
+                .catch(error => {
+                    console.error('Error loading chart:', error);
+                    document.getElementById('chartContainer').innerHTML = '<div class="error">Failed to load chart data</div>';
+                });
+        }
+        
+        function updateStats(data) {
+            document.getElementById('totalPings').textContent = data.total_pings;
+            document.getElementById('successRate').textContent = `${(100 - data.packet_loss_rate).toFixed(1)}%`;
+            document.getElementById('avgResponseTime').textContent = `${data.avg_response_time.toFixed(1)}ms`;
+            document.getElementById('packetLossRate').textContent = `${data.packet_loss_rate.toFixed(1)}%`;
+            
+            document.getElementById('statsContainer').style.display = 'grid';
+        }
+        
+        function refreshData() {
+            if (currentHost) {
+                loadData();
+            }
+            loadHosts();
+        }
+        
+        function showError(message) {
+            const container = document.querySelector('.container');
+            const errorDiv = document.createElement('div');
+            errorDiv.className = 'error';
+            errorDiv.textContent = message;
+            container.insertBefore(errorDiv, container.firstChild.nextSibling);
+            
+            setTimeout(() => {
+                errorDiv.remove();
+            }, 5000);
+        }
+        
+        // Auto-refresh every 30 seconds if a host is selected
+        setInterval(() => {
+            if (currentHost) {
+                loadData();
+            }
+        }, 30000);
+    </script>
+</body>
+</html>

network_check_tool-0.0.1/network_checker/views/__init__.py

@@ -0,0 +1,3 @@
+from .dashboard import dashboard_bp
+
+__all__ = ['dashboard_bp']

network_check_tool-0.0.1/network_checker/views/dashboard.py

@@ -0,0 +1,174 @@
+from flask import Blueprint, render_template, jsonify, request
+from datetime import datetime, timedelta
+from sqlalchemy import desc, func
+import plotly.graph_objects as go
+import plotly.utils
+import json
+from ..models import db, PingResult
+
+dashboard_bp = Blueprint('dashboard', __name__, url_prefix='/')
+
+
+@dashboard_bp.route('/')
+def index():
+    """Main dashboard page"""
+    return render_template('dashboard.html')
+
+
+@dashboard_bp.route('/api/hosts')
+def get_hosts():
+    """Get list of monitored hosts"""
+    hosts = db.session.query(PingResult.target_host).distinct().all()
+    return jsonify([host[0] for host in hosts])
+
+
+@dashboard_bp.route('/api/ping_data')
+def get_ping_data():
+    """Get ping data for visualization"""
+    host = request.args.get('host')
+    hours = int(request.args.get('hours', 24))
+    
+    if not host:
+        return jsonify({'error': 'Host parameter is required'}), 400
+    
+    # Get data for the specified time range
+    since = datetime.utcnow() - timedelta(hours=hours)
+    
+    results = db.session.query(PingResult).filter(
+        PingResult.target_host == host,
+        PingResult.timestamp >= since
+    ).order_by(PingResult.timestamp).all()
+    
+    if not results:
+        return jsonify({'error': 'No data found for the specified host'}), 404
+    
+    # Prepare data for plotting
+    timestamps = []
+    response_times = []
+    packet_losses = []
+    
+    for result in results:
+        timestamps.append(result.timestamp.isoformat())
+        response_times.append(result.response_time if not result.packet_loss else None)
+        packet_losses.append(1 if result.packet_loss else 0)
+    
+    return jsonify({
+        'host': host,
+        'timestamps': timestamps,
+        'response_times': response_times,
+        'packet_losses': packet_losses,
+        'total_pings': len(results),
+        'successful_pings': sum(1 for r in results if not r.packet_loss),
+        'packet_loss_rate': (sum(packet_losses) / len(packet_losses)) * 100 if packet_losses else 0
+    })
+
+
+@dashboard_bp.route('/api/ping_chart')
+def get_ping_chart():
+    """Generate Plotly chart for ping data"""
+    host = request.args.get('host')
+    hours = int(request.args.get('hours', 24))
+    
+    if not host:
+        return jsonify({'error': 'Host parameter is required'}), 400
+    
+    since = datetime.utcnow() - timedelta(hours=hours)
+    
+    results = db.session.query(PingResult).filter(
+        PingResult.target_host == host,
+        PingResult.timestamp >= since
+    ).order_by(PingResult.timestamp).all()
+    
+    if not results:
+        return jsonify({'error': 'No data found'}), 404
+    
+    # Separate successful pings and packet losses
+    successful_times = []
+    successful_response_times = []
+    failed_times = []
+    
+    for result in results:
+        if result.packet_loss:
+            failed_times.append(result.timestamp)
+        else:
+            successful_times.append(result.timestamp)
+            successful_response_times.append(result.response_time)
+    
+    # Create plotly figure
+    fig = go.Figure()
+    
+    # Add successful pings
+    if successful_times:
+        fig.add_trace(go.Scatter(
+            x=successful_times,
+            y=successful_response_times,
+            mode='lines+markers',
+            name='Response Time (ms)',
+            line=dict(color='green'),
+            marker=dict(size=4)
+        ))
+    
+    # Add packet loss markers
+    if failed_times:
+        fig.add_trace(go.Scatter(
+            x=failed_times,
+            y=[max(successful_response_times) * 1.1] * len(failed_times) if successful_response_times else [100] * len(failed_times),
+            mode='markers',
+            name='Packet Loss',
+            marker=dict(color='red', symbol='x', size=8)
+        ))
+    
+    fig.update_layout(
+        title=f'Ping Results for {host} (Last {hours} hours)',
+        xaxis_title='Time',
+        yaxis_title='Response Time (ms)',
+        template='plotly_white',
+        hovermode='x unified'
+    )
+    
+    return jsonify(json.loads(plotly.utils.PlotlyJSONEncoder().encode(fig)))
+
+
+@dashboard_bp.route('/api/stats')
+def get_stats():
+    """Get overall statistics"""
+    host = request.args.get('host')
+    hours = int(request.args.get('hours', 24))
+    
+    since = datetime.utcnow() - timedelta(hours=hours)
+    
+    if host:
+        query = db.session.query(PingResult).filter(
+            PingResult.target_host == host,
+            PingResult.timestamp >= since
+        )
+    else:
+        query = db.session.query(PingResult).filter(
+            PingResult.timestamp >= since
+        )
+    
+    results = query.all()
+    
+    if not results:
+        return jsonify({
+            'total_pings': 0,
+            'successful_pings': 0,
+            'failed_pings': 0,
+            'packet_loss_rate': 0,
+            'avg_response_time': 0,
+            'min_response_time': 0,
+            'max_response_time': 0
+        })
+    
+    successful = [r for r in results if not r.packet_loss and r.response_time is not None]
+    successful_response_times = [r.response_time for r in successful]
+    
+    return jsonify({
+        'total_pings': len(results),
+        'successful_pings': len(successful),
+        'failed_pings': len(results) - len(successful),
+        'packet_loss_rate': ((len(results) - len(successful)) / len(results)) * 100,
+        'avg_response_time': sum(successful_response_times) / len(successful_response_times) if successful_response_times else 0,
+        'min_response_time': min(successful_response_times) if successful_response_times else 0,
+        'max_response_time': max(successful_response_times) if successful_response_times else 0
+    })

network_check_tool-0.0.1/pyproject.toml

@@ -0,0 +1,47 @@
+[tool.poetry]
+name = "network-check-tool"
+version = "0.0.1"
+description = "A network monitoring tool with ping tracking and dashboard visualization"
+authors = ["hardwork9047 <tomatosimple1104@gmail.com>"]
+readme = "README.md"
+license = "MIT"
+homepage = "https://github.com/hardwork9047/network-checker"
+repository = "https://github.com/hardwork9047/network-checker"
+documentation = "https://github.com/hardwork9047/network-checker"
+packages = [{ include = "network_checker" }]
+
+include = [
+    "network_checker/config/config.py",
+    "network_checker/templates/*",
+    "network_checker/static/*",
+    "network_checker/cli.py"
+]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+flask = "^3.1.0"
+flask-sqlalchemy = "^3.1.1"
+pandas = "^2.2.3"
+flask-cors = "^4.0.0"
+click = "^8.1.3"
+ping3 = "^4.0.4"
+apscheduler = "^3.10.4"
+plotly = "^5.17.0"
+toml = "^0.10.2"
+
+[tool.poetry.scripts]
+network-checker = "network_checker.cli:cli"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.4"
+black = "^24.0.0"
+
+[tool.black]
+line-length = 88
+target-version = ['py310']
+include = '\.pyi?$'
+skip-string-normalization = false
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"