flixopt 2.2.0b0__py3-none-any.whl → 2.2.0rc2__py3-none-any.whl

flixopt/io.py

@@ -23,7 +23,7 @@ def replace_timeseries(obj, mode: Literal['name', 'stats', 'data'] = 'name'):
         return [replace_timeseries(v, mode) for v in obj]
     elif isinstance(obj, TimeSeries):  # Adjust this based on the actual class
         if obj.all_equal:
-            return obj.selected_data.values.max().item()
+            return obj.active_data.values[0].item()
         elif mode == 'name':
             return f'::::{obj.name}'
         elif mode == 'stats':
@@ -44,7 +44,7 @@ def insert_dataarray(obj, ds: xr.Dataset):
         return [insert_dataarray(v, ds) for v in obj]
     elif isinstance(obj, str) and obj.startswith('::::'):
         da = ds[obj[4:]]
-        if 'time' in da.dims and da.isel(time=-1).isnull().any().item():
+        if da.isel(time=-1).isnull():
             return da.isel(time=slice(0, -1))
         return da
     else:
@@ -79,17 +79,15 @@ def _save_to_yaml(data, output_file='formatted_output.yaml'):
         output_file (str): Path to output YAML file
     """
     # Process strings to normalize all newlines and handle special patterns
-    processed_data = _normalize_complex_data(data)
+    processed_data = _process_complex_strings(data)
 
     # Define a custom representer for strings
     def represent_str(dumper, data):
-        # Use literal block style (|) for multi-line strings
+        # Use literal block style (|) for any string with newlines
         if '\n' in data:
-            # Clean up formatting for literal block style
-            data = data.strip()  # Remove leading/trailing whitespace
             return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|')
 
-        # Use quoted style for strings with special characters
+        # Use quoted style for strings with special characters to ensure proper parsing
         elif any(char in data for char in ':`{}[]#,&*!|>%@'):
             return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='"')
 
@@ -99,80 +97,53 @@ def _save_to_yaml(data, output_file='formatted_output.yaml'):
     # Add the string representer to SafeDumper
     yaml.add_representer(str, represent_str, Dumper=yaml.SafeDumper)
 
-    # Configure dumper options for better formatting
-    class CustomDumper(yaml.SafeDumper):
-        def increase_indent(self, flow=False, indentless=False):
-            return super(CustomDumper, self).increase_indent(flow, False)
-
     # Write to file with settings that ensure proper formatting
     with open(output_file, 'w', encoding='utf-8') as file:
         yaml.dump(
             processed_data,
             file,
-            Dumper=CustomDumper,
+            Dumper=yaml.SafeDumper,
             sort_keys=False,  # Preserve dictionary order
             default_flow_style=False,  # Use block style for mappings
-            width=1000,  # Set a reasonable line width
+            width=float('inf'),  # Don't wrap long lines
             allow_unicode=True,  # Support Unicode characters
-            indent=2,  # Set consistent indentation
         )
 
 
-def _normalize_complex_data(data):
+def _process_complex_strings(data):
     """
-    Recursively normalize strings in complex data structures.
-
-    Handles dictionaries, lists, and strings, applying various text normalization
-    rules while preserving important formatting elements.
+    Process dictionary data recursively with comprehensive string normalization.
+    Handles various types of strings and special formatting.
 
     Args:
-        data: Any data type (dict, list, str, or primitive)
+        data: The data to process (dict, list, str, or other)
 
     Returns:
-        Data with all strings normalized according to defined rules
+        Processed data with normalized strings
     """
     if isinstance(data, dict):
-        return {key: _normalize_complex_data(value) for key, value in data.items()}
-
+        return {k: _process_complex_strings(v) for k, v in data.items()}
     elif isinstance(data, list):
-        return [_normalize_complex_data(item) for item in data]
-
+        return [_process_complex_strings(item) for item in data]
     elif isinstance(data, str):
-        return _normalize_string_content(data)
-
-    else:
-        return data
-
-
-def _normalize_string_content(text):
-    """
-    Apply comprehensive string normalization rules.
-
-    Args:
-        text: The string to normalize
+        # Step 1: Normalize line endings to \n
+        normalized = data.replace('\r\n', '\n').replace('\r', '\n')
 
-    Returns:
-        Normalized string with standardized formatting
-    """
-    # Standardize line endings
-    text = text.replace('\r\n', '\n').replace('\r', '\n')
+        # Step 2: Handle escaped newlines with robust regex
+        normalized = re.sub(r'(?<!\\)\\n', '\n', normalized)
 
-    # Convert escaped newlines to actual newlines (avoiding double-backslashes)
-    text = re.sub(r'(?<!\\)\\n', '\n', text)
+        # Step 3: Handle unnecessary double backslashes
+        normalized = re.sub(r'\\\\(n)', r'\\\1', normalized)
 
-    # Normalize double backslashes before specific escape sequences
-    text = re.sub(r'\\\\([rtn])', r'\\\1', text)
+        # Step 4: Ensure proper formatting of "[time: N]:\n---------"
+        normalized = re.sub(r'(\[time: \d+\]):\s*\\?n', r'\1:\n', normalized)
 
-    # Standardize constraint headers format
-    text = re.sub(r'Constraint\s*`([^`]+)`\s*(?:\\n|[\s\n]*)', r'Constraint `\1`\n', text)
+        # Step 5: Ensure "Constraint `...`" patterns are properly formatted
+        normalized = re.sub(r'Constraint `([^`]+)`\\?n', r'Constraint `\1`\n', normalized)
 
-    # Clean up ellipsis patterns
-    text = re.sub(r'[\t ]*(\.\.\.)', r'\1', text)
-
-    # Limit consecutive newlines (max 2)
-    text = re.sub(r'\n{3,}', '\n\n', text)
-
-    return text.strip()
+        return normalized
+    else:
+        return data
 
 
 def document_linopy_model(model: linopy.Model, path: pathlib.Path = None) -> Dict[str, str]:

flixopt/linear_converters.py

@@ -165,7 +165,7 @@ class CoolingTower(LinearConverter):
             label,
             inputs=[P_el, Q_th],
             outputs=[],
-            conversion_factors=[{P_el.label: -1, Q_th.label: specific_electricity_demand}],
+            conversion_factors=[{P_el.label: 1, Q_th.label: -specific_electricity_demand}],
             on_off_parameters=on_off_parameters,
             meta_data=meta_data,
         )
@@ -177,12 +177,12 @@ class CoolingTower(LinearConverter):
 
     @property
     def specific_electricity_demand(self):
-        return self.conversion_factors[0][self.Q_th.label]
+        return -self.conversion_factors[0][self.Q_th.label]
 
     @specific_electricity_demand.setter
     def specific_electricity_demand(self, value):
         check_bounds(value, 'specific_electricity_demand', self.label_full, 0, 1)
-        self.conversion_factors[0][self.Q_th.label] = value
+        self.conversion_factors[0][self.Q_th.label] = -value
 
 
 @register_class_for_io