pyconvexity 0.4.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

pyconvexity/models/components.py

@@ -8,29 +8,27 @@ with proper validation and error handling.
 import sqlite3
 from typing import Dict, Any, Optional, List
 
-from pyconvexity.core.types import (
-    Component, CreateComponentRequest, StaticValue
-)
-from pyconvexity.core.errors import (
-    ComponentNotFound, ValidationError, DatabaseError
-)
+from pyconvexity.core.types import Component, CreateComponentRequest, StaticValue
+from pyconvexity.core.errors import ComponentNotFound, ValidationError, DatabaseError
 
 
 def get_component_type(conn: sqlite3.Connection, component_id: int) -> str:
     """
     Get component type for a component ID.
-    
+
     Args:
         conn: Database connection
         component_id: ID of the component
-        
+
     Returns:
         Component type string (e.g., "BUS", "GENERATOR")
-        
+
     Raises:
         ComponentNotFound: If component doesn't exist
     """
-    cursor = conn.execute("SELECT component_type FROM components WHERE id = ?", (component_id,))
+    cursor = conn.execute(
+        "SELECT component_type FROM components WHERE id = ?", (component_id,)
+    )
     row = cursor.fetchone()
     if not row:
         raise ComponentNotFound(component_id)
@@ -39,104 +37,108 @@ def get_component_type(conn: sqlite3.Connection, component_id: int) -> str:
 
 def get_component(conn: sqlite3.Connection, component_id: int) -> Component:
     """
-    Get component by ID.
-    
+    Get component by ID (single network per database).
+
     Args:
         conn: Database connection
         component_id: ID of the component
-        
+
     Returns:
         Component object with all fields populated
-        
+
     Raises:
         ComponentNotFound: If component doesn't exist
     """
-    cursor = conn.execute("""
-        SELECT id, network_id, component_type, name, longitude, latitude, 
+    cursor = conn.execute(
+        """
+        SELECT id, component_type, name, longitude, latitude, 
                carrier_id, bus_id, bus0_id, bus1_id
         FROM components WHERE id = ?
-    """, (component_id,))
-    
+    """,
+        (component_id,),
+    )
+
     row = cursor.fetchone()
     if not row:
         raise ComponentNotFound(component_id)
-    
+
     return Component(
         id=row[0],
-        network_id=row[1],
-        component_type=row[2],
-        name=row[3],
-        longitude=row[4],
-        latitude=row[5],
-        carrier_id=row[6],
-        bus_id=row[7],
-        bus0_id=row[8],
-        bus1_id=row[9]
+        component_type=row[1],
+        name=row[2],
+        longitude=row[3],
+        latitude=row[4],
+        carrier_id=row[5],
+        bus_id=row[6],
+        bus0_id=row[7],
+        bus1_id=row[8],
     )
 
 
 def list_components_by_type(
-    conn: sqlite3.Connection, 
-    network_id: int, 
-    component_type: Optional[str] = None
+    conn: sqlite3.Connection, component_type: Optional[str] = None
 ) -> List[Component]:
     """
-    List components by type.
-    
+    List components by type (single network per database).
+
     Args:
         conn: Database connection
-        network_id: Network ID to filter by
         component_type: Optional component type filter (e.g., "BUS", "GENERATOR")
-        
+
     Returns:
         List of Component objects
     """
     if component_type:
-        cursor = conn.execute("""
-            SELECT id, network_id, component_type, name, longitude, latitude, 
+        cursor = conn.execute(
+            """
+            SELECT id, component_type, name, longitude, latitude, 
                    carrier_id, bus_id, bus0_id, bus1_id
             FROM components 
-            WHERE network_id = ? AND component_type = ?
+            WHERE component_type = ?
             ORDER BY name
-        """, (network_id, component_type.upper()))
+        """,
+            (component_type.upper(),),
+        )
     else:
-        cursor = conn.execute("""
-            SELECT id, network_id, component_type, name, longitude, latitude, 
+        cursor = conn.execute(
+            """
+            SELECT id, component_type, name, longitude, latitude, 
                    carrier_id, bus_id, bus0_id, bus1_id
             FROM components 
-            WHERE network_id = ?
             ORDER BY component_type, name
-        """, (network_id,))
-    
+        """
+        )
+
     components = []
     for row in cursor.fetchall():
-        components.append(Component(
-            id=row[0],
-            network_id=row[1],
-            component_type=row[2],
-            name=row[3],
-            longitude=row[4],
-            latitude=row[5],
-            carrier_id=row[6],
-            bus_id=row[7],
-            bus0_id=row[8],
-            bus1_id=row[9]
-        ))
-    
+        components.append(
+            Component(
+                id=row[0],
+                component_type=row[1],
+                name=row[2],
+                longitude=row[3],
+                latitude=row[4],
+                carrier_id=row[5],
+                bus_id=row[6],
+                bus0_id=row[7],
+                bus1_id=row[8],
+            )
+        )
+
     return components
 
 
 def insert_component(conn: sqlite3.Connection, request: CreateComponentRequest) -> int:
     """
-    Insert a new component.
-    
+    Insert a new component (single network per database).
+
     Args:
         conn: Database connection
         request: Component creation request with all necessary fields
-        
+
     Returns:
         ID of the newly created component
-        
+
     Raises:
         DatabaseError: If insertion fails
         ValidationError: If required fields are missing
@@ -144,58 +146,59 @@ def insert_component(conn: sqlite3.Connection, request: CreateComponentRequest)
     # Determine carrier_id - use provided value or auto-assign default
     # CONSTRAINT components must have carrier_id=None per database schema
     carrier_id = request.carrier_id
-    if carrier_id is None and request.component_type.upper() != 'CONSTRAINT':
-        carrier_id = get_default_carrier_id(conn, request.network_id, request.component_type)
-    elif request.component_type.upper() == 'CONSTRAINT':
+    if carrier_id is None and request.component_type.upper() != "CONSTRAINT":
+        carrier_id = get_default_carrier_id(conn, request.component_type)
+    elif request.component_type.upper() == "CONSTRAINT":
         carrier_id = None  # Explicitly keep None for constraints
-    
+
     # Insert the component
-    cursor = conn.execute("""
+    cursor = conn.execute(
+        """
         INSERT INTO components (
-            network_id, component_type, name, longitude, latitude, 
+            component_type, name, longitude, latitude, 
             carrier_id, bus_id, bus0_id, bus1_id, 
             created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
-    """, (
-        request.network_id,
-        request.component_type,
-        request.name,
-        request.longitude,
-        request.latitude,
-        carrier_id,
-        request.bus_id,
-        request.bus0_id,
-        request.bus1_id
-    ))
-    
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
+    """,
+        (
+            request.component_type,
+            request.name,
+            request.longitude,
+            request.latitude,
+            carrier_id,
+            request.bus_id,
+            request.bus0_id,
+            request.bus1_id,
+        ),
+    )
+
     component_id = cursor.lastrowid
     if not component_id:
         raise DatabaseError("Failed to create component")
-    
+
     # If description is provided, store it as an attribute
     if request.description:
         from pyconvexity.models.attributes import set_static_attribute
-        set_static_attribute(conn, component_id, "description", StaticValue(request.description))
-    
+
+        set_static_attribute(
+            conn, component_id, "description", StaticValue(request.description)
+        )
+
     # If this is a BUS, ensure unmet load exists
     if request.component_type.upper() == "BUS":
-        # Get unmet_load_active flag from network
-        cursor = conn.execute("""
-            SELECT COALESCE(unmet_load_active, 1) FROM networks WHERE id = ?
-        """, (request.network_id,))
-        
-        row = cursor.fetchone()
-        # Explicitly convert to boolean to avoid int/bool type confusion
-        unmet_load_active = bool(row[0]) if row else True
-        
-        ensure_unmet_load_for_bus(conn, request.network_id, component_id, request.name, unmet_load_active)
-    
+        # Get unmet_load_active flag from network config
+        from pyconvexity.models.network import get_network_config
+
+        network_config = get_network_config(conn)
+        unmet_load_active = network_config.get("unmet_load_active", True)
+
+        ensure_unmet_load_for_bus(conn, component_id, request.name, unmet_load_active)
+
     return component_id
 
 
 def create_component(
     conn: sqlite3.Connection,
-    network_id: int,
     component_type: str,
     name: str,
     description: Optional[str] = None,
@@ -204,14 +207,13 @@ def create_component(
     carrier_id: Optional[int] = None,
     bus_id: Optional[int] = None,
     bus0_id: Optional[int] = None,
-    bus1_id: Optional[int] = None
+    bus1_id: Optional[int] = None,
 ) -> int:
     """
-    Create a component and return its ID - convenience function.
-    
+    Create a component and return its ID - convenience function (single network per database).
+
     Args:
         conn: Database connection
-        network_id: Network ID
         component_type: Type of component (e.g., "BUS", "GENERATOR")
         name: Component name
         description: Optional description
@@ -221,12 +223,11 @@ def create_component(
         bus_id: Optional bus ID (for single-bus components)
         bus0_id: Optional first bus ID (for two-bus components)
         bus1_id: Optional second bus ID (for two-bus components)
-        
+
     Returns:
         ID of the newly created component
     """
     request = CreateComponentRequest(
-        network_id=network_id,
         component_type=component_type,
         name=name,
         description=description,
@@ -235,7 +236,7 @@ def create_component(
         carrier_id=carrier_id,
         bus_id=bus_id,
         bus0_id=bus0_id,
-        bus1_id=bus1_id
+        bus1_id=bus1_id,
     )
     return insert_component(conn, request)
 
@@ -250,11 +251,11 @@ def update_component(
     carrier_id: Optional[int] = None,
     bus_id: Optional[int] = None,
     bus0_id: Optional[int] = None,
-    bus1_id: Optional[int] = None
+    bus1_id: Optional[int] = None,
 ) -> None:
     """
     Update a component.
-    
+
     Args:
         conn: Database connection
         component_id: ID of component to update
@@ -266,14 +267,14 @@ def update_component(
         bus_id: New bus ID (optional)
         bus0_id: New first bus ID (optional)
         bus1_id: New second bus ID (optional)
-        
+
     Raises:
         ComponentNotFound: If component doesn't exist
     """
     # Build dynamic SQL based on what fields are being updated
     set_clauses = []
     params = []
-    
+
     if name is not None:
         set_clauses.append("name = ?")
         params.append(name)
@@ -295,21 +296,22 @@ def update_component(
     if bus1_id is not None:
         set_clauses.append("bus1_id = ?")
         params.append(bus1_id)
-    
+
     # Update component table fields if any changes
     if set_clauses:
         set_clauses.append("updated_at = datetime('now')")
         params.append(component_id)
-        
+
         sql = f"UPDATE components SET {', '.join(set_clauses)} WHERE id = ?"
         cursor = conn.execute(sql, params)
-        
+
         if cursor.rowcount == 0:
             raise ComponentNotFound(component_id)
-    
+
     # Handle description as an attribute
     if description is not None:
         from pyconvexity.models.attributes import set_static_attribute, delete_attribute
+
         if description == "":
             # Remove description attribute if empty
             try:
@@ -318,148 +320,152 @@ def update_component(
                 pass  # Already doesn't exist
         else:
             # Set description as attribute
-            set_static_attribute(conn, component_id, "description", StaticValue(description))
+            set_static_attribute(
+                conn, component_id, "description", StaticValue(description)
+            )
 
 
 def delete_component(conn: sqlite3.Connection, component_id: int) -> None:
     """
     Delete a component and all its attributes.
-    
+
     Args:
         conn: Database connection
         component_id: ID of component to delete
-        
+
     Raises:
         ComponentNotFound: If component doesn't exist
     """
     # First delete all component attributes
-    conn.execute("DELETE FROM component_attributes WHERE component_id = ?", (component_id,))
-    
+    conn.execute(
+        "DELETE FROM component_attributes WHERE component_id = ?", (component_id,)
+    )
+
     # Then delete the component itself
     cursor = conn.execute("DELETE FROM components WHERE id = ?", (component_id,))
-    
+
     if cursor.rowcount == 0:
         raise ComponentNotFound(component_id)
 
 
-def list_component_attributes(
-    conn: sqlite3.Connection,
-    component_id: int
-) -> List[str]:
+def list_component_attributes(conn: sqlite3.Connection, component_id: int) -> List[str]:
     """
     List all attribute names for a component.
-    
+
     Args:
         conn: Database connection
         component_id: Component ID
-        
+
     Returns:
         List of attribute names
     """
-    cursor = conn.execute("""
+    cursor = conn.execute(
+        """
         SELECT attribute_name FROM component_attributes 
         WHERE component_id = ? ORDER BY attribute_name
-    """, (component_id,))
-    
+    """,
+        (component_id,),
+    )
+
     return [row[0] for row in cursor.fetchall()]
 
 
-def get_component_by_name(conn: sqlite3.Connection, network_id: int, name: str) -> Component:
+def get_component_by_name(conn: sqlite3.Connection, name: str) -> Component:
     """
-    Get a component by name.
-    
+    Get a component by name (single network per database).
+
     Args:
         conn: Database connection
-        network_id: Network ID
         name: Component name
-        
+
     Returns:
         Component object
-        
+
     Raises:
         ComponentNotFound: If component doesn't exist
     """
-    cursor = conn.execute("""
-        SELECT id, network_id, component_type, name, longitude, latitude, 
+    cursor = conn.execute(
+        """
+        SELECT id, component_type, name, longitude, latitude, 
                carrier_id, bus_id, bus0_id, bus1_id
         FROM components 
-        WHERE network_id = ? AND name = ?
-    """, (network_id, name))
-    
+        WHERE name = ?
+    """,
+        (name,),
+    )
+
     row = cursor.fetchone()
     if not row:
-        raise ComponentNotFound(f"Component '{name}' not found in network {network_id}")
-    
+        raise ComponentNotFound(f"Component '{name}' not found")
+
     return Component(
         id=row[0],
-        network_id=row[1],
-        component_type=row[2],
-        name=row[3],
-        longitude=row[4],
-        latitude=row[5],
-        carrier_id=row[6],
-        bus_id=row[7],
-        bus0_id=row[8],
-        bus1_id=row[9]
+        component_type=row[1],
+        name=row[2],
+        longitude=row[3],
+        latitude=row[4],
+        carrier_id=row[5],
+        bus_id=row[6],
+        bus0_id=row[7],
+        bus1_id=row[8],
     )
 
 
-def get_component_id(conn: sqlite3.Connection, network_id: int, name: str) -> int:
+def get_component_id(conn: sqlite3.Connection, name: str) -> int:
     """
-    Get component ID by name.
-    
+    Get component ID by name (single network per database).
+
     Args:
         conn: Database connection
-        network_id: Network ID
         name: Component name
-        
+
     Returns:
         Component ID
-        
+
     Raises:
         ComponentNotFound: If component doesn't exist
     """
-    component = get_component_by_name(conn, network_id, name)
+    component = get_component_by_name(conn, name)
     return component.id
 
 
-def component_exists(conn: sqlite3.Connection, network_id: int, name: str) -> bool:
+def component_exists(conn: sqlite3.Connection, name: str) -> bool:
     """
-    Check if a component exists.
-    
+    Check if a component exists (single network per database).
+
     Args:
         conn: Database connection
-        network_id: Network ID
         name: Component name
-        
+
     Returns:
         True if component exists, False otherwise
     """
-    cursor = conn.execute("""
-        SELECT 1 FROM components WHERE network_id = ? AND name = ?
-    """, (network_id, name))
-    
+    cursor = conn.execute(
+        """
+        SELECT 1 FROM components WHERE name = ?
+    """,
+        (name,),
+    )
+
     return cursor.fetchone() is not None
 
 
 def get_component_carrier_map(
-    conn: sqlite3.Connection, 
-    network_id: int, 
-    component_type: Optional[str] = None
+    conn: sqlite3.Connection, component_type: Optional[str] = None
 ) -> Dict[str, str]:
     """
-    Get mapping from component names to carrier names.
-    
+    Get mapping from component names to carrier names (single network per database).
+
     Args:
         conn: Database connection
-        network_id: Network ID
         component_type: Optional component type filter
-        
+
     Returns:
         Dictionary mapping component names to carrier names
     """
     if component_type:
-        cursor = conn.execute("""
+        cursor = conn.execute(
+            """
             SELECT c.name,
                    CASE 
                        WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
@@ -467,10 +473,13 @@ def get_component_carrier_map(
                    END as carrier_name
             FROM components c
             LEFT JOIN carriers carr ON c.carrier_id = carr.id
-            WHERE c.network_id = ? AND c.component_type = ?
-        """, (network_id, component_type.upper()))
+            WHERE c.component_type = ?
+        """,
+            (component_type.upper(),),
+        )
     else:
-        cursor = conn.execute("""
+        cursor = conn.execute(
+            """
             SELECT c.name,
                    CASE 
                        WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
@@ -478,110 +487,125 @@ def get_component_carrier_map(
                    END as carrier_name
             FROM components c
             LEFT JOIN carriers carr ON c.carrier_id = carr.id
-            WHERE c.network_id = ?
-        """, (network_id,))
-    
+        """
+        )
+
     return {row[0]: row[1] for row in cursor.fetchall()}
 
 
 # Helper functions
 
-def get_default_carrier_id(
-    conn: sqlite3.Connection, 
-    network_id: int, 
-    component_type: str
-) -> int:
-    """Get default carrier ID for a component type."""
+
+def get_default_carrier_id(conn: sqlite3.Connection, component_type: str) -> int:
+    """Get default carrier ID for a component type (single network per database)."""
     # Default carrier names based on PyPSA conventions
     default_carrier_name = {
-        'BUS': 'AC',
-        'GENERATOR': 'electricity',
-        'LOAD': 'electricity', 
-        'STORAGE_UNIT': 'electricity',
-        'STORE': 'electricity',
-        'LINE': 'AC',
-        'LINK': 'AC'
-    }.get(component_type.upper(), 'AC')
-    
+        "BUS": "AC",
+        "GENERATOR": "electricity",
+        "LOAD": "electricity",
+        "STORAGE_UNIT": "electricity",
+        "STORE": "electricity",
+        "LINE": "AC",
+        "LINK": "AC",
+    }.get(component_type.upper(), "AC")
+
     # Try to find the default carrier
-    cursor = conn.execute("""
-        SELECT id FROM carriers WHERE network_id = ? AND name = ? LIMIT 1
-    """, (network_id, default_carrier_name))
-    
+    cursor = conn.execute(
+        """
+        SELECT id FROM carriers WHERE name = ? LIMIT 1
+    """,
+        (default_carrier_name,),
+    )
+
     row = cursor.fetchone()
     if row:
         return row[0]
-    
+
     # If not found, try AC
-    cursor = conn.execute("""
-        SELECT id FROM carriers WHERE network_id = ? AND name = 'AC' LIMIT 1
-    """, (network_id,))
-    
+    cursor = conn.execute(
+        """
+        SELECT id FROM carriers WHERE name = 'AC' LIMIT 1
+    """
+    )
+
     row = cursor.fetchone()
     if row:
         return row[0]
-    
+
     # If still not found, get any carrier
-    cursor = conn.execute("""
-        SELECT id FROM carriers WHERE network_id = ? LIMIT 1
-    """, (network_id,))
-    
+    cursor = conn.execute(
+        """
+        SELECT id FROM carriers LIMIT 1
+    """
+    )
+
     row = cursor.fetchone()
     if row:
         return row[0]
-    
-    raise DatabaseError(f"No carriers found in network {network_id}")
+
+    raise DatabaseError("No carriers found in database")
 
 
 def ensure_unmet_load_for_bus(
-    conn: sqlite3.Connection, 
-    network_id: int, 
-    bus_id: int, 
-    bus_name: str, 
-    unmet_load_active: bool
+    conn: sqlite3.Connection, bus_id: int, bus_name: str, unmet_load_active: bool
 ) -> None:
-    """Ensure there is exactly one UNMET_LOAD per bus."""
+    """Ensure there is exactly one UNMET_LOAD per bus (single network per database)."""
     # Check if unmet load already exists for this bus
-    cursor = conn.execute("""
+    cursor = conn.execute(
+        """
         SELECT id FROM components 
-        WHERE network_id = ? AND bus_id = ? AND component_type = 'UNMET_LOAD' 
+        WHERE bus_id = ? AND component_type = 'UNMET_LOAD' 
         LIMIT 1
-    """, (network_id, bus_id))
-    
+    """,
+        (bus_id,),
+    )
+
     if cursor.fetchone():
         return  # Already exists
-    
+
     # Get default carrier for generators (unmet loads are treated as generators)
-    carrier_id = get_default_carrier_id(conn, network_id, "GENERATOR")
-    
+    carrier_id = get_default_carrier_id(conn, "GENERATOR")
+
     # Insert unmet load component - sanitize bus name for PyPSA compatibility
     # Remove spaces, periods, and other problematic characters
     sanitized_bus_name = bus_name.replace(" ", "_").replace(".", "_").replace("-", "_")
     name = f"unmet_load_{sanitized_bus_name}"
-    cursor = conn.execute("""
+    cursor = conn.execute(
+        """
         INSERT INTO components (
-            network_id, component_type, name, carrier_id, bus_id, 
+            component_type, name, carrier_id, bus_id, 
             created_at, updated_at
-        ) VALUES (?, 'UNMET_LOAD', ?, ?, ?, datetime('now'), datetime('now'))
-    """, (network_id, name, carrier_id, bus_id))
-    
+        ) VALUES ('UNMET_LOAD', ?, ?, ?, datetime('now'), datetime('now'))
+    """,
+        (name, carrier_id, bus_id),
+    )
+
     unmet_load_id = cursor.lastrowid
-    
+
     # Set fixed attributes for unmet load
     from pyconvexity.models.attributes import set_static_attribute
+
     set_static_attribute(conn, unmet_load_id, "marginal_cost", StaticValue(1e6))
     set_static_attribute(conn, unmet_load_id, "p_nom", StaticValue(1e6))
-    set_static_attribute(conn, unmet_load_id, "p_max_pu", StaticValue(1.0))  # Can run at full capacity
-    set_static_attribute(conn, unmet_load_id, "p_min_pu", StaticValue(0.0))  # Can be turned off
-    set_static_attribute(conn, unmet_load_id, "sign", StaticValue(1.0))      # Positive power sign (generation)
+    set_static_attribute(
+        conn, unmet_load_id, "p_max_pu", StaticValue(1.0)
+    )  # Can run at full capacity
+    set_static_attribute(
+        conn, unmet_load_id, "p_min_pu", StaticValue(0.0)
+    )  # Can be turned off
+    set_static_attribute(
+        conn, unmet_load_id, "sign", StaticValue(1.0)
+    )  # Positive power sign (generation)
     set_static_attribute(conn, unmet_load_id, "active", StaticValue(unmet_load_active))
 
 
-def get_bus_name_to_id_map(conn: sqlite3.Connection, network_id: int) -> Dict[str, int]:
-    """Get mapping from bus names to component IDs."""
-    cursor = conn.execute("""
+def get_bus_name_to_id_map(conn: sqlite3.Connection) -> Dict[str, int]:
+    """Get mapping from bus names to component IDs (single network per database)."""
+    cursor = conn.execute(
+        """
         SELECT name, id FROM components 
-        WHERE network_id = ? AND component_type = 'BUS'
-    """, (network_id,))
-    
+        WHERE component_type = 'BUS'
+    """
+    )
+
     return {row[0]: row[1] for row in cursor.fetchall()}