inewave 1.6.0__py3-none-any.whl → 1.7.1__py3-none-any.whl

inewave/__init__.py

@@ -6,7 +6,7 @@ inewave é um módulo em Python para manipulação dos arquivos de entrada
 e saída do NEWAVE.
 """
 
-__version__ = "1.6.0"
+__version__ = "1.7.1"
 
 from . import newave  # noqa
 from . import nwlistcf  # noqa

inewave/newave/__init__.py

@@ -53,3 +53,13 @@ from .eco_fpha import EcoFpha  # noqa
 from .nwv_avl_evap import NwvAvlEvap  # noqa
 from .nwv_cortes_evap import NwvCortesEvap  # noqa
 from .nwv_eco_evap import NwvEcoEvap  # noqa
+from .energiaf import Energiaf  # noqa
+from .energiab import Energiab  # noqa
+from .energias import Energias  # noqa
+from .enavazf import Enavazf  # noqa
+from .enavazb import Enavazb  # noqa
+from .engnat import Engnat  # noqa
+from .vazaof import Vazaof  # noqa
+from .vazaob import Vazaob  # noqa
+from .vazaos import Vazaos  # noqa
+from .vazinat import Vazinat  # noqa

inewave/newave/modelos/pmo.py

@@ -1,7 +1,7 @@
 # Imports do próprio módulo
 
 from inewave.config import MAX_ANOS_ESTUDO, MAX_ITERS, MAX_MESES_ESTUDO
-from inewave.config import MAX_REES
+from inewave.config import MAX_REES, MAX_UTES
 from inewave.config import MESES_DF
 
 # Imports de módulos externos
@@ -11,7 +11,7 @@ from cfinterface.components.field import Field
 from cfinterface.components.integerfield import IntegerField
 from cfinterface.components.literalfield import LiteralField
 from cfinterface.components.floatfield import FloatField
-from datetime import timedelta
+from datetime import timedelta, datetime
 import numpy as np  # type: ignore
 import pandas as pd  # type: ignore
 from typing import IO, List, Optional
@@ -153,6 +153,76 @@ class BlocoEafPastCfugaMedioPMO(Block):
             i += 1
 
 
+class BlocoEnergiaArmazenadaMaximaPMO(Block):
+    """
+    Bloco de informações da energia armazenada máxima dos REE
+    por configuração localizado no arquivo `pmo.dat`.
+    """
+
+    BEGIN_PATTERN = "ENERGIA ARMAZENAVEL MAXIMA POR REE"
+    END_PATTERN = ""
+
+    def __init__(self, previous=None, next=None, data=None) -> None:
+        super().__init__(previous, next, data)
+
+    def __eq__(self, o: object) -> bool:
+        if not isinstance(o, BlocoEnergiaArmazenadaMaximaPMO):
+            return False
+        bloco: BlocoEnergiaArmazenadaMaximaPMO = o
+        if not all(
+            [
+                isinstance(self.data, pd.DataFrame),
+                isinstance(o.data, pd.DataFrame),
+            ]
+        ):
+            return False
+        else:
+            return self.data.equals(bloco.data)
+
+    # Override
+    def read(self, file: IO, *args, **kwargs):
+        def converte_tabela_em_df():
+            df = pd.DataFrame(
+                data={
+                    "nome_ree": np.tile(np.array(nomes), len(configuracoes)),
+                    "configuracao": np.repeat(
+                        np.array(configuracoes), len(nomes)
+                    ),
+                    "valor_MWmes": tabela_valores.flatten(),
+                }
+            )
+            return df
+
+        # Pula as linhas iniciais
+        for _ in range(4):
+            file.readline()
+
+        linha_nomes = file.readline()
+        nomes = [n.strip() for n in linha_nomes.split(" ") if len(n) > 2][1:]
+        num_rees = len(nomes)
+        linha_valores = Line(
+            [IntegerField(3, 5)]
+            + [FloatField(15, 8 + 15 * i, 1) for i in range(num_rees)]
+        )
+        tabela_valores = np.zeros(
+            (MAX_MESES_ESTUDO, num_rees), dtype=np.float64
+        )
+        configuracoes: List[int] = []
+        i = 0
+        while True:
+            linha = file.readline()
+            if len(linha) < 3:
+                tabela_valores = tabela_valores[:i, :]
+                self.data = converte_tabela_em_df()
+                break
+
+            dados_linha = linha_valores.read(linha)
+            configuracoes.append(dados_linha[0])
+            tabela_valores[i, :] = dados_linha[1:]
+
+            i += 1
+
+
 class BlocoEnergiaArmazenadaInicialPMO(Block):
     """
     Bloco de informações da energia armazenada inicial dos REE
@@ -277,6 +347,174 @@ class BlocoVolumeArmazenadoInicialPMO(Block):
         self.data = converte_tabela_em_df()
 
 
+class BlocoGeracaoMinimaUsinasTermicasPMO(Block):
+    """
+    Bloco de informações sobre a geração térmica mínima
+    por usina existentes no arquivo `pmo.dat`.
+    """
+
+    BEGIN_PATTERN = "GERACAO TERMICA MINIMA POR USINA"
+    END_PATTERN = ""
+
+    def __init__(self, previous=None, next=None, data=None) -> None:
+        super().__init__(previous, next, data)
+        # Cria a estrutura de uma linha da tabela
+        self.__line = Line(
+            [IntegerField(6, 2), LiteralField(12, 9), IntegerField(7, 22)]
+            + [FloatField(7, 30 + 8 * i, 2) for i in range(12)]
+        )
+
+    def __eq__(self, o: object) -> bool:
+        if not isinstance(o, BlocoGeracaoMinimaUsinasTermicasPMO):
+            return False
+        bloco: BlocoGeracaoMinimaUsinasTermicasPMO = o
+        if not all(
+            [
+                isinstance(self.data, pd.DataFrame),
+                isinstance(o.data, pd.DataFrame),
+            ]
+        ):
+            return False
+        else:
+            return self.data.equals(bloco.data)
+
+    # Override
+    def read(self, file: IO, *args, **kwargs):
+        def converte_tabela_em_df():
+            cols_meses = [str(m) for m in range(1, 13)]
+            df = pd.DataFrame(tabela, columns=cols_meses)
+            df["codigo_usina"] = codigos_usinas
+            df["nome_usina"] = nomes_usinas
+            df["ano"] = anos
+            df = df.melt(
+                id_vars=["codigo_usina", "nome_usina", "ano"],
+                value_vars=cols_meses,
+                var_name="mes",
+                value_name="valor_MWmed",
+            )
+            df = df.astype({"mes": int})
+            df["data"] = df.apply(
+                lambda linha: datetime(linha["ano"], linha["mes"], 1), axis=1
+            )
+            return df.drop(columns=["ano", "mes"])
+
+        # Pula as linhas iniciais
+        for _ in range(6):
+            file.readline()
+        # Variáveis auxiliares
+        codigos_usinas: List[int] = []
+        nomes_usinas: List[str] = []
+        codigo_atual = 0
+        nome_atual = ""
+        anos: List[int] = []
+        tabela = np.zeros(
+            (MAX_ANOS_ESTUDO * MAX_UTES, len(MESES_DF)), dtype=np.float64
+        )
+        i = 0
+        while True:
+            linha: str = file.readline()
+            # Confere se acabou
+            if len(linha) < 3 or "X--------------------" in linha:
+                tabela = tabela[:i, :]
+                self.data = converte_tabela_em_df()
+                break
+            # Lê mais uma linha
+            dados = self.__line.read(linha)
+            if dados[0] is not None:
+                codigo_atual = dados[0]
+            if len(dados[1]) > 0:
+                nome_atual = dados[1]
+            codigos_usinas.append(codigo_atual)
+            nomes_usinas.append(nome_atual)
+            anos.append(dados[2])
+            tabela[i, :] = dados[3:]
+            i += 1
+
+
+class BlocoGeracaoMaximaUsinasTermicasPMO(Block):
+    """
+    Bloco de informações sobre a geração térmica máxima
+    por usina existentes no arquivo `pmo.dat`.
+    """
+
+    BEGIN_PATTERN = "GERACAO TERMICA MAXIMA POR USINA"
+    END_PATTERN = ""
+
+    def __init__(self, previous=None, next=None, data=None) -> None:
+        super().__init__(previous, next, data)
+        # Cria a estrutura de uma linha da tabela
+        self.__line = Line(
+            [IntegerField(6, 2), LiteralField(12, 9), IntegerField(7, 22)]
+            + [FloatField(7, 30 + 8 * i, 2) for i in range(12)]
+        )
+
+    def __eq__(self, o: object) -> bool:
+        if not isinstance(o, BlocoGeracaoMaximaUsinasTermicasPMO):
+            return False
+        bloco: BlocoGeracaoMaximaUsinasTermicasPMO = o
+        if not all(
+            [
+                isinstance(self.data, pd.DataFrame),
+                isinstance(o.data, pd.DataFrame),
+            ]
+        ):
+            return False
+        else:
+            return self.data.equals(bloco.data)
+
+    # Override
+    def read(self, file: IO, *args, **kwargs):
+        def converte_tabela_em_df():
+            cols_meses = [str(m) for m in range(1, 13)]
+            df = pd.DataFrame(tabela, columns=cols_meses)
+            df["codigo_usina"] = codigos_usinas
+            df["nome_usina"] = nomes_usinas
+            df["ano"] = anos
+            df = df.melt(
+                id_vars=["codigo_usina", "nome_usina", "ano"],
+                value_vars=cols_meses,
+                var_name="mes",
+                value_name="valor_MWmed",
+            )
+            df = df.astype({"mes": int})
+            df["data"] = df.apply(
+                lambda linha: datetime(linha["ano"], linha["mes"], 1), axis=1
+            )
+            return df.drop(columns=["ano", "mes"])
+
+        # Pula as linhas iniciais
+        for _ in range(6):
+            file.readline()
+        # Variáveis auxiliares
+        codigos_usinas: List[int] = []
+        nomes_usinas: List[str] = []
+        codigo_atual = 0
+        nome_atual = ""
+        anos: List[int] = []
+        tabela = np.zeros(
+            (MAX_ANOS_ESTUDO * MAX_UTES, len(MESES_DF)), dtype=np.float64
+        )
+        i = 0
+        while True:
+            linha: str = file.readline()
+            # Confere se acabou
+            if len(linha) < 3 or "X--------------------" in linha:
+                tabela = tabela[:i, :]
+                self.data = converte_tabela_em_df()
+                break
+            # Lê mais uma linha
+            dados = self.__line.read(linha)
+            if dados[0] is not None:
+                codigo_atual = dados[0]
+            if len(dados[1]) > 0:
+                nome_atual = dados[1]
+            codigos_usinas.append(codigo_atual)
+            nomes_usinas.append(nome_atual)
+            anos.append(dados[2])
+            tabela[i, :] = dados[3:]
+            i += 1
+
+
 class BlocoConvergenciaPMO(Block):
     """
     Bloco com as informações de convergência do NEWAVE obtidas
@@ -822,7 +1060,9 @@ class BlocoProdutibilidadesConfiguracaoPMO(Block):
         while True:
             linha = file.readline()
             # Verifica se acabou:
-            if "PRODUTIBILIDADES ACUMULADAS PARA CALCULO DE" in linha:
+            if ("DADOS DE PENALIDADE POR PERIODO" in linha) or (
+                "PRODUTIBILIDADES ACUMULADAS PARA CALCULO DE" in linha
+            ):
                 if cfg_atual != 0:
                     df_atual = self.__fecha_configuracao(
                         df_usinas,

inewave/newave/modelos/vazinat.py

@@ -0,0 +1,92 @@
+from cfinterface.components.section import Section
+from cfinterface.components.line import Line
+from cfinterface.components.floatfield import FloatField
+from typing import IO
+from datetime import datetime
+from inewave.config import MAX_ANOS_HISTORICO
+import pandas as pd  # type: ignore
+import numpy as np  # type: ignore
+
+
+class SecaoDadosVazinat(Section):
+    """
+    Registro com os dados das séries históricas de vazão incremental por
+    configuração existentes no arquivo vazinat.dat.
+    """
+
+    def __init__(self, previous=None, next=None, data=None) -> None:
+        super().__init__(previous, next, data)
+
+    def __eq__(self, o: object) -> bool:
+        if not isinstance(o, SecaoDadosVazinat):
+            return False
+        bloco: SecaoDadosVazinat = o
+        if not all(
+            [
+                isinstance(self.data, pd.DataFrame),
+                isinstance(o.data, pd.DataFrame),
+            ]
+        ):
+            return False
+        else:
+            return self.data.equals(bloco.data)
+
+    def read(
+        self,
+        file: IO,
+        numero_uhes: int = 164,
+        numero_configuracoes: int = 60,
+        ano_inicio_historico: int = 1931,
+        *args,
+        **kwargs,
+    ):
+        numero_registros = (
+            MAX_ANOS_HISTORICO * 12 * numero_uhes * numero_configuracoes
+        )
+        self.__linha = Line(
+            [
+                FloatField(size=8, starting_position=8 * i)
+                for i in range(numero_registros)
+            ],
+            storage="BINARY",
+        )
+        dados = self.__linha.read(file.read(self.__linha.size))
+        datas_df = pd.date_range(
+            datetime(year=ano_inicio_historico, month=1, day=1),
+            datetime(
+                year=ano_inicio_historico + MAX_ANOS_HISTORICO - 1,
+                month=12,
+                day=1,
+            ),
+            freq="MS",
+        ).to_numpy()
+        datas_df = np.tile(datas_df, numero_uhes * numero_configuracoes)
+        uhes_df = np.tile(
+            np.repeat(np.arange(1, numero_uhes + 1), 12 * MAX_ANOS_HISTORICO),
+            numero_configuracoes,
+        )
+        configuracoes_df = np.repeat(
+            np.arange(1, numero_configuracoes + 1),
+            12 * MAX_ANOS_HISTORICO * numero_uhes,
+        )
+
+        df = pd.DataFrame(
+            data={
+                "configuracao": configuracoes_df,
+                "data": datas_df,
+                "indice_usina": uhes_df,
+                "valor": dados,
+            }
+        )
+        self.data = df
+
+    def write(self, file: IO, *args, **kwargs):
+        dados = self.data["valor"].to_numpy()
+        linha = Line(
+            [
+                FloatField(size=8, starting_position=8 * i)
+                for i in range(len(dados))
+            ],
+            storage="BINARY",
+        )
+        file.write(linha.write(dados))

inewave/newave/pmo.py

@@ -7,6 +7,7 @@ from inewave.newave.modelos.pmo import BlocoRiscoDeficitENSPMO
 from inewave.newave.modelos.pmo import BlocoCustoOperacaoPMO
 from inewave.newave.modelos.pmo import BlocoCustoOperacaoTotalPMO
 from inewave.newave.modelos.pmo import BlocoProdutibilidadesConfiguracaoPMO
+from inewave.newave.modelos.pmo import BlocoEnergiaArmazenadaMaximaPMO
 from inewave.newave.modelos.pmo import BlocoEnergiaArmazenadaInicialPMO
 from inewave.newave.modelos.pmo import BlocoVolumeArmazenadoInicialPMO
 from inewave.newave.modelos.pmo import BlocoPenalidadeViolacaoOutrosUsosPMO
@@ -20,6 +21,10 @@ from inewave.newave.modelos.pmo import (
 from inewave.newave.modelos.pmo import (
     BlocoPenalidadeViolacaoTurbinamentoMinimoPMO,
 )
+from inewave.newave.modelos.pmo import (
+    BlocoGeracaoMinimaUsinasTermicasPMO,
+    BlocoGeracaoMaximaUsinasTermicasPMO,
+)
 
 from cfinterface.files.blockfile import BlockFile
 from typing import TypeVar, Optional
@@ -52,6 +57,7 @@ class Pmo(BlockFile):
         BlocoCustoOperacaoPMO,
         BlocoCustoOperacaoTotalPMO,
         BlocoProdutibilidadesConfiguracaoPMO,
+        BlocoEnergiaArmazenadaMaximaPMO,
         BlocoEnergiaArmazenadaInicialPMO,
         BlocoVolumeArmazenadoInicialPMO,
         BlocoPenalidadeViolacaoOutrosUsosPMO,
@@ -61,6 +67,8 @@ class Pmo(BlockFile):
         BlocoPenalidadeViolacaoEvaporacaoPMO,
         BlocoPenalidadeViolacaoTurbinamentoMaximoPMO,
         BlocoPenalidadeViolacaoTurbinamentoMinimoPMO,
+        BlocoGeracaoMinimaUsinasTermicasPMO,
+        BlocoGeracaoMaximaUsinasTermicasPMO,
     ]
 
     @property
@@ -150,6 +158,25 @@ class Pmo(BlockFile):
         b = self.data.get_blocks_of_type(BlocoConfiguracoesExpansaoPMO)
         if isinstance(b, list):
             return b[2].data
+        elif isinstance(b, BlocoConfiguracoesExpansaoPMO):
+            return b.data
+        return None
+
+    @property
+    def energia_armazenada_maxima(self) -> Optional[pd.DataFrame]:
+        """
+        Valores da energia armazenada máxima para cada REE do caso.
+
+        - nome_ree (`str`)
+        - configuracao (`int`)
+        - valor_MWmes (`float`)
+
+        :return: As energias em um DataFrame.
+        :rtype: pd.DataFrame | None
+        """
+        b = self.data.get_blocks_of_type(BlocoEnergiaArmazenadaMaximaPMO)
+        if isinstance(b, BlocoEnergiaArmazenadaMaximaPMO):
+            return b.data
         return None
 
     @property
@@ -161,7 +188,7 @@ class Pmo(BlockFile):
         - valor_MWmes (`float`)
         - valor_percentual (`float`)
 
-        :return: As configurações em um DataFrame.
+        :return: As energias em um DataFrame.
         :rtype: pd.DataFrame | None
         """
         b = self.data.get_blocks_of_type(BlocoEnergiaArmazenadaInicialPMO)
@@ -502,3 +529,57 @@ class Pmo(BlockFile):
         if isinstance(b, BlocoPenalidadeViolacaoEvaporacaoPMO):
             return b.data
         return None
+
+    @property
+    def geracao_minima_usinas_termicas(
+        self,
+    ) -> Optional[pd.DataFrame]:
+        """
+        Tabela de geração térmica mínima por usina térmica
+        existente no caso.
+
+        - codigo_usina (`int`)
+        - nome_usina (`str`)
+        - data (`datetime`)
+        - valor_MWmed (`float`)
+
+        :return: As gerações em um DataFrame.
+        :rtype: pd.DataFrame | None
+        """
+        b = self.data.get_blocks_of_type(BlocoGeracaoMinimaUsinasTermicasPMO)
+        cols = ["codigo_usina", "nome_usina", "data", "valor_MWmed"]
+        if isinstance(b, list):
+            df = pd.concat([b.data for b in b], ignore_index=True)
+            df = df.sort_values(by=["codigo_usina", "data"])
+            return df[cols]
+        elif isinstance(b, BlocoGeracaoMinimaUsinasTermicasPMO):
+            df = b.data.sort_values(by=["codigo_usina", "data"])
+            return df[cols]
+        return None
+
+    @property
+    def geracao_maxima_usinas_termicas(
+        self,
+    ) -> Optional[pd.DataFrame]:
+        """
+        Tabela de geração térmica máxima por usina térmica
+        existente no caso.
+
+        - codigo_usina (`int`)
+        - nome_usina (`str`)
+        - data (`datetime`)
+        - valor_MWmed (`float`)
+
+        :return: As gerações em um DataFrame.
+        :rtype: pd.DataFrame | None
+        """
+        b = self.data.get_blocks_of_type(BlocoGeracaoMaximaUsinasTermicasPMO)
+        cols = ["codigo_usina", "nome_usina", "data", "valor_MWmed"]
+        if isinstance(b, list):
+            df = pd.concat([b.data for b in b], ignore_index=True)
+            df = df.sort_values(by=["codigo_usina", "data"])
+            return df[cols]
+        elif isinstance(b, BlocoGeracaoMaximaUsinasTermicasPMO):
+            df = b.data.sort_values(by=["codigo_usina", "data"])
+            return df[cols]
+        return None

inewave/newave/sistema.py

@@ -130,8 +130,8 @@ class Sistema(SectionFile):
         Tabela com a geração das usinas não simuladas por fonte
         de geração.
 
-        - submercado (`int`)
-        - bloco (`int`)
+        - codigo_submercado (`int`)
+        - indice_bloco (`int`)
         - fonte (`str`)
         - data (`int`)
         - valor (`float`)

inewave/newave/vazinat.py

@@ -0,0 +1,43 @@
+from cfinterface.files.sectionfile import SectionFile
+from inewave.newave.modelos.vazinat import SecaoDadosVazinat
+import pandas as pd  # type: ignore
+
+from typing import TypeVar, Optional
+
+
+class Vazinat(SectionFile):
+    """
+    Armazena os dados de saída do NEWAVE referentes às séries históricas
+    de vazão por UHE.
+    """
+
+    T = TypeVar("T")
+
+    SECTIONS = [SecaoDadosVazinat]
+    STORAGE = "BINARY"
+
+    @property
+    def series(self) -> Optional[pd.DataFrame]:
+        """
+        Obtém a tabela com os dados das séries de vazão
+        incremental por UHE.
+
+        - data (`datetime`): data para o valor histórico
+        - indice_usina (`int`): índice da usina conforme ordem de
+            declaração no arquivo de configuração de usinas hidrelétricas
+        - valor (`float`): vazão incremental em m3/s
+
+        :return: A tabela com os dados das séries
+        :rtype: pd.DataFrame | None
+        """
+        sections = [r for r in self.data.of_type(SecaoDadosVazinat)]
+        if len(sections) > 0:
+            return sections[0].data
+        else:
+            return None
+
+    @series.setter
+    def series(self, df: pd.DataFrame):
+        sections = [r for r in self.data.of_type(SecaoDadosVazinat)]
+        if len(sections) > 0:
+            sections[0].data = df

inewave/nwlistop/__init__.py

@@ -83,8 +83,15 @@ from .hmont import Hmont  # noqa
 from .intercambio import Intercambio  # noqa
 from .invade import Invade  # noqa
 from .invadem import Invadem  # noqa
-from .mediasmerc import Mediasmerc  # noqa
 from .mediassin import Mediassin  # noqa
+from .mediasmerc import Mediasmerc  # noqa
+from .mediasree import Mediasree  # noqa
+from .mediasusih import Mediasusih  # noqa
+from .mediasusit import Mediasusit  # noqa
+from .mediasusie import Mediasusie  # noqa
+from .mediasrep import Mediasrep  # noqa
+from .mediasrhq import Mediasrhq  # noqa
+from .mediasrhv import Mediasrhv  # noqa
 from .mercl import Mercl  # noqa
 from .merclsin import Merclsin  # noqa
 from .mevmin import Mevmin  # noqa

inewave/nwlistop/mediasmerc.py

@@ -1,9 +1,11 @@
 import pandas as pd  # type: ignore
 
-from inewave.nwlistop.modelos.mediasmerc import LeituraMediasMerc
+from cfinterface.files.sectionfile import SectionFile
 
+from inewave.nwlistop.modelos.mediasmerc import TabelaMediasmerc
 
-class Mediasmerc:
+
+class Mediasmerc(SectionFile):
     """
     Armazena os dados das saídas referentes às médias de diversas variáveis
     agrupadas por submercado.
@@ -13,26 +15,23 @@ class Mediasmerc:
 
     """
 
-    def __init__(self, dados: pd.DataFrame):
-        self.__dados = dados
-
-    def __eq__(self, o: object) -> bool:
-        """
-        A igualdade entre Mediasmerc avalia todos os valores da tabela.
-        """
-        if not isinstance(o, Mediasmerc):
-            return False
-        m: Mediasmerc = o
-        return self.medias.equals(m.medias)
+    SECTIONS = [TabelaMediasmerc]
 
     @property
-    def medias(self) -> pd.DataFrame:
-        return self.__dados
+    def valores(self) -> pd.DataFrame:
+        """
+        Tabela com os valores de médias para as variáveis dos submercados.
 
-    @medias.setter
-    def medias(self, d: pd.DataFrame) -> pd.DataFrame:
-        self.__dados = d
+        - estagio (`int`)
+        - codigo_submercado (`int`)
+        - <variavel_1> (`float`)
+        - ...
+        - <variavel_n> (`float`)
 
-    @classmethod
-    def le_arquivo(cls, diretorio: str, nome_arquivo="MEDIAS-MERC.CSV"):
-        return cls(LeituraMediasMerc(diretorio).le_arquivo(nome_arquivo))
+        :return: A tabela como um DataFrame
+        :rtype: pd.DataFrame | None
+        """
+        b = self.data.get_sections_of_type(TabelaMediasmerc)
+        if isinstance(b, TabelaMediasmerc):
+            return b.data
+        return None

inewave/nwlistop/mediasree.py

@@ -0,0 +1,37 @@
+import pandas as pd  # type: ignore
+
+from cfinterface.files.sectionfile import SectionFile
+
+from inewave.nwlistop.modelos.mediasree import TabelaMediasree
+
+
+class Mediasree(SectionFile):
+    """
+    Armazena os dados das saídas referentes às médias de diversas variáveis
+    agrupadas por REE.
+
+    Esta classe lida com as informações de saída fornecidas pelo
+    NWLISTOP e reproduzidas nos `MEDIAS-REE.CSV`.
+
+    """
+
+    SECTIONS = [TabelaMediasree]
+
+    @property
+    def valores(self) -> pd.DataFrame:
+        """
+        Tabela com os valores de médias para as variáveis dos REE.
+
+        - estagio (`int`)
+        - codigo_ree (`int`)
+        - <variavel_1> (`float`)
+        - ...
+        - <variavel_n> (`float`)
+
+        :return: A tabela como um DataFrame
+        :rtype: pd.DataFrame | None
+        """
+        b = self.data.get_sections_of_type(TabelaMediasree)
+        if isinstance(b, TabelaMediasree):
+            return b.data
+        return None