pyconvexity 0.4.2.post1__py3-none-any.whl → 0.4.6__py3-none-any.whl

pyconvexity/solvers/pypsa/storage.py

@@ -29,6 +29,15 @@ class ResultStorage:
     and storing them back to the database with proper validation and error handling.
     """
 
+    def __init__(self, verbose: bool = False):
+        """
+        Initialize ResultStorage.
+
+        Args:
+            verbose: Enable detailed logging output
+        """
+        self.verbose = verbose
+
     def store_results(
         self,
         conn,
@@ -51,71 +60,30 @@ class ResultStorage:
         run_id = solve_result.get("run_id", str(uuid.uuid4()))
 
         try:
-            logger.info("=" * 80)
-            logger.info("📊 STARTING RESULT STORAGE")
-            logger.info("=" * 80)
-
             # Store component results
-            logger.info("📝 Step 1: Storing component results (timeseries data)...")
             component_stats = self._store_component_results(conn, network, scenario_id)
-            logger.info(f"✅ Component results stored: {component_stats}")
 
             # Calculate network statistics first
-            logger.info("📊 Step 2: Calculating network statistics...")
             network_stats = self._calculate_network_statistics(
                 conn, network, solve_result
             )
-            logger.info(f"✅ Network statistics calculated")
-            logger.info(
-                f"   - Total generation: {network_stats.get('core_summary', {}).get('total_generation_mwh', 0):.2f} MWh"
-            )
-            logger.info(
-                f"   - Total cost: {network_stats.get('core_summary', {}).get('total_cost', 0):.2f}"
-            )
 
             # Store solve summary with network statistics
-            logger.info(
-                "💾 Step 3: Storing solve summary to network_solve_results table..."
-            )
             self._store_solve_summary(conn, solve_result, scenario_id, network_stats)
-            # Explicit commit after storing summary
             conn.commit()
-            logger.info("✅ Solve summary stored and committed successfully")
 
             # Store year-based statistics if available
             year_stats_stored = 0
             if solve_result.get("year_statistics"):
-                logger.info(
-                    f"📅 Step 4: Storing year-based statistics ({len(solve_result['year_statistics'])} years)..."
-                )
                 year_stats_stored = self._store_year_based_statistics(
                     conn, network, solve_result["year_statistics"], scenario_id
                 )
-                # Explicit commit after storing year statistics
                 conn.commit()
-                logger.info(
-                    f"✅ Year-based statistics stored and committed: {year_stats_stored} years"
-                )
-            else:
-                logger.warning(
-                    "⚠️ No year_statistics in solve_result - skipping year-based storage"
-                )
-                logger.info(
-                    f"   Available solve_result keys: {list(solve_result.keys())}"
-                )
-
-            logger.info("=" * 80)
-            logger.info("✅ RESULT STORAGE COMPLETED SUCCESSFULLY")
-            logger.info("=" * 80)
 
-            # Final verification - check if data was actually stored
-            cursor = conn.execute(
-                "SELECT COUNT(*) FROM network_solve_results WHERE scenario_id IS ? ",
-                (scenario_id,) if scenario_id is not None else (None,),
-            )
-            count = cursor.fetchone()[0]
+            total_gen = network_stats.get("core_summary", {}).get("total_generation_mwh", 0)
+            total_cost = network_stats.get("core_summary", {}).get("total_cost", 0)
             logger.info(
-                f"🔍 Verification: {count} solve result(s) found in network_solve_results table"
+                f"Results stored: {total_gen:.0f} MWh generation, {total_cost:.0f} cost, {year_stats_stored} years"
             )
 
             return {
@@ -127,10 +95,7 @@ class ResultStorage:
             }
 
         except Exception as e:
-            logger.error("=" * 80)
-            logger.error(f"❌ RESULT STORAGE FAILED: {e}")
-            logger.error("=" * 80)
-            logger.exception("Full traceback:")
+            logger.error(f"Result storage failed: {e}")
             return {
                 "component_stats": {},
                 "network_stats": {},
@@ -382,22 +347,12 @@ class ResultStorage:
     ):
         """Store solve summary to network_solve_results table (single network per database)."""
         try:
-            # Debug logging
-            logger.info(
-                f"📝 _store_solve_summary called with scenario_id={scenario_id} (type={type(scenario_id)})"
-            )
-
             # Prepare solve summary data
             solver_name = solve_result.get("solver_name", "unknown")
             solve_status = solve_result.get("status", "unknown")
             objective_value = solve_result.get("objective_value")
             solve_time = solve_result.get("solve_time", 0.0)
 
-            logger.info(f"   solver_name: {solver_name}")
-            logger.info(f"   solve_status: {solve_status}")
-            logger.info(f"   objective_value: {objective_value}")
-            logger.info(f"   solve_time: {solve_time}")
-
             # Create enhanced solve result with network statistics for serialization
             enhanced_solve_result = {
                 **solve_result,
@@ -406,31 +361,20 @@ class ResultStorage:
 
             # Delete existing result for this scenario first (handles NULL scenario_id correctly)
             if scenario_id is None:
-                logger.info("🗑️ Deleting existing base scenario (NULL) results")
-                delete_result = conn.execute(
+                conn.execute(
                     "DELETE FROM network_solve_results WHERE scenario_id IS NULL"
                 )
-                logger.info(f"   Deleted {delete_result.rowcount} existing rows")
             else:
-                logger.info(
-                    f"🗑️ Deleting existing results for scenario_id={scenario_id}"
-                )
-                delete_result = conn.execute(
+                conn.execute(
                     "DELETE FROM network_solve_results WHERE scenario_id = ?",
                     (scenario_id,),
                 )
-                logger.info(f"   Deleted {delete_result.rowcount} existing rows")
 
-            logger.info(f"💾 Inserting solve results for scenario_id={scenario_id}")
-            logger.info(
-                f"   Serializing results_json ({len(str(enhanced_solve_result))} chars)..."
-            )
             results_json = self._serialize_results_json(enhanced_solve_result)
-            logger.info(f"   Serializing metadata_json...")
             metadata_json = self._serialize_metadata_json(enhanced_solve_result)
 
             # Insert new solve results summary
-            insert_result = conn.execute(
+            conn.execute(
                 """
                 INSERT INTO network_solve_results (
                     scenario_id, solver_name, solve_type, solve_status,
@@ -449,20 +393,8 @@ class ResultStorage:
                 ),
             )
 
-            logger.info(f"✅ Inserted solve summary (rowid={insert_result.lastrowid})")
-
-            # Verify insertion
-            verify_cursor = conn.execute(
-                "SELECT COUNT(*), solver_name, solve_status FROM network_solve_results WHERE scenario_id IS ?",
-                (scenario_id,) if scenario_id is not None else (None,),
-            )
-            verify_result = verify_cursor.fetchone()
-            logger.info(
-                f"🔍 Verification: {verify_result[0]} row(s) with solver={verify_result[1]}, status={verify_result[2]}"
-            )
-
         except Exception as e:
-            logger.error(f"❌ FAILED to store solve summary: {e}", exc_info=True)
+            logger.error(f"Failed to store solve summary: {e}")
             raise  # Re-raise to trigger rollback
 
     def _calculate_network_statistics(
@@ -605,30 +537,19 @@ class ResultStorage:
         This is the primary calculation - per-year stats will be calculated separately.
         """
         try:
-            logger.info("🔍 _calculate_carrier_statistics: Starting calculation...")
-
             # Calculate all-year statistics directly from the network
             # Extract years from network snapshots
             if hasattr(network.snapshots, "levels"):
                 # Multi-period optimization - get years from period level
                 period_values = network.snapshots.get_level_values(0)
                 years = sorted(period_values.unique())
-                logger.info(
-                    f"   Detected multi-period optimization with years: {years}"
-                )
             elif hasattr(network.snapshots, "year"):
                 years = sorted(network.snapshots.year.unique())
-                logger.info(f"   Detected DatetimeIndex with years: {years}")
             elif hasattr(network, "_available_years"):
                 years = network._available_years
-                logger.info(f"   Using _available_years: {years}")
             else:
                 years = [2020]  # Fallback
-                logger.warning(f"   No year information found, using fallback: {years}")
-
-            logger.info(
-                f"📅 Calculating all-year carrier statistics for {len(years)} years: {years}"
-            )
+                logger.warning(f"No year information found, using fallback: {years}")
 
             # Calculate per-year statistics first
             all_year_stats = {
@@ -694,51 +615,10 @@ class ResultStorage:
                             year_stats["energy_capacity_by_carrier"].get(carrier, 0.0)
                         )
 
-            logger.info(f"Calculated all-year carrier statistics:")
-            logger.info(
-                f"  Total dispatch: {sum(all_year_stats['dispatch_by_carrier'].values()):.2f} MWh"
-            )
-            logger.info(
-                f"  Total emissions: {sum(all_year_stats['emissions_by_carrier'].values()):.2f} tonnes CO2"
-            )
-            logger.info(
-                f"  Total capital cost: {sum(all_year_stats['capital_cost_by_carrier'].values()):.2f} USD"
-            )
-            logger.info(
-                f"  Total operational cost: {sum(all_year_stats['operational_cost_by_carrier'].values()):.2f} USD"
-            )
-            logger.info(
-                f"  Final power capacity: {sum(all_year_stats['power_capacity_by_carrier'].values()):.2f} MW"
-            )
-            
-            # Detailed logging for cost and emission statistics by carrier
-            logger.info("=" * 80)
-            logger.info("📊 DETAILED CARRIER STATISTICS (RAW VALUES FROM MODEL):")
-            logger.info("=" * 80)
-            for carrier in sorted(all_carriers_with_unmet):
-                dispatch = all_year_stats['dispatch_by_carrier'].get(carrier, 0.0)
-                emissions = all_year_stats['emissions_by_carrier'].get(carrier, 0.0)
-                capital_cost = all_year_stats['capital_cost_by_carrier'].get(carrier, 0.0)
-                operational_cost = all_year_stats['operational_cost_by_carrier'].get(carrier, 0.0)
-                total_cost = all_year_stats['total_system_cost_by_carrier'].get(carrier, 0.0)
-                power_cap = all_year_stats['power_capacity_by_carrier'].get(carrier, 0.0)
-                energy_cap = all_year_stats['energy_capacity_by_carrier'].get(carrier, 0.0)
-                
-                if dispatch > 0.001 or emissions > 0.001 or capital_cost > 0.001 or operational_cost > 0.001:
-                    logger.info(f"  {carrier}:")
-                    logger.info(f"    - Dispatch: {dispatch:.2f} MWh")
-                    logger.info(f"    - Emissions: {emissions:.2f} tonnes CO2")
-                    logger.info(f"    - Capital Cost: {capital_cost:.2f} USD")
-                    logger.info(f"    - Operational Cost: {operational_cost:.2f} USD")
-                    logger.info(f"    - Total System Cost: {total_cost:.2f} USD")
-                    logger.info(f"    - Power Capacity: {power_cap:.2f} MW")
-                    logger.info(f"    - Energy Capacity: {energy_cap:.2f} MWh")
-            logger.info("=" * 80)
-
             return all_year_stats
 
         except Exception as e:
-            logger.error(f"Failed to calculate carrier statistics: {e}", exc_info=True)
+            logger.error(f"Failed to calculate carrier statistics: {e}")
             return {
                 "dispatch_by_carrier": {},
                 "power_capacity_by_carrier": {},
@@ -836,19 +716,15 @@ class ResultStorage:
                     )
 
                     stored_count += 1
-                    logger.info(f"Stored year-based statistics for year {year}")
 
                 except Exception as e:
                     logger.error(f"Failed to store statistics for year {year}: {e}")
                     continue
 
-            logger.info(
-                f"Successfully stored year-based statistics for {stored_count} years"
-            )
             return stored_count
 
         except Exception as e:
-            logger.error(f"Failed to store year-based statistics: {e}", exc_info=True)
+            logger.error(f"Failed to store year-based statistics: {e}")
             return 0
 
     def _calculate_year_carrier_statistics(
@@ -859,7 +735,6 @@ class ResultStorage:
         For now, only calculate capacity statistics.
         """
         try:
-            logger.info(f"   🔍 Calculating statistics for year {year}...")
             # Initialize carrier statistics
             carrier_stats = {
                 "dispatch_by_carrier": {},
@@ -1136,24 +1011,6 @@ class ResultStorage:
 
                             # Calculate annualized capital cost for this year
                             annual_capital_cost = capacity_mw * capital_cost_per_mw
-                            
-                            # Log capital cost calculation details with unit check
-                            if annual_capital_cost > 0.001:
-                                logger.info(
-                                    f"    💰 Capital cost calc for {gen_name} ({carrier_name}) in year {year}: "
-                                    f"{capacity_mw:.2f} MW × {capital_cost_per_mw:.2f} currency/MW = {annual_capital_cost:.2f} currency"
-                                )
-                                # Check if values seem too small (might be in kUSD instead of USD)
-                                if capital_cost_per_mw > 0 and capital_cost_per_mw < 1:
-                                    logger.warning(
-                                        f"      ⚠️ WARNING: capital_cost_per_mw ({capital_cost_per_mw:.2f}) seems very small. "
-                                        f"Expected USD/MW but might be in kUSD/MW (thousands)?"
-                                    )
-                                if annual_capital_cost > 0 and annual_capital_cost < 1000:
-                                    logger.warning(
-                                        f"      ⚠️ WARNING: annual_capital_cost ({annual_capital_cost:.2f}) seems very small. "
-                                        f"Expected USD but might be in kUSD (thousands)?"
-                                    )
 
                             if carrier_name in carrier_stats["capital_cost_by_carrier"]:
                                 carrier_stats["capital_cost_by_carrier"][
@@ -1459,24 +1316,6 @@ class ResultStorage:
 
                                 # Calculate operational cost for this year
                                 operational_cost = generation_mwh * marginal_cost
-                                
-                                # Log operational cost calculation details with unit check
-                                if operational_cost > 0.001:
-                                    logger.info(
-                                        f"    💰 Operational cost calc for {gen_name} ({carrier_name}) in year {year}: "
-                                        f"{generation_mwh:.2f} MWh × {marginal_cost:.2f} currency/MWh = {operational_cost:.2f} currency"
-                                    )
-                                    # Check if values seem too small (might be in kUSD instead of USD)
-                                    if marginal_cost > 0 and marginal_cost < 1:
-                                        logger.warning(
-                                            f"      ⚠️ WARNING: marginal_cost ({marginal_cost:.2f}) seems very small. "
-                                            f"Expected USD/MWh but might be in kUSD/MWh (thousands)?"
-                                        )
-                                    if operational_cost > 0 and operational_cost < 1000:
-                                        logger.warning(
-                                            f"      ⚠️ WARNING: operational_cost ({operational_cost:.2f}) seems very small. "
-                                            f"Expected USD but might be in kUSD (thousands)?"
-                                        )
 
                                 if (
                                     carrier_name
@@ -1899,50 +1738,10 @@ class ResultStorage:
                                     carrier_name
                                 ] += capacity_mw
 
-            logger.info(f"Calculated year {year} carrier statistics:")
-            logger.info(
-                f"  Dispatch: {sum(carrier_stats['dispatch_by_carrier'].values()):.2f} MWh"
-            )
-            logger.info(
-                f"  Emissions: {sum(carrier_stats['emissions_by_carrier'].values()):.2f} tonnes CO2"
-            )
-            logger.info(
-                f"  Capital cost: {sum(carrier_stats['capital_cost_by_carrier'].values()):.2f} USD"
-            )
-            logger.info(
-                f"  Operational cost: {sum(carrier_stats['operational_cost_by_carrier'].values()):.2f} USD"
-            )
-            logger.info(
-                f"  Total system cost: {sum(carrier_stats['total_system_cost_by_carrier'].values()):.2f} USD"
-            )
-            logger.info(
-                f"  Power capacity: {sum(carrier_stats['power_capacity_by_carrier'].values()):.2f} MW"
-            )
-            logger.info(
-                f"  Energy capacity: {sum(carrier_stats['energy_capacity_by_carrier'].values()):.2f} MWh"
-            )
-            
-            # Detailed logging for year-specific statistics
-            logger.info(f"  📊 Year {year} detailed carrier stats (RAW VALUES):")
-            for carrier in sorted(all_carriers_with_unmet):
-                dispatch = carrier_stats['dispatch_by_carrier'].get(carrier, 0.0)
-                emissions = carrier_stats['emissions_by_carrier'].get(carrier, 0.0)
-                capital_cost = carrier_stats['capital_cost_by_carrier'].get(carrier, 0.0)
-                operational_cost = carrier_stats['operational_cost_by_carrier'].get(carrier, 0.0)
-                total_cost = carrier_stats['total_system_cost_by_carrier'].get(carrier, 0.0)
-                
-                if dispatch > 0.001 or emissions > 0.001 or capital_cost > 0.001 or operational_cost > 0.001:
-                    logger.info(f"    {carrier}: dispatch={dispatch:.2f} MWh, emissions={emissions:.2f} tCO2, "
-                              f"capital={capital_cost:.2f} USD, operational={operational_cost:.2f} USD, "
-                              f"total={total_cost:.2f} USD")
-
             return carrier_stats
 
         except Exception as e:
-            logger.error(
-                f"Failed to calculate year {year} carrier statistics: {e}",
-                exc_info=True,
-            )
+            logger.error(f"Failed to calculate year {year} carrier statistics: {e}")
             return {
                 "dispatch_by_carrier": {},
                 "power_capacity_by_carrier": {},
@@ -2000,10 +1799,8 @@ class ResultStorage:
             )
 
             year_results = cursor.fetchall()
-            logger.info(f"Found {len(year_results)} year-based results to sum")
 
             if not year_results:
-                logger.warning(f"No year-based results found")
                 return totals
 
             # For capacity: use the LAST YEAR only (final capacity state)
@@ -2031,10 +1828,6 @@ class ResultStorage:
                             value or 0
                         )
 
-                logger.info(
-                    f"Used last year ({last_year}) capacity as all-year capacity"
-                )
-
             except Exception as e:
                 logger.error(f"Failed to process last year ({last_year}) results: {e}")
 
@@ -2091,35 +1884,10 @@ class ResultStorage:
                     logger.error(f"Failed to process year {year} results: {e}")
                     continue
 
-            logger.info(f"Summed carrier statistics across {len(year_results)} years:")
-            logger.info(
-                f"  Final power capacity: {sum(totals['power_capacity_by_carrier'].values()):.2f} MW"
-            )
-            logger.info(
-                f"  Final energy capacity: {sum(totals['energy_capacity_by_carrier'].values()):.2f} MWh"
-            )
-            logger.info(
-                f"  Total dispatch: {sum(totals['dispatch_by_carrier'].values()):.2f} MWh"
-            )
-            logger.info(
-                f"  Total emissions: {sum(totals['emissions_by_carrier'].values()):.2f} tonnes CO2"
-            )
-            logger.info(
-                f"  Total capital cost: {sum(totals['capital_cost_by_carrier'].values()):.2f} USD"
-            )
-            logger.info(
-                f"  Total operational cost: {sum(totals['operational_cost_by_carrier'].values()):.2f} USD"
-            )
-            logger.info(
-                f"  Total system cost: {sum(totals['total_system_cost_by_carrier'].values()):.2f} USD"
-            )
-
             return totals
 
         except Exception as e:
-            logger.error(
-                f"Failed to sum year-based carrier statistics: {e}", exc_info=True
-            )
+            logger.error(f"Failed to sum year-based carrier statistics: {e}")
             # Return empty structure on error
             return {
                 "dispatch_by_carrier": {},

pyconvexity-0.4.6.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: pyconvexity
+Version: 0.4.6
+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/pyconvexity
+Project-URL: Repository, https://github.com/bayesian-energy/pyconvexity
+Project-URL: Issues, https://github.com/bayesian-energy/pyconvexity/issues
+Project-URL: Documentation, https://pyconvexity.readthedocs.io
+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: data
+Requires-Dist: country-converter>=1.0.0; extra == "data"
+Requires-Dist: pyyaml>=6.0.0; extra == "data"
+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[data,excel,netcdf,pypsa]; extra == "all"
+
+# pyconvexity
+
+Python library for energy system modeling and optimization with PyPSA.
+
+[![PyPI version](https://badge.fury.io/py/pyconvexity.svg)](https://badge.fury.io/py/pyconvexity)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Overview
+
+pyconvexity is the Python library that powers [Convexity](https://bayesian.energy/convexity), providing programmatic access to energy system modeling and optimization. It stores models in SQLite databases and integrates with PyPSA for solving.
+
+## Installation
+
+```bash
+pip install pyconvexity
+```
+
+With optional dependencies:
+
+```bash
+pip install pyconvexity[pypsa]     # PyPSA solver integration
+pip install pyconvexity[excel]     # Excel import/export
+pip install pyconvexity[all]       # All optional dependencies
+```
+
+## Quick Start
+
+```python
+import pyconvexity as px
+
+# Create a new 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 Network",
+        start_time="2024-01-01 00:00:00",
+        end_time="2024-01-01 23:00:00",
+        time_resolution="PT1H",
+    )
+    px.create_network(conn, network_req)
+    
+    # Create components
+    carrier_id = px.create_carrier(conn, name="AC")
+    bus_id = px.create_component(conn, "BUS", "Main Bus", carrier_id=carrier_id)
+    
+    conn.commit()
+
+# Solve the network
+result = px.solve_network("my_model.db", solver_name="highs")
+print(f"Success: {result['success']}, Objective: {result['objective_value']}")
+```
+
+## Documentation
+
+Full documentation is available at: **[docs.bayesian.energy](https://docs.bayesian.energy/convexity/user-guide/advanced-features/pyconvexity/)**
+
+- [API Reference](https://docs.bayesian.energy/convexity/user-guide/advanced-features/pyconvexity/api/api-reference)
+- [Examples & Tutorials](https://docs.bayesian.energy/convexity/user-guide/advanced-features/pyconvexity/examples/example-1/)
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/bayesian-energy/pyconvexity.git
+cd pyconvexity
+pip install -e ".[dev,all]"
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Documentation Deployment
+
+API documentation is auto-generated and synced to [bayesian-docs](https://github.com/bayesian-energy/bayesian-docs).
+
+**Generate API docs locally:**
+
+```bash
+python scripts/generate_api_docs.py --output-dir api-docs
+```
+
+**How it works:**
+1. On push to `main` or release, the `sync-docs.yml` workflow runs
+2. It generates API markdown from Python docstrings
+3. Commits the generated docs to the `bayesian-docs` repository
+
+**Setup for maintainers:**
+- Add `DOCS_DEPLOY_TOKEN` secret to the repo (personal access token with `repo` scope for bayesian-docs)
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+

{pyconvexity-0.4.2.post1.dist-info → pyconvexity-0.4.6.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pyconvexity/__init__.py,sha256=TJvgkEaMHFFWhIGaOdjMgc4rHVIxHKni3Ggg1YAQziE,5347
-pyconvexity/_version.py,sha256=BObAQyMJTgNEQbPpM5x4R8aeAPCZ_eHVSXPwL90NUlk,28
+pyconvexity/_version.py,sha256=bbBpXE_PBbo_SaI807mDML0QJywD0_ufCDPgAMlDHaE,22
 pyconvexity/timeseries.py,sha256=QdKbiqjAlxkJATyKm2Kelx1Ea2PsAnnCYfVLU5VER1Y,11085
 pyconvexity/core/__init__.py,sha256=gdyyHNqOc4h9Nfe9u6NA936GNzH6coGNCMgBvvvOnGE,1196
 pyconvexity/core/database.py,sha256=vwCmuN0B0xwImh6L0bFR4vNWHw_wVfYSG1KwsUjK4iY,14831
@@ -11,7 +11,7 @@ pyconvexity/data/loaders/__init__.py,sha256=6xPtOmH2n1mNby7ZjA-2Mk9F48Q246RNsyMn
 pyconvexity/data/loaders/cache.py,sha256=R-DUIiFpphjyi5EitcUZwzwUdZeqN6poYVyuNpKzB4g,7040
 pyconvexity/data/schema/01_core_schema.sql,sha256=xCCxUl65IGYxaMxAbgZVS7jVceRUJ_wOMw5c7cm6_Ww,16903
 pyconvexity/data/schema/02_data_metadata.sql,sha256=BbpTkH1s7IbZQkDBRF2kL_UR9tzMEWDBYS3VBkwDRu0,4323
-pyconvexity/data/schema/03_validation_data.sql,sha256=bxadwwN9Om0KYwRo3lXom33TJI5cg4n2n_X0rpK2CoA,88454
+pyconvexity/data/schema/03_validation_data.sql,sha256=Y4iZ1RzqMzeaBWalecT6BRd8I3MSW5nclXJI3cE_JAQ,88663
 pyconvexity/data/sources/__init__.py,sha256=Dn6_oS7wB-vLjMj2YeXlmIl6hNjACbicimSabKxIWnc,108
 pyconvexity/data/sources/gem.py,sha256=v8OYCMsb2t-8u-YmK8vzMsgI9ArUAOAXMZZQOFpJ-nI,14923
 pyconvexity/io/__init__.py,sha256=FCyvRDfBUrrNei-y5JVod6MMN1bkPMSSfE0fpKi1aKQ,751
@@ -23,20 +23,20 @@ pyconvexity/models/__init__.py,sha256=WqDSq1Mst7iJsFytausruoM562FKlOKV0Egmnpm290
 pyconvexity/models/attributes.py,sha256=RpH3rBoHD33xBSXUEfaD-CvRj3JruolCwexo6HPMGC8,23388
 pyconvexity/models/carriers.py,sha256=L_WuDMW13k8aaA-obsDPxjmpZgZELiIAZuNtxq7YLpg,3447
 pyconvexity/models/components.py,sha256=vxznTAvAzF99ILcc1DdLtj4K6k8aqclwlH1VhLcFAMM,17570
-pyconvexity/models/network.py,sha256=A5_GVxVeuthAmVKfoSA4ANhVXKwuRizke3E7eR0P8rM,11535
+pyconvexity/models/network.py,sha256=P2Cuxv2lX9gWDwIBDDFqLs1sznhAXYquYNYstaMPjfU,14352
 pyconvexity/models/results.py,sha256=6j1H4AwVmp94L97gl_sGnE8izMxkU5o89guKIU8JdtE,4169
 pyconvexity/models/scenarios.py,sha256=-0UPUDXf6r9mFriA-z2fD5KKMARm2PUBjLba49S9mCI,5867
 pyconvexity/solvers/__init__.py,sha256=t1gOUTqbYDCtIvKPqGVY1fjKwqJi2Od9bGeIO7bPvJE,667
 pyconvexity/solvers/pypsa/__init__.py,sha256=nudu0AOYEfPhpGHZ1Q9pUgjGeeIJd_zeULc975iyluE,555
-pyconvexity/solvers/pypsa/api.py,sha256=9cK5cnJxRI6rkCvqELwMcTFGbmFYJgDsXD6UKCQ5Yfw,17897
+pyconvexity/solvers/pypsa/api.py,sha256=OXGfVsv76HIXMJ4b_5LSiWW1OL5Xiq5EnUzaArTuaTI,18196
 pyconvexity/solvers/pypsa/batch_loader.py,sha256=w525_lqanKtARKgicajhBiDwIJzkaU_HbkL1I82gDqg,12361
-pyconvexity/solvers/pypsa/builder.py,sha256=Nx6fSNzbW4KYbqrgQD-dSlnzvGmypCwcjXwm5KNFq9c,24351
+pyconvexity/solvers/pypsa/builder.py,sha256=SOr77SmDCYKNxfb-wGHYRX5A0M7zdv_E2Sjyf82uS6Y,24208
 pyconvexity/solvers/pypsa/constraints.py,sha256=20WliFDhPQGMAsS4VOTU8LZJpsFpLVRHpNsZW49GTcc,16397
-pyconvexity/solvers/pypsa/solver.py,sha256=RjHece-2j3dvzR0zVJYLoSBJnSxbAYPx2f0MN_h6acM,74176
-pyconvexity/solvers/pypsa/storage.py,sha256=7IoT2DpWBKe6jTdKe11a_48d8AuI1TzNMe7LSI3PG-g,107947
+pyconvexity/solvers/pypsa/solver.py,sha256=oXX2kqU9AWg8GgsMOV0fYqv93XjIk8Kh-fKWbQSzaig,63239
+pyconvexity/solvers/pypsa/storage.py,sha256=9edLe46f62jvpai1mNQEKypV77L26VyFdvKgQLCEA3o,94635
 pyconvexity/validation/__init__.py,sha256=VJNZlFoWABsWwUKktNk2jbtXIepH5omvC0WtsTS7o3o,583
 pyconvexity/validation/rules.py,sha256=GiNadc8hvbWBr09vUkGiLLTmSdvtNSeGLFwvCjlikYY,9241
-pyconvexity-0.4.2.post1.dist-info/METADATA,sha256=P68R4qaVX3K5d9fumRaXUby3q22i7CKXg9hUdnO9nss,2019
-pyconvexity-0.4.2.post1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyconvexity-0.4.2.post1.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
-pyconvexity-0.4.2.post1.dist-info/RECORD,,
+pyconvexity-0.4.6.dist-info/METADATA,sha256=YEKMDpHrBrlWJZ8VA1DJgHrLN2oLXZNl3aojYwebRfg,4967
+pyconvexity-0.4.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyconvexity-0.4.6.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
+pyconvexity-0.4.6.dist-info/RECORD,,