pyarchinit-mini 2.1.0__tar.gz → 2.1.2__tar.gz

{pyarchinit_mini-2.1.0 → pyarchinit_mini-2.1.2}/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [2.1.2] - 2026-02-24
+
+### Fixed
+- `us_relationships_table` missing from concurrency columns migration: caused
+  `OperationalError: no such column: entity_uuid` when opening Harris Matrix editor
+  on existing databases. Migration now auto-runs on startup.
+
+## [2.1.1] - 2026-02-24
+
+### Fixed
+- Added missing MCP server tool files: `create_harris_matrix_tool.py` and `create_database_tool.py`
+  that caused `ModuleNotFoundError` on startup (pre-existing bug, never committed to repo)
+- `pyarchinit-mini-web` now starts correctly without ImportError from mcp_server
+
 ## [2.1.0] - 2026-02-24
 
 ### Added

{pyarchinit_mini-2.1.0/pyarchinit_mini.egg-info → pyarchinit_mini-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyarchinit-mini
-Version: 2.1.0
+Version: 2.1.2
 Summary: Lightweight archaeological data management system with REST API, Web UI, Desktop GUI, CLI, multi-user authentication, real-time collaboration, analytics dashboard, PyArchInit import/export, Heriverse/ATON export integration, and 3D CRUD viewer
 Home-page: https://github.com/enzococca/pyarchinit-mini
 Author: PyArchInit Team

{pyarchinit_mini-2.1.0 → pyarchinit_mini-2.1.2}/pyarchinit_mini/__init__.py

@@ -23,7 +23,7 @@ Features:
 - Scalable and modular architecture
 """
 
-__version__ = "2.1.0"
+__version__ = "2.1.2"
 __author__ = "PyArchInit Team"
 __email__ = "enzo.ccc@gmail.com"
 

{pyarchinit_mini-2.1.0 → pyarchinit_mini-2.1.2}/pyarchinit_mini/database/migrations.py

@@ -173,7 +173,8 @@ class DatabaseMigrations:
             migrations_applied = 0
 
             tables = [
-                'site_table', 'us_table', 'inventario_materiali_table',
+                'site_table', 'us_table', 'us_relationships_table',
+                'inventario_materiali_table',
                 'periodizzazione_table', 'media_table', 'media_thumb_table',
                 'documentation_table', 'users',
             ]

pyarchinit_mini-2.1.2/pyarchinit_mini/mcp_server/tools/create_database_tool.py

@@ -0,0 +1,130 @@
+"""
+Create Database Tool
+
+Creates a new empty PyArchInit-Mini database (SQLite or PostgreSQL) with the full schema.
+"""
+
+import logging
+import os
+from typing import Dict, Any
+from .base_tool import BaseTool, ToolDescription
+
+logger = logging.getLogger(__name__)
+
+
+class CreateDatabaseTool(BaseTool):
+    """Create a new PyArchInit-Mini database with full schema"""
+
+    def to_tool_description(self) -> ToolDescription:
+        return ToolDescription(
+            name="create_database",
+            description=(
+                "Create a new empty PyArchInit-Mini database with the complete schema. "
+                "Supports SQLite (file-based) and PostgreSQL. "
+                "Use this to initialize a fresh database for a new project."
+            ),
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "db_type": {
+                        "type": "string",
+                        "enum": ["sqlite", "postgresql"],
+                        "description": "Database type to create",
+                        "default": "sqlite"
+                    },
+                    "db_path": {
+                        "type": "string",
+                        "description": "Path for SQLite database file (e.g. /home/user/myproject.db). Required for sqlite."
+                    },
+                    "pg_host": {
+                        "type": "string",
+                        "description": "PostgreSQL host (default: localhost)",
+                        "default": "localhost"
+                    },
+                    "pg_port": {
+                        "type": "string",
+                        "description": "PostgreSQL port (default: 5432)",
+                        "default": "5432"
+                    },
+                    "pg_database": {
+                        "type": "string",
+                        "description": "PostgreSQL database name"
+                    },
+                    "pg_user": {
+                        "type": "string",
+                        "description": "PostgreSQL username"
+                    },
+                    "pg_password": {
+                        "type": "string",
+                        "description": "PostgreSQL password"
+                    },
+                    "overwrite": {
+                        "type": "boolean",
+                        "description": "If true, overwrite existing database (default: false)",
+                        "default": False
+                    }
+                },
+                "required": ["db_type"]
+            }
+        )
+
+    async def execute(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            db_type = arguments.get("db_type", "sqlite")
+            overwrite = arguments.get("overwrite", False)
+
+            from pyarchinit_mini.database.database_creator import create_empty_database
+
+            if db_type == "sqlite":
+                db_path = arguments.get("db_path")
+                if not db_path:
+                    return self._format_error("db_path is required for SQLite databases")
+
+                db_path = os.path.abspath(os.path.expanduser(db_path))
+
+                if os.path.exists(db_path) and not overwrite:
+                    return self._format_error(
+                        f"Database already exists at {db_path}. Set overwrite=true to replace it."
+                    )
+
+                logger.info(f"Creating SQLite database at {db_path}")
+                result = create_empty_database("sqlite", db_path, overwrite=overwrite)
+
+            elif db_type == "postgresql":
+                host = arguments.get("pg_host", "localhost")
+                port = arguments.get("pg_port", "5432")
+                database = arguments.get("pg_database")
+                user = arguments.get("pg_user")
+                password = arguments.get("pg_password", "")
+
+                if not all([database, user]):
+                    return self._format_error("pg_database and pg_user are required for PostgreSQL")
+
+                config = {
+                    "host": host,
+                    "port": int(port),
+                    "database": database,
+                    "username": user,
+                    "password": password
+                }
+
+                logger.info(f"Creating PostgreSQL database {database} on {host}:{port}")
+                result = create_empty_database("postgresql", config, overwrite=overwrite)
+
+            else:
+                return self._format_error(f"Unsupported db_type: {db_type}. Use 'sqlite' or 'postgresql'.")
+
+            return self._format_success(
+                result={
+                    "db_type": result.get("db_type"),
+                    "tables_created": result.get("tables_created"),
+                    "message": result.get("message")
+                },
+                message=result.get("message", "Database created successfully")
+            )
+
+        except FileExistsError:
+            return self._format_error("Database already exists. Set overwrite=true to replace it.")
+        except Exception as e:
+            logger.error(f"CreateDatabaseTool error: {str(e)}", exc_info=True)
+            return self._format_error(f"Failed to create database: {str(e)}")

pyarchinit_mini-2.1.2/pyarchinit_mini/mcp_server/tools/create_harris_matrix_tool.py

@@ -0,0 +1,170 @@
+"""
+Create Harris Matrix Tool
+
+Creates or updates a Harris Matrix for a site from provided stratigraphic relationships.
+"""
+
+import logging
+from typing import Dict, Any, List, Optional
+from .base_tool import BaseTool, ToolDescription
+
+logger = logging.getLogger(__name__)
+
+
+class CreateHarrisMatrixTool(BaseTool):
+    """Create or update Harris Matrix relationships for a site"""
+
+    def __init__(self, db_session, config):
+        super().__init__(db_session, config)
+        from pyarchinit_mini.database.manager import DatabaseManager
+        from pyarchinit_mini.database.connection import DatabaseConnection
+        from pyarchinit_mini.services.us_service import USService
+        import os
+        db_url = getattr(config, 'database_url', None) or os.getenv('DATABASE_URL', 'sqlite:///pyarchinit_mini.db')
+        connection = DatabaseConnection.from_url(db_url)
+        self.db_manager = DatabaseManager(connection)
+        self.us_service = USService(self.db_manager)
+
+    def to_tool_description(self) -> ToolDescription:
+        return ToolDescription(
+            name="create_harris_matrix",
+            description=(
+                "Create or update Harris Matrix stratigraphic relationships for a site. "
+                "Accepts a list of relationships between stratigraphic units (US) and stores them "
+                "in the database. Supports all standard Harris Matrix relationship types: "
+                "copre/è coperto da, taglia/è tagliato da, si appoggia a/è appoggiato da, "
+                "uguale a, si lega a, viene prima di/viene dopo."
+            ),
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "site_name": {
+                        "type": "string",
+                        "description": "Name of the archaeological site"
+                    },
+                    "relationships": {
+                        "type": "array",
+                        "description": "List of stratigraphic relationships to create",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "us_from": {
+                                    "type": ["string", "integer"],
+                                    "description": "Source US number"
+                                },
+                                "us_to": {
+                                    "type": ["string", "integer"],
+                                    "description": "Target US number"
+                                },
+                                "relationship_type": {
+                                    "type": "string",
+                                    "description": "Type of relationship (e.g. 'copre', 'taglia', 'uguale a', 'si lega a')"
+                                }
+                            },
+                            "required": ["us_from", "us_to", "relationship_type"]
+                        }
+                    },
+                    "overwrite": {
+                        "type": "boolean",
+                        "description": "If true, delete existing relationships for the site before inserting (default: false)",
+                        "default": False
+                    }
+                },
+                "required": ["site_name", "relationships"]
+            }
+        )
+
+    async def execute(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            site_name = arguments.get("site_name")
+            relationships = arguments.get("relationships", [])
+            overwrite = arguments.get("overwrite", False)
+
+            if not site_name:
+                return self._format_error("site_name is required")
+            if not relationships:
+                return self._format_error("relationships list is required and cannot be empty")
+
+            session = self.db_manager.get_session()
+            created = 0
+            skipped = 0
+            errors = []
+
+            try:
+                from sqlalchemy import text
+
+                if overwrite:
+                    session.execute(
+                        text("DELETE FROM us_relationships_table WHERE sito = :sito"),
+                        {"sito": site_name}
+                    )
+                    session.commit()
+                    logger.info(f"Deleted existing relationships for site {site_name}")
+
+                for rel in relationships:
+                    try:
+                        us_from = str(rel["us_from"])
+                        us_to = str(rel["us_to"])
+                        rel_type = rel["relationship_type"]
+
+                        # Check if relationship already exists
+                        existing = session.execute(
+                            text("""SELECT id_relationship FROM us_relationships_table
+                                    WHERE sito = :sito AND us_from = :us_from
+                                    AND us_to = :us_to AND relationship_type = :rel_type"""),
+                            {"sito": site_name, "us_from": us_from,
+                             "us_to": us_to, "rel_type": rel_type}
+                        ).fetchone()
+
+                        if existing:
+                            skipped += 1
+                            continue
+
+                        from datetime import datetime
+                        import uuid
+                        session.execute(
+                            text("""INSERT INTO us_relationships_table
+                                    (sito, us_from, us_to, relationship_type,
+                                     created_at, updated_at, version_number, sync_status, entity_uuid)
+                                    VALUES (:sito, :us_from, :us_to, :rel_type,
+                                            :created_at, :updated_at, 1, 'new', :uuid)"""),
+                            {
+                                "sito": site_name,
+                                "us_from": us_from,
+                                "us_to": us_to,
+                                "rel_type": rel_type,
+                                "created_at": datetime.now(),
+                                "updated_at": datetime.now(),
+                                "uuid": str(uuid.uuid4())
+                            }
+                        )
+                        created += 1
+
+                    except Exception as e:
+                        errors.append(f"Rel {rel.get('us_from')}→{rel.get('us_to')}: {str(e)}")
+
+                session.commit()
+
+            finally:
+                session.close()
+
+            result = {
+                "site_name": site_name,
+                "created": created,
+                "skipped": skipped,
+                "errors": errors
+            }
+
+            if errors:
+                return self._format_success(
+                    result=result,
+                    message=f"Created {created} relationships ({skipped} skipped, {len(errors)} errors)"
+                )
+            return self._format_success(
+                result=result,
+                message=f"Successfully created {created} relationships for site '{site_name}' ({skipped} already existed)"
+            )
+
+        except Exception as e:
+            logger.error(f"CreateHarrisMatrixTool error: {str(e)}", exc_info=True)
+            return self._format_error(f"Failed to create Harris Matrix: {str(e)}")

{pyarchinit_mini-2.1.0 → pyarchinit_mini-2.1.2/pyarchinit_mini.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyarchinit-mini
-Version: 2.1.0
+Version: 2.1.2
 Summary: Lightweight archaeological data management system with REST API, Web UI, Desktop GUI, CLI, multi-user authentication, real-time collaboration, analytics dashboard, PyArchInit import/export, Heriverse/ATON export integration, and 3D CRUD viewer
 Home-page: https://github.com/enzococca/pyarchinit-mini
 Author: PyArchInit Team

{pyarchinit_mini-2.1.0 → pyarchinit_mini-2.1.2}/pyarchinit_mini.egg-info/SOURCES.txt

@@ -125,6 +125,8 @@ pyarchinit_mini/mcp_server/tools/build_3d_tool.py
 pyarchinit_mini/mcp_server/tools/chatgpt_fetch_tool.py
 pyarchinit_mini/mcp_server/tools/chatgpt_search_tool.py
 pyarchinit_mini/mcp_server/tools/configure_em_nodes_tool.py
+pyarchinit_mini/mcp_server/tools/create_database_tool.py
+pyarchinit_mini/mcp_server/tools/create_harris_matrix_tool.py
 pyarchinit_mini/mcp_server/tools/data_import_parser_tool.py
 pyarchinit_mini/mcp_server/tools/data_management_tool.py
 pyarchinit_mini/mcp_server/tools/database_manager_tool.py

{pyarchinit_mini-2.1.0 → pyarchinit_mini-2.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyarchinit-mini"
-version = "2.1.0"
+version = "2.1.2"
 description = "Lightweight archaeological data management system with REST API, Web UI, Desktop GUI, CLI, multi-user authentication, real-time collaboration, analytics dashboard, PyArchInit import/export, Heriverse/ATON export integration, and 3D CRUD viewer"
 readme = "README.md"
 license = {text = "GPL-2.0"}