psr-factory 5.0.0b35__py3-none-win_amd64.whl → 5.0.0b37__py3-none-win_amd64.whl

psr/factory/__init__.py

@@ -2,6 +2,6 @@
 # Unauthorized copying of this file, via any medium is strictly prohibited
 # Proprietary and confidential
 
-__version__ = "5.0.0b35"
+__version__ = "5.0.0b37"
 
 from .api import *

psr/outputs/__init__.py

@@ -0,0 +1,5 @@
+# PSR Factory. Copyright (C) PSR, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+from outputs import *

psr/outputs/outputs.py

@@ -0,0 +1,179 @@
+# PSR Factory. Copyright (C) PSR, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+import csv
+import os
+from pathlib import Path
+from typing import (List)
+import pandas
+import psr.factory
+
+
+_language_dict_map = {
+    0: 'ENG',
+    1: 'ESP',
+    2: 'POR',
+}
+
+_default_language = 0
+
+
+def __rename_lang_columns(df: pandas.DataFrame) -> pandas.DataFrame:
+    default_language_code = _language_dict_map.get(_default_language, 'ENG')
+    languages = list(_language_dict_map.values())
+    languages.remove(default_language_code)
+    lang_cols = [col for col in df.columns if col.startswith(tuple(languages))]
+    df = df.drop(columns=lang_cols)
+    # Rename the default language column to remove prefix ENG-
+    for column in df.columns:
+        if column.startswith(f"{default_language_code}-"):
+            new_col = column[len(f"{default_language_code}-"):]
+            df = df.rename(columns={column: new_col})
+    return df
+
+
+def get_available_outputs_by_model(tool_path: str) -> pandas.DataFrame:
+    dat_file = os.path.join(tool_path, "indexdat.fmt")
+    if not os.path.exists(dat_file):
+        raise FileNotFoundError(f"Could not find {dat_file}")
+    cls_file = os.path.join(tool_path, "indexcls.fmt")
+    if not os.path.exists(cls_file):
+        raise FileNotFoundError(f"Could not find {cls_file}")
+    typ_file = os.path.join(tool_path, "indextyp.fmt")
+    if not os.path.exists(typ_file):
+        raise FileNotFoundError(f"Could not find {typ_file}")
+
+    dat_df = pandas.read_csv(dat_file, delimiter=',', encoding='latin1', skiprows=1)
+    dat_df = __rename_lang_columns(dat_df)
+    dat_df.drop(columns=["PSRIO"], inplace=True)
+
+    cls_df = pandas.read_csv(cls_file, delimiter=',', encoding='latin1', skiprows=1)
+    cls_df = __rename_lang_columns(cls_df)
+    cls_df.rename(columns={"Name": "ClassName"}, inplace=True)
+    cls_df.drop(columns=["Description", "PSRIO-Class"], inplace=True)
+
+    typ_df = pandas.read_csv(typ_file, delimiter=',', encoding='latin1', skiprows=1)
+    typ_df = __rename_lang_columns(typ_df)
+    typ_df.rename(columns={"Name": "TypeName"}, inplace=True)
+
+    # merge class names and type names
+    dat_df = dat_df.merge(cls_df, how='left', left_on='Class', right_on='!Class')
+    dat_df = dat_df.merge(typ_df, how='left', left_on='Type', right_on='!Type')
+    dat_df.drop(columns=["!Class", "!Type"], inplace=True)
+    dat_df.rename(columns={"!Num": "Number", "TypeName": "Type", "ClassName": "Class"}, inplace=True)
+
+    return dat_df
+
+
+class AvailableOutput:
+    def __init__(self):
+        self.filename = ""
+        self.file_type = ""
+        self.description = ""
+        self.unit = ""
+        self.attribute_class = ""
+        self.case_path = ""
+    def load_dataframe(self) -> psr.factory.DataFrame:
+        full_file_name = str(self)
+        return psr.factory.load_dataframe(full_file_name)
+
+    def __str__(self):
+        return os.path.join(self.case_path, f"{self.filename}.{self.file_type}")
+
+    def __repr__(self):
+        return f"AvailableOutput(path='{str(self)}', description='{self.description}', unit='{self.unit}', attribute_class={self.attribute_class})"
+
+
+def get_available_outputs(case_path: str) -> List[AvailableOutput]:
+    indice_grf_path = os.path.join(case_path, "indice.grf")
+    outputs = []
+    with open(indice_grf_path, 'r', encoding='latin1') as f:
+        next(f)  # Skip header
+        next(f)
+        reader = csv.reader(f, delimiter=',')
+        for row in reader:
+            if len(row) >= 4:
+                output = AvailableOutput()
+                full_file_name = row[0].strip()
+                output.filename, output.file_type = os.path.splitext(full_file_name)
+                output.filename = output.filename.strip()
+                output.file_type = output.file_type.lstrip('.').strip()
+                output.description = row[1].strip()
+                output.unit = row[2].strip()
+                output.attribute_class = row[3].strip()
+                output.case_path = case_path
+                outputs.append(output)
+    return outputs
+
+
+class OutputsDataFrame(pandas.DataFrame):
+    def __setitem__(self, key, value):
+        if isinstance(value, bool):
+            self.loc[key, 'Active'] = value
+        else:
+            super().__setitem__(key, value)
+            
+    def save(self, case_path: str) -> None:
+        save(self, case_path)
+
+
+def save(df: pandas.DataFrame, case_path: str) -> None:
+    index_df = load_index_dat(case_path)
+
+    for filename, row in df.iterrows():
+        mask = index_df['Num'] == row['Num']
+        if any(mask):
+            index_df.loc[mask, 'YN'] = 1 if row['Active'] else 0
+
+    output_lines = ['Num Graph...........................|...Unid Type  Y/N']
+    for _, row in index_df.iterrows():
+        line = f"{row['Num']:>3d} {row['Description']:<33}{row['Unit']:7} {int(row['Type']):>4d} {row['YN']:>4d}"
+        output_lines.append(line)
+        
+    index_file = os.path.join(case_path, "index.dat")
+    with open(index_file, 'w', encoding='utf-8') as f:
+        for line in output_lines:
+            f.write(f"{line}\n")
+
+
+def load_index_dat(case_path: str) -> pandas.DataFrame:
+    index_file = os.path.join(case_path, "index.dat")
+    if not os.path.exists(index_file):
+        raise FileNotFoundError(f"Could not find {index_file}")
+    
+    widths = [4, 33, 8, 5, 4]
+    names = ['Num', 'Description', 'Unit', 'Type', 'YN']
+    
+    return pandas.read_fwf(
+        index_file,
+        widths=widths,
+        names=names,
+        skiprows=1
+    )
+
+
+def load(case_path: str) -> OutputsDataFrame:
+    sddp_path = Path("C:/PSR")
+    sddp_dirs = [d for d in sddp_path.iterdir() if d.name.startswith("Sddp")]
+    if not sddp_dirs:
+        raise FileNotFoundError("Could not find SDDP installation")
+    sddp_path = sorted(sddp_dirs)[-1]
+            
+    fmt_file = Path(sddp_path) / "Oper" / "indexdat.fmt"
+    if not fmt_file.exists():
+        raise FileNotFoundError(f"Could not find {fmt_file}")
+        
+    fmt_df = pandas.read_csv(fmt_file, delimiter=',', encoding='latin1', skiprows=1)
+    index_df = load_index_dat(case_path)
+    
+    outputs_df = OutputsDataFrame()
+    for _, row in fmt_df.iterrows():
+        num = row['!Num']
+        filename = row['Filename']
+        index_row = index_df[index_df['Num'] == num]
+        if not index_row.empty:
+            outputs_df.loc[filename, 'Num'] = num
+            outputs_df.loc[filename, 'Active'] = bool(index_row['YN'].iloc[0])
+            
+    return outputs_df

psr/outputs/resample.py

@@ -0,0 +1,289 @@
+import datetime as dt
+from typing import List, Dict, Optional, Tuple
+
+import numpy as np
+import pandas
+import pandas as pd
+import psr.factory
+
+HOURS_PER_DAY = 24
+DAYS_PER_WEEK = 7
+HOURS_PER_WEEK = HOURS_PER_DAY * DAYS_PER_WEEK  # 168 hours
+WEEKS_PER_YEAR = 52
+AR_STAGE_SAMPLES = 6
+
+_number_of_days_per_month = {1: 31, 2: 28, 3: 31, 4: 30, 5: 31, 6: 30, 7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31}
+
+_g_week_start_date_by_year: Dict[int, List[dt.datetime]] = {}
+
+_week_max_hours = 7 * 24
+
+
+def get_sddp_stages_by_year(year: int) -> List[dt.datetime]:
+    global _g_week_start_date_by_year
+    if year not in _g_week_start_date_by_year:
+        _g_week_start_date_by_year[year] = [
+            dt.datetime(year, 1, 1),
+            dt.datetime(year, 1, 8),
+            dt.datetime(year, 1, 15),
+            dt.datetime(year, 1, 22),
+            dt.datetime(year, 1, 29),
+            dt.datetime(year, 2, 5),
+            dt.datetime(year, 2, 12),
+            dt.datetime(year, 2, 19),
+            dt.datetime(year, 2, 26),
+            dt.datetime(year, 3, 5),
+            dt.datetime(year, 3, 12),
+            dt.datetime(year, 3, 19),
+            dt.datetime(year, 3, 26),
+            dt.datetime(year, 4, 2),
+            dt.datetime(year, 4, 9),
+            dt.datetime(year, 4, 16),
+            dt.datetime(year, 4, 23),
+            dt.datetime(year, 4, 30),
+            dt.datetime(year, 5, 7),
+            dt.datetime(year, 5, 14),
+            dt.datetime(year, 5, 21),
+            dt.datetime(year, 5, 28),
+            dt.datetime(year, 6, 4),
+            dt.datetime(year, 6, 11),
+            dt.datetime(year, 6, 18),
+            dt.datetime(year, 6, 25),
+            dt.datetime(year, 7, 2),
+            dt.datetime(year, 7, 9),
+            dt.datetime(year, 7, 16),
+            dt.datetime(year, 7, 23),
+            dt.datetime(year, 7, 30),
+            dt.datetime(year, 8, 6),
+            dt.datetime(year, 8, 13),
+            dt.datetime(year, 8, 20),
+            dt.datetime(year, 8, 27),
+            dt.datetime(year, 9, 3),
+            dt.datetime(year, 9, 10),
+            dt.datetime(year, 9, 17),
+            dt.datetime(year, 9, 24),
+            dt.datetime(year, 10, 1),
+            dt.datetime(year, 10, 8),
+            dt.datetime(year, 10, 15),
+            dt.datetime(year, 10, 22),
+            dt.datetime(year, 10, 29),
+            dt.datetime(year, 11, 5),
+            dt.datetime(year, 11, 12),
+            dt.datetime(year, 11, 19),
+            dt.datetime(year, 11, 26),
+            dt.datetime(year, 12, 3),
+            dt.datetime(year, 12, 10),
+            dt.datetime(year, 12, 17),
+            dt.datetime(year, 12, 24)
+        ]
+    return _g_week_start_date_by_year[year]
+
+
+def get_closest_sddp_stage_date(y: int, m: int, d: int, previous_date: bool = True) -> Optional[dt.datetime]:
+    """Get the closest SDDP stage date for a given year, month, and day."""
+    dates = get_sddp_stages_by_year(y)
+    sdat = dt.datetime(y, m, d)
+    offset = 0 if previous_date else + 1
+    last_date = dates[-1]
+    if previous_date and sdat >= last_date:
+        return last_date
+    elif not previous_date and sdat >= last_date:
+        dates = get_sddp_stages_by_year(y + 1)
+        return dates[0]
+    else:
+        for index in range(len(dates)-1):
+            if dates[index] <= sdat < dates[index+1]:
+                return dates[index + offset]
+    return None
+
+
+def get_sddp_week(y: int, m: int, d: int) -> int:
+    dates = get_sddp_stages_by_year(y)
+    sdat = dt.datetime(y, m, d)
+    if dates[-1] <= sdat <= dt.datetime(y, 12, 31):
+        return WEEKS_PER_YEAR
+    else:
+        for index in range(len(dates)-1):
+            if dates[index] <= sdat < dates[index+1]:
+                return index + 1
+    return -1
+
+
+def get_sddp_start_date_and_stage(year, month, day) -> Tuple[dt.datetime, int]:
+    sddp_date = get_closest_sddp_stage_date(year, month, day, previous_date=True)
+    sddp_week = get_sddp_week(sddp_date.year, sddp_date.month, sddp_date.day)
+    return sddp_date, sddp_week
+
+
+def get_hour_block_map_from_study(study: psr.factory.Study) -> pandas.DataFrame:
+    """
+    Extract the HourBlockMap from the study and return as a DataFrame.
+    """
+    # FixedDurationOfBlocks(block)
+    stage_type = study.get("StageType")
+    hour_block_map_df = study.get_df("HourBlockMap")
+
+    if hour_block_map_df.empty:
+        initial_year = study.get("InitialYear")
+        end_year = initial_year + 10
+        total_blocks = study.get("NumberOfBlocks")
+        block_duration = {}
+        total_duration = 0
+        for block in range(1, total_blocks + 1):
+            # block duration is a percentage of total hours in a stage
+            block_duration[block] = study.get(f"FixedDurationOfBlocks({block})")
+            total_duration += block_duration[block]
+
+        if total_duration > 99.9:
+            # Group stage hours on blocks based on their relative durations to the total number of hours (total_duration)
+            if stage_type == 1:
+                total_duration = _week_max_hours
+                # weekly stages, fixed stage duration
+                mapping_data = []
+                for year in range(initial_year, end_year):
+                    start_date = pandas.Timestamp(f"{year}-01-01")
+                    for week in range(1, 53):
+                        accumulated_hours = total_duration
+                        for block in range(total_blocks, 0, -1):
+                            current_duration = int(block_duration[block] * total_duration // 100)
+                            if block != 1:
+                                current_hours = accumulated_hours - current_duration
+                            else:
+                                current_hours = 0
+                            for hour in range(current_hours, accumulated_hours):
+                                datetime_point = start_date + pandas.Timedelta(weeks=week - 1, hours=hour)
+                                formatted_datetime = f"{datetime_point.year}/{week:02d} {hour + 1}h"
+                                mapping_data.append({
+                                    'datetime': formatted_datetime,
+                                    'year': datetime_point.year,
+                                    'sddp_stage': week,
+                                    'sddp_block': block,
+                                    'stage_hour': hour + 1
+                                })
+                            accumulated_hours -= current_duration
+                hour_block_map_df = pandas.DataFrame(mapping_data).set_index('datetime')
+                # sort dataframe by year, sddp_stage, sddp_block, stage_hour
+                hour_block_map_df.sort_values(by=['year', 'sddp_stage', 'sddp_block', 'stage_hour'], inplace=True)
+            elif stage_type == 2:
+                # monthly stages, variable stage duration
+                mapping_data = []
+                for year in range(initial_year, end_year):
+                    for month in range(1, 13):
+                        start_date = pandas.Timestamp(f"{year}-{month:02d}-01")
+                        days_in_month = _number_of_days_per_month[month]
+                        total_duration = days_in_month * HOURS_PER_DAY
+                        accumulated_hours = total_duration
+                        for block in range(total_blocks, 0, -1):
+                            current_duration = int(block_duration[block] * total_duration // 100)
+                            if block != 1:
+                                current_hours = accumulated_hours - current_duration
+                            else:
+                                current_hours = 0
+                            for hour in range(current_hours, accumulated_hours):
+                                datetime_point = start_date + pandas.Timedelta(hours=hour)
+                                formatted_datetime = f"{datetime_point.year}/{datetime_point.month:02d} {hour + 1}h"
+                                mapping_data.append({
+                                    'datetime': formatted_datetime,
+                                    'year': datetime_point.year,
+                                    'sddp_stage': month,
+                                    'sddp_block': block,
+                                    'stage_hour': hour + 1
+                                })
+                            accumulated_hours -= current_duration
+                hour_block_map_df = pandas.DataFrame(mapping_data).set_index('datetime')
+                # sort dataframe by year, sddp_stage, sddp_block, stage_hour
+                hour_block_map_df.sort_values(by=['year', 'sddp_stage', 'sddp_block', 'stage_hour'], inplace=True)
+
+        else:
+            raise ValueError("Total duration of blocks must be 100% or more.")
+    else:
+        # format HourBlockMap dataframe to have year, sddp_week, sddp_block columns
+        # its index datetime column is in the following format: 'YYYY/WW HHHh', where WW is the week number (1-52) and HHH is the hour of the week (1-168)
+        # for weekly cases. for monthly cases, it is 'YYYY/MM HHHh', where MM is the month number (1-12) and HHH is the hour of the month (1-744).
+        hour_block_map_df = hour_block_map_df.reset_index()
+        hour_block_map_df['year'] = hour_block_map_df['datetime'].str.slice(0, 4).astype(int)
+        hour_block_map_df['sddp_stage'] = hour_block_map_df['datetime'].str.slice(5, 7).astype(int)
+        hour_block_map_df['stage_hour'] = hour_block_map_df['datetime'].str.slice(8, -1).astype(int)
+        hour_block_map_df['sddp_block'] = ((hour_block_map_df['hour_of_week'] - 1) // 6) + 1
+        hour_block_map_df = hour_block_map_df.set_index('datetime')[['year', 'sddp_week', 'sddp_block']]
+    return hour_block_map_df
+
+
+def remap_hourly_to_stage(hourly_df: pd.DataFrame, hour_block_map_df: pd.DataFrame, stage_type: int,
+                          aggregation_method: str = 'mean') -> pd.DataFrame:
+    """
+    Strategy to Map hourly data into weekly/monthly data:
+    - Merge the hourly data dataframe with the Study's hour block map dataframe
+    - Aggregate by stage and/or by block using avg, sum, max, etc
+    """
+    # create indices before merging
+    if stage_type == 1:
+        # weekly stages
+        hourly_df = hourly_df.copy()
+
+        hourly_df['year'] = hourly_df.index.year
+        hourly_df['sddp_stage'] = 0
+        hourly_df['stage_hour'] = 0
+        for irow, (index, row) in enumerate(hourly_df.iterrows()):
+            stage_start_date = get_closest_sddp_stage_date(index.year, index.month, index.day, previous_date=True)
+            week = get_sddp_week(index.year, index.month, index.day)
+            hour_of_week = ((index - stage_start_date).days * 24) + index.hour + 1
+            hourly_df.at[row.name, 'sddp_stage'] = week
+            hourly_df.at[row.name, 'stage_hour'] = hour_of_week
+    elif stage_type == 2:
+        # monthly stages
+        hourly_df = hourly_df.copy()
+        hourly_df['year'] = hourly_df.index.year
+        hourly_df['sddp_stage'] = hourly_df.index.month
+        hourly_df['stage_hour'] = ((hourly_df.index.day - 1) * 24) + hourly_df.index.hour + 1
+    else:
+        raise ValueError("Unsupported stage type. Only weekly (1) and monthly (2) are supported.")
+    hourly_df = hourly_df.set_index('year,sddp_stage,stage_hour'.split(','))
+    hour_block_map_df = hour_block_map_df.set_index('year,sddp_stage,stage_hour'.split(','))
+    merged_df = pd.merge(hourly_df, hour_block_map_df, left_index=True, right_index=True, how='inner')
+
+    numeric_cols = hourly_df.select_dtypes(include=[np.number]).columns.tolist()
+    result = merged_df.groupby(['year', 'sddp_stage'])[numeric_cols].agg(aggregation_method).reset_index()
+    result.sort_values(by=['year', 'sddp_stage'], inplace=True)
+    result.set_index(['year', 'sddp_stage'], inplace=True)
+    return result
+
+
+def remap_hourly_to_blocks(hourly_df: pd.DataFrame, hour_block_map_df: pd.DataFrame, stage_type: int,
+                          aggregation_method: str = 'mean') -> pd.DataFrame:
+    """
+    Strategy to Map hourly data into weekly/by block data:
+    - Merge the hourly data dataframe with the Study's hour block map dataframe
+    - Aggregate by stage and/or by block using avg, sum, max, etc
+    """
+    # create indices before merging
+    if stage_type == 1:
+        # weekly stages
+        hourly_df = hourly_df.copy()
+
+        hourly_df['year'] = hourly_df.index.year
+        hourly_df['sddp_stage'] = 0
+        hourly_df['stage_hour'] = 0
+        for irow, (index, row) in enumerate(hourly_df.iterrows()):
+            stage_start_date = get_closest_sddp_stage_date(index.year, index.month, index.day, previous_date=True)
+            week = get_sddp_week(index.year, index.month, index.day)
+            hour_of_week = ((index - stage_start_date).days * 24) + index.hour + 1
+            hourly_df.at[row.name, 'sddp_stage'] = week
+            hourly_df.at[row.name, 'stage_hour'] = hour_of_week
+    elif stage_type == 2:
+        # monthly stages
+        hourly_df = hourly_df.copy()
+        hourly_df['year'] = hourly_df.index.year
+        hourly_df['sddp_stage'] = hourly_df.index.month
+        hourly_df['stage_hour'] = ((hourly_df.index.day - 1) * 24) + hourly_df.index.hour + 1
+    else:
+        raise ValueError("Unsupported stage type. Only weekly (1) and monthly (2) are supported.")
+    hourly_df = hourly_df.set_index('year,sddp_stage,stage_hour'.split(','))
+    hour_block_map_df = hour_block_map_df.set_index('year,sddp_stage,stage_hour'.split(','))
+    merged_df = pd.merge(hourly_df, hour_block_map_df, left_index=True, right_index=True, how='inner')
+
+    numeric_cols = hourly_df.select_dtypes(include=[np.number]).columns.tolist()
+    result = merged_df.groupby(['year', 'sddp_stage', 'sddp_block'])[numeric_cols].agg(aggregation_method).reset_index()
+    result.sort_values(by=['year', 'sddp_stage', 'sddp_block'], inplace=True)
+    result.set_index(['year', 'sddp_stage', 'sddp_block'], inplace=True)
+    return result

{psr_factory-5.0.0b35.dist-info → psr_factory-5.0.0b37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psr-factory
-Version: 5.0.0b35
+Version: 5.0.0b37
 Summary: PSR database management module.
 Author-email: "PSR Inc." <psrfactory@psr-inc.com>
 License-Expression: MIT
@@ -28,11 +28,7 @@ Requires-Dist: pandas; extra == "pandas"
 Provides-Extra: polars
 Requires-Dist: polars; extra == "polars"
 Provides-Extra: cloud
-Requires-Dist: zeep; extra == "cloud"
-Requires-Dist: filelock; extra == "cloud"
-Requires-Dist: pefile; extra == "cloud"
-Requires-Dist: boto3; extra == "cloud"
-Requires-Dist: botocore; extra == "cloud"
+Requires-Dist: psr-cloud; extra == "cloud"
 Provides-Extra: execqueue-client
 Requires-Dist: requests; extra == "execqueue-client"
 Provides-Extra: execqueue-server
@@ -41,19 +37,12 @@ Requires-Dist: Flask; extra == "execqueue-server"
 Requires-Dist: python-ulid; extra == "execqueue-server"
 Requires-Dist: sqlalchemy; extra == "execqueue-server"
 Requires-Dist: python-dotenv; extra == "execqueue-server"
-Requires-Dist: pefile; extra == "execqueue-server"
-Requires-Dist: zeep; extra == "execqueue-server"
-Requires-Dist: filelock; extra == "execqueue-server"
-Requires-Dist: requests; extra == "execqueue-server"
+Requires-Dist: psr-cloud; extra == "execqueue-server"
 Provides-Extra: all
 Requires-Dist: pandas; extra == "all"
 Requires-Dist: polars; extra == "all"
 Requires-Dist: psutil; extra == "all"
-Requires-Dist: zeep; extra == "all"
-Requires-Dist: filelock; extra == "all"
-Requires-Dist: pefile; extra == "all"
-Requires-Dist: boto3; extra == "all"
-Requires-Dist: botocore; extra == "all"
+Requires-Dist: psr-cloud; extra == "all"
 Dynamic: license-file
 
 PSR Factory (version 4.0.40)

{psr_factory-5.0.0b35.dist-info → psr_factory-5.0.0b37.dist-info}/RECORD

@@ -16,9 +16,9 @@ psr/execqueue/config.py,sha256=rUOzO5dtTkwWoZlZfk06K9RE94xCx53T1bJ1h5JaDUo,1446
 psr/execqueue/db.py,sha256=sNr_StNEgZZQCKcyCWiB1WrQJIhE9UvLUxPA2tWiXGs,8498
 psr/execqueue/server.py,sha256=LolYERWRt96P_ip4yKU7DsN7M_n9d_pbflbT0ckUV0E,15782
 psr/execqueue/watcher.py,sha256=R1dyXJ-OYn_QjqdItBwbLJZQ2LcbtdHqnRaYkyphi4w,5637
-psr/factory/__init__.py,sha256=IMo21Cp22rUOCVUwDb5X1n0jUeYrZFWeVQo0VrJig9I,219
+psr/factory/__init__.py,sha256=xVvV3CZT_Z-M0QRD9SbJVZqMd4Gpx4Fv7MpB7f9Ifek,219
 psr/factory/api.py,sha256=QASwrk5SbbAqz63u7EhGoBBqqXOqMnicjL-eJ3gOGe0,104270
-psr/factory/factory.dll,sha256=7VbGrK_2TYm3eNGEyxpn_cmWjpXQRv7MuBhkD2W8LlI,18362192
+psr/factory/factory.dll,sha256=0P76qLc9iW4NpQ0_bTzGdQTZrAht2W-qkBtT6mbSdBk,18362192
 psr/factory/factory.pmd,sha256=kr5xf2knYu_SJeyCsmoyYVgFwd4-VURi28rno40GIRY,250936
 psr/factory/factory.pmk,sha256=OvpqDnaCc1eeOWGQxogD0Nbg9M0PE1UZPcD65PeePV8,580337
 psr/factory/factorylib.py,sha256=o5Irbw6k-yIOJVUtDu2YYqw2x16P2LmCdouImwSssdw,28290
@@ -27,14 +27,17 @@ psr/factory/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 psr/factory/samples/__init__.py,sha256=xxOch5Fokzjy571a6OHD87FWM17qKgvfcbr8xn-n36I,80
 psr/factory/samples/sddp_case01.py,sha256=eLhtOAS2STl9-H7Nr5VUG4ATO0bVcn-CJtCn3Rf-vpI,5044
 psr/factory/samples/sddp_case21.py,sha256=Eymn3q0uyaGSmZaTr0Yk2q9yf1-enqdoUFXPwuQ1YOk,8807
+psr/outputs/__init__.py,sha256=Yo-4vz3BMuMQJ-9DqhVx3up6jn2UB3TP9XWGcLrHDEI,192
+psr/outputs/outputs.py,sha256=gzmKl9Ma6K9gjpTTBc45p-IT7DgEX-PzRqtsQSWfja0,6727
+psr/outputs/resample.py,sha256=6fVBWOzxu3utkavGS5EIUd0QpSZm6kc-J1Qv8Bk0X6o,14276
 psr/psrfcommon/__init__.py,sha256=WXR560XQllIjtFpWd0jiJEbUAQIyh5-6lwj-42_J95c,200
 psr/psrfcommon/psrfcommon.py,sha256=NABM5ahvyfSizDC9c0Vu9dVK1pD_vOzIGFHL1oz2E1o,1464
 psr/psrfcommon/tempfile.py,sha256=5S13wa2DCLYTUdwbLm_KMBRnDRJ0WDlu8GO2BmZoNdg,3939
 psr/runner/__init__.py,sha256=kI9HDX-B_LMQJUHHylFHas2rNpWfNNa0pZXoIvX_Alw,230
 psr/runner/runner.py,sha256=hCVH62HAZK_M9YUiHQgqCkMevN17utegjfRIw49MdvM,27542
 psr/runner/version.py,sha256=mch2Y8anSXGMn9w72Z78PhSRhOyn55EwaoLAYhY4McE,194
-psr_factory-5.0.0b35.dist-info/licenses/LICENSE.txt,sha256=N6mqZK2Ft3iXGHj-by_MHC_dJo9qwn0URjakEPys3H4,1089
-psr_factory-5.0.0b35.dist-info/METADATA,sha256=JeHb8F1LzhFMM2uWRK8d0uQRdkkb40hjcvtBgJdacSo,3957
-psr_factory-5.0.0b35.dist-info/WHEEL,sha256=ZjXRCNaQ9YSypEK2TE0LRB0sy2OVXSszb4Sx1XjM99k,97
-psr_factory-5.0.0b35.dist-info/top_level.txt,sha256=Jb393O96WQk3b5D1gMcrZBLKJJgZpzNjTPoldUi00ck,4
-psr_factory-5.0.0b35.dist-info/RECORD,,
+psr_factory-5.0.0b37.dist-info/licenses/LICENSE.txt,sha256=N6mqZK2Ft3iXGHj-by_MHC_dJo9qwn0URjakEPys3H4,1089
+psr_factory-5.0.0b37.dist-info/METADATA,sha256=-H1CZp6wnWtOr2veC2PtGGR6aBBs20Tc00eP1iDYs5E,3486
+psr_factory-5.0.0b37.dist-info/WHEEL,sha256=ZjXRCNaQ9YSypEK2TE0LRB0sy2OVXSszb4Sx1XjM99k,97
+psr_factory-5.0.0b37.dist-info/top_level.txt,sha256=Jb393O96WQk3b5D1gMcrZBLKJJgZpzNjTPoldUi00ck,4
+psr_factory-5.0.0b37.dist-info/RECORD,,