pyconvexity 0.1.0__py3-none-any.whl

pyconvexity/validation/rules.py

@@ -0,0 +1,301 @@
+"""
+Validation rules and operations for PyConvexity.
+
+Provides validation logic for component attributes, data types, and timeseries alignment.
+"""
+
+import sqlite3
+import json
+import logging
+from typing import Dict, Any, Optional, List
+
+from pyconvexity.core.types import (
+    ValidationRule, StaticValue, TimeseriesPoint, TimePeriod, TimeseriesValidationResult
+)
+from pyconvexity.core.errors import (
+    ValidationError, InvalidDataType
+)
+
+logger = logging.getLogger(__name__)
+
+
+def get_validation_rule(
+    conn: sqlite3.Connection, 
+    component_type: str, 
+    attribute_name: str
+) -> ValidationRule:
+    """
+    Get validation rule for a specific component type and attribute.
+    
+    Args:
+        conn: Database connection
+        component_type: Type of component (e.g., "BUS", "GENERATOR")
+        attribute_name: Name of the attribute
+        
+    Returns:
+        ValidationRule object with all validation information
+        
+    Raises:
+        ValidationError: If no validation rule is found
+    """
+    cursor = conn.execute("""
+        SELECT component_type, attribute_name, data_type, unit, default_value, allowed_storage_types, 
+               is_required, is_input, description
+        FROM attribute_validation_rules 
+        WHERE component_type = ? AND attribute_name = ?
+    """, (component_type, attribute_name))
+    
+    row = cursor.fetchone()
+    if not row:
+        raise ValidationError(f"No validation rule found for {component_type}.{attribute_name}")
+    
+    allowed_storage_types = row[5]
+    allows_static = allowed_storage_types in ("static", "static_or_timeseries")
+    allows_timeseries = allowed_storage_types in ("timeseries", "static_or_timeseries")
+    
+    # Parse default value
+    default_value = None
+    if row[4]:  # default_value_string
+        default_value = parse_default_value(row[4])
+    
+    return ValidationRule(
+        component_type=row[0],
+        attribute_name=row[1],
+        data_type=row[2],
+        unit=row[3],
+        default_value_string=row[4],
+        allowed_storage_types=allowed_storage_types,
+        allows_static=allows_static,
+        allows_timeseries=allows_timeseries,
+        is_required=bool(row[6]),
+        is_input=bool(row[7]),
+        description=row[8],
+        default_value=default_value
+    )
+
+
+def list_validation_rules(
+    conn: sqlite3.Connection,
+    component_type: str
+) -> List[ValidationRule]:
+    """
+    List validation rules for a component type.
+    
+    Args:
+        conn: Database connection
+        component_type: Type of component
+        
+    Returns:
+        List of ValidationRule objects
+    """
+    cursor = conn.execute("""
+        SELECT component_type, attribute_name, data_type, unit, default_value, allowed_storage_types, 
+               is_required, is_input, description
+        FROM attribute_validation_rules 
+        WHERE component_type = ?
+        ORDER BY attribute_name
+    """, (component_type,))
+    
+    rules = []
+    for row in cursor.fetchall():
+        allowed_storage_types = row[5]
+        allows_static = allowed_storage_types in ("static", "static_or_timeseries")
+        allows_timeseries = allowed_storage_types in ("timeseries", "static_or_timeseries")
+        
+        # Parse default value
+        default_value = None
+        if row[4]:  # default_value_string
+            default_value = parse_default_value(row[4])
+        
+        rules.append(ValidationRule(
+            component_type=row[0],
+            attribute_name=row[1],
+            data_type=row[2],
+            unit=row[3],
+            default_value_string=row[4],
+            allowed_storage_types=allowed_storage_types,
+            allows_static=allows_static,
+            allows_timeseries=allows_timeseries,
+            is_required=bool(row[6]),
+            is_input=bool(row[7]),
+            description=row[8],
+            default_value=default_value
+        ))
+    
+    return rules
+
+
+def get_all_validation_rules(conn: sqlite3.Connection) -> Dict[str, Any]:
+    """
+    Get all validation rules from the database.
+    This replaces the need to load the entire JSON file into memory.
+    
+    Args:
+        conn: Database connection
+        
+    Returns:
+        Dictionary mapping component types to their validation rules
+    """
+    try:
+        cursor = conn.execute("""
+            SELECT component_type, attribute_name, data_type, unit, default_value, allowed_storage_types, 
+                   is_required, is_input, description
+            FROM attribute_validation_rules 
+        """)
+        
+        rules = {}
+        for row in cursor.fetchall():
+            component_type = row[0]
+            attribute_name = row[1]
+            data_type = row[2]
+            unit = row[3]
+            default_value = row[4]
+            allowed_storage_types = row[5]
+            is_required = bool(row[6])
+            is_input = bool(row[7])
+            description = row[8]
+            
+            if component_type not in rules:
+                rules[component_type] = {}
+            
+            rules[component_type][attribute_name] = {
+                'data_type': data_type,
+                'unit': unit,
+                'default_value': default_value,
+                'allowed_storage_types': allowed_storage_types,
+                'is_required': is_required,
+                'is_input': is_input,
+                'description': description
+            }
+        
+        return rules
+    except Exception as e:
+        logger.error(f"Error getting all validation rules: {e}")
+        return {}
+
+
+def validate_static_value(value: StaticValue, rule: ValidationRule) -> None:
+    """
+    Validate static value against rule.
+    
+    Args:
+        value: StaticValue to validate
+        rule: ValidationRule to validate against
+        
+    Raises:
+        InvalidDataType: If value type doesn't match rule
+    """
+    value_type = value.data_type()
+    
+    if value_type != rule.data_type:
+        raise InvalidDataType(expected=rule.data_type, actual=value_type)
+
+
+def validate_timeseries_alignment(
+    conn: sqlite3.Connection,
+    network_id: int,
+    timeseries: List[TimeseriesPoint]
+) -> TimeseriesValidationResult:
+    """
+    Validate timeseries alignment with network periods.
+    
+    Args:
+        conn: Database connection
+        network_id: Network ID
+        timeseries: List of timeseries points to validate
+        
+    Returns:
+        TimeseriesValidationResult with validation details
+    """
+    # Get network time periods
+    from pyconvexity.models.network import get_network_time_periods
+    network_periods = get_network_time_periods(conn, network_id)
+    network_period_indices = {p.period_index for p in network_periods}
+    
+    # Get provided period indices
+    provided_period_indices = {p.period_index for p in timeseries}
+    
+    # Find missing and extra periods
+    missing_periods = list(network_period_indices - provided_period_indices)
+    extra_periods = list(provided_period_indices - network_period_indices)
+    
+    is_valid = len(missing_periods) == 0 and len(extra_periods) == 0
+    
+    return TimeseriesValidationResult(
+        is_valid=is_valid,
+        missing_periods=missing_periods,
+        extra_periods=extra_periods,
+        total_network_periods=len(network_periods),
+        provided_periods=len(timeseries)
+    )
+
+
+def parse_default_value(s: str) -> Optional[StaticValue]:
+    """
+    Parse default value string.
+    
+    Args:
+        s: String representation of default value
+        
+    Returns:
+        StaticValue object or None if parsing fails
+    """
+    # Try to parse as JSON first
+    try:
+        value = json.loads(s)
+        if isinstance(value, float):
+            return StaticValue(value)
+        elif isinstance(value, int):
+            return StaticValue(value)
+        elif isinstance(value, bool):
+            return StaticValue(value)
+        elif isinstance(value, str):
+            return StaticValue(value)
+        else:
+            return None
+    except (json.JSONDecodeError, ValueError):
+        # Fallback to string
+        return StaticValue(s)
+
+
+def get_attribute_setter_info(
+    conn: sqlite3.Connection,
+    component_type: str,
+    attribute_name: str,
+) -> Dict[str, Any]:
+    """
+    Get the appropriate function name for setting an attribute.
+    
+    Args:
+        conn: Database connection
+        component_type: Type of component
+        attribute_name: Name of the attribute
+        
+    Returns:
+        Dictionary with setter function information
+        
+    Raises:
+        ValidationError: If attribute or data type is unknown
+    """
+    rule = get_validation_rule(conn, component_type, attribute_name)
+    
+    function_name = {
+        "float": "set_float_attribute",
+        "int": "set_integer_attribute", 
+        "boolean": "set_boolean_attribute",
+        "string": "set_string_attribute",
+    }.get(rule.data_type)
+    
+    if not function_name:
+        raise ValidationError(f"Unknown data type: {rule.data_type}")
+    
+    return {
+        "function_name": function_name,
+        "data_type": rule.data_type,
+        "allows_static": rule.allows_static,
+        "allows_timeseries": rule.allows_timeseries,
+        "is_required": rule.is_required,
+        "default_value": rule.default_value_string,
+        "unit": rule.unit,
+        "description": rule.description
+    }

pyconvexity-0.1.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: pyconvexity
+Version: 0.1.0
+Summary: Python library for energy system modeling and optimization with PyPSA
+Author-email: Convexity Team <info@convexity.com>
+License: MIT
+Project-URL: Homepage, https://github.com/bayesian-energy/convexity-js
+Project-URL: Repository, https://github.com/bayesian-energy/convexity-js
+Project-URL: Issues, https://github.com/bayesian-energy/convexity-js/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=1.5.0
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pyarrow>=10.0.0
+Provides-Extra: pypsa
+Requires-Dist: pypsa>=0.25.0; extra == "pypsa"
+Requires-Dist: networkx; extra == "pypsa"
+Requires-Dist: scipy; extra == "pypsa"
+Requires-Dist: xarray; extra == "pypsa"
+Provides-Extra: excel
+Requires-Dist: openpyxl>=3.0.0; extra == "excel"
+Requires-Dist: xlsxwriter>=3.0.0; extra == "excel"
+Provides-Extra: netcdf
+Requires-Dist: netcdf4>=1.6.0; extra == "netcdf"
+Requires-Dist: xarray>=2022.3.0; extra == "netcdf"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: isort>=5.10.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pre-commit>=2.20.0; extra == "dev"
+Provides-Extra: all
+Requires-Dist: pyconvexity[excel,netcdf,pypsa]; extra == "all"
+
+# PyConvexity
+
+**Energy system modeling library for optimization and analysis.**
+
+PyConvexity provides the core functionality of the [Convexity](https://github.com/bayesian-energy/convexity-js) desktop application as a reusable, pip-installable Python library.
+
+## Installation
+
+```bash
+pip install pyconvexity
+```
+
+## Quick Start
+
+```python
+import pyconvexity as px
+
+# Create a new energy system model database
+px.create_database_with_schema("my_model.db")
+
+# Create a network
+with px.database_context("my_model.db") as conn:
+    network_req = px.CreateNetworkRequest(
+        name="My Energy Network",
+        description="Example renewable energy system",
+        start_time="2024-01-01 00:00:00",
+        end_time="2024-01-02 00:00:00",
+        time_resolution="H"
+    )
+    network_id = px.create_network(conn, network_req)
+    
+    # Create carriers (energy types)
+    ac_carrier = px.create_carrier(conn, network_id, "AC")
+    
+    # Create components
+    bus_id = px.create_component(
+        conn, network_id, "BUS", "Main Bus",
+        latitude=40.7128, longitude=-74.0060,
+        carrier_id=ac_carrier
+    )
+    
+    # Set component attributes
+    px.set_static_attribute(conn, bus_id, "v_nom", px.StaticValue(230.0))
+    
+    conn.commit()
+
+print(f"✅ Created network {network_id} with bus {bus_id}")
+```
+
+## Features
+
+- **Database Management**: SQLite-based energy system model storage
+- **Component Modeling**: Buses, generators, loads, lines, storage, etc.
+- **Time Series Support**: Efficient storage and retrieval of temporal data
+- **Validation**: Built-in validation rules for energy system components
+- **PyPSA Integration**: Compatible with PyPSA energy system modeling
+- **Type Safety**: Full type hints and data validation
+
+## Core Concepts
+
+### Networks
+Energy system models organized as networks with time periods and carriers.
+
+### Components
+Physical and virtual elements: buses, generators, loads, transmission lines, storage units, etc.
+
+### Attributes
+Component properties that can be static values or time series data.
+
+### Scenarios
+Different parameter sets for the same network topology.
+
+## Documentation
+
+- **Full Documentation**: [Convexity Documentation](https://github.com/bayesian-energy/convexity-js)
+- **API Reference**: See docstrings in the code
+- **Examples**: Check the `examples/` directory
+
+## Development
+
+PyConvexity is developed as part of the [Convexity](https://github.com/bayesian-energy/convexity-js) project by [Bayesian Energy](https://bayesianenergy.com).
+
+## License
+
+MIT License - see [LICENSE](https://github.com/bayesian-energy/convexity-js/blob/main/LICENSE) file for details.
+
+## Related Projects
+
+- **[Convexity](https://github.com/bayesian-energy/convexity-js)**: Desktop application for energy system modeling
+- **[PyPSA](https://pypsa.org/)**: Python for Power System Analysis
+- **[Linopy](https://linopy.readthedocs.io/)**: Linear optimization with Python

pyconvexity-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+pyconvexity/__init__.py,sha256=mEtafBwQ1A9s-hEv3o3XeXlJ7iFtbdS691wVUUw5miY,3303
+pyconvexity/_version.py,sha256=5CA6z91JO_fS9ADhN6383Ps_rUNBx3K4gJNbVRJmeYY,133
+pyconvexity/core/__init__.py,sha256=4SYAE4zqzGIRFSP4IoT7EzK-LCTB1HLe9EWhfi2aUmU,1253
+pyconvexity/core/database.py,sha256=zqurVzPGuWei0jII1PTMAY-qaR-fr_A7uLxm__6KIlE,9276
+pyconvexity/core/errors.py,sha256=HhrrOOEBJrzyB56_pmqh3NWvX6uHqWWNkdE5XM16rYI,2881
+pyconvexity/core/types.py,sha256=eoVOAcDJWzjJKO9lYN7O17Us0XbahBpVBwv6uxdldh0,8508
+pyconvexity/models/__init__.py,sha256=eVwf0ZTTEq1nM9M3NSMvj2yLPUOPNKMXv2A5GLT34-c,1470
+pyconvexity/models/attributes.py,sha256=I6t1x7HX1gLw_lA6K87_GGmLAO34fpe4ZDX7_3LzMx4,13974
+pyconvexity/models/components.py,sha256=K7QWelMVU_D18skvBZbap9dxP2AMS2116fcpmemkE6U,14629
+pyconvexity/models/network.py,sha256=-itmot8StUdXogDpZUhGVIUC5uAEucYQ1LiTN1vPdA4,12923
+pyconvexity/validation/__init__.py,sha256=_6SVqXkaDFqmagub_O064Zm_QIdBrOra-Gvvbo9vM4I,549
+pyconvexity/validation/rules.py,sha256=bshO2Ibw8tBurg708Dmf79rIBoGV32t-jNHltjap9Pw,9323
+pyconvexity-0.1.0.dist-info/METADATA,sha256=ltUWa115nNRTIAl4xbzFDjC2s9Q5LOhJcJHwMBS6ea4,4751
+pyconvexity-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyconvexity-0.1.0.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
+pyconvexity-0.1.0.dist-info/RECORD,,

pyconvexity-0.1.0.dist-info/WHEEL

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

pyconvexity-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyconvexity