calibrate-suite 0.1.0__py3-none-any.whl

calibrate_suite-0.1.0.dist-info/RECORD

@@ -0,0 +1,47 @@
+calibrate_suite-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet_server/__init__.py,sha256=Jf0LmjLdSxA38SIb-lY0nIdeW66QK_FsMxbh-ZqqGx4,870
+fleet_server/app.py,sha256=qzc0ycWyFTjvi_DppD_TqGeO3vxJT6tv2EEUDiSJL7I,13307
+fleet_server/config.py,sha256=aMrHL_z6YuVharn9OLejgKgldxe8wRh8t5NKIrsDMa4,2737
+fleet_server/utils.py,sha256=IoE40x__8T8cGm7uOwDE_lysbtE53WU_uJI9Ip0ZRlA,4680
+fleet_server/templates/error.html,sha256=ZlZD0zy_c2XdgcWnJEFPQIJBqgscj-KUEXnhvDFcx_U,1570
+fleet_server/templates/index.html,sha256=YpAqEIQfWN46DP8N5mawyzRiypk56vIpExq9_Xmsmc0,3373
+fleet_server/templates/viewer.html,sha256=2veSnySQiw6w8O7j0rIwSe4j2ANDCsctaaUXyMige9g,16620
+gui/__init__.py,sha256=NQP_dgQPkLbTEhfhg02dSnsEhav5nS5_BN6CUeNjG1Y,71
+gui/main.py,sha256=aiVmi8WUiErp75DxEk26lcIsCGETW8bDmDl1bGTaE6Y,492
+gui/assets/2d-or-3d-fleet-upload.png,sha256=oYGgiSd2sI3yliMyHNYjkkhmpL8K3fTnHPCArszqi-E,41886
+gui/assets/2d_3d_overlay_output.jpg,sha256=UX77BHFz76YG32E6Ondgstkv6qyNE9m2Tv6MrhK2oBg,801670
+gui/assets/3d-or-2d-overlay_page.png,sha256=s59mEWhtqlXg04p4vmVQbMR0g20AXAZ2_nXYP_21KrI,62965
+gui/assets/3d-or-2d-record-page.png,sha256=Lsbi0XjJgVDJeKZfSqzWKS90K-xsLzd_DGdaCRNDXVg,71243
+gui/assets/3d_3d_overlay_output.png,sha256=kA20FdLb7H_AZW0iPPQ7KWHIdpYQ9ku8UsaQOau7NBY,143166
+gui/assets/3d_or_2d_calibrate-page.png,sha256=MmzOANq-ny9WwLH26tXNdqdQw22HyLZmyYw5Wd0SIQE,91215
+gui/assets/GUI_homepage.png,sha256=-Ev-hZ7l2zaOslxL-x3lpWLfBOxybJaHtFSt0C4VWQ4,74582
+gui/assets/hardware_setup.jpeg,sha256=IrcbI8ADXQO_yiUtembTqP0uBbkQS89P1JLhxnXQNxY,77890
+gui/assets/single_lidar_calibrate_page.png,sha256=wAJ2_l0Hqf_Tq5wTlk6j1ev6VYDk7VkKFp9Xkfna3PM,45377
+gui/assets/single_lidar_output.png,sha256=L6nwvXaS2noNq4W13ZG65miI_AG1I8EuY2sDMy7t7gQ,56091
+gui/assets/single_lidar_record_page.png,sha256=OwZAuXOoiE443kZkopZOxhehvDwTjej85xgkJ9xX1tM,60437
+gui/assets/virya.jpg,sha256=F4VdYXoMO8F80jc32n-tgWQwJTCEGjtd7vgya18Diag,23752
+gui/widgets/calibrator_widget.py,sha256=wS5Bo6VIJBOXj-mi1vB8tO9zKocieQd08TdL_Lejn7U,40732
+gui/widgets/extractor_widget.py,sha256=ztlGSIzUsMKlqSXSjdVvDxpsUsrm7Z0FylgVAXjpvWs,22146
+gui/widgets/home_widget.py,sha256=XRDCcAZNqFfS41aCkotT-hET9n4IR0TtGV7qhMQkR88,4305
+gui/widgets/recorder_widget.py,sha256=5DBI7rrDTSQrBJ4Bp_iFvdv0rNmKvBPLNW_WeVDapA0,4612
+gui/widgets/single_lidar_widget.py,sha256=AtM5cKzXglNZjFUdksVwQVYpFvlqwFbAe9xZwrvqupI,25731
+gui/widgets/three_d_calib_widget.py,sha256=_WskIWSl3hYbaCbkzYwNI3GVoqHTNXyqASASimzHPx0,3213
+gui/widgets/two_d_calib_widget.py,sha256=3l6BHhDLO4ETTSMVdKwL4rWMsluKBlHPsngSsoInOVA,3104
+gui/widgets/uploader_widget.py,sha256=udzqiS8bPJy_6li8zV8a6-QbyBfkEFi5CB9g1wgsqdw,5395
+gui/widgets/validator_widget.py,sha256=lS4EI-9hWZwOJwX1d0EtgsGioPRvdbmtBSeCLukcdTw,24655
+gui/windows/main_window.py,sha256=6OstmZfWjQzBgnHyCTJc3LzEymgTQpWrapx2cjORHmY,1982
+gui/windows/main_window_ui.py,sha256=4yVIRJ6KIDwxeP0kvy_IkoI29cIBp2LSUarr7AZuEH4,1627
+rviz_configs/2D-3D.rviz,sha256=QfBz1jXWHeZH93HYoq2Ee_tXFS6QC1DIO2rexUB6Wgk,6143
+rviz_configs/3D-3D.rviz,sha256=p4EA2kVYB-FNCRapjBjkIIn_uv6Ysznfj9aW1SMQ6es,6094
+rviz_configs/default_calib.rviz,sha256=nYIH16YlNcbQhAXPBfQbsQ5AXkNT7BXTWfdxwkvOJgo,5610
+utils/__init__.py,sha256=jGrHBgfZKHPs8RloUjIW-f7LAH_n6uGKfCaDnjcz7Yk,376
+utils/calibration_common.py,sha256=M6IAyi97tPpQk320aoPruGffa7dAO679RWax5tVQoL4,606
+utils/cli_calibrate.py,sha256=F1l-JLTOs39JHm-sTLWcUwcjKerZGpXjEXm8USFt9QY,1267
+utils/cli_fleet_server.py,sha256=OvkCo-ClGlwNKDJTfH5InLm0NWjxWSiSf-yAZnl2QVk,1700
+utils/data_extractor_common.py,sha256=3DsIwFd35dfl8ZoKfsm5VA-gZmveySmBUkiErXbCN18,2611
+utils/gui_helpers.py,sha256=hgj5AG0oH2dZMnclwzazFQlwebpBPW0JjNM_AHb9hko,723
+calibrate_suite-0.1.0.dist-info/METADATA,sha256=Y_mxIIZjcbnkocqexaznleEvkwGNmkWcQK_fQdqkFHk,25332
+calibrate_suite-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+calibrate_suite-0.1.0.dist-info/entry_points.txt,sha256=huEnH7M9a_ycUhzZ3FnXR0rw8iRsr3jj71TTSd4Srl8,104
+calibrate_suite-0.1.0.dist-info/top_level.txt,sha256=SCAdU5VbFfkNGQO4zgAwM2qsZnWr0I_8k3F70Ch0EcQ,36
+calibrate_suite-0.1.0.dist-info/RECORD,,

calibrate_suite-0.1.0.dist-info/WHEEL

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

calibrate_suite-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+calibrate-suite = utils.cli_calibrate:main
+fleet-server = utils.cli_fleet_server:main

calibrate_suite-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

calibrate_suite-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+fleet_server
+gui
+rviz_configs
+utils

fleet_server/__init__.py

@@ -0,0 +1,32 @@
+"""
+Fleet Server - REST API for Calibration Management
+
+Provides web dashboard and REST API for managing robot calibration results.
+"""
+
+__version__ = "0.1.0"
+
+def create_app(debug=False, env_file=None):
+   
+    import os
+    from pathlib import Path
+    from flask import Flask
+    
+    # Load environment configuration if specified
+    if env_file and os.path.exists(env_file):
+        from dotenv import load_dotenv
+        load_dotenv(env_file)
+    
+    # Import app from main module (when installed via pip/setup.py)
+    try:
+        # When installed as package
+        from fleet_server.app import app as flask_app
+    except ImportError:
+        # Fallback for development (src in path)
+        from .app import app as flask_app
+    
+    if debug:
+        flask_app.config['DEBUG'] = True
+        flask_app.config['ENV'] = 'development'
+    
+    return flask_app

fleet_server/app.py

@@ -0,0 +1,377 @@
+"""Fleet Server - Calibration Artifact Management
+
+REST API server for managing robot calibration results across a fleet.
+Handles upload, storage, retrieval, and visualization of calibration data.
+"""
+
+import os
+import datetime
+import json
+from pathlib import Path
+from flask import Flask, request, jsonify, render_template, send_from_directory, abort
+import sqlite3
+
+from .config import get_config, Config
+
+# Initialize configuration and directories BEFORE importing utils
+config = get_config()
+config.ensure_directories()
+
+# Now safe to import utils (which uses logging)
+from .utils import logger, sanitize_filename, validate_upload, get_safe_path, format_filesize
+
+# Create Flask app
+app = Flask(__name__, template_folder='templates')
+
+DB_PATH = config.DATABASE_PATH
+UPLOAD_FOLDER = config.UPLOAD_FOLDER
+MAX_UPLOAD_SIZE = config.MAX_UPLOAD_SIZE
+
+logger.info(f"Fleet Server starting in {config.FLASK_ENV} mode")
+logger.info(f"Database: {DB_PATH}")
+logger.info(f"Upload folder: {UPLOAD_FOLDER}")
+
+def init_db():
+    """Initialize SQLite database with required schema"""
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        c = conn.cursor()
+        
+        # Robots Table
+        c.execute('''CREATE TABLE IF NOT EXISTS robots
+                     (id TEXT PRIMARY KEY, 
+                      name TEXT, 
+                      model TEXT, 
+                      last_calib_date TEXT,
+                      status TEXT DEFAULT 'active')''')
+        
+        # Calibrations Table with more metadata
+        c.execute('''CREATE TABLE IF NOT EXISTS calibrations
+                     (id INTEGER PRIMARY KEY AUTOINCREMENT, 
+                      robot_id TEXT, 
+                      timestamp TEXT, 
+                      artifacts_path TEXT,
+                      file_size INTEGER,
+                      score REAL,
+                      notes TEXT,
+                      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                      FOREIGN KEY(robot_id) REFERENCES robots(id))''')
+        
+        # Create indices for faster queries
+        c.execute('''CREATE INDEX IF NOT EXISTS idx_robot_id 
+                     ON calibrations(robot_id)''')
+        c.execute('''CREATE INDEX IF NOT EXISTS idx_timestamp 
+                     ON calibrations(timestamp)''')
+        
+        conn.commit()
+        conn.close()
+        logger.info("Database initialized successfully")
+    except Exception as e:
+        logger.error(f"Database initialization failed: {e}")
+        raise
+
+# Initialize database on startup
+init_db()
+
+@app.template_filter('basename')
+def basename_filter(s):
+    """Jinja2 filter to get basename of path"""
+    return os.path.basename(s)
+
+@app.template_filter('filesize')
+def filesize_filter(size_bytes):
+    """Jinja2 filter to format file size"""
+    return format_filesize(size_bytes)
+
+@app.template_filter('format_timestamp')
+def format_timestamp_filter(timestamp_str):
+    """Jinja2 filter to format timestamp from YYYYMMDD_HHMMSS to readable format"""
+    if not timestamp_str:
+        return 'Unknown'
+    try:
+        # Parse from YYYYMMDD_HHMMSS format
+        dt = datetime.datetime.strptime(timestamp_str, '%Y%m%d_%H%M%S')
+        # Return in readable format: YYYY-MM-DD HH:MM:SS
+        return dt.strftime('%Y-%m-%d %H:%M:%S')
+    except (ValueError, TypeError):
+        return timestamp_str
+
+@app.before_request
+def log_request():
+    """Log incoming requests"""
+    logger.debug(f"{request.method} {request.path}")
+
+@app.after_request
+def log_response(response):
+    """Log outgoing responses"""
+    logger.debug(f"Response: {response.status_code}")
+    return response
+
+# ============================================================================
+# ROUTES
+# ============================================================================
+
+@app.route('/')
+def index():
+    """Dashboard showing robots and recent calibrations"""
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        conn.row_factory = sqlite3.Row
+        c = conn.cursor()
+        
+        c.execute("SELECT * FROM robots ORDER BY last_calib_date DESC")
+        robots = c.fetchall()
+        
+        c.execute("""SELECT * FROM calibrations 
+                     ORDER BY timestamp DESC LIMIT 20""")
+        recent = c.fetchall()
+        
+        conn.close()
+        logger.info(f"Dashboard accessed: {len(robots)} robots, {len(recent)} recent calibrations")
+        return render_template('index.html', robots=robots, recent=recent)
+    
+    except Exception as e:
+        logger.error(f"Dashboard error: {e}")
+        return render_template('error.html', error=str(e)), 500
+
+@app.route('/api/robots', methods=['GET'])
+def get_robots():
+    """API endpoint: Get all robots"""
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        conn.row_factory = sqlite3.Row
+        c = conn.cursor()
+        c.execute("SELECT * FROM robots ORDER BY last_calib_date DESC")
+        robots = [dict(row) for row in c.fetchall()]
+        conn.close()
+        
+        return jsonify({'status': 'success', 'robots': robots}), 200
+    except Exception as e:
+        logger.error(f"Get robots error: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/files/<path:filename>')
+def serve_file(filename):
+    """Serve uploaded calibration files with security checks"""
+    try:
+        # Sanitize filename and check path
+        safe_filename = sanitize_filename(filename)
+        safe_path = get_safe_path(UPLOAD_FOLDER, safe_filename)
+        
+        if safe_path is None:
+            logger.warning(f"Attempted unsafe file access: {filename}")
+            abort(403)
+        
+        if not os.path.exists(safe_path):
+            logger.warning(f"File not found: {safe_path}")
+            abort(404)
+        
+        logger.info(f"Serving file: {safe_filename}")
+        return send_from_directory(UPLOAD_FOLDER, safe_filename)
+    
+    except Exception as e:
+        logger.error(f"File serve error: {e}")
+        abort(500)
+
+@app.route('/view/<int:calib_id>')
+def view_calibration(calib_id):
+    """View 3D visualization of calibration result"""
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        conn.row_factory = sqlite3.Row
+        c = conn.cursor()
+        
+        c.execute("SELECT * FROM calibrations WHERE id = ?", (calib_id,))
+        calib = c.fetchone()
+        conn.close()
+        
+        if calib:
+            filename = os.path.basename(calib['artifacts_path'])
+            file_url = f"/files/{filename}"
+            logger.info(f"Viewing calibration {calib_id}")
+            return render_template('viewer.html', file_url=file_url, calib=calib)
+        else:
+            logger.warning(f"Calibration not found: {calib_id}")
+            abort(404)
+    
+    except Exception as e:
+        logger.error(f"View calibration error: {e}")
+        abort(500)
+
+@app.route('/api/upload', methods=['POST'])
+def upload_calibration():
+    """Upload calibration artifacts and metadata"""
+    try:
+        # Validate request
+        if 'artifacts' not in request.files:
+            logger.warning("Upload: No file part in request")
+            return jsonify({'error': 'No file part'}), 400
+        
+        file = request.files['artifacts']
+        if file.filename == '':
+            logger.warning("Upload: Empty filename")
+            return jsonify({'error': 'No selected file'}), 400
+        
+        # Parse metadata
+        meta_str = request.form.get('metadata', '{}')
+        try:
+            metadata = json.loads(meta_str)
+        except json.JSONDecodeError:
+            logger.warning("Upload: Invalid JSON metadata")
+            return jsonify({'error': 'Invalid metadata JSON'}), 400
+        
+        robot_id = metadata.get('robot_id', 'unknown')
+        score = float(metadata.get('score', 0.0))
+        notes = metadata.get('notes', '')
+        
+        # Validate upload
+        is_valid, error_msg = validate_upload(file, file.filename)
+        if not is_valid:
+            logger.warning(f"Upload validation failed for {robot_id}: {error_msg}")
+            return jsonify({'error': error_msg}), 400
+        
+        # Sanitize filename
+        original_filename = file.filename
+        filename = sanitize_filename(original_filename)
+        if not filename:
+            logger.warning(f"Upload: Could not sanitize filename {original_filename}")
+            return jsonify({'error': 'Invalid filename'}), 400
+        
+        # Generate unique filename
+        ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        final_filename = f"{robot_id}_{ts}_{filename}"
+        filepath = os.path.join(UPLOAD_FOLDER, final_filename)
+        
+        # Save file
+        file.save(filepath)
+        file_size = os.path.getsize(filepath)
+        
+        # Update database
+        conn = sqlite3.connect(DB_PATH)
+        c = conn.cursor()
+        
+        try:
+            # Upsert Robot
+            c.execute("""INSERT OR REPLACE INTO robots 
+                         (id, name, model, last_calib_date, status) 
+                         VALUES (?, ?, ?, ?, 'active')""",
+                      (robot_id, metadata.get('robot_name', robot_id), 
+                       metadata.get('robot_model', 'Unknown'), ts))
+            
+            # Insert Calibration
+            c.execute("""INSERT INTO calibrations 
+                         (robot_id, timestamp, artifacts_path, file_size, score, notes) 
+                         VALUES (?, ?, ?, ?, ?, ?)""",
+                      (robot_id, ts, final_filename, file_size, score, notes))
+            
+            conn.commit()
+            calib_id = c.lastrowid
+            conn.close()
+            
+            logger.info(f"Upload successful: Robot={robot_id}, File={final_filename}, Size={format_filesize(file_size)}, Score={score:.4f}")
+            
+            return jsonify({
+                'status': 'success', 
+                'id': calib_id,
+                'filename': final_filename,
+                'file_size': file_size
+            }), 201
+        
+        except sqlite3.Error as e:
+            conn.close()
+            logger.error(f"Database error during upload: {e}")
+            return jsonify({'error': f'Database error: {str(e)}'}), 500
+    
+    except Exception as e:
+        logger.error(f"Upload error: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/calibrations/<robot_id>', methods=['GET'])
+def get_robot_calibrations(robot_id):
+    """Get all calibrations for a specific robot"""
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        conn.row_factory = sqlite3.Row
+        c = conn.cursor()
+        
+        c.execute("""SELECT * FROM calibrations 
+                     WHERE robot_id = ? 
+                     ORDER BY timestamp DESC""", (robot_id,))
+        calibrations = [dict(row) for row in c.fetchall()]
+        conn.close()
+        
+        logger.info(f"Retrieved {len(calibrations)} calibrations for {robot_id}")
+        return jsonify({'status': 'success', 'calibrations': calibrations}), 200
+    
+    except Exception as e:
+        logger.error(f"Get robot calibrations error: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/stats', methods=['GET'])
+def get_stats():
+    """Get fleet statistics"""
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        c = conn.cursor()
+        
+        c.execute("SELECT COUNT(*) FROM robots")
+        robot_count = c.fetchone()[0]
+        
+        c.execute("SELECT COUNT(*) FROM calibrations")
+        calib_count = c.fetchone()[0]
+        
+        c.execute("SELECT AVG(score) FROM calibrations")
+        avg_score = c.fetchone()[0] or 0.0
+        
+        c.execute("SELECT AVG(file_size) FROM calibrations")
+        avg_size = c.fetchone()[0] or 0
+        
+        conn.close()
+        
+        logger.info(f"Stats: {robot_count} robots, {calib_count} calibrations")
+        
+        return jsonify({
+            'status': 'success',
+            'robots': robot_count,
+            'calibrations': calib_count,
+            'avg_score': round(avg_score, 4),
+            'avg_file_size': format_filesize(int(avg_size))
+        }), 200
+    
+    except Exception as e:
+        logger.error(f"Get stats error: {e}")
+        return jsonify({'error': str(e)}), 500
+
+# ============================================================================
+# ERROR HANDLERS
+# ============================================================================
+
+@app.errorhandler(404)
+def not_found(e):
+    """Handle 404 errors"""
+    logger.warning(f"404 Not Found: {request.path}")
+    return jsonify({'error': 'Not found'}), 404
+
+@app.errorhandler(500)
+def internal_error(e):
+    """Handle 500 errors"""
+    logger.error(f"500 Internal Server Error: {str(e)}")
+    return jsonify({'error': 'Internal server error'}), 500
+
+# ============================================================================
+# MAIN
+# ============================================================================
+
+if __name__ == '__main__':
+    try:
+        logger.info(f"Starting Fleet Server on {config.FLASK_HOST}:{config.FLASK_PORT}")
+        app.run(
+            host=config.FLASK_HOST,
+            port=config.FLASK_PORT,
+            debug=config.FLASK_DEBUG,
+            use_reloader=False  # Disable reloader in production
+        )
+    except Exception as e:
+        logger.error(f"Failed to start server: {e}")
+        raise
+