pyconvexity 0.3.8.post7__py3-none-any.whl → 0.4.1__py3-none-any.whl

pyconvexity/core/types.py

@@ -13,11 +13,11 @@ from typing import Dict, Any, Optional, List, Union
 class StaticValue:
     """
     Represents a static (non-time-varying) attribute value.
-    
+
     Mirrors the Rust StaticValue enum while providing Python conveniences.
     Supports float, int, bool, and string values with proper type conversion.
     """
-    
+
     def __init__(self, value: Union[float, int, bool, str]):
         # Check bool before int since bool is subclass of int in Python
         if isinstance(value, bool):
@@ -30,21 +30,23 @@ class StaticValue:
             self.data = {"String": value}
         else:
             raise ValueError(f"Unsupported value type: {type(value)}")
-    
+
     def to_json(self) -> str:
         """
         Return raw value as JSON to match Rust serialization format.
-        
+
         Rust stores: 123.45, 42, true, "hello"
         Not: {"Float": 123.45}, {"Integer": 42}, etc.
         """
         import math
-        
+
         if "Float" in self.data:
             float_val = self.data["Float"]
             # Ensure finite values only
             if not math.isfinite(float_val):
-                raise ValueError(f"Cannot serialize non-finite float value: {float_val}")
+                raise ValueError(
+                    f"Cannot serialize non-finite float value: {float_val}"
+                )
             return json.dumps(float_val)
         elif "Integer" in self.data:
             return json.dumps(self.data["Integer"])
@@ -55,7 +57,7 @@ class StaticValue:
         else:
             # Fallback to original format if unknown
             return json.dumps(self.data)
-    
+
     def data_type(self) -> str:
         """Get data type name - mirrors Rust implementation"""
         if "Float" in self.data:
@@ -68,7 +70,7 @@ class StaticValue:
             return "string"
         else:
             return "unknown"
-    
+
     def as_f64(self) -> float:
         """Convert to float, mirroring Rust implementation"""
         if "Float" in self.data:
@@ -82,7 +84,7 @@ class StaticValue:
                 return float(self.data["String"])
             except ValueError:
                 return 0.0
-    
+
     def value(self) -> Union[float, int, bool, str]:
         """Get the raw Python value"""
         if "Float" in self.data:
@@ -95,10 +97,10 @@ class StaticValue:
             return self.data["String"]
         else:
             raise ValueError("Unknown data type in StaticValue")
-    
+
     def __repr__(self) -> str:
         return f"StaticValue({self.value()})"
-    
+
     def __eq__(self, other) -> bool:
         if isinstance(other, StaticValue):
             return self.data == other.data
@@ -109,73 +111,74 @@ class StaticValue:
 class Timeseries:
     """
     Efficient timeseries data structure matching the new Rust implementation.
-    
-    Stores values as a flat array for maximum performance, matching the 
+
+    Stores values as a flat array for maximum performance, matching the
     unified Rust Timeseries struct.
     """
+
     values: List[float]
     length: int
     start_index: int
     data_type: str
     unit: Optional[str]
     is_input: bool
-    
+
     def __post_init__(self):
         # Ensure length matches values array
         self.length = len(self.values)
         # Ensure all values are float32-compatible
         self.values = [float(v) for v in self.values]
-    
+
     def get_value(self, index: int) -> Optional[float]:
         """Get value at specific index."""
         if 0 <= index < len(self.values):
             return self.values[index]
         return None
-    
+
     def get_range(self, start: int, end: int) -> List[float]:
         """Get a range of values efficiently."""
         end = min(end, len(self.values))
         start = min(start, end)
         return self.values[start:end]
-    
-    def sample(self, max_points: int) -> 'Timeseries':
+
+    def sample(self, max_points: int) -> "Timeseries":
         """Apply sampling if the timeseries is too large."""
         if len(self.values) <= max_points:
             return self
-        
+
         step = len(self.values) // max_points
         sampled_values = []
-        
+
         for i in range(0, len(self.values), max(1, step)):
             sampled_values.append(self.values[i])
-        
+
         # Always include the last point if not already included
         if self.values and sampled_values[-1] != self.values[-1]:
             sampled_values.append(self.values[-1])
-        
+
         return Timeseries(
             values=sampled_values,
             length=len(sampled_values),
             start_index=self.start_index,
             data_type=self.data_type,
             unit=self.unit,
-            is_input=self.is_input
+            is_input=self.is_input,
         )
-    
-    def slice(self, start_index: int, end_index: int) -> 'Timeseries':
+
+    def slice(self, start_index: int, end_index: int) -> "Timeseries":
         """Apply range filtering."""
         start = max(0, start_index - self.start_index)
         end = max(0, end_index - self.start_index)
         end = min(end, len(self.values))
         start = min(start, end)
-        
+
         return Timeseries(
             values=self.values[start:end],
             length=end - start,
             start_index=self.start_index + start,
             data_type=self.data_type,
             unit=self.unit,
-            is_input=self.is_input
+            is_input=self.is_input,
         )
 
 
@@ -183,9 +186,10 @@ class Timeseries:
 class TimeseriesMetadata:
     """
     Metadata about a timeseries without loading the full data.
-    
+
     Mirrors Rust TimeseriesMetadata struct.
     """
+
     length: int
     start_time: int
     end_time: int
@@ -200,9 +204,10 @@ class TimeseriesMetadata:
 class TimePeriod:
     """
     Represents a time period in the network's time axis.
-    
+
     Mirrors Rust TimePeriod structure.
     """
+
     timestamp: int
     period_index: int
     formatted_time: str
@@ -212,9 +217,10 @@ class TimePeriod:
 class TimeseriesValidationResult:
     """
     Result of validating timeseries alignment with network time periods.
-    
+
     Mirrors Rust TimeseriesValidationResult.
     """
+
     is_valid: bool
     missing_periods: List[int]
     extra_periods: List[int]
@@ -226,9 +232,10 @@ class TimeseriesValidationResult:
 class ValidationRule:
     """
     Validation rule for component attributes.
-    
+
     Mirrors Rust ValidationRule with all fields.
     """
+
     component_type: str
     attribute_name: str
     data_type: str
@@ -246,11 +253,11 @@ class ValidationRule:
 class AttributeValue:
     """
     Represents either a static value or timeseries data for a component attribute.
-    
+
     Uses efficient Timeseries format for optimal performance.
     Mirrors Rust AttributeValue enum.
     """
-    
+
     def __init__(self, value: Union[StaticValue, Timeseries]):
         if isinstance(value, StaticValue):
             self.variant = "Static"
@@ -264,31 +271,29 @@ class AttributeValue:
             raise ValueError(
                 f"AttributeValue must be StaticValue or Timeseries, got {type(value)}"
             )
-    
+
     @classmethod
-    def static(cls, value: StaticValue) -> 'AttributeValue':
+    def static(cls, value: StaticValue) -> "AttributeValue":
         """Create a static attribute value"""
         return cls(value)
-    
+
     @classmethod
-    def timeseries(cls, timeseries: Timeseries) -> 'AttributeValue':
+    def timeseries(cls, timeseries: Timeseries) -> "AttributeValue":
         """Create a timeseries attribute value (new format)"""
         return cls(timeseries)
-    
-    
+
     def is_static(self) -> bool:
         """Check if this is a static value"""
         return self.variant == "Static"
-    
+
     def is_timeseries(self) -> bool:
         """Check if this is a timeseries value"""
         return self.variant == "Timeseries"
-    
+
     def as_timeseries(self) -> Optional[Timeseries]:
         """Get the timeseries data in new format"""
         return self.timeseries_value if self.is_timeseries() else None
-    
-    
+
     def __repr__(self) -> str:
         if self.is_static():
             return f"AttributeValue.static({self.static_value})"
@@ -300,12 +305,12 @@ class AttributeValue:
 @dataclass
 class Component:
     """
-    Represents a component in the energy system model.
-    
-    Mirrors Rust Component struct exactly.
+    Represents a component in the energy system model (single network per database).
+
+    Mirrors Rust Component struct.
     """
+
     id: int
-    network_id: int
     component_type: str
     name: str
     longitude: Optional[float] = None
@@ -320,9 +325,10 @@ class Component:
 class Network:
     """
     Represents a network/model in the system.
-    
+
     Enhanced version of network information with additional metadata.
     """
+
     id: int
     name: str
     description: Optional[str] = None
@@ -336,11 +342,11 @@ class Network:
 @dataclass
 class CreateComponentRequest:
     """
-    Request structure for creating a new component.
-    
+    Request structure for creating a new component (single network per database).
+
     Mirrors Rust CreateComponentRequest.
     """
-    network_id: int
+
     component_type: str
     name: str
     description: Optional[str] = None
@@ -356,9 +362,10 @@ class CreateComponentRequest:
 class CreateNetworkRequest:
     """
     Request structure for creating a new network.
-    
+
     Mirrors Rust CreateNetworkRequest.
     """
+
     name: str
     description: Optional[str] = None
     time_resolution: Optional[str] = None
@@ -371,8 +378,8 @@ class Carrier:
     """
     Represents an energy carrier (e.g., electricity, heat, gas).
     """
+
     id: int
-    network_id: int
     name: str
     co2_emissions: float = 0.0
     color: Optional[str] = None
@@ -384,8 +391,8 @@ class Scenario:
     """
     Represents a scenario within a network.
     """
+
     id: int
-    network_id: int
     name: str
     description: Optional[str] = None
     is_master: bool = False

pyconvexity/data/__init__.py

@@ -12,7 +12,6 @@ __all__ = [
     # GEM (Global Energy Monitor) functions
     "get_generators_from_gem",
     "add_gem_generators_to_network",
-    
     # Caching utilities
     "DataCache",
 ]

pyconvexity/data/loaders/cache.py

@@ -14,112 +14,113 @@ from datetime import datetime, timedelta
 
 logger = logging.getLogger(__name__)
 
+
 class DataCache:
     """Manages caching of processed datasets."""
-    
+
     def __init__(self, cache_dir: Optional[str] = None):
         """
         Initialize the cache manager.
-        
+
         Args:
             cache_dir: Directory to store cache files. Defaults to 'data/cache'
         """
         if cache_dir is None:
             cache_dir = "data/cache"
-        
+
         self.cache_dir = Path(cache_dir)
         self.cache_dir.mkdir(parents=True, exist_ok=True)
-        
+
         # Cache metadata file
         self.metadata_file = self.cache_dir / "cache_metadata.json"
         self._load_metadata()
-    
+
     def _load_metadata(self):
         """Load cache metadata from file."""
         if self.metadata_file.exists():
             try:
-                with open(self.metadata_file, 'r') as f:
+                with open(self.metadata_file, "r") as f:
                     self.metadata = json.load(f)
             except (json.JSONDecodeError, FileNotFoundError):
                 self.metadata = {}
         else:
             self.metadata = {}
-    
+
     def _save_metadata(self):
         """Save cache metadata to file."""
-        with open(self.metadata_file, 'w') as f:
+        with open(self.metadata_file, "w") as f:
             json.dump(self.metadata, f, indent=2)
-    
+
     def _get_cache_key(self, dataset_name: str, filters: Dict[str, Any]) -> str:
         """Generate a unique cache key for a dataset and filters combination."""
         # Create a hash of the filters
         filters_str = json.dumps(filters, sort_keys=True)
         filters_hash = hashlib.md5(filters_str.encode()).hexdigest()
-        
+
         return f"{dataset_name}_{filters_hash}"
-    
+
     def _get_cache_file_path(self, cache_key: str) -> Path:
         """Get the file path for a cache key."""
         return self.cache_dir / f"{cache_key}.parquet"
-    
+
     def get_cached_data(
-        self, 
-        dataset_name: str, 
-        filters: Dict[str, Any]
+        self, dataset_name: str, filters: Dict[str, Any]
     ) -> Optional[pd.DataFrame]:
         """
         Retrieve cached data if available and not expired.
-        
+
         Args:
             dataset_name: Name of the dataset
             filters: Filters applied to the dataset
-            
+
         Returns:
             pandas.DataFrame or None: Cached data if available and valid
         """
         cache_key = self._get_cache_key(dataset_name, filters)
         cache_file = self._get_cache_file_path(cache_key)
-        
+
         # Check if cache file exists
         if not cache_file.exists():
             return None
-        
+
         # Check if cache entry exists in metadata
         if cache_key not in self.metadata:
             # Clean up orphaned cache file
             cache_file.unlink(missing_ok=True)
             return None
-        
+
         # Check if cache is expired (default: 7 days)
         cache_info = self.metadata[cache_key]
-        created_time = datetime.fromisoformat(cache_info['created'])
-        max_age = timedelta(days=cache_info.get('max_age_days', 7))
-        
+        created_time = datetime.fromisoformat(cache_info["created"])
+        max_age = timedelta(days=cache_info.get("max_age_days", 7))
+
         if datetime.now() - created_time > max_age:
             logger.info(f"Cache expired for '{dataset_name}', removing...")
             self._remove_cache_entry(cache_key)
             return None
-        
+
         # Load cached data
         try:
             cached_data = pd.read_parquet(cache_file)
-            logger.info(f"Loaded cached data for '{dataset_name}' ({len(cached_data)} rows)")
+            logger.info(
+                f"Loaded cached data for '{dataset_name}' ({len(cached_data)} rows)"
+            )
             return cached_data
         except Exception as e:
             logger.warning(f"Failed to load cached data for '{dataset_name}': {e}")
             self._remove_cache_entry(cache_key)
             return None
-    
+
     def cache_data(
-        self, 
-        dataset_name: str, 
-        data: pd.DataFrame, 
+        self,
+        dataset_name: str,
+        data: pd.DataFrame,
         filters: Dict[str, Any],
-        max_age_days: int = 7
+        max_age_days: int = 7,
     ):
         """
         Cache processed data.
-        
+
         Args:
             dataset_name: Name of the dataset
             data: Processed pandas DataFrame
@@ -128,84 +129,84 @@ class DataCache:
         """
         cache_key = self._get_cache_key(dataset_name, filters)
         cache_file = self._get_cache_file_path(cache_key)
-        
+
         # Save data to parquet file
         data.to_parquet(cache_file, index=False)
-        
+
         # Update metadata
         self.metadata[cache_key] = {
-            'dataset_name': dataset_name,
-            'filters': filters,
-            'created': datetime.now().isoformat(),
-            'max_age_days': max_age_days,
-            'rows': len(data),
-            'columns': list(data.columns)
+            "dataset_name": dataset_name,
+            "filters": filters,
+            "created": datetime.now().isoformat(),
+            "max_age_days": max_age_days,
+            "rows": len(data),
+            "columns": list(data.columns),
         }
-        
+
         self._save_metadata()
         logger.info(f"Cached data for '{dataset_name}' ({len(data)} rows)")
-    
+
     def _remove_cache_entry(self, cache_key: str):
         """Remove a cache entry and its file."""
         cache_file = self._get_cache_file_path(cache_key)
         cache_file.unlink(missing_ok=True)
-        
+
         if cache_key in self.metadata:
             del self.metadata[cache_key]
             self._save_metadata()
-    
+
     def clear_cache(self, dataset_name: Optional[str] = None):
         """
         Clear cache entries.
-        
+
         Args:
             dataset_name: If provided, only clear cache for this dataset
         """
         keys_to_remove = []
-        
+
         for cache_key, info in self.metadata.items():
-            if dataset_name is None or info['dataset_name'] == dataset_name:
+            if dataset_name is None or info["dataset_name"] == dataset_name:
                 keys_to_remove.append(cache_key)
-        
+
         for key in keys_to_remove:
             self._remove_cache_entry(key)
-        
+
         logger.info(f"Cleared {len(keys_to_remove)} cache entries")
-    
+
     def get_cache_info(self) -> Dict[str, Any]:
         """Get information about the cache."""
         total_size = 0
         dataset_counts = {}
-        
+
         for cache_key, info in self.metadata.items():
-            dataset_name = info['dataset_name']
+            dataset_name = info["dataset_name"]
             dataset_counts[dataset_name] = dataset_counts.get(dataset_name, 0) + 1
-            
+
             cache_file = self._get_cache_file_path(cache_key)
             if cache_file.exists():
                 total_size += cache_file.stat().st_size
-        
+
         return {
-            'total_entries': len(self.metadata),
-            'total_size_mb': round(total_size / (1024 * 1024), 2),
-            'dataset_counts': dataset_counts,
-            'cache_dir': str(self.cache_dir)
+            "total_entries": len(self.metadata),
+            "total_size_mb": round(total_size / (1024 * 1024), 2),
+            "dataset_counts": dataset_counts,
+            "cache_dir": str(self.cache_dir),
         }
-    
+
     def cleanup_expired_cache(self):
         """Remove expired cache entries."""
         expired_keys = []
-        
+
         for cache_key, info in self.metadata.items():
-            created_time = datetime.fromisoformat(info['created'])
-            max_age = timedelta(days=info.get('max_age_days', 7))
-            
+            created_time = datetime.fromisoformat(info["created"])
+            max_age = timedelta(days=info.get("max_age_days", 7))
+
             if datetime.now() - created_time > max_age:
                 expired_keys.append(cache_key)
-        
+
         for key in expired_keys:
             self._remove_cache_entry(key)
-        
+
         if expired_keys:
             logger.info(f"Cleaned up {len(expired_keys)} expired cache entries")
         else: