diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index 71c72338..65231611 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -4,9 +4,17 @@ on: branches: - main workflow_dispatch: - + +permissions: + pages: write + id-token: write + +concurrency: + group: "pages" + cancel-in-progress: false + jobs: - docs: + build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 @@ -16,18 +24,23 @@ jobs: run: uv python install - name: Install the project run: | - uv sync --all-extras --dev - - name: Runs tests - run: | - uv run pytest ./tests + uv sync --extra docs - name: Sphinx build run: | uv run sphinx-build -M html docs/source docs/build - - name: Deploy - uses: peaceiris/actions-gh-pages@v3 - if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }} + - name: Upload Pages artifact + uses: actions/upload-pages-artifact@v3 with: - publish_branch: gh-pages - github_token: ${{ secrets.GITHUB_TOKEN }} - publish_dir: docs/build/html - force_orphan: true \ No newline at end of file + path: docs/build/html + + deploy: + needs: build + if: github.event_name == 'push' || github.ref == 'refs/heads/main' + runs-on: ubuntu-latest + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - name: Deploy to GitHub Pages + id: deployment + uses: actions/deploy-pages@v4 diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 4075c51e..7fe7c845 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -9,11 +9,39 @@ on: - main jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Install uv + uses: astral-sh/setup-uv@v3 + - name: Set up Python 3.12 + run: uv python install 3.12 + - name: Install the project + run: uv sync --extra lint + - name: Ruff check + run: uv run ruff check ./idecomp + - name: Ruff format check + run: uv run ruff format --check ./idecomp + + typecheck: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Install uv + uses: astral-sh/setup-uv@v3 + - name: Set up Python 3.12 + run: uv python install 3.12 + - name: Install the project + run: uv sync --extra lint + - name: Static type check + run: uv run mypy ./idecomp + test: runs-on: ubuntu-latest strategy: matrix: - python-version: ["3.10", "3.11", "3.12"] + python-version: ["3.11", "3.12", "3.13", "3.14"] steps: - uses: actions/checkout@v4 - name: Install uv @@ -21,11 +49,9 @@ jobs: - name: Set up Python ${{ matrix.python-version }} run: uv python install ${{ matrix.python-version }} - name: Install the project - run: | - uv sync --all-extras --dev - - name: Runs tests - run: | - uv run pytest --cov-report=xml --cov=idecomp ./tests + run: uv sync --extra test + - name: Run tests + run: uv run pytest --cov-report=xml --cov=idecomp ./tests - uses: codecov/codecov-action@v4 with: token: ${{ secrets.CODECOV_TOKEN }} @@ -35,12 +61,16 @@ jobs: name: codecov-idecomp fail_ci_if_error: true verbose: true - - name: Static type check - run: | - uv run mypy ./idecomp - - name: Linter code check - run: | - uv run ruff check ./idecomp + + docs: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Install uv + uses: astral-sh/setup-uv@v3 + - name: Set up Python 3.12 + run: uv python install 3.12 + - name: Install the project + run: uv sync --extra docs - name: Sphinx build - run: | - uv run sphinx-build -M html docs/source docs/build \ No newline at end of file + run: uv run sphinx-build -b html -W --keep-going docs/source docs/build/html diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml deleted file mode 100644 index 18512344..00000000 --- a/.github/workflows/publish.yml +++ /dev/null @@ -1,40 +0,0 @@ -name: deploy - - -on: - release: - types: [created] - -jobs: - build-and-publish: - runs-on: ubuntu-latest - environment: - name: pypi - url: https://pypi.org/p/idecomp - permissions: - id-token: write - steps: - - uses: actions/checkout@v4 - - name: Install uv - uses: astral-sh/setup-uv@v3 - - name: Set up Python - run: uv python install 3.11 - - name: Install the project - run: | - uv sync --all-extras --dev - - name: Runs tests - run: | - uv run pytest ./tests - - name: Static typing check - run: | - uv run mypy ./idecomp - - name: PEP8 check - run: | - uv run ruff check ./idecomp - - name: Builds package - if: startsWith(github.ref, 'refs/tags') - run: | - uv build - - name: PyPI publish - if: startsWith(github.ref, 'refs/tags') - uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 00000000..8274781c --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,47 @@ +name: release + +on: + push: + tags: + - "v*" + +jobs: + build-and-publish: + runs-on: ubuntu-latest + environment: + name: pypi + url: https://pypi.org/p/idecomp + permissions: + id-token: write + contents: write + steps: + - uses: actions/checkout@v4 + - name: Install uv + uses: astral-sh/setup-uv@v3 + - name: Set up Python + run: uv python install 3.12 + - name: Install the project + run: uv sync --extra test --extra lint + - name: Validate version + run: | + PKG_VERSION=$(grep -oP '__version__\s*=\s*"\K[^"]+' idecomp/__init__.py) + TAG_VERSION=${GITHUB_REF#refs/tags/v} + if [ "$PKG_VERSION" != "$TAG_VERSION" ]; then + echo "Version mismatch: __init__.py=$PKG_VERSION tag=$TAG_VERSION" + exit 1 + fi + - name: Run tests + run: uv run pytest ./tests + - name: Type check + run: uv run mypy ./idecomp + - name: Lint check + run: uv run ruff check ./idecomp + - name: Build package + run: uv build + - name: PyPI publish + uses: pypa/gh-action-pypi-publish@release/v1 + - name: Create GitHub Release + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + gh release create ${{ github.ref_name }} --generate-notes || echo "Release already exists" diff --git a/.gitignore b/.gitignore index b5033d48..c0e44073 100644 --- a/.gitignore +++ b/.gitignore @@ -141,4 +141,10 @@ teste.py teste.txt # UV -uv.lock \ No newline at end of file +uv.lock + +# Claude Code +.claude/ + +# Implementation plans +plans/ \ No newline at end of file diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 00000000..748062de --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,17 @@ +repos: + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.15.5 + hooks: + - id: ruff + args: [--fix] + - id: ruff-format + + - repo: local + hooks: + - id: mypy + name: mypy + entry: uv run --no-sync mypy ./idecomp + language: system + types: [python] + pass_filenames: false + stages: [pre-commit] diff --git a/CHANGELOG.md b/CHANGELOG.md index 1a911fd8..1c592d64 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,88 +1,192 @@ -# v1.8.2 +# Changelog + +Todas as mudancas relevantes deste projeto serao documentadas neste arquivo. + +O formato segue o [Keep a Changelog](https://keepachangelog.com/pt-BR/1.1.0/). + +## [Nao Publicado] + +## [1.9.0] - 2026-03-10 + +### Adicionado + +- Documentação de arquitetura, FAQ e guia de desempenho (pt_BR) +- Blocos autosummary na referência de API para 41 classes do DECOMP e 2 de libs +- Arquivo `CONTRIBUTING.md` com instruções de desenvolvimento +- Workflow de release com publicação automática no PyPI via tag +- Hooks de pre-commit com ruff e mypy +- Suporte a Python 3.13 e 3.14 na matriz de CI + +### Modificado + +- Dependência cfinterface atualizada para `>=1.9.0` +- Dependência pandas atualizada para `>=3.0.0` +- Dependência numpy atualizada para `>=2.2.1` +- Versão mínima de Python alterada de 3.10 para 3.11 +- Tipagem estrita mypy em todos os 97 arquivos fonte +- Tema da documentação migrado de RTD para Furo com suporte a dark mode +- CI reestruturado em 4 jobs paralelos (lint, typecheck, test, docs) +- Deploy da documentação migrado para GitHub Pages oficial +- README expandido com badges, exemplos e seções de contribuição +- CHANGELOG reformatado para o padrão Keep a Changelog + +### Removido + +- Suporte a Python 3.10 + +## [1.8.2] - 2026-02-04 + +### Modificado - Dependência cfinterface fixada em `>=1.8,<=1.8.3` para compatibilidade com a versão atual -# v1.8.1 +## [1.8.1] - 2026-02-04 + +### Modificado - Aumento nas capacidade máximas de estágios (25) e subsistemas (15) para processamento -# v1.8.0 +## [1.8.0] - 2026-02-02 + +### Modificado - Atualiza processamento do `postos.dat` para suporte a python `>=3.13` e pandas `>=3.0.0` -# v1.7.3 +## [1.7.3] - 2025-12-29 + +### Modificado - Atualiza registro AC COTARE do `dadger.rvX` com maior precisão de dígitos significativos -# v1.7.2 +## [1.7.2] - 2025-12-29 + +### Modificado - Atualiza registro AC COTARE do `dadger.rvX` para utilizar notação científica com formatador 'D' -# v1.7.1 +## [1.7.1] - 2025-01-22 + +### Modificado - Atualiza requisitos mínimos de dependências: `numpy` reduzida para `>=2.0` -# v1.7.0 +## [1.7.0] - 2025-01-10 + +### Adicionado + +- Suporte à leitura do arquivo de saída `dec_eco_evap.csv`, `dec_eco_qlat.csv`, `dec_estatevap.csv`, `dec_estatfpha.rvX`, `dec_oper_evap.csv`, `dec_oper_rhesoft.csv`, `eco_fpha_.rvX`. + +### Corrigido -- Gestão do projeto através de arquivo `pyproject.toml` em substituição ao par `setup.py` + `requirements.txt`. - Correção no processamento do registro de alteração cadastral de potência efetiva (AC POTEFE) do arquivo `dadger.rvX`. - Correção na expansão para DataFrame dos registros de duração dos patamares (DP) do arquivo `dadger.rvX`. - Correção na leitura da versão do DECOMP nos arquivos de saída. - Correção na leitura das probabilidades em casos deterministicos. + +### Modificado + +- Gestão do projeto através de arquivo `pyproject.toml` em substituição ao par `setup.py` + `requirements.txt`. - Atualizado o suporte ao registro de intercâmbio (IA) do arquivo `dadger.rvX`. -- Suporte à leitura do arquivo de saída `dec_eco_evap.csv`, `dec_eco_qlat.csv`, `dec_estatevap.csv`, `dec_estatfpha.rvX`, `dec_oper_evap.csv`, `dec_oper_rhesoft.csv`, `eco_fpha_.rvX`. - Dependência da cfinterface atualizada para v1.8.0. - Descontinuado o uso do `pylama` como linter para garantir padrões PEP de código devido à falta de suporte em Python >= 3.12. Adoção do [ruff](https://github.com/astral-sh/ruff) em substituição. -# v1.6.0 +## [1.6.0] - 2024-10-04 + +### Adicionado - Suporte à leitura do arquivo de saída `avl_turb_max.csv`. - Suporte à leitura dos arquivos de saída `oper_disp_usih.csv`, `oper_disp_usih_ree.csv` e`oper_disp_subm.csv`. -# v1.5.0 +## [1.5.0] - 2024-08-16 + +### Adicionado -- Dependência da cfinterface atualizada para v1.7.1. - Suporte à leitura do arquivo de saída `mapcut.rvX` [#35](https://github.com/rjmalves/idecomp/issues/35). - Suporte à leitura e escrita do arquivo de saída `cortdeco.rvX`[#35](https://github.com/rjmalves/idecomp/issues/35). + +### Modificado + +- Dependência da cfinterface atualizada para v1.7.1. - Simplifica a estrutura de armazenamento dos dados do arquivo `vazoes.rvX` permitindo alterações no número de cenários [#33](https://github.com/rjmalves/idecomp/issues/33). -# v1.4.0 +## [1.4.0] - 2024-04-22 + +### Adicionado -- Dependência da cfinterface atualizada para v1.7.0. -- Uso de slots nas definições de componentes..= - Novos dados em formatos das LIBS: restrições elétricas especiais. - Adicionado suporte ao registro DA (desvios de água) do arquivo dadger. -# v1.3.0 +### Modificado + +- Dependência da cfinterface atualizada para v1.7.0. +- Uso de slots nas definições de componentes. + +## [1.3.0] - 2024-02-23 + +### Adicionado - Suporte à leitura do arquivo de saída `avl_cortesfpha_dec`. + +### Modificado + - Padronização da nomenclatura da unidade de decisão do modelo como "estágio". - Atualizado o número máximo de cenários lidos no arquivo relato para o máximo suportado pelo modelo. -# v1.2.0 +## [1.2.0] - 2024-02-05 + +### Adicionado - Suporte à leitura do arquivo de saída `dec_fcf_cortes_00N.rvX`. - Suporte à leitura do arquivo de saída `oper_desvio_fpha.csv`. -# v1.1.1 +## [1.1.1] - 2024-01-04 + +### Corrigido - Fix na leitura do arquivo `vazoes.rvX` quando gerado por versões antigas do GEVAZP, onde o número de postos não fazia parte dos dados do arquivo. -# v1.1.0 +## [1.1.0] - 2023-12-29 + +### Modificado - Atualizada a modelagem dos registros do dadger sensíveis ao número de estágios para o máximo suportado pelo modelo (TI, VE). - Atualizada a modelagem com propriedades para registros do dadger de manutenção e disponibilidade (MP, MT, FD). - Atualizada na classe `Dadger` as propriedades para acesso aos registros atualizados (MP, MT, FD). -# v1.0.1 +## [1.0.1] - 2023-12-21 + +### Corrigido - Fix nas colunas o DataFrame de Volume Útil de Reservatórios do arquivo Relato -# v1.0.0 +## [1.0.0] - 2023-12-21 + +### Adicionado - Primeira major release - Suporte à leitura e escrita todos os arquivos de entrada utilizados oficialmente no modelo DECOMP - Suporte aos registros utilizados pelo polinômio de jusante em LIBS - Adicionados registros VL, VA e VU ao dadger - Registros do dadger com número de campos variáveis por patamar agora suportam o máximo do modelo DECOMP (5) + +### Depreciado + - Métodos le_arquivo e escreve_arquivo deprecados + +[Nao Publicado]: https://github.com/rjmalves/idecomp/compare/v1.8.2...HEAD +[1.8.2]: https://github.com/rjmalves/idecomp/compare/v1.8.1...v1.8.2 +[1.8.1]: https://github.com/rjmalves/idecomp/compare/v1.8.0...v1.8.1 +[1.8.0]: https://github.com/rjmalves/idecomp/compare/v1.7.3...v1.8.0 +[1.7.3]: https://github.com/rjmalves/idecomp/compare/v1.7.2...v1.7.3 +[1.7.2]: https://github.com/rjmalves/idecomp/compare/v1.7.1...v1.7.2 +[1.7.1]: https://github.com/rjmalves/idecomp/compare/v1.7.0...v1.7.1 +[1.7.0]: https://github.com/rjmalves/idecomp/compare/v1.6.0...v1.7.0 +[1.6.0]: https://github.com/rjmalves/idecomp/compare/v1.5.0...v1.6.0 +[1.5.0]: https://github.com/rjmalves/idecomp/compare/v1.4.0...v1.5.0 +[1.4.0]: https://github.com/rjmalves/idecomp/compare/v1.3.0...v1.4.0 +[1.3.0]: https://github.com/rjmalves/idecomp/compare/v1.2.0...v1.3.0 +[1.2.0]: https://github.com/rjmalves/idecomp/compare/v1.1.1...v1.2.0 +[1.1.1]: https://github.com/rjmalves/idecomp/compare/v1.1.0...v1.1.1 +[1.1.0]: https://github.com/rjmalves/idecomp/compare/v1.0.1...v1.1.0 +[1.0.1]: https://github.com/rjmalves/idecomp/compare/v1.0.0...v1.0.1 +[1.0.0]: https://github.com/rjmalves/idecomp/releases/tag/v1.0.0 diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 00000000..3abddc97 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,108 @@ +# Como Contribuir + +Obrigado pelo interesse em contribuir com o _idecomp_! Este guia descreve o fluxo de trabalho recomendado para configurar o ambiente, manter a qualidade do código e enviar contribuições. + +## Configuracao do Ambiente + +Clone o repositório e instale as dependências de desenvolvimento com `uv`: + +```bash +git clone https://github.com/rjmalves/idecomp.git +cd idecomp +uv sync --extra dev +``` + +Verifique se a instalação está correta executando a suíte de testes: + +```bash +uv run pytest ./tests +``` + +## Hooks de Pre-commit + +O projeto utiliza [pre-commit](https://pre-commit.com/) para garantir a qualidade do código antes de cada commit. Instale o `pre-commit` e registre os hooks no repositório: + +```bash +pip install pre-commit +pre-commit install +``` + +Os hooks de `ruff` (lint) e `ruff-format` (formatação) são executados automaticamente em todo commit. + +O hook do `mypy` está configurado com `stages: [manual]` porque os stubs de tipo do `cfinterface` estão incompletos e bloqueariam todos os commits se executados automaticamente. Para executar a verificação completa de tipos manualmente: + +```bash +pre-commit run --hook-stage manual --all-files +``` + +Alternativamente, o `mypy` pode ser executado diretamente: + +```bash +uv run mypy ./idecomp +``` + +## Ferramentas de Qualidade + +| Ferramenta | Propósito | Comando | +| ------------- | ------------------------------- | ------------------------------ | +| `ruff check` | Linting (PEP8 e outras regras) | `uv run ruff check ./idecomp` | +| `ruff format` | Formatação automática do código | `uv run ruff format ./idecomp` | +| `mypy` | Verificação de tipagem estática | `uv run mypy ./idecomp` | +| `pytest` | Execução da suíte de testes | `uv run pytest ./tests` | + +Para verificar a formatação sem aplicar mudanças: + +```bash +uv run ruff format --check ./idecomp +``` + +## Convencoes de Codigo + +- **PEP8**: O estilo do código é verificado pelo `ruff`, seguindo as diretrizes do [PEP8](https://peps.python.org/pep-0008/). +- **Tipagem estatica obrigatoria**: Todas as variáveis e funções devem ter tipos declarados ou inferíveis. Evite tipos ambíguos ou que variam durante a execução. +- **Dados tabulares como DataFrame**: Propriedades das classes que retornam dados tabulares devem retornar `pd.DataFrame`, seguindo as formas normais de dados tabulares sempre que possível. +- **Nomenclatura em snake_case**: Propriedades das classes e colunas dos `pd.DataFrame` devem ser nomeadas em `snake_case`, evitando ambiguidades. + +## Executando Testes + +Para executar todos os testes: + +```bash +uv run pytest ./tests +``` + +Para executar com relatório de cobertura: + +```bash +uv run pytest --cov=idecomp ./tests +``` + +## Construindo a Documentacao + +Instale as dependências de documentação e gere o site localmente: + +```bash +uv sync --extra docs +uv run sphinx-build -M html docs/source docs/build +``` + +O site gerado estará disponível em `docs/build/html/index.html`. + +## Fluxo de Pull Requests + +1. Faça um fork do repositório e crie um branch descritivo a partir do `main`: + ```bash + git checkout -b minha-contribuicao + ``` +2. Implemente as mudanças, seguindo as convenções de código descritas acima. +3. Certifique-se de que os testes passam e que não há erros de lint ou tipagem: + ```bash + uv run pytest ./tests + uv run ruff check ./idecomp + uv run mypy ./idecomp + ``` +4. Faça commit das mudanças e envie o branch para o seu fork: + ```bash + git push origin minha-contribuicao + ``` +5. Abra um Pull Request no repositório principal. O CI executará automaticamente lint, verificação de tipos, testes e build da documentação. diff --git a/README.md b/README.md index a2115102..526883cc 100644 --- a/README.md +++ b/README.md @@ -1,36 +1,62 @@ # idecomp -[![tests](https://github.com/rjmalves/idecomp/actions/workflows/main.yml/badge.svg)](https://github.com/rjmalves/idecomp/actions/workflows/main.yml) -[![codecov](https://codecov.io/gh/rjmalves/idecomp/branch/main/graph/badge.svg?token=ZSJBGO81JP)](https://codecov.io/gh/rjmalves/idecomp) +[![tests](https://github.com/rjmalves/idecomp/actions/workflows/main.yml/badge.svg)](https://github.com/rjmalves/idecomp/actions/workflows/main.yml) [![codecov](https://codecov.io/gh/rjmalves/idecomp/branch/main/graph/badge.svg?token=ZSJBGO81JP)](https://codecov.io/gh/rjmalves/idecomp) [![PyPI](https://img.shields.io/pypi/v/idecomp)](https://pypi.org/project/idecomp/) [![Python](https://img.shields.io/pypi/pyversions/idecomp)](https://pypi.org/project/idecomp/) [![Licenca](https://img.shields.io/pypi/l/idecomp)](https://github.com/rjmalves/idecomp/blob/main/LICENSE.md) [![docs](https://img.shields.io/badge/docs-online-blue)](https://rjmalves.github.io/idecomp/) O `idecomp` é um pacote Python para manipulação dos arquivos de entrada e saída do programa [DECOMP](http://www.cepel.br/pt_br/produtos/decomp-modelo-de-planejamento-da-operacao-de-sistemas-hidrotermicos-interligados-de-curto-prazo.htm). O DECOMP é desenvolvido pelo [CEPEL](http://www.cepel.br/) e utilizado para os estudos de planejamento e operação do Sistema Interligado Nacional (SIN). O idecomp oferece: -- Meios para leitura dos arquivos de entrada e saída do DECOMP +- Leitura e escrita de arquivos de entrada e saída do DECOMP +- Dados tabulares com pandas DataFrame para análise e pós-processamento +- Mapeamento classe-por-arquivo, com uma classe dedicada para cada arquivo do DECOMP +- Base sólida no framework [cfinterface](https://github.com/rjmalves/cfinterface) para leitura de formatos de colunas fixas +- Tipagem estática completa, compatível com mypy e verificadores de tipo +- Suporte a Python >= 3.11 com API moderna orientada a objetos -- Facilidades para estudo e análise dos dados utilizando DataFrames do pandas +## Exemplo Rápido -- Dados estruturados em modelos com o uso do paradigma de orientação a objetos (OOP) +```python +from idecomp.decomp import Dadger +# Leitura do arquivo dadger.rv0 +dadger = Dadger.read("dadger.rv0") + +# Acesso aos registros de usinas termelétricas no estágio 1 +termicas = dadger.ct(estagio=1) +print(f"Usinas termelétricas no estágio 1: {len(termicas)}") +``` ## Instalação -O idecomp é compatível com versões de Python >= 3.8. +O idecomp é compatível com versões de Python >= 3.11. -É possível instalar a versão distribuída oficialmente com pip: +Instalação com pip (recomendado): ``` -python -m pip install idecomp +pip install idecomp ``` -É possível realizar a instalação da versão de desenvolvimento fazendo o uso do Git. +Instalação alternativa com uv: ``` -pip install git+https://github.com/rjmalves/idecomp +uv add idecomp ``` ## Documentação -Guias, tutoriais e as referências podem ser encontrados no site oficial do pacote: https://rjmalves.github.io/idecomp +Guias, tutoriais e referências de API estão disponíveis no site oficial do pacote: +https://rjmalves.github.io/idecomp/ + +## Projetos Relacionados + +- [inewave](https://github.com/rjmalves/inewave) — pacote equivalente para manipulação dos arquivos do NEWAVE +- [cfinterface](https://github.com/rjmalves/cfinterface) — framework base para leitura e escrita de formatos de colunas fixas + +## Contribuindo + +Contribuições são bem-vindas! Consulte o [CONTRIBUTING.md](CONTRIBUTING.md) para instruções sobre como configurar o ambiente de desenvolvimento e enviar contribuições. + +## Licenca + +Distribuído sob a licença MIT. Consulte o arquivo [LICENSE.md](LICENSE.md) para mais detalhes. diff --git a/docs/source/conf.py b/docs/source/conf.py index 7d6d7ee4..0bbdf0c0 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -1,19 +1,6 @@ -# Configuration file for the Sphinx documentation builder. -# -# This file only contains a selection of the most common options. For a full -# list see the documentation: -# https://www.sphinx-doc.org/en/master/usage/configuration.html - -# -- Path setup -------------------------------------------------------------- - -# If extensions (or modules to document with autodoc) are in another directory, -# add these directories to sys.path here. If the directory is relative to the -# documentation root, use os.path.abspath to make it absolute, like shown here. -# import os import sys from datetime import date -from typing import List import plotly.io as pio pio.renderers.default = "sphinx_gallery" @@ -21,9 +8,6 @@ sys.path.insert(0, os.path.abspath("../../")) from idecomp import __version__ # noqa: E402 - -# -- Project information ----------------------------------------------------- - project = "idecomp" copyright = f"{date.today().year}, Rogerio Alves" author = "Rogerio Alves" @@ -32,11 +16,6 @@ release = __version__ today = date.today().strftime("%d/%m/%Y") -# -- General configuration --------------------------------------------------- - -# Add any Sphinx extension module names here, as strings. They can be -# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom -# ones. extensions = [ "sphinx.ext.autosummary", "sphinx.ext.autodoc", @@ -46,65 +25,37 @@ "sphinx.ext.githubpages", "sphinx_gallery.gen_gallery", "numpydoc", - "sphinx_rtd_theme", ] - -# generate autosummary pages autosummary_generate = True - -# Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] - -# The language for content autogenerated by Sphinx. Refer to documentation -# for a list of supported languages. -# -# This is also used if you do content translation via gettext catalogs. -# Usually you set "language" from the command line for these cases. language = "pt_BR" - -# The suffix of source filenames. source_suffix = ".rst" - -# The encoding of source files. source_encoding = "utf-8" - -# The master toctree document. master_doc = "index" - -# List of patterns, relative to source directory, that match files and -# directories to ignore when looking for source files. -# This pattern also affects html_static_path and html_extra_path. -exclude_patterns: List[str] = [] +exclude_patterns: list[str] = [] add_module_names = False -pygments_style = "sphinx" +pygments_style = "friendly" +pygments_dark_style = "monokai" modindex_common_prefix = ["idecomp."] -# -- Options for HTML output ------------------------------------------------- - -# The theme to use for HTML and HTML Help pages. See the documentation for -# a list of builtin themes. -# -html_theme = "sphinx_rtd_theme" +html_theme = "furo" html_theme_options = { - "logo_only": True, - # Toc options - "collapse_navigation": False, - "sticky_navigation": True, - "navigation_depth": 4, - "includehidden": True, - "titles_only": False, + "light_css_variables": { + "color-brand-primary": "#2962ff", + "color-brand-content": "#2962ff", + }, + "dark_css_variables": { + "color-brand-primary": "#5c8aff", + "color-brand-content": "#5c8aff", + }, + "sidebar_hide_name": True, } -# Add any paths that contain custom static files (such as style sheets) here, -# relative to this directory. They are copied after the builtin static files, -# so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ["_static"] html_logo = "_static/logo_idecomp_svg.svg" -# The reST default role (used for this markup: `text`) to use for all -# documents. default_role = "obj" numpydoc_show_class_members = False @@ -118,11 +69,8 @@ "cfinterface": ("https://rjmalves.github.io/cfinterface/", None), } -# https://github.com/sphinx-gallery/sphinx-gallery sphinx_gallery_conf = { - # path to your examples scripts "examples_dirs": "../../examples", - # path where to save gallery generated examples "gallery_dirs": "examples", "backreferences_dir": "gen_modules/generated", } diff --git a/docs/source/geral/contribuicao.rst b/docs/source/geral/contribuicao.rst index 6d822ed0..760ebca0 100644 --- a/docs/source/geral/contribuicao.rst +++ b/docs/source/geral/contribuicao.rst @@ -1,48 +1,26 @@ Como contribuir? ================= -O framework `cfinterface` e dependências de desenvolvimento ------------------------------------------------------------- +.. note:: -O módulo *idecomp* é desenvolvido considerando o framework proposto no módulo `cfinterface `_. + Para instruções de configuração do ambiente de desenvolvimento, instalação de dependências + e fluxo de Pull Requests, consulte o arquivo `CONTRIBUTING.md `_ + na raiz do repositório. -A abordagem proposta no framework consiste em classificar os arquivos processados com relação à sua construção. São definidas três classes de arquvos: +O framework `cfinterface` +-------------------------- -- :obj:`~cfinterface.files.blockfile.BlockFile` -- :obj:`~cfinterface.files.sectionfile.SectionFile` -- :obj:`~cfinterface.files.registerfile.RegisterFile` +O módulo *idecomp* é desenvolvido com o framework `cfinterface `_, que oferece três modelos de arquivo: -Esta classificação independe do arquivo ser constituído de armazenamento no formato texto ou binário, sendo que -esta informação é fornecida na declaração da classe que modela o arquivo em questão. Também é possível fornecer -informações sobre a codificação padrão utilizada em casos de arquivos gerados com caracteres especiais. +- :obj:`~cfinterface.files.blockfile.BlockFile` — blocos com padrão específico de início/fim +- :obj:`~cfinterface.files.sectionfile.SectionFile` — seções obrigatórias em ordem fixa +- :obj:`~cfinterface.files.registerfile.RegisterFile` — linhas com formato constante -A modelagem de arquivos como :obj:`~cfinterface.files.blockfile.BlockFile` se baseia na definição de blocos do arquivo que -possuem um padrão específico, binário ou textual, que indica o início de um conjunto de informações que seja -autocontido e bem definido. Opcionalmente, também pode haver um padrão de terminação, ou o bloco pode determinar -a sua terminação seguindo outros critérios. Um bloco é definido como um elemento da classe :obj:`~cfinterface.components.block.Block`. -Exemplos de arquivos do módulo *idecomp* que são implementados através deste modelo são o :ref:`relato.rvX ` e :ref:`inviab_unic.rvX `. +Arquivos podem ser texto ou binário. Exemplos no *idecomp*: -O uso dos modelos da :obj:`~cfinterface.files.sectionfile.SectionFile` se baseia na definição de seções do arquivo que -sempre aparecem em uma mesma ordem e são obrigatórias. Da mesma forma, o arquivo pode ser binário ou textual. Diferentemente da modelagem -por :obj:`~cfinterface.files.blockfile.BlockFile`, que permite que um mesmo bloco apareça diversas vezes no arquivo, a abordagem -por seções não permite flexibilidade na definição de quais conteúdos aparecem e na ordem que aparecem. Podem, cada objeto -:obj:`~cfinterface.components.section.Section` pode definir o seu critério de fim, permitindo uma certa flexibilidade dentro de cada -seção. Exemplos de arquivos do módulo *idecomp* que são implementados através deste modelo são o :ref:`caso.dat ` e :ref:`arquivos.rvX `. - -Por fim, a abordagem por :obj:`~cfinterface.files.registerfile.RegisterFile` se baseia na definição de unidades mínimas de conteúdo -que ocupam sempre uma única linha e tem formato constante, que são chamadas de registros. Da mesma forma, o arquivo pode ser binário ou textual. -Registros podem ser vistos como blocos de uma só linha mas, devido à sua simplicidade, são de mais fácil definição, através da classe -:obj:`~cfinterface.components.register.Register`. A implementação de um registro consiste apenas na sua definição, visto que -a leitura e a escrita deste são inteiramente obtidas do formato dos seus campos. No *idecomp*, os arquivos :ref:`dadger.rvX ` e :ref:`dadgnl.rvX ` são modelados -seguindo esta abordagem. - - - -Para instalar as dependências de desenvolvimento, incluindo as necessárias para a geração automática do site:: - - $ git clone https://github.com/rjmalves/idecomp.git - $ cd idecomp - $ pip install -r dev-requirements.txt +- :obj:`~cfinterface.files.blockfile.BlockFile`: :ref:`relato.rvX `, :ref:`inviab_unic.rvX ` +- :obj:`~cfinterface.files.sectionfile.SectionFile`: :ref:`caso.dat `, :ref:`arquivos.rvX ` +- :obj:`~cfinterface.files.registerfile.RegisterFile`: :ref:`dadger.rvX `, :ref:`dadgnl.rvX ` .. warning:: @@ -50,68 +28,42 @@ Para instalar as dependências de desenvolvimento, incluindo as necessárias par automaticamente pelos scripts de CI no caso de qualquer modificação no branch `main`. -Diretrizes de modelagem para o módulo `idecomp` ------------------------------------------------- +Diretrizes de modelagem +------------------------ -A principal diretriz para o desenvolvimento do *idecomp* é a relação entre arquivos do modelo DECOMP e as classes -disponíveis para uso. Cada arquivo de entrada do modelo é mapeado para uma classe do módulo, que segue -o nome geralmente utilizado para o arquivo nos casos de exemplo que são fornecidos junto com o modelo pelo desenvolvedor -ou pelo ONS para publicação dos decks das revisões semanais do PMO. É utilizado sempre `PascalCase` para determinação dos nomes -das classes, sendo que abreviações que possivelmente se encontram nos nomes dos arquivos são ignoradas na mudança de caso. Por exemplo: +Cada arquivo de entrada do DECOMP é mapeado para uma classe com nome `PascalCase` (ignorando abreviações). Exemplos: -- `arquivos.rvX` é modelado na classe :ref:`Arquivos ` -- `dadger.rvX` é modelado na classe :ref:`Dadger ` -- `relato.rvX` é modelado na classe :ref:`Relato ` +- `arquivos.rvX` → classe :ref:`Arquivos ` +- `dadger.rvX` → classe :ref:`Dadger ` +- `relato.rvX` → classe :ref:`Relato ` -É convencionado, sempre que possível, que as propriedades das classes que contém os dados processados dos arquivos -lidem com objetos do tipo :obj:`~pandas.DataFrame` para a representação de dados tabulares. Além disso, se possível, -é recomendado processar a informação contida nos arquivos para que esteja na seguindo as formas normais -para dados tabulares, mesmo quando há divergência na representação textual nos arquivos de entrada do DECOMP. +**Dados tabulares**: Propriedades retornam :obj:`~pandas.DataFrame` quando possível, normalizadas para formas tabulares padrão. -As propriedades das classes e também as colunas dos :obj:`~pandas.DataFrame` que são produzidos são convencionados de -serem nomeados em `snake_case`. Além disso, deve-se evitar ao máximo ambiguidades na escolha dos nomes das propriedades e -das colunas. Alguns pontos recorrentes onde são encontradas ambiguidades e deve-se adotar um termo único são: +**Nomenclatura**: Use `snake_case` para propriedades e colunas, evitando ambiguidades: -- Propriedade ou :obj:`~pandas.DataFrame` que contenha informações de usinas (hidrelétricas, termelétricas, etc.) e venham e conter atributos - como código (`int`) e nome (`str`) convenciona-se chamar de *nome_usina* e *codigo_usina*, para garantir o único sentido possível. -- Propriedade ou :obj:`~pandas.DataFrame` que contenha informações relativas aos submercados de energia, que ora são - mencionados como subsistemas de energia, adota-se o termo único *submercado*. De modo semelhante, locais onde apareçam - informações desta entendidade são denominados *codigo_submercado* e *nome_submercado*. O mesmo raciocínio se aplica - ao se referir a REE. +- Usinas: `codigo_usina`, `nome_usina` +- Submercados/subsistemas: `codigo_submercado`, `nome_submercado` +- REE: similar aos submercados Convenções de código --------------------- -O *idecomp* considera critérios de qualidade de código em seus scripts de Integração Contínua (CI), além de uma bateria de testes unitários. -Desta forma, não é possível realizar uma *release* de uma versão que não passe em todos os testes estabelecidos ou não -atenda aos critérios de qualidade de código impostos. +Todas as releases passam por testes e controle de qualidade. As convenções são: -A primeira convenção é que sejam seguidas as diretrizes de sintaxe `PEP8 `_, provenientes do guia de estilo -do autor da linguagem. Além disso, não é recomendado que existam funções muito complexas, com uma quantidade -excessiva de *branches* e *loops*, o que piora e legibilidade do código. Isto pode ser garantido através de módulos -específicos para análise de qualidade de código, como será mencionado a seguir. A única exceção é a regra `E203 `_. - -Para garantir a formatação é recomendado utilizar o módulo `black `_, que realiza formatação automática e possui -integração nativa com alguns editores de texto no formato de *plugins* ou extensões. - -A segunda convenção é que seja utilizada tipagem estática. Isto é, não deve ser uitilizada uma variável em código a qual possua -tipo de dados que possa mudar durante a execução do mesmo. Além disso, não deve ser declarada uma variável cujo tipo não é possível de -ser inferido em qualquer situação, permanencendo incerto para o leitor o tipo de dados da variável a menos que seja feita uma -execução de teste do programa. +1. **PEP8**: Siga as diretrizes de sintaxe usando `ruff `_ para formatação (``ruff format``) e lint (``ruff check``). +2. **Tipagem estática**: Todas as variáveis devem ter tipos declarados ou inferíveis. Evite tipos que variam durante a execução. Procedimentos de teste ----------------------- -O *idecomp* realiza testes utilizando o pacote de testes de Python `pytest `_ -e controle da qualidade de código com `pylama `_. -A tipagem estática é garantida através do uso de `mypy `_ -, que é sempre executado nos scripts de Integração Contínua (CI). +Execute antes de cada ``git push``: + +.. code-block:: bash -Antes de realizar um ``git push`` é recomendado que se realize estes três procedimentos -descritos, que serão novamente executados pelo ambiente de CI:: + $ uv run pytest ./tests + $ uv run mypy ./idecomp + $ uv run ruff check ./idecomp - $ pytest ./tests - $ mypy ./idecomp - $ pylama ./idecomp --ignore E203 +Usa-se `pytest `_ para testes, `mypy `_ para tipagem, e `ruff `_ para lint. diff --git a/docs/source/geral/instalacao.rst b/docs/source/geral/instalacao.rst index 26ac0187..e7ed1a32 100644 --- a/docs/source/geral/instalacao.rst +++ b/docs/source/geral/instalacao.rst @@ -1,43 +1,64 @@ Instalação ============ -O *idecomp* é compatível com versões de Python >= 3.8. +O *idecomp* requer Python >= 3.11. -Em posse de uma instalação local de Python, é recomendado que se use um ambiente virtual para instalação de módulos de terceiros, sendo que o *idecomp* não é uma exceção. -Para mais detalhes sobre o uso de ambientes virtuais, recomenda-se a leitura do recurso oficial de Python para ambientes virtuais: `venv `_. - -Antes de prosseguir, é necessário verificar se está instalada a última versão do ``pip``, o gerenciador de pacotes de Python. Isso pode ser feito com, por exemplo:: - - $ python -m pip install ---upgrade pip +Use um ambiente virtual para instalar dependências. Veja a documentação oficial de `venv `_ para detalhes. Instalando a versão distribuída oficialmente --------------------------------------------- -É possível instalar a versão distribuída oficialmente com ``pip``:: +É possível instalar a versão distribuída oficialmente com ``pip``: + +.. code-block:: bash + + pip install idecomp + +Para atualizar para uma versão mais recente, basta adicionar a flag ``--upgrade``: + +.. code-block:: bash + + pip install --upgrade idecomp + +Para instalar uma versão específica: - $ pip install idecomp +.. code-block:: bash -Para atualizar para uma versão mais recente, basta adicionar a flag ``--upgrade``:: + pip install idecomp==x.y.z - $ pip install --upgrade idecomp +.. tip:: -Para instalar uma versão específica:: + Se você utiliza o gerenciador de pacotes `uv `_, é possível adicionar o *idecomp* ao seu projeto com: + + .. code-block:: bash + + uv add idecomp - $ pip install --upgrade idecomp==x.y.z Instalando a versão de desenvolvimento ---------------------------------------- +---------------------------------------- + +É possível realizar a instalação da versão de desenvolvimento clonando o repositório e instalando as dependências com `uv `_: + +.. code-block:: bash + + git clone https://github.com/rjmalves/idecomp.git + cd idecomp + uv sync --extra dev + +Também é possível instalar diretamente a partir do repositório remoto com ``pip``, sem necessidade de clonar: + +.. code-block:: bash -É possível realizar a instalação desta versão fazendo o uso do `Git `_. Para instalar a versão de desenvolvimento, é necessário -primeiramente desinstalar a versão instalada (se houver), com:: + pip install git+https://github.com/rjmalves/idecomp - $ pip uninstall idecomp -Em seguida, basta fazer:: +Verificando a instalação +-------------------------- - $ pip install git+https://github.com/rjmalves/idecomp +Após a instalação, verifique se o pacote está disponível: -Também é possível selecionar um branch ou release específicos:: +.. code-block:: bash - $ pip install git+https://github.com/rjmalves/idecomp@v1.0.0 + python -c "import idecomp; print(idecomp.__version__)" diff --git a/docs/source/guias/arquitetura.rst b/docs/source/guias/arquitetura.rst new file mode 100644 index 00000000..3beacbb6 --- /dev/null +++ b/docs/source/guias/arquitetura.rst @@ -0,0 +1,178 @@ +Arquitetura do idecomp +====================== + +Visao Geral +----------- + +O *idecomp* é um pacote Python que oferece uma interface de alto nível para leitura e +escrita dos arquivos do modelo `DECOMP `_, desenvolvido pelo CEPEL e +utilizado para o planejamento da operação de curto prazo do Sistema Interligado Nacional (SIN). +Cada arquivo suportado pelo pacote é representado por uma classe Python dedicada, que encapsula +a lógica de leitura, escrita e acesso aos dados. + +A base do idecomp é o framework `cfinterface `_, +que fornece as classes-base responsáveis pelo mecanismo de parse de arquivos de texto estruturado. +O idecomp atua como uma camada de domínio sobre esse framework: as classes de arquivo do idecomp +herdam de classes-base do cfinterface e definem quais modelos de registros ou blocos compõem +cada arquivo do DECOMP. + +Dessa forma, o desenvolvedor que utiliza o idecomp não precisa conhecer os detalhes do protocolo +de parse — basta instanciar a classe do arquivo desejado, chamar o método ``read`` para carregar +os dados do disco e acessar as propriedades que retornam os dados em estruturas Python convenientes, +como ``pd.DataFrame`` do `pandas `_. + +Estrutura de Pacotes +-------------------- + +O idecomp organiza seu código em dois subpacotes principais: + +``idecomp/decomp/`` + Contém as 41 classes de arquivo do DECOMP, uma por arquivo suportado. Exemplos: + ``Dadger``, ``Relato``, ``Vazoes``, ``DecOperSist``, ``Hidr``, entre outros. + Todas as classes são expostas diretamente em ``idecomp.decomp`` via importação no + ``__init__.py`` do subpacote. + +``idecomp/decomp/modelos/`` + Contém os modelos de registros e blocos utilizados pelas classes de arquivo acima. + São 45 módulos de modelos, organizados em subdiretórios: + + ``idecomp/decomp/modelos/blocos/`` + Definições de blocos reutilizáveis entre diferentes arquivos, como + ``VersaoModelo``, que identifica a versão do DECOMP a partir de um cabeçalho. + + ``idecomp/decomp/modelos/arquivoscsv/`` + Adaptador para arquivos de saída no formato CSV, base para arquivos como + ``DecOperSist``, ``DecOperUsih``, ``DecOperRee``, entre outros. + +``idecomp/libs/`` + Contém 2 módulos auxiliares para arquivos do tipo LIBS utilizados em conjunto + com o DECOMP: ``UsinasHidreletricas`` (``usinas_hidreletricas.py``) e + ``Restricoes`` (``restricoes.py``), com seus respectivos modelos em + ``idecomp/libs/modelos/``. + +Framework cfinterface +--------------------- + +O cfinterface define três classes-base para arquivos de texto estruturado. O idecomp +utiliza todas as três, dependendo do formato do arquivo DECOMP em questão: + +:class:`cfinterface.files.registerfile.RegisterFile` + Base para arquivos orientados a registros, em que cada linha do arquivo corresponde + a um registro identificado por uma palavra-chave no início da linha. O arquivo + ``dadger.rvX`` é o principal exemplo: cada seção de dados (usinas, restrições, + configurações de estudo) é representada por um tipo de registro próprio. + + .. code-block:: python + + from idecomp.decomp import Dadger + + arq = Dadger.read("./dadger.rv0") + + # Acessa o registro TE (título do estudo) + titulo = arq.te + print(titulo) + + # Acessa a tabela de usinas hidrelétricas como DataFrame + df_usinas = arq.uh + print(df_usinas.head()) + + # Modifica um dado e salva o arquivo de entrada atualizado + arq.te = "Novo titulo do estudo" + arq.write("./dadger.rv0") + +:class:`cfinterface.files.blockfile.BlockFile` + Base para arquivos orientados a blocos, em que o conteúdo é dividido em seções + delimitadas por cabeçalhos textuais. O arquivo ``relato.rvX`` é o principal + exemplo: cada bloco de resultados (convergência, balanço energético, CMO) é + identificado por um padrão textual de abertura e fechamento. + + .. code-block:: python + + from idecomp.decomp import Relato + + arq = Relato.read("./relato.rv0") + + # Acessa o bloco de convergência como DataFrame + df_conv = arq.convergencia + print(df_conv.head(10)) + +``ArquivoCSV`` (``idecomp.decomp.modelos.arquivoscsv.arquivocsv``) + Adaptador interno do idecomp construído sobre o cfinterface para arquivos de saída + no formato CSV gerados pelo DECOMP. Classes como ``DecOperSist``, ``DecOperUsih`` + e ``DecOperRee`` herdam de ``ArquivoCSV`` e implementam apenas a especificação + das colunas e versões suportadas. + + .. code-block:: python + + from idecomp.decomp import DecOperSist + + arq = DecOperSist.read("./dec_oper_sist.csv") + + # Acessa a tabela de operação por submercado + df = arq.tabela + print(df.head()) + +Fluxo de Dados +-------------- + +O fluxo de dados no idecomp segue sempre o mesmo padrão, independentemente do tipo +de arquivo (registro, bloco ou CSV): + +1. **Leitura do arquivo bruto**: o método de classe ``ClassName.read(caminho)`` abre o + arquivo no disco e aciona o mecanismo de parse do cfinterface. +2. **Construção do objeto Python**: o cfinterface percorre o arquivo linha a linha, + identificando registros ou blocos e instanciando os modelos correspondentes. +3. **Acesso via propriedades**: o objeto retornado expõe os dados através de propriedades + Python, que retornam ``pd.DataFrame`` para dados tabulares ou valores escalares + tipados para configurações simples. +4. **Escrita opcional**: para arquivos de entrada, o método ``instancia.write(caminho)`` + serializa o estado atual do objeto de volta para o formato de texto do DECOMP. + +.. code-block:: python + + from idecomp.decomp import Vazoes + + # 1. Leitura: arquivo bruto -> objeto Python + arq_vazoes = Vazoes.read("./vazoes.rv0") + + # 2. Acesso: propriedade retorna pd.DataFrame + df = arq_vazoes.previsoes + print(df.shape) + + # 3. Modificação e escrita (somente para arquivos de entrada) + df.iloc[:, 1:] *= 1.1 + arq_vazoes.previsoes = df + arq_vazoes.write("./vazoes.rv0") + +Arquivos de saída do DECOMP (como ``relato.rvX``, ``dec_oper_sist.csv``) não +implementam o método ``write``, pois são gerados exclusivamente pelo próprio modelo. +Tentativas de chamar ``write`` em instâncias desses arquivos resultam em erro. + +Modelos e Registros +------------------- + +Cada classe de arquivo em ``idecomp/decomp/`` delega o parse dos dados para classes +de modelo definidas em ``idecomp/decomp/modelos/``. Essa separação mantém as classes +de arquivo focadas na interface pública (propriedades e métodos) enquanto os modelos +cuidam dos detalhes de formatação e posicionamento de campos. + +Para arquivos baseados em ``RegisterFile`` (como ``Dadger``), os modelos são +subclasses de ``Register`` do cfinterface. Cada subclasse de ``Register`` define: + +- O código (palavra-chave) que identifica a linha no arquivo. +- Os campos (posição, tipo e nome) que compõem o registro. + +Para arquivos baseados em ``BlockFile`` (como ``Relato``), os modelos são subclasses +de ``Block`` do cfinterface. Cada subclasse de ``Block`` define: + +- O padrão textual que delimita o início do bloco. +- A lógica de leitura das linhas internas ao bloco. + +Os modelos em ``idecomp/decomp/modelos/blocos/`` são blocos reutilizáveis compartilhados +entre múltiplos arquivos. Por exemplo, o bloco ``VersaoModelo`` aparece em todos os +arquivos CSV do DECOMP e é responsável por identificar a versão do modelo a partir +do cabeçalho, permitindo que o idecomp selecione a estrutura de colunas correta para +cada versão do DECOMP. + +Para aprofundamento nos mecanismos internos de ``Register``, ``Block`` e ``RegisterFile``, +consulte a `documentação do cfinterface `_. diff --git a/docs/source/guias/desempenho.rst b/docs/source/guias/desempenho.rst new file mode 100644 index 00000000..4704208c --- /dev/null +++ b/docs/source/guias/desempenho.rst @@ -0,0 +1,252 @@ +Guia de Desempenho +================== + +Este guia apresenta as características de desempenho do *idecomp* e estratégias +práticas para otimizar fluxos de trabalho que processam grandes volumes de arquivos +do DECOMP. As recomendações aqui descritas são especialmente relevantes para análises +em lote, como a consolidação de resultados de múltiplos cenários ou revisões. + +Importacao +---------- + +Ao executar ``import idecomp`` ou ``from idecomp.decomp import AlgumaClasse``, o +interpretador Python carrega o módulo ``idecomp/__init__.py``, que importa +imediatamente o subpacote ``idecomp.decomp``. O ``__init__.py`` desse subpacote, +por sua vez, importa todas as **41 classes de arquivo** do DECOMP de uma vez. Esse +comportamento de importação antecipada (*eager import*) garante que a interface +pública do pacote esteja sempre disponível de forma consistente, mas implica um +custo de inicialização proporcional ao número de módulos carregados. + +Para a maioria dos scripts interativos e notebooks, esse custo é imperceptível. +Entretanto, em aplicações que chamam scripts Python repetidamente — por exemplo, +pipelines de automação que invocam o interpretador a cada execução — o tempo de +inicialização do processo pode ser relevante. Nesses casos, é possível reduzir o +escopo da importação apontando diretamente para o módulo do arquivo desejado, em +vez de importar pelo namespace agregado do subpacote. + +.. code-block:: python + + # Importa pelo namespace agregado: carrega todos os 41 modulos + from idecomp.decomp import Dadger + + # Importa diretamente do modulo: carrega apenas o modulo necessario + from idecomp.decomp.dadger import Dadger + +A segunda forma acessa ``idecomp/decomp/dadger.py`` diretamente, sem acionar a +importação em cadeia de todos os demais módulos do subpacote. O resultado funcional +é idêntico — a classe ``Dadger`` obtida é a mesma — mas o tempo de importação é +menor quando apenas um ou poucos arquivos precisam ser processados. + +Para medir o impacto no seu ambiente, utilize o módulo ``time`` do Python antes de +decidir qual estratégia adotar: + +.. code-block:: python + + import time + + inicio = time.perf_counter() + from idecomp.decomp.dadger import Dadger + fim = time.perf_counter() + + print(f"Tempo de importacao: {(fim - inicio) * 1000:.2f} ms") + +Leitura e Escrita de Arquivos +------------------------------ + +O padrão básico de leitura de um arquivo é sempre o mesmo: instanciar a classe +correspondente chamando o método de classe ``read`` com o caminho do arquivo no +disco. O objeto retornado mantém todos os dados do arquivo em memória e expõe as +informações por meio de propriedades que retornam ``pd.DataFrame`` ou valores +escalares tipados. + +.. code-block:: python + + from idecomp.decomp import DecOperSist + + # Leitura de um unico arquivo + arq = DecOperSist.read("./resultados/dec_oper_sist.csv") + df = arq.tabela + print(df.shape) + +Em análises de resultados do DECOMP, é comum processar o mesmo arquivo de saída +proveniente de múltiplos cenários ou revisões armazenados em diretórios separados. +O padrão recomendado para esse caso é iterar sobre os caminhos, ler cada arquivo, +extrair o DataFrame desejado e acumulá-los em uma lista para concatenação ao final: + +.. code-block:: python + + from pathlib import Path + import pandas as pd + from idecomp.decomp.dec_oper_sist import DecOperSist + + dfs = [] + for caminho in Path("./resultados").glob("*/dec_oper_sist.csv"): + arq = DecOperSist.read(str(caminho)) + dfs.append(arq.tabela) + + df_total = pd.concat(dfs, ignore_index=True) + print(f"Total de linhas consolidadas: {len(df_total)}") + +Concatenar ao final, em vez de concatenar incrementalmente dentro do loop, evita a +criação de cópias intermediárias do DataFrame a cada iteração — um padrão de +desempenho amplamente recomendado pelo próprio pandas. Quando o número de arquivos +for muito grande, considere adicionar ao DataFrame uma coluna de identificação +(nome do diretório ou do cenário) antes de acrescentá-lo à lista, para facilitar +a rastreabilidade dos dados na análise subsequente. + +Para medir o tempo total de um processamento em lote, envolva o loop com o módulo +``time``: + +.. code-block:: python + + import time + from pathlib import Path + import pandas as pd + from idecomp.decomp.dec_oper_sist import DecOperSist + + caminhos = list(Path("./resultados").glob("*/dec_oper_sist.csv")) + inicio = time.perf_counter() + + dfs = [] + for caminho in caminhos: + arq = DecOperSist.read(str(caminho)) + dfs.append(arq.tabela) + + df_total = pd.concat(dfs, ignore_index=True) + fim = time.perf_counter() + + print(f"{len(caminhos)} arquivos processados em {fim - inicio:.2f}s") + +Uso de Memoria +-------------- + +Cada objeto de arquivo do *idecomp* mantém em memória a representação Python +completa do arquivo lido — registros, blocos ou colunas CSV, dependendo do tipo. +Para arquivos de saída CSV com muitas linhas (como ``dec_oper_sist.csv`` com colunas +de estágio, cenário e patamar), o objeto pode ocupar memória significativa quando +múltiplos arquivos são carregados simultaneamente. + +O padrão recomendado para operações em lote é **ler, extrair e descartar**: após +obter o DataFrame desejado de um objeto de arquivo, remova a referência ao objeto +com ``del`` para que o coletor de lixo do Python possa liberar a memória associada. + +.. code-block:: python + + from idecomp.decomp.dec_oper_sist import DecOperSist + + arq = DecOperSist.read("./dec_oper_sist.csv") + df = arq.tabela # extrai o DataFrame necessario + del arq # libera o objeto do arquivo da memoria + + # A partir daqui, apenas df permanece em memoria + print(df.head()) + +Em loops que processam dezenas ou centenas de arquivos, combine esse padrão com +uma chamada explícita ao coletor de lixo ao final de cada iteração quando o +consumo de memória for crítico: + +.. code-block:: python + + import gc + from pathlib import Path + import pandas as pd + from idecomp.decomp.dec_oper_sist import DecOperSist + + dfs = [] + for caminho in Path("./resultados").glob("*/dec_oper_sist.csv"): + arq = DecOperSist.read(str(caminho)) + df_parcial = arq.tabela + del arq # descarta o objeto antes de passar para o proximo arquivo + gc.collect() # forca a coleta de lixo (recomendado para lotes muito grandes) + dfs.append(df_parcial) + + df_total = pd.concat(dfs, ignore_index=True) + +Note que ``gc.collect()`` adiciona um pequeno overhead por chamada. Avalie se o +ganho de memória justifica esse custo no seu caso de uso, medindo o consumo de +memória com ferramentas como ``tracemalloc`` (biblioteca padrão) ou ``memory_profiler`` +(pacote externo). + +Dicas de Otimizacao +-------------------- + +As dicas a seguir sintetizam as práticas mais eficientes para uso do *idecomp* em +fluxos de trabalho de maior escala. + +**1. Prefira importações diretas de módulo quando o tempo de inicialização importa.** +Use ``from idecomp.decomp.nome_modulo import NomeClasse`` em vez de +``from idecomp.decomp import NomeClasse`` para evitar o carregamento antecipado de +todos os 41 módulos. Aplique essa estratégia em scripts invocados repetidamente por +pipelines de automação. + +**2. Use geradores para processar arquivos em lote sem acumular todos na memória.** +Se o objetivo é calcular estatísticas ou filtrar linhas, um gerador evita carregar +todos os DataFrames simultaneamente: + +.. code-block:: python + + from pathlib import Path + import pandas as pd + from idecomp.decomp.dec_oper_sist import DecOperSist + + def gerar_tabelas(padrao): + for caminho in Path("./resultados").glob(padrao): + arq = DecOperSist.read(str(caminho)) + yield arq.tabela + del arq + + # Concatena sob demanda, sem manter todos os objetos vivos ao mesmo tempo + df_total = pd.concat(gerar_tabelas("*/dec_oper_sist.csv"), ignore_index=True) + +**3. Filtre os DataFrames imediatamente após a extração.** +Quanto antes as linhas irrelevantes forem descartadas, menor será o consumo de +memória ao longo do processamento. Aplique filtros baseados em colunas como +``estagio``, ``cenario`` ou ``patamar`` logo após acessar a propriedade do arquivo: + +.. code-block:: python + + from idecomp.decomp.dec_oper_sist import DecOperSist + + arq = DecOperSist.read("./dec_oper_sist.csv") + df = arq.tabela + + # Filtra apenas o primeiro estagio antes de qualquer outra operacao + df_filtrado = df[df["estagio"] == 1].copy() + del arq, df + +**4. Libere objetos de arquivo com ``del`` após extrair os dados necessários.** +Objetos de arquivo do *idecomp* não são referências leves — eles armazenam a +representação estruturada completa do arquivo. Descartá-los explicitamente com +``del`` após a extração do DataFrame é especialmente importante em loops com muitas +iterações. + +**5. Utilize ``gc.collect()`` em lotes muito grandes.** +Para processamentos com centenas de arquivos de grande volume, chame ``gc.collect()`` +periodicamente (por exemplo, a cada 50 arquivos) para garantir que objetos +descartados sejam de fato liberados antes que o Python reutilize a memória. Avalie +o impacto com ``tracemalloc`` antes e depois de adotar essa prática: + +.. code-block:: python + + import gc + import tracemalloc + from pathlib import Path + import pandas as pd + from idecomp.decomp.dec_oper_sist import DecOperSist + + tracemalloc.start() + + dfs = [] + caminhos = list(Path("./resultados").glob("*/dec_oper_sist.csv")) + for i, caminho in enumerate(caminhos): + arq = DecOperSist.read(str(caminho)) + dfs.append(arq.tabela) + del arq + if (i + 1) % 50 == 0: + gc.collect() + + df_total = pd.concat(dfs, ignore_index=True) + + memoria_atual, memoria_pico = tracemalloc.get_traced_memory() + tracemalloc.stop() + print(f"Pico de memoria: {memoria_pico / 1024 / 1024:.1f} MB") diff --git a/docs/source/guias/faq.rst b/docs/source/guias/faq.rst new file mode 100644 index 00000000..d5a08cf9 --- /dev/null +++ b/docs/source/guias/faq.rst @@ -0,0 +1,374 @@ +Perguntas Frequentes (FAQ) +========================== + +Esta página reúne as dúvidas mais comuns sobre o uso do *idecomp*. As respostas estão +organizadas por tema para facilitar a navegação. + +Instalacao +---------- + +Como instalo o idecomp? +^^^^^^^^^^^^^^^^^^^^^^^ + +O *idecomp* está disponível no PyPI e pode ser instalado com o ``pip``: + +.. code-block:: bash + + pip install idecomp + +Para instalar uma versão específica: + +.. code-block:: bash + + pip install idecomp==1.8.2 + +Recomenda-se utilizar um ambiente virtual (``venv`` ou ``conda``) para evitar conflitos +de dependências. + +Qual versão do Python é compatível com o idecomp? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +O *idecomp* requer **Python 3.11 ou superior**. As versões 3.11, 3.12, 3.13 e 3.14 são +testadas no CI e recomendadas para uso em produção. + +Estou com problemas de conflito de versão com o cfinterface. O que fazer? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +O *idecomp* depende da biblioteca `cfinterface `_, +que é responsável pelo mecanismo de parse dos arquivos. A versão compatível é +``>=1.9.0``. Caso você tenha uma versão incompatível instalada, force a reinstalação com +a restrição correta: + +.. code-block:: bash + + pip install "cfinterface>=1.9.0" --force-reinstall + +Se o conflito persistir, crie um ambiente virtual limpo e instale o *idecomp* a partir +do zero: + +.. code-block:: bash + + python -m venv .venv + source .venv/bin/activate # Linux/macOS + # .venv\Scripts\activate # Windows + pip install idecomp + +Leitura de Arquivos +------------------- + +Como leio um arquivo do DECOMP com o idecomp? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Utilize o método de classe ``read`` da classe correspondente ao arquivo desejado, +passando o caminho para o arquivo no disco: + +.. code-block:: python + + from idecomp.decomp import Dadger + + arq = Dadger.read("./dadger.rv0") + print(arq) + +O mesmo padrão se aplica a todos os arquivos suportados. Por exemplo, para ler o +arquivo de relato: + +.. code-block:: python + + from idecomp.decomp import Relato + + arq = Relato.read("./relato.rv0") + +Quais arquivos do DECOMP são suportados? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +O *idecomp* suporta **41 arquivos** do modelo DECOMP. Todos estão disponíveis no +módulo ``idecomp.decomp``. Os mais utilizados são: + +- ``Dadger`` — arquivo principal de dados gerais do estudo (``dadger.rvX``) +- ``Relato`` — arquivo de relatório de resultados (``relato.rvX``) +- ``Vazoes`` — arquivo de vazões previstas e geradas (``vazoes.rvX``) +- ``Hidr`` — cadastro de usinas hidrelétricas (``hidr.dat``) +- ``Caso`` — arquivo de identificação do caso (``caso.dat``) +- ``DecOperSist`` — operação por submercado em formato CSV (``dec_oper_sist.csv``) +- ``DecOperUsih`` — operação por usina hidrelétrica (``dec_oper_usih.csv``) +- ``DecOperRee`` — operação por reservatório equivalente (``dec_oper_ree.csv``) + +Para ver a lista completa, inspecione o módulo: + +.. code-block:: python + + import idecomp.decomp as decomp + print(dir(decomp)) + +O arquivo não foi encontrado. Como tratar o erro? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Quando o caminho fornecido não existe, o Python levanta ``FileNotFoundError``. Trate +o erro explicitamente para fornecer mensagens mais informativas ao usuário: + +.. code-block:: python + + from idecomp.decomp import Relato + + caminho = "./relato.rv0" + try: + arq = Relato.read(caminho) + except FileNotFoundError: + print(f"Arquivo não encontrado: {caminho}") + print("Verifique se o caminho está correto e se o DECOMP foi executado.") + +Como o idecomp lida com a codificação dos arquivos? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +O *idecomp* utiliza codificação **UTF-8** por padrão para leitura e escrita. Arquivos +gerados por versões antigas do DECOMP podem estar em Latin-1 (ISO-8859-1). Nesse caso, +pode ocorrer ``UnicodeDecodeError`` durante a leitura. + +Se encontrar esse erro, converta o arquivo para UTF-8 antes de processá-lo: + +.. code-block:: python + + # Converte de Latin-1 para UTF-8 + with open("relato.rv0", "r", encoding="latin-1") as f: + conteudo = f.read() + + with open("relato_utf8.rv0", "w", encoding="utf-8") as f: + f.write(conteudo) + + from idecomp.decomp import Relato + arq = Relato.read("./relato_utf8.rv0") + +Escrita de Arquivos +------------------- + +Como escrevo um arquivo de entrada modificado? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Para arquivos de entrada (como ``Dadger``, ``Vazoes``, ``Hidr``), utilize o método +``write`` na instância do objeto após realizar as modificações desejadas: + +.. code-block:: python + + from idecomp.decomp import Vazoes + + arq = Vazoes.read("./vazoes.rv0") + + # Eleva todas as previsões em 10% + df = arq.previsoes + df.iloc[:, 1:] *= 1.1 + arq.previsoes = df + + # Salva o arquivo modificado + arq.write("./vazoes_modificado.rv0") + +Por que não consigo chamar ``write`` em arquivos de saída? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Arquivos de saída do DECOMP — como ``Relato``, ``DecOperSist``, ``DecOperUsih`` e +outros arquivos no formato CSV — são gerados exclusivamente pelo próprio modelo e +**não implementam o método ``write``**. Esses arquivos são somente leitura no contexto +do *idecomp*. + +Tentar chamar ``write`` em uma instância de arquivo de saída levanta ``AttributeError``: + +.. code-block:: python + + from idecomp.decomp import Relato + + arq = Relato.read("./relato.rv0") + # Isso levanta AttributeError: 'Relato' object has no attribute 'write' + # arq.write("./relato.rv0") + +Para modificar resultados, trabalhe diretamente com os DataFrames retornados pelas +propriedades e salve-os em outros formatos (CSV, Parquet, Excel, etc.): + +.. code-block:: python + + from idecomp.decomp import DecOperSist + + arq = DecOperSist.read("./dec_oper_sist.csv") + df = arq.tabela + df.to_csv("./resultado_filtrado.csv", index=False) + +Como lidar com erros de permissão ao escrever? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Se o diretório de destino não existir ou não tiver permissão de escrita, o Python +levantará ``FileNotFoundError`` ou ``PermissionError``. Garanta que o diretório +existe antes de escrever: + +.. code-block:: python + + import os + from idecomp.decomp import Dadger + + arq = Dadger.read("./dadger.rv0") + + diretorio_saida = "./saida/estudo_modificado" + os.makedirs(diretorio_saida, exist_ok=True) + + arq.write(os.path.join(diretorio_saida, "dadger.rv0")) + +DataFrames e Dados +------------------ + +Como acesso os dados de um arquivo como DataFrame? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +As propriedades das classes do *idecomp* retornam dados tabulares diretamente como +``pd.DataFrame`` do `pandas `_. Basta acessar a propriedade +correspondente ao dado desejado: + +.. code-block:: python + + from idecomp.decomp import Relato + + arq = Relato.read("./relato.rv0") + + # Retorna pd.DataFrame com as iterações de convergência + df_convergencia = arq.convergencia + print(df_convergencia.dtypes) + print(df_convergencia.head(5)) + +Para descobrir quais propriedades estão disponíveis em uma classe, use ``help()`` ou +inspecione os atributos do objeto: + +.. code-block:: python + + from idecomp.decomp import DecOperSist + + arq = DecOperSist.read("./dec_oper_sist.csv") + # Lista propriedades e métodos públicos + props = [attr for attr in dir(arq) if not attr.startswith("_")] + print(props) + +Como filtro e modifico um DataFrame retornado por uma propriedade? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Use as operações padrão do pandas sobre o DataFrame retornado. Para modificar os +dados e persistir a alteração no objeto, atribua o DataFrame modificado de volta +à mesma propriedade: + +.. code-block:: python + + from idecomp.decomp import Vazoes + + arq = Vazoes.read("./vazoes.rv0") + + # Acessa o DataFrame de previsões + df = arq.previsoes + + # Filtra apenas os primeiros 5 estágios + df_filtrado = df[df["estagio"] <= 5].copy() + print(df_filtrado) + + # Modifica todos os valores e atualiza o objeto + df.iloc[:, 1:] *= 1.1 + arq.previsoes = df + arq.write("./vazoes_modificado.rv0") + +Como as propriedades se relacionam com os blocos e registros internos do DECOMP? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Cada propriedade de uma classe de arquivo corresponde a um **registro** (em arquivos +baseados em ``RegisterFile``) ou a um **bloco** (em arquivos baseados em +``BlockFile``). Os modelos internos ficam em ``idecomp/decomp/modelos/``. + +Por exemplo, no ``Dadger`` (``RegisterFile``), a propriedade ``uh`` corresponde ao +registro ``UH`` do ``dadger.rvX``, que define as usinas hidrelétricas do estudo: + +.. code-block:: python + + from idecomp.decomp import Dadger + + arq = Dadger.read("./dadger.rv0") + + # Propriedade 'uh' mapeia para o registro UH do dadger.rvX + df_usinas = arq.uh + print(df_usinas.columns.tolist()) + +No ``Relato`` (``BlockFile``), a propriedade ``convergencia`` mapeia para o bloco +de convergência do ``relato.rvX``, delimitado por um padrão textual específico no +arquivo de saída. + +Para entender a correspondência entre propriedades e registros/blocos de um arquivo +específico, consulte a :doc:`../referencia/decomp/index` ou a documentação do cfinterface. + +Erros Comuns +------------ + +Recebi um erro de parse do cfinterface. O que significa? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Erros de parse geralmente indicam que o arquivo do DECOMP está **malformado** ou em +uma versão não reconhecida. O cfinterface tenta fazer o parse linha a linha e levanta +exceções quando encontra conteúdo inesperado. + +Verifique os pontos mais comuns: + +1. O arquivo está completo e não foi truncado durante a execução do DECOMP. +2. A extensão e o nome do arquivo correspondem ao tipo esperado (``dadger.rv0``, + ``relato.rv0``, ``dec_oper_sist.csv``, etc.). +3. O arquivo não foi editado manualmente de forma incorreta. + +.. code-block:: python + + from idecomp.decomp import Dadger + + # Se o arquivo estiver malformado, use try/except para capturar o erro + try: + arq = Dadger.read("./dadger.rv0") + except Exception as e: + print(f"Erro ao ler o arquivo: {type(e).__name__}: {e}") + print("Verifique se o arquivo dadger.rv0 está íntegro.") + +Como lidar com versões diferentes do DECOMP? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Alguns arquivos de saída CSV do DECOMP possuem estruturas de colunas diferentes +conforme a versão do modelo. O *idecomp* utiliza o dicionário ``VERSIONS`` do +cfinterface para lidar com isso automaticamente: ao ler o arquivo, o *idecomp* +inspeciona o cabeçalho e seleciona a estrutura de colunas correta. + +Caso o arquivo tenha sido gerado por uma versão do DECOMP não reconhecida, o *idecomp* +pode não conseguir fazer o parse corretamente. Verifique a versão do DECOMP que +gerou o arquivo: + +.. code-block:: python + + from idecomp.decomp import DecOperSist + + arq = DecOperSist.read("./dec_oper_sist.csv") + + # Verifica a versão detectada no cabeçalho + if hasattr(arq, "versao"): + print(f"Versão detectada: {arq.versao}") + +Se a versão não for suportada, considere atualizar o *idecomp* para a versão mais +recente, que pode incluir suporte a versões mais novas do DECOMP. + +Uma propriedade está retornando ``None``. Por que? +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Quando uma propriedade retorna ``None``, o registro ou bloco correspondente **não +foi encontrado no arquivo**. Isso pode ocorrer quando: + +1. O arquivo não contém aquele bloco de dados (por exemplo, o estudo não modelou + a feature correspondente). +2. O arquivo está em uma versão mais antiga do DECOMP que não gerava aquele campo. +3. O arquivo está correto, mas o dado esperado não foi gerado nesta execução. + +Sempre verifique se a propriedade é ``None`` antes de operar sobre ela: + +.. code-block:: python + + from idecomp.decomp import Relato + + arq = Relato.read("./relato.rv0") + + df_cmo = arq.cmo_medio_subsistema + if df_cmo is None: + print("Dados de CMO não encontrados no arquivo relato.rv0.") + print("Verifique se o estudo incluiu o cálculo de CMO.") + else: + print(df_cmo.head()) diff --git a/docs/source/index.rst b/docs/source/index.rst index 8752326d..63bb7e88 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -9,13 +9,13 @@ Interface de Programação para o DECOMP **Data:** |today| .. toctree:: - :caption: Apresentação + :caption: Apresentação :maxdepth: 3 apresentacao/apresentacao.rst .. toctree:: - :caption: Geral + :caption: Geral :maxdepth: 3 geral/instalacao @@ -23,6 +23,14 @@ Interface de Programação para o DECOMP examples/index.rst geral/contribuicao +.. toctree:: + :caption: Guias + :maxdepth: 2 + + guias/arquitetura + guias/desempenho + guias/faq + .. toctree:: :caption: Referência :maxdepth: 2 @@ -30,4 +38,4 @@ Interface de Programação para o DECOMP referencia/decomp/index.rst referencia/libs/index.rst -:ref:`genindex` \ No newline at end of file +:ref:`genindex` diff --git a/docs/source/referencia/decomp/index.rst b/docs/source/referencia/decomp/index.rst index 7592e39b..0e6c8a7c 100644 --- a/docs/source/referencia/decomp/index.rst +++ b/docs/source/referencia/decomp/index.rst @@ -3,6 +3,51 @@ DECOMP ======= +.. autosummary:: + :nosignatures: + + idecomp.decomp.arquivos.Arquivos + idecomp.decomp.avl_cortesfpha_dec.AvlCortesFpha + idecomp.decomp.avl_turb_max.AvlTurbMax + idecomp.decomp.caso.Caso + idecomp.decomp.cortdeco.Cortdeco + idecomp.decomp.custos.Custos + idecomp.decomp.dadger.Dadger + idecomp.decomp.dadgnl.Dadgnl + idecomp.decomp.decomptim.Decomptim + idecomp.decomp.dec_avl_evap.DecAvlEvap + idecomp.decomp.dec_cortes_evap.DecCortesEvap + idecomp.decomp.dec_desvfpha.DecDesvFpha + idecomp.decomp.dec_eco_cotajus.DecEcoCotajus + idecomp.decomp.dec_eco_discr.DecEcoDiscr + idecomp.decomp.dec_eco_evap.DecEcoEvap + idecomp.decomp.dec_eco_qlat.DecEcoQlat + idecomp.decomp.dec_estatevap.DecEstatEvap + idecomp.decomp.dec_estatfpha.DecEstatFpha + idecomp.decomp.dec_fcf_cortes.DecFcfCortes + idecomp.decomp.dec_oper_evap.DecOperEvap + idecomp.decomp.dec_oper_gnl.DecOperGnl + idecomp.decomp.dec_oper_interc.DecOperInterc + idecomp.decomp.dec_oper_ree.DecOperRee + idecomp.decomp.dec_oper_rhesoft.DecOperRheSoft + idecomp.decomp.dec_oper_sist.DecOperSist + idecomp.decomp.dec_oper_usie.DecOperUsie + idecomp.decomp.dec_oper_usih.DecOperUsih + idecomp.decomp.dec_oper_usit.DecOperUsit + idecomp.decomp.eco_fpha.EcoFpha + idecomp.decomp.fcfnw.Fcfnw + idecomp.decomp.hidr.Hidr + idecomp.decomp.inviabunic.InviabUnic + idecomp.decomp.mapcut.Mapcut + idecomp.decomp.oper_desvio_fpha.OperDesvioFpha + idecomp.decomp.oper_disp_usih.OperDispUsih + idecomp.decomp.oper_disp_usih_ree.OperDispUsihRee + idecomp.decomp.oper_disp_usih_subm.OperDispUsihSubm + idecomp.decomp.postos.Postos + idecomp.decomp.relato.Relato + idecomp.decomp.relgnl.Relgnl + idecomp.decomp.vazoes.Vazoes + .. toctree:: :maxdepth: 2 diff --git a/docs/source/referencia/libs/index.rst b/docs/source/referencia/libs/index.rst index 00652a81..9f0cd062 100644 --- a/docs/source/referencia/libs/index.rst +++ b/docs/source/referencia/libs/index.rst @@ -3,6 +3,12 @@ LIBS ======= +.. autosummary:: + :nosignatures: + + idecomp.libs.restricoes.Restricoes + idecomp.libs.usinas_hidreletricas.UsinasHidreletricas + .. toctree:: :maxdepth: 2 diff --git a/idecomp/__init__.py b/idecomp/__init__.py index 7edfdb4a..1cd1457a 100644 --- a/idecomp/__init__.py +++ b/idecomp/__init__.py @@ -6,6 +6,6 @@ e saída do DECOMP. """ -__version__ = "1.8.2" +__version__ = "1.9.0" from . import decomp # noqa diff --git a/idecomp/decomp/arquivos.py b/idecomp/decomp/arquivos.py index f1b112cb..13356649 100644 --- a/idecomp/decomp/arquivos.py +++ b/idecomp/decomp/arquivos.py @@ -1,7 +1,8 @@ -from idecomp.decomp.modelos.arquivos import BlocoNomesArquivos +from typing import TypeVar from cfinterface.files.sectionfile import SectionFile -from typing import TypeVar, Optional, List + +from idecomp.decomp.modelos.arquivos import BlocoNomesArquivos class Arquivos(SectionFile): @@ -19,7 +20,7 @@ class Arquivos(SectionFile): SECTIONS = [BlocoNomesArquivos] - def __le_nome_por_indice(self, indice: int) -> Optional[str]: + def __le_nome_por_indice(self, indice: int) -> str | None: b = self.data.get_sections_of_type(BlocoNomesArquivos) if isinstance(b, BlocoNomesArquivos): if indice in b.data.index: @@ -28,14 +29,14 @@ def __le_nome_por_indice(self, indice: int) -> Optional[str]: return dado return None - def __atualiza_nome_por_indice(self, indice: int, nome: str): + def __atualiza_nome_por_indice(self, indice: int, nome: str) -> None: b = self.data.get_sections_of_type(BlocoNomesArquivos) if isinstance(b, BlocoNomesArquivos): if indice in b.data.index: b.data.iloc[indice, 0] = nome @property - def arquivos(self) -> List[str]: + def arquivos(self) -> list[str]: """ Os nomes dos arquivos utilizados. @@ -48,78 +49,78 @@ def arquivos(self) -> List[str]: ) @property - def dadger(self) -> Optional[str]: + def dadger(self) -> str | None: """ Nome do arquivo de dados gerais utilizado pelo DECOMP. """ return self.__le_nome_por_indice(0) @dadger.setter - def dadger(self, arq: str): + def dadger(self, arq: str) -> None: self.__atualiza_nome_por_indice(0, arq) @property - def vazoes(self) -> Optional[str]: + def vazoes(self) -> str | None: """ Nome do arquivo de vazões incrementais afluentes. """ return self.__le_nome_por_indice(1) @vazoes.setter - def vazoes(self, arq: str): + def vazoes(self, arq: str) -> None: self.__atualiza_nome_por_indice(1, arq) @property - def hidr(self) -> Optional[str]: + def hidr(self) -> str | None: """ Nome do arquivo de cadastro dos dados das hidrelétricas. """ return self.__le_nome_por_indice(2) @hidr.setter - def hidr(self, arq: str): + def hidr(self, arq: str) -> None: self.__atualiza_nome_por_indice(2, arq) @property - def mlt(self) -> Optional[str]: + def mlt(self) -> str | None: """ Nome do arquivo com as médias mensais de longo termo (MLT). """ return self.__le_nome_por_indice(3) @mlt.setter - def mlt(self, arq: str): + def mlt(self, arq: str) -> None: self.__atualiza_nome_por_indice(3, arq) @property - def perdas(self) -> Optional[str]: + def perdas(self) -> str | None: """ Nome do arquivo com as perdas no sistema. """ return self.__le_nome_por_indice(4) @perdas.setter - def perdas(self, arq: str): + def perdas(self, arq: str) -> None: self.__atualiza_nome_por_indice(4, arq) @property - def dadgnl(self) -> Optional[str]: + def dadgnl(self) -> str | None: """ Nome do arquivo com os dados das usinas térmicas GNL. """ return self.__le_nome_por_indice(5) @dadgnl.setter - def dadgnl(self, arq: str): + def dadgnl(self, arq: str) -> None: self.__atualiza_nome_por_indice(5, arq) @property - def caminho(self) -> Optional[str]: + def caminho(self) -> str | None: """ Caminho para os executáveis do DECOMP. """ return self.__le_nome_por_indice(6) @caminho.setter - def caminho(self, arq: str): + def caminho(self, arq: str) -> None: self.__atualiza_nome_por_indice(6, arq) diff --git a/idecomp/decomp/avl_cortesfpha_dec.py b/idecomp/decomp/avl_cortesfpha_dec.py index 3b1a2259..0461dfb4 100644 --- a/idecomp/decomp/avl_cortesfpha_dec.py +++ b/idecomp/decomp/avl_cortesfpha_dec.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.avl_cortesfpha_dec import TabelaCortesFpha +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.avl_cortesfpha_dec import TabelaCortesFpha +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo class AvlCortesFpha(ArquivoCSV): @@ -14,7 +13,7 @@ class AvlCortesFpha(ArquivoCSV): BLOCKS = [VersaoModelo, TabelaCortesFpha] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/avl_turb_max.py b/idecomp/decomp/avl_turb_max.py index 72ed2c5b..a5144363 100644 --- a/idecomp/decomp/avl_turb_max.py +++ b/idecomp/decomp/avl_turb_max.py @@ -1,5 +1,3 @@ -from typing import Optional - import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV @@ -14,7 +12,7 @@ class AvlTurbMax(ArquivoCSV): BLOCKS = [TabelaAvlTurbMax] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/caso.py b/idecomp/decomp/caso.py index b5be5d02..b0c6959f 100644 --- a/idecomp/decomp/caso.py +++ b/idecomp/decomp/caso.py @@ -1,7 +1,8 @@ -from idecomp.decomp.modelos.caso import NomeCaso +from typing import Any, TypeVar from cfinterface.files.sectionfile import SectionFile -from typing import TypeVar, Optional + +from idecomp.decomp.modelos.caso import NomeCaso class Caso(SectionFile): @@ -18,11 +19,11 @@ class Caso(SectionFile): SECTIONS = [NomeCaso] - def __init__(self, data=...) -> None: + def __init__(self, data: Any = ...) -> None: super().__init__(data) @property - def arquivos(self) -> Optional[str]: + def arquivos(self) -> str | None: """ Caminho para o arquivo `arquivos.dat` de entrada do DECOMP. @@ -35,7 +36,7 @@ def arquivos(self) -> Optional[str]: return None @arquivos.setter - def arquivos(self, a: str): + def arquivos(self, a: str) -> None: b = self.data.get_sections_of_type(NomeCaso) if isinstance(b, NomeCaso): b.data = a diff --git a/idecomp/decomp/cortdeco.py b/idecomp/decomp/cortdeco.py index 7d91d3d2..120398b6 100644 --- a/idecomp/decomp/cortdeco.py +++ b/idecomp/decomp/cortdeco.py @@ -1,8 +1,9 @@ +from typing import IO, Any, TypeVar + +import pandas as pd # type: ignore[import-untyped] from cfinterface.files.sectionfile import SectionFile -from idecomp.decomp.modelos.cortdeco import SecaoDadosCortdeco -import pandas as pd # type: ignore -from typing import TypeVar, Optional, Union, List, IO +from idecomp.decomp.modelos.cortdeco import SecaoDadosCortdeco class Cortdeco(SectionFile): @@ -16,25 +17,25 @@ class Cortdeco(SectionFile): SECTIONS = [SecaoDadosCortdeco] STORAGE = "BINARY" - def __obtem_secao_cortdeco(self) -> Optional[pd.DataFrame]: + def __obtem_secao_cortdeco(self) -> pd.DataFrame | None: s = self.data.get_sections_of_type(SecaoDadosCortdeco) return s.data if not isinstance(s, list) and s is not None else None @classmethod def read( cls, - content: Union[str, bytes], + content: str | bytes, tamanho_registro: int = 0, registro_ultimo_corte_no: pd.DataFrame = pd.DataFrame(), numero_total_cortes: int = 0, numero_patamares_carga: int = 3, numero_estagios: int = 0, - codigos_uhes: List[int] = [], - codigos_uhes_tempo_viagem: List[int] = [], - codigos_submercados: List[int] = [], + codigos_uhes: list[int] = [], + codigos_uhes_tempo_viagem: list[int] = [], + codigos_submercados: list[int] = [], lag_maximo_tempo_viagem: int = 3, - *args, - **kwargs + *args: Any, + **kwargs: Any, ) -> "Cortdeco": a = super().read( content, @@ -48,26 +49,26 @@ def read( codigos_submercados=codigos_submercados, lag_maximo_tempo_viagem=lag_maximo_tempo_viagem, *args, - **kwargs + **kwargs, ) - return a + return a # type: ignore[return-value] def write( self, - to: Union[str, IO], + to: str | IO[Any], df_registro_ultimo_corte_no: pd.DataFrame = pd.DataFrame(), - *args, - **kwargs - ): + *args: Any, + **kwargs: Any, + ) -> None: super().write( to, df_registro_ultimo_corte_no=df_registro_ultimo_corte_no, *args, - **kwargs + **kwargs, ) @property - def cortes(self) -> Optional[pd.DataFrame]: + def cortes(self) -> pd.DataFrame | None: """ Retorna o conjunto dos cortes de Benders construídos durante o cálculo da política @@ -99,13 +100,13 @@ def cortes(self) -> Optional[pd.DataFrame]: return self.__obtem_secao_cortdeco() @cortes.setter - def cortes(self, df: pd.DataFrame): + def cortes(self, df: pd.DataFrame) -> None: dados = self.__obtem_secao_cortdeco() if dados is not None: dados = df @property - def coeficientes_volume_armazenado(self) -> Optional[pd.DataFrame]: + def coeficientes_volume_armazenado(self) -> pd.DataFrame | None: """ Retorna o conjunto dos coeficientes dos cortes de Benders construídos durante o cálculo da política para os eixos de volume armazenado @@ -159,7 +160,7 @@ def __cria_data_frame(df_cortes: pd.DataFrame) -> pd.DataFrame: return None @property - def coeficientes_defluencia_tempo_viagem(self) -> Optional[pd.DataFrame]: + def coeficientes_defluencia_tempo_viagem(self) -> pd.DataFrame | None: """ Retorna o conjunto dos coeficientes dos cortes de Benders construídos durante o cálculo da política para os eixos de vazão defluente passada @@ -188,9 +189,7 @@ def __cria_data_frame(df_cortes: pd.DataFrame) -> pd.DataFrame: "uhe", expand=True )[1] df_melted["codigo_usina"] = ( - df_melted["variable"] - .str.split("_", expand=True)[0] - .astype(int) + df_melted["variable"].str.split("_", expand=True)[0].astype(int) ) df_melted["lag"] = ( df_melted["variable"] @@ -223,7 +222,7 @@ def __cria_data_frame(df_cortes: pd.DataFrame) -> pd.DataFrame: return None @property - def coeficientes_geracao_gnl(self) -> Optional[pd.DataFrame]: + def coeficientes_geracao_gnl(self) -> pd.DataFrame | None: """ Retorna o conjunto dos coeficientes dos cortes de Benders construídos durante o cálculo da política para os eixos de geração térmica diff --git a/idecomp/decomp/custos.py b/idecomp/decomp/custos.py index 57db1cfb..0c9acdbe 100644 --- a/idecomp/decomp/custos.py +++ b/idecomp/decomp/custos.py @@ -1,9 +1,10 @@ -from idecomp.decomp.modelos.custos import BlocoRelatorioCustos +from typing import Any, TypeVar +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.block import Block from cfinterface.files.blockfile import BlockFile -from typing import List, TypeVar, Optional -import pandas as pd # type: ignore + +from idecomp.decomp.modelos.custos import BlocoRelatorioCustos class Custos(BlockFile): @@ -22,14 +23,14 @@ class Custos(BlockFile): BlocoRelatorioCustos, ] - def __init__(self, data=...) -> None: + def __init__(self, data: Any = ...) -> None: super().__init__(data) self.__relatorios_variaveis_duais = None self.__relatorios_fcf = None def __concatena_blocos( - self, blocos, indice_data: int - ) -> Optional[pd.DataFrame]: + self, blocos: list[Any], indice_data: int + ) -> pd.DataFrame | None: """ Adiciona uma coluna com o estágio de cada bloco, assumindo a mesma ordem das séries de energia. @@ -52,7 +53,7 @@ def __concatena_blocos( return None @property - def relatorio_variaveis_duais(self) -> Optional[pd.DataFrame]: + def relatorio_variaveis_duais(self) -> pd.DataFrame | None: """ Obtém a tabela das variáveis duais do armazenamento de cada UHE, nos problemas resolvidos pelo DECOMP. @@ -66,7 +67,7 @@ def relatorio_variaveis_duais(self) -> Optional[pd.DataFrame]: :rtype: pd.DataFrame | None """ if self.__relatorios_variaveis_duais is None: - blocos_custos: List[BlocoRelatorioCustos] = [] + blocos_custos: list[BlocoRelatorioCustos] = [] for b in self.data.of_type(BlocoRelatorioCustos): blocos_custos.append(b) self.__relatorios_variaveis_duais = self.__concatena_blocos( @@ -75,7 +76,7 @@ def relatorio_variaveis_duais(self) -> Optional[pd.DataFrame]: return self.__relatorios_variaveis_duais @property - def relatorio_fcf(self) -> Optional[pd.DataFrame]: + def relatorio_fcf(self) -> pd.DataFrame | None: """ Obtém a tabela dos cortes da FCF nos quais o DECOMP acoplou durante a resolução dos seus problemas. @@ -89,7 +90,7 @@ def relatorio_fcf(self) -> Optional[pd.DataFrame]: :rtype: pd.DataFrame | None """ if self.__relatorios_fcf is None: - blocos_custos: List[BlocoRelatorioCustos] = [] + blocos_custos: list[BlocoRelatorioCustos] = [] for b in self.data.of_type(BlocoRelatorioCustos): blocos_custos.append(b) self.__relatorios_fcf = self.__concatena_blocos(blocos_custos, 1) diff --git a/idecomp/decomp/dadger.py b/idecomp/decomp/dadger.py index f8749e27..7fde43bf 100644 --- a/idecomp/decomp/dadger.py +++ b/idecomp/decomp/dadger.py @@ -1,7 +1,7 @@ -from typing import Any, List, Optional, Type, TypeVar, Union +from typing import Any, TypeVar, Union import numpy as np -import pandas # type: ignore +import pandas # type: ignore[import-untyped] from cfinterface.components.register import Register from cfinterface.files.registerfile import RegisterFile @@ -217,7 +217,7 @@ class Dadger(RegisterFile): DA, ] - def __init__(self, data=...) -> None: + def __init__(self, data: Any = ...) -> None: super().__init__(data) def __expande_colunas_df(self, df: pandas.DataFrame) -> pandas.DataFrame: @@ -229,8 +229,9 @@ def __expande_colunas_df(self, df: pandas.DataFrame) -> pandas.DataFrame: num_elementos = len(df.at[0, c]) particoes_coluna = [f"{c}_{i}" for i in range(1, num_elementos + 1)] df[particoes_coluna] = df.apply( - lambda linha: linha[c] - + [np.nan] * max(0, num_elementos - len(linha[c])), + lambda linha: ( + linha[c] + [np.nan] * max(0, num_elementos - len(linha[c])) + ), axis=1, result_type="expand", ) @@ -238,8 +239,8 @@ def __expande_colunas_df(self, df: pandas.DataFrame) -> pandas.DataFrame: return df def __registros_ou_df( - self, t: Type[T], **kwargs - ) -> Optional[Union[T, List[T], pandas.DataFrame]]: + self, t: type[T], **kwargs: Any + ) -> T | list[T] | pandas.DataFrame | None: if kwargs.get("df"): return self.__expande_colunas_df(self._as_df(t)) else: @@ -247,7 +248,7 @@ def __registros_ou_df( return self.data.get_registers_of_type(t, **kwargs_sem_df) @property - def te(self) -> Optional[TE]: + def te(self) -> TE | None: """ Obtém o (único) registro que define o nome do estudo no :class:`Dadger` @@ -263,10 +264,10 @@ def te(self) -> Optional[TE]: def sb( self, - codigo_submercado: Optional[int] = None, - nome_submercado: Optional[str] = None, + codigo_submercado: int | None = None, + nome_submercado: str | None = None, df: bool = False, - ) -> Optional[Union[SB, List[SB], pandas.DataFrame]]: + ) -> SB | list[SB] | pandas.DataFrame | None: """ Obtém um registro que define os submercados existentes no estudo descrito pelo :class:`Dadger`. @@ -287,12 +288,12 @@ def sb( def uh( self, - codigo_usina: Optional[int] = None, - codigo_ree: Optional[int] = None, - volume_inicial: Optional[float] = None, - evaporacao: Optional[int] = None, + codigo_usina: int | None = None, + codigo_ree: int | None = None, + volume_inicial: float | None = None, + evaporacao: int | None = None, df: bool = False, - ) -> Optional[Union[UH, List[UH], pandas.DataFrame]]: + ) -> UH | list[UH] | pandas.DataFrame | None: """ Obtém um registro que define uma usina hidrelétrica existente no estudo descrito pelo :class:`Dadger`. @@ -323,13 +324,13 @@ def uh( def ue( self, - codigo_usina: Optional[int] = None, - codigo_submercado: Optional[int] = None, - nome_usina: Optional[str] = None, - codigo_usina_montante: Optional[int] = None, - codigo_usina_jusante: Optional[int] = None, + codigo_usina: int | None = None, + codigo_submercado: int | None = None, + nome_usina: str | None = None, + codigo_usina_montante: int | None = None, + codigo_usina_jusante: int | None = None, df: bool = False, - ) -> Optional[Union[UE, List[UE], pandas.DataFrame]]: + ) -> UE | list[UE] | pandas.DataFrame | None: """ Obtém um registro que define uma usina elevatória existente no estudo descrito pelo :class:`Dadger`. @@ -366,12 +367,12 @@ def ue( def ct( self, - codigo_usina: Optional[int] = None, - estagio: Optional[int] = None, - codigo_submercado: Optional[int] = None, - nome_usina: Optional[str] = None, + codigo_usina: int | None = None, + estagio: int | None = None, + codigo_submercado: int | None = None, + nome_usina: str | None = None, df: bool = False, - ) -> Optional[Union[CT, List[CT], pandas.DataFrame]]: + ) -> CT | list[CT] | pandas.DataFrame | None: """ Obtém um registro que define uma usina termelétrica existente no estudo descrito pelo :class:`Dadger`. @@ -402,11 +403,11 @@ def ct( def dp( self, - estagio: Optional[int] = None, - codigo_submercado: Optional[int] = None, - numero_patamares: Optional[int] = None, + estagio: int | None = None, + codigo_submercado: int | None = None, + numero_patamares: int | None = None, df: bool = False, - ) -> Optional[Union[DP, List[DP], pandas.DataFrame]]: + ) -> DP | list[DP] | pandas.DataFrame | None: """ Obtém um registro que define as durações dos patamares no estudo descrito pelo :class:`Dadger`. @@ -437,11 +438,11 @@ def dp( def pq( self, - nome: Optional[str] = None, - codigo_submercado: Optional[int] = None, - estagio: Optional[int] = None, + nome: str | None = None, + codigo_submercado: int | None = None, + estagio: int | None = None, df: bool = False, - ) -> Optional[Union[PQ, List[PQ], pandas.DataFrame]]: + ) -> PQ | list[PQ] | pandas.DataFrame | None: """ Obtém um registro que define as gerações das pequenas usinas no estudo descrito pelo :class:`Dadger`. @@ -471,11 +472,11 @@ def pq( def ia( self, - estagio: Optional[int] = None, - nome_submercado_de: Optional[str] = None, - nome_submercado_para: Optional[str] = None, + estagio: int | None = None, + nome_submercado_de: str | None = None, + nome_submercado_para: str | None = None, df: bool = False, - ) -> Optional[Union[IA, List[IA], pandas.DataFrame]]: + ) -> IA | list[IA] | pandas.DataFrame | None: """ Obtém um registro que define os limites de intercâmbio no estudo descrito pelo :class:`Dadger`. @@ -504,11 +505,11 @@ def ia( def ri( self, - codigo_usina: Optional[int] = None, - estagio: Optional[int] = None, - codigo_submercado: Optional[int] = None, + codigo_usina: int | None = None, + estagio: int | None = None, + codigo_submercado: int | None = None, df: bool = False, - ) -> Optional[Union[RI, List[RI], pandas.DataFrame]]: + ) -> RI | list[RI] | pandas.DataFrame | None: """ Obtém um registro que define as restrições de Itaipu no estudo descrito pelo :class:`Dadger`. @@ -539,8 +540,8 @@ def ac( codigo_usina: int, modificacao: Any, df: bool = False, - **kwargs, - ) -> Optional[Union[AC, List[AC], pandas.DataFrame]]: + **kwargs: Any, + ) -> AC | list[AC] | pandas.DataFrame | None: """ Obtém um registro que define modificações nos parâmetros das UHE em um :class:`Dadger`. @@ -562,12 +563,12 @@ def ac( def cd( self, - codigo_curva: Optional[int] = None, - codigo_submercado: Optional[int] = None, - nome_curva: Optional[str] = None, - estagio: Optional[int] = None, + codigo_curva: int | None = None, + codigo_submercado: int | None = None, + nome_curva: str | None = None, + estagio: int | None = None, df: bool = False, - ) -> Optional[Union[CD, List[CD], pandas.DataFrame]]: + ) -> CD | list[CD] | pandas.DataFrame | None: """ Obtém um registro que define as curvas de déficit no estudo descrito pelo :class:`Dadger`. @@ -597,7 +598,7 @@ def cd( ) @property - def tx(self) -> Optional[TX]: + def tx(self) -> TX | None: """ Obtém o (único) registro que define a taxa de desconto aplicada no estudo definido no :class:`Dadger` @@ -612,7 +613,7 @@ def tx(self) -> Optional[TX]: return None @property - def gp(self) -> Optional[GP]: + def gp(self) -> GP | None: """ Obtém o (único) registro que define o gap para convergência considerado no estudo definido no :class:`Dadger` @@ -627,7 +628,7 @@ def gp(self) -> Optional[GP]: return None @property - def ni(self) -> Optional[NI]: + def ni(self) -> NI | None: """ Obtém o (único) registro que define o número máximo de iterações do DECOMP no estudo definido no :class:`Dadger` @@ -642,7 +643,7 @@ def ni(self) -> Optional[NI]: return None @property - def dt(self) -> Optional[DT]: + def dt(self) -> DT | None: """ Obtém o (único) registro que define a data de referência do estudo definido no :class:`Dadger` @@ -658,11 +659,11 @@ def dt(self) -> Optional[DT]: def re( self, - codigo_restricao: Optional[int] = None, - estagio_inicial: Optional[int] = None, - estagio_final: Optional[int] = None, + codigo_restricao: int | None = None, + estagio_inicial: int | None = None, + estagio_final: int | None = None, df: bool = False, - ) -> Optional[Union[RE, List[RE], pandas.DataFrame]]: + ) -> RE | list[RE] | pandas.DataFrame | None: """ Obtém um registro que cadastra uma restrição elétrica existente no estudo descrito pelo :class:`Dadger`. @@ -691,10 +692,10 @@ def re( def lu( # noqa self, - codigo_restricao: Optional[int] = None, - estagio: Optional[int] = None, + codigo_restricao: int | None = None, + estagio: int | None = None, df: bool = False, - ) -> Optional[Union[LU, List[LU], pandas.DataFrame]]: + ) -> LU | list[LU] | pandas.DataFrame | None: """ Obtém um registro que especifica os limites inferiores e superiores por patamar de uma restrição elétrica existente @@ -742,7 +743,7 @@ def lu( # noqa """ - def cria_registro() -> Optional[LU]: + def cria_registro() -> LU | None: re = self.re(codigo_restricao=codigo_restricao) if isinstance(re, list) or re is None: return None @@ -786,12 +787,12 @@ def cria_registro() -> Optional[LU]: def fu( self, - codigo_restricao: Optional[int] = None, - estagio: Optional[int] = None, - codigo_usina: Optional[int] = None, - coeficiente: Optional[float] = None, + codigo_restricao: int | None = None, + estagio: int | None = None, + codigo_usina: int | None = None, + coeficiente: float | None = None, df: bool = False, - ) -> Optional[Union[FU, List[FU], pandas.DataFrame]]: + ) -> FU | list[FU] | pandas.DataFrame | None: """ Obtém um registro que cadastra os coeficientes das restrições elétricas. @@ -823,12 +824,12 @@ def fu( def ft( self, - codigo_restricao: Optional[int] = None, - estagio: Optional[int] = None, - codigo_usina: Optional[int] = None, - coeficiente: Optional[float] = None, + codigo_restricao: int | None = None, + estagio: int | None = None, + codigo_usina: int | None = None, + coeficiente: float | None = None, df: bool = False, - ) -> Optional[Union[FT, List[FT], pandas.DataFrame]]: + ) -> FT | list[FT] | pandas.DataFrame | None: """ Obtém um registro que cadastra os coeficientes das restrições elétricas. @@ -860,13 +861,13 @@ def ft( def fi( self, - codigo_restricao: Optional[int] = None, - estagio: Optional[int] = None, - codigo_submercado_de: Optional[int] = None, - codigo_submercado_para: Optional[int] = None, - coeficiente: Optional[float] = None, + codigo_restricao: int | None = None, + estagio: int | None = None, + codigo_submercado_de: int | None = None, + codigo_submercado_para: int | None = None, + coeficiente: float | None = None, df: bool = False, - ) -> Optional[Union[FI, List[FI], pandas.DataFrame]]: + ) -> FI | list[FI] | pandas.DataFrame | None: """ Obtém um registro que cadastra os coeficientes das restrições elétricas. @@ -901,10 +902,10 @@ def fi( def vi( self, - codigo_usina: Optional[int] = None, - duracao: Optional[int] = None, + codigo_usina: int | None = None, + duracao: int | None = None, df: bool = False, - ) -> Optional[Union[VI, List[VI], pandas.DataFrame]]: + ) -> VI | list[VI] | pandas.DataFrame | None: """ Obtém um registro que especifica os tempos de viagem da água em uma UHE existente no no estudo descrito @@ -926,8 +927,8 @@ def vi( ) def ir( - self, tipo: Optional[str] = None, df: bool = False - ) -> Optional[Union[IR, List[IR], pandas.DataFrame]]: + self, tipo: str | None = None, df: bool = False + ) -> IR | list[IR] | pandas.DataFrame | None: """ Obtém um registro que especifica os relatórios de saída a serem produzidos pelo DECOMP após a execução do estudo @@ -946,8 +947,8 @@ def ir( return self.__registros_ou_df(IR, tipo=tipo, df=df) def rt( - self, restricao: Optional[str] = None, df: bool = False - ) -> Optional[Union[RT, List[RT], pandas.DataFrame]]: + self, restricao: str | None = None, df: bool = False + ) -> RT | list[RT] | pandas.DataFrame | None: """ Obtém um registro que especifica uma retirada de restrição de soleira de vertedouro ou canal de desvio. @@ -966,10 +967,10 @@ def rt( def fc( self, - tipo: Optional[str] = None, - caminho: Optional[str] = None, + tipo: str | None = None, + caminho: str | None = None, df: bool = False, - ) -> Optional[Union[FC, List[FC], pandas.DataFrame]]: + ) -> FC | list[FC] | pandas.DataFrame | None: """ Obtém um registro que especifica os caminhos para os arquivos com a FCF do NEWAVE. @@ -989,8 +990,8 @@ def fc( return self.__registros_ou_df(FC, tipo=tipo, caminho=caminho, df=df) def ea( - self, codigo_ree: Optional[int] = None, df: bool = False - ) -> Optional[Union[EA, List[EA], pandas.DataFrame]]: + self, codigo_ree: int | None = None, df: bool = False + ) -> EA | list[EA] | pandas.DataFrame | None: """ Obtém um registro que especifica a ENA dos meses anteriores ao estudo. @@ -1007,10 +1008,10 @@ def ea( def es( self, - codigo_ree: Optional[int] = None, - numero_semanas: Optional[int] = None, + codigo_ree: int | None = None, + numero_semanas: int | None = None, df: bool = False, - ) -> Optional[Union[ES, List[ES], pandas.DataFrame]]: + ) -> ES | list[ES] | pandas.DataFrame | None: """ Obtém um registro que especifica a ENA das semanas anteriores ao estudo. @@ -1031,8 +1032,8 @@ def es( ) def qi( - self, codigo_usina: Optional[int] = None, df: bool = False - ) -> Optional[Union[QI, List[QI], pandas.DataFrame]]: + self, codigo_usina: int | None = None, df: bool = False + ) -> QI | list[QI] | pandas.DataFrame | None: """ Obtém um registro que especifica o tempo de viagem para cálculo da ENA. @@ -1049,8 +1050,8 @@ def qi( return self.__registros_ou_df(QI, codigo_usina=codigo_usina, df=df) def ti( - self, codigo_usina: Optional[int] = None, df: bool = False - ) -> Optional[Union[TI, List[TI], pandas.DataFrame]]: + self, codigo_usina: int | None = None, df: bool = False + ) -> TI | list[TI] | pandas.DataFrame | None: """ Obtém um registro que especifica as taxas de irrigação por posto (UHE) existente no estudo especificado no :class:`Dadger` @@ -1068,10 +1069,10 @@ def ti( def da( self, - codigo_usina_retirada: Optional[int] = None, - codigo_usina_retorno: Optional[int] = None, + codigo_usina_retirada: int | None = None, + codigo_usina_retorno: int | None = None, df: bool = False, - ) -> Optional[Union[DA, List[DA], pandas.DataFrame]]: + ) -> DA | list[DA] | pandas.DataFrame | None: """ Obtém um registro que especifica as retiradas de água para outros usos (desvios de água) por usina (UHE) existente no @@ -1097,10 +1098,10 @@ def da( def mp( self, - codigo_usina: Optional[int] = None, - frequencia: Optional[int] = None, + codigo_usina: int | None = None, + frequencia: int | None = None, df: bool = False, - ) -> Optional[Union[MP, List[MP], pandas.DataFrame]]: + ) -> MP | list[MP] | pandas.DataFrame | None: """ Obtém um registro que especifica as manutenções programadas por UHE existente no estudo especificado no :class:`Dadger` @@ -1122,10 +1123,10 @@ def mp( def mt( self, - codigo_usina: Optional[int] = None, - codigo_submercado: Optional[int] = None, + codigo_usina: int | None = None, + codigo_submercado: int | None = None, df: bool = False, - ) -> Optional[Union[MT, List[MT], pandas.DataFrame]]: + ) -> MT | list[MT] | pandas.DataFrame | None: """ Obtém um registro que especifica as manutenções programadas por UTE existente no estudo especificado no :class:`Dadger` @@ -1150,10 +1151,10 @@ def mt( def fd( self, - codigo_usina: Optional[int] = None, - frequencia: Optional[int] = None, + codigo_usina: int | None = None, + frequencia: int | None = None, df: bool = False, - ) -> Optional[Union[FD, List[FD], pandas.DataFrame]]: + ) -> FD | list[FD] | pandas.DataFrame | None: """ Obtém um registro que especifica os fatores de disponibilidade por UHE existente no estudo especificado no :class:`Dadger` @@ -1175,18 +1176,18 @@ def fd( def fp( self, - codigo_usina: Optional[int] = None, - estagio: Optional[int] = None, - tipo_entrada_janela_turbinamento: Optional[int] = None, - numero_pontos_turbinamento: Optional[int] = None, - limite_inferior_janela_turbinamento: Optional[float] = None, - limite_superior_janela_turbinamento: Optional[float] = None, - tipo_entrada_janela_volume: Optional[int] = None, - numero_pontos_volume: Optional[int] = None, - limite_inferior_janela_volume: Optional[float] = None, - limite_superior_janela_volume: Optional[float] = None, + codigo_usina: int | None = None, + estagio: int | None = None, + tipo_entrada_janela_turbinamento: int | None = None, + numero_pontos_turbinamento: int | None = None, + limite_inferior_janela_turbinamento: float | None = None, + limite_superior_janela_turbinamento: float | None = None, + tipo_entrada_janela_volume: int | None = None, + numero_pontos_volume: int | None = None, + limite_inferior_janela_volume: float | None = None, + limite_superior_janela_volume: float | None = None, df: bool = False, - ) -> Optional[Union[FP, List[FP], pandas.DataFrame]]: + ) -> FP | list[FP] | pandas.DataFrame | None: """ Obtém um registro que especifica as taxas de irrigação por posto (UHE) existente no estudo especificado no :class:`Dadger` @@ -1242,8 +1243,8 @@ def fp( ) def rq( - self, codigo_ree: Optional[int] = None, df: bool = False - ) -> Optional[Union[RQ, List[RQ], pandas.DataFrame]]: + self, codigo_ree: int | None = None, df: bool = False + ) -> RQ | list[RQ] | pandas.DataFrame | None: """ Obtém um registro que especifica as vazões mínimas históricas por REE existentes no estudo especificado no :class:`Dadger` @@ -1260,8 +1261,8 @@ def rq( return self.__registros_ou_df(RQ, codigo_ree=codigo_ree, df=df) def ve( - self, codigo_usina: Optional[int] = None, df: bool = False - ) -> Optional[Union[VE, List[VE], pandas.DataFrame]]: + self, codigo_usina: int | None = None, df: bool = False + ) -> VE | list[VE] | pandas.DataFrame | None: """ Obtém um registro que especifica os volumes de espera por posto (UHE) existente no estudo especificado no :class:`Dadger` @@ -1279,11 +1280,11 @@ def ve( def hv( self, - codigo_restricao: Optional[int] = None, - estagio_inicial: Optional[int] = None, - estagio_final: Optional[int] = None, + codigo_restricao: int | None = None, + estagio_inicial: int | None = None, + estagio_final: int | None = None, df: bool = False, - ) -> Optional[Union[HV, List[HV], pandas.DataFrame]]: + ) -> HV | list[HV] | pandas.DataFrame | None: """ Obtém um registro que cadastra uma restrição de volume mínimo armazenado existente no estudo descrito pelo :class:`Dadger`. @@ -1312,10 +1313,10 @@ def hv( def lv( # noqa self, - codigo_restricao: Optional[int] = None, - estagio: Optional[int] = None, + codigo_restricao: int | None = None, + estagio: int | None = None, df: bool = False, - ) -> Optional[Union[LV, List[LV], pandas.DataFrame]]: + ) -> LV | list[LV] | pandas.DataFrame | None: """ Obtém um registro que especifica os limites inferior e superior de uma restrição de volume mínimo existente @@ -1363,7 +1364,7 @@ def lv( # noqa """ - def cria_registro() -> Optional[LV]: + def cria_registro() -> LV | None: hv = self.hv(codigo_restricao=codigo_restricao) if isinstance(hv, list) or hv is None: return None @@ -1405,13 +1406,13 @@ def cria_registro() -> Optional[LV]: def cv( self, - codigo_restricao: Optional[int] = None, - estagio: Optional[int] = None, - codigo_usina: Optional[int] = None, - coeficiente: Optional[float] = None, - tipo: Optional[str] = None, + codigo_restricao: int | None = None, + estagio: int | None = None, + codigo_usina: int | None = None, + coeficiente: float | None = None, + tipo: str | None = None, df: bool = False, - ) -> Optional[Union[CV, List[CV], pandas.DataFrame]]: + ) -> CV | list[CV] | pandas.DataFrame | None: """ Obtém um registro que cadastra os coeficientes das restrições de volume. @@ -1446,11 +1447,11 @@ def cv( def hq( self, - codigo_restricao: Optional[int] = None, - estagio_inicial: Optional[int] = None, - estagio_final: Optional[int] = None, + codigo_restricao: int | None = None, + estagio_inicial: int | None = None, + estagio_final: int | None = None, df: bool = False, - ) -> Optional[Union[HQ, List[HQ], pandas.DataFrame]]: + ) -> HQ | list[HQ] | pandas.DataFrame | None: """ Obtém um registro que cadastra uma restrição de vazão existente no estudo descrito pelo :class:`Dadger`. @@ -1479,10 +1480,10 @@ def hq( def lq( # noqa self, - codigo_restricao: Optional[int] = None, - estagio: Optional[int] = None, + codigo_restricao: int | None = None, + estagio: int | None = None, df: bool = False, - ) -> Optional[Union[LQ, List[LQ], pandas.DataFrame]]: + ) -> LQ | list[LQ] | pandas.DataFrame | None: """ Obtém um registro que especifica os limites inferiores e superiores por patamar de uma restrição de vazão existente @@ -1530,7 +1531,7 @@ def lq( # noqa """ - def cria_registro() -> Optional[LQ]: + def cria_registro() -> LQ | None: hq = self.hq(codigo_restricao=codigo_restricao) if isinstance(hq, list) or hq is None: return None @@ -1572,13 +1573,13 @@ def cria_registro() -> Optional[LQ]: def cq( self, - codigo_restricao: Optional[int] = None, - estagio: Optional[int] = None, - codigo_usina: Optional[int] = None, - coeficiente: Optional[float] = None, - tipo: Optional[str] = None, + codigo_restricao: int | None = None, + estagio: int | None = None, + codigo_usina: int | None = None, + coeficiente: float | None = None, + tipo: str | None = None, df: bool = False, - ) -> Optional[Union[CQ, List[CQ], pandas.DataFrame]]: + ) -> CQ | list[CQ] | pandas.DataFrame | None: """ Obtém um registro que cadastra os coeficientes das restrições de vazão. @@ -1613,16 +1614,16 @@ def cq( def he( self, - codigo_restricao: Optional[int] = None, - estagio: Optional[int] = None, - tipo_limite: Optional[int] = None, - forma_calculo_produtibilidades: Optional[int] = None, - tipo_valores_produtibilidades: Optional[int] = None, - tipo_penalidade: Optional[int] = None, - valor_penalidade: Optional[float] = None, - arquivo_produtibilidades: Optional[str] = None, + codigo_restricao: int | None = None, + estagio: int | None = None, + tipo_limite: int | None = None, + forma_calculo_produtibilidades: int | None = None, + tipo_valores_produtibilidades: int | None = None, + tipo_penalidade: int | None = None, + valor_penalidade: float | None = None, + arquivo_produtibilidades: str | None = None, df: bool = False, - ) -> Optional[Union[HE, List[HE], pandas.DataFrame]]: + ) -> HE | list[HE] | pandas.DataFrame | None: """ Obtém um registro que cadastra uma restrição de energia armazenada existente no estudo descrito pelo :class:`Dadger`. @@ -1671,11 +1672,11 @@ def he( def cm( self, - codigo_restricao: Optional[int] = None, - codigo_ree: Optional[int] = None, - coeficiente: Optional[float] = None, + codigo_restricao: int | None = None, + codigo_ree: int | None = None, + coeficiente: float | None = None, df: bool = False, - ) -> Optional[Union[CM, List[CM], pandas.DataFrame]]: + ) -> CM | list[CM] | pandas.DataFrame | None: """ Obtém um registro que cadastra os coeficientes das restrições de energia armazenada. @@ -1702,7 +1703,7 @@ def cm( ) @property - def ev(self) -> Optional[EV]: + def ev(self) -> EV | None: """ Obtém o (único) registro que define a evaporação :class:`Dadger` @@ -1717,7 +1718,7 @@ def ev(self) -> Optional[EV]: return None @property - def fj(self) -> Optional[FJ]: + def fj(self) -> FJ | None: """ Obtém o (único) registro que define o arquivo `polinjus` :class:`Dadger` @@ -1732,7 +1733,7 @@ def fj(self) -> Optional[FJ]: return None @property - def pu(self) -> Optional[PU]: + def pu(self) -> PU | None: """ Obtém o (único) registro que define se será usado PL único. @@ -1746,7 +1747,7 @@ def pu(self) -> Optional[PU]: return None @property - def rc(self) -> Optional[RC]: + def rc(self) -> RC | None: """ Obtém o (único) registro que insere restrições do tipo escada. @@ -1762,11 +1763,11 @@ def rc(self) -> Optional[RC]: def pe( self, - codigo_submercado: Optional[int] = None, - tipo: Optional[int] = None, - penalidade: Optional[float] = None, + codigo_submercado: int | None = None, + tipo: int | None = None, + penalidade: float | None = None, df: bool = False, - ) -> Optional[Union[PE, List[PE], pandas.DataFrame]]: + ) -> PE | list[PE] | pandas.DataFrame | None: """ Obtém um registro que altera penalidades de vertimento, intercâmbio e desvios. @@ -1794,11 +1795,11 @@ def pe( def ts( self, - tolerancia_primaria: Optional[float] = None, - tolerancia_secundaria: Optional[float] = None, - zera_coeficientes: Optional[int] = None, - tolerancia_teste_otimalidade: Optional[float] = None, - ) -> Optional[Union[TS, List[TS]]]: + tolerancia_primaria: float | None = None, + tolerancia_secundaria: float | None = None, + zera_coeficientes: int | None = None, + tolerancia_teste_otimalidade: float | None = None, + ) -> TS | list[TS] | None: """ Obtém um registro que altera as tolerâncias do solver. @@ -1825,13 +1826,13 @@ def ts( def pv( self, - penalidade_variaveis_folga: Optional[float] = None, - tolerancia_viabilidade_restricoes: Optional[float] = None, - iteracoes_atualizacao_penalidade: Optional[int] = None, - fator_multiplicacao_folga: Optional[float] = None, - valor_inicial_variaveis_folga: Optional[float] = None, - valor_final_variaveis_folga: Optional[float] = None, - ) -> Optional[Union[PV, List[PV]]]: + penalidade_variaveis_folga: float | None = None, + tolerancia_viabilidade_restricoes: float | None = None, + iteracoes_atualizacao_penalidade: int | None = None, + fator_multiplicacao_folga: float | None = None, + valor_inicial_variaveis_folga: float | None = None, + valor_final_variaveis_folga: float | None = None, + ) -> PV | list[PV] | None: """ Obtém um registro que altera as penalidades das variáveis de folga. @@ -1869,10 +1870,10 @@ def pv( def cx( self, - codigo_newave: Optional[int] = None, - codigo_decomp: Optional[int] = None, + codigo_newave: int | None = None, + codigo_decomp: int | None = None, df: bool = False, - ) -> Optional[Union[CX, List[CX], pandas.DataFrame]]: + ) -> CX | list[CX] | pandas.DataFrame | None: """ Obtém um registro que altera as tolerâncias do solver. @@ -1892,7 +1893,7 @@ def cx( ) @property - def fa(self) -> Optional[FA]: + def fa(self) -> FA | None: """ Obtém o (único) registro que define o arquivo de índices. @@ -1906,7 +1907,7 @@ def fa(self) -> Optional[FA]: return None @property - def vt(self) -> Optional[VT]: + def vt(self) -> VT | None: """ Obtém o (único) registro que define o arquivo com cenários de vento. @@ -1921,7 +1922,7 @@ def vt(self) -> Optional[VT]: return None @property - def cs(self) -> Optional[CS]: + def cs(self) -> CS | None: """ Obtém o (único) registro que habilita a consistência de dados. @@ -1937,9 +1938,9 @@ def cs(self) -> Optional[CS]: def vl( self, - codigo_usina_influenciada: Optional[int] = None, + codigo_usina_influenciada: int | None = None, df: bool = False, - ) -> Optional[Union[VL, List[VL], pandas.DataFrame]]: + ) -> VL | list[VL] | pandas.DataFrame | None: """ Obtém um registro que define uma usina hidrelétrica que sofre influência de vazão lateral na cota de jusante existente @@ -1962,10 +1963,10 @@ def vl( def vu( self, - codigo_usina_influenciada: Optional[int] = None, - codigo_usina_influenciadora: Optional[int] = None, + codigo_usina_influenciada: int | None = None, + codigo_usina_influenciadora: int | None = None, df: bool = False, - ) -> Optional[Union[VU, List[VU], pandas.DataFrame]]: + ) -> VU | list[VU] | pandas.DataFrame | None: """ Obtém um registro que define uma usina hidrelétrica que tem influencia sobre a vazão de jusante da primeira existente @@ -1991,10 +1992,10 @@ def vu( def va( self, - codigo_usina_influenciada: Optional[int] = None, - codigo_posto_influenciador: Optional[int] = None, + codigo_usina_influenciada: int | None = None, + codigo_posto_influenciador: int | None = None, df: bool = False, - ) -> Optional[Union[VA, List[VA], pandas.DataFrame]]: + ) -> VA | list[VA] | pandas.DataFrame | None: """ Obtém um registro que define um posto que tem influencia sobre a vazão de jusante da primeira existente @@ -2018,9 +2019,7 @@ def va( df=df, ) - def pd( - self, algoritmo: Optional[str] = None - ) -> Optional[Union[PD, List[PD]]]: + def pd(self, algoritmo: str | None = None) -> PD | list[PD] | None: """ Obtém um registro que especifica o algoritmo usado para a solução. diff --git a/idecomp/decomp/dadgnl.py b/idecomp/decomp/dadgnl.py index e9526583..85cd1830 100644 --- a/idecomp/decomp/dadgnl.py +++ b/idecomp/decomp/dadgnl.py @@ -1,8 +1,10 @@ +from typing import Any, TypeVar + +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.register import Register from cfinterface.files.registerfile import RegisterFile -from idecomp.decomp.modelos.dadgnl import TG, GS, NL, GL -from typing import Type, List, Optional, TypeVar, Union -import pandas as pd # type: ignore + +from idecomp.decomp.modelos.dadgnl import GL, GS, NL, TG class Dadgnl(RegisterFile): @@ -23,21 +25,17 @@ class Dadgnl(RegisterFile): REGISTERS = [TG, GS, NL, GL] - def __init__(self, data=...) -> None: + def __init__(self, data: Any = ...) -> None: super().__init__(data) def __expande_colunas_df(self, df: pd.DataFrame) -> pd.DataFrame: - colunas_com_listas = df.map( - lambda linha: isinstance(linha, list) - ).all() + colunas_com_listas = df.map(lambda linha: isinstance(linha, list)).all() nomes_colunas = [ c for c in colunas_com_listas[colunas_com_listas].index ] for c in nomes_colunas: num_elementos = len(df.at[0, c]) - particoes_coluna = [ - f"{c}_{i}" for i in range(1, num_elementos + 1) - ] + particoes_coluna = [f"{c}_{i}" for i in range(1, num_elementos + 1)] df[particoes_coluna] = df.apply( lambda linha: linha[c], axis=1, result_type="expand" ) @@ -45,8 +43,8 @@ def __expande_colunas_df(self, df: pd.DataFrame) -> pd.DataFrame: return df def __registros_ou_df( - self, t: Type[T], **kwargs - ) -> Optional[Union[T, List[T], pd.DataFrame]]: + self, t: type[T], **kwargs: Any + ) -> T | list[T] | pd.DataFrame | None: if kwargs.get("df"): return self.__expande_colunas_df(self._as_df(t)) else: @@ -55,12 +53,12 @@ def __registros_ou_df( def tg( self, - codigo_usina: Optional[int] = None, - codigo_submercado: Optional[int] = None, - nome: Optional[str] = None, - estagio: Optional[int] = None, + codigo_usina: int | None = None, + codigo_submercado: int | None = None, + nome: str | None = None, + estagio: int | None = None, df: bool = False, - ) -> Optional[Union[TG, List[TG], pd.DataFrame]]: + ) -> TG | list[TG] | pd.DataFrame | None: """ Obtém um registro que define uma usina termelétrica existente no estudo descrito pelo :class:`Dadgnl`. @@ -94,10 +92,10 @@ def tg( def gs( self, - mes: Optional[int] = None, - semanas: Optional[int] = None, + mes: int | None = None, + semanas: int | None = None, df: bool = False, - ) -> Optional[Union[GS, List[GS], pd.DataFrame]]: + ) -> GS | list[GS] | pd.DataFrame | None: """ Obtém um registro que define o número de semanas em cada mês de estudo no :class:`Dadgnl`. @@ -117,11 +115,11 @@ def gs( def nl( self, - codigo_usina: Optional[int] = None, - codigo_submercado: Optional[int] = None, - lag: Optional[int] = None, + codigo_usina: int | None = None, + codigo_submercado: int | None = None, + lag: int | None = None, df: bool = False, - ) -> Optional[Union[NL, List[NL], pd.DataFrame]]: + ) -> NL | list[NL] | pd.DataFrame | None: """ Obtém um registro que define o número de lags para o despacho de uma UTE. @@ -149,12 +147,12 @@ def nl( def gl( self, - codigo_usina: Optional[int] = None, - codigo_submercado: Optional[int] = None, - estagio: Optional[int] = None, - data_inicio: Optional[str] = None, + codigo_usina: int | None = None, + codigo_submercado: int | None = None, + estagio: int | None = None, + data_inicio: str | None = None, df: bool = False, - ) -> Optional[Union[GL, List[GL], pd.DataFrame]]: + ) -> GL | list[GL] | pd.DataFrame | None: """ Obtém um registro que define o despacho por patamar e a duração dos patamares para uma UTE GNL. diff --git a/idecomp/decomp/dec_avl_evap.py b/idecomp/decomp/dec_avl_evap.py index e133a6d6..d1ba0414 100644 --- a/idecomp/decomp/dec_avl_evap.py +++ b/idecomp/decomp/dec_avl_evap.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.dec_avl_evap import TabelaAvlEvap +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo +from idecomp.decomp.modelos.dec_avl_evap import TabelaAvlEvap class DecAvlEvap(ArquivoCSV): @@ -14,7 +13,7 @@ class DecAvlEvap(ArquivoCSV): BLOCKS = [VersaoModelo, TabelaAvlEvap] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_cortes_evap.py b/idecomp/decomp/dec_cortes_evap.py index 1a439c5f..a914f813 100644 --- a/idecomp/decomp/dec_cortes_evap.py +++ b/idecomp/decomp/dec_cortes_evap.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.dec_cortes_evap import TabelaCortesEvap +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo +from idecomp.decomp.modelos.dec_cortes_evap import TabelaCortesEvap class DecCortesEvap(ArquivoCSV): @@ -14,7 +13,7 @@ class DecCortesEvap(ArquivoCSV): BLOCKS = [VersaoModelo, TabelaCortesEvap] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_desvfpha.py b/idecomp/decomp/dec_desvfpha.py index 53b1a53c..a7b930fa 100644 --- a/idecomp/decomp/dec_desvfpha.py +++ b/idecomp/decomp/dec_desvfpha.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.dec_desvfpha import TabelaDesvFpha +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo +from idecomp.decomp.modelos.dec_desvfpha import TabelaDesvFpha class DecDesvFpha(ArquivoCSV): @@ -14,7 +13,7 @@ class DecDesvFpha(ArquivoCSV): BLOCKS = [VersaoModelo, TabelaDesvFpha] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_eco_cotajus.py b/idecomp/decomp/dec_eco_cotajus.py index 87895306..4bc15af1 100644 --- a/idecomp/decomp/dec_eco_cotajus.py +++ b/idecomp/decomp/dec_eco_cotajus.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.dec_eco_cotajus import TabelaEcoCotajus +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo +from idecomp.decomp.modelos.dec_eco_cotajus import TabelaEcoCotajus class DecEcoCotajus(ArquivoCSV): @@ -15,7 +14,7 @@ class DecEcoCotajus(ArquivoCSV): BLOCKS = [VersaoModelo, TabelaEcoCotajus] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_eco_discr.py b/idecomp/decomp/dec_eco_discr.py index f07c6fa2..f130f9ad 100644 --- a/idecomp/decomp/dec_eco_discr.py +++ b/idecomp/decomp/dec_eco_discr.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.dec_eco_discr import TabelaEcoDiscr +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo +from idecomp.decomp.modelos.dec_eco_discr import TabelaEcoDiscr class DecEcoDiscr(ArquivoCSV): @@ -15,7 +14,7 @@ class DecEcoDiscr(ArquivoCSV): BLOCKS = [VersaoModelo, TabelaEcoDiscr] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_eco_evap.py b/idecomp/decomp/dec_eco_evap.py index c0940d23..165a5c4a 100644 --- a/idecomp/decomp/dec_eco_evap.py +++ b/idecomp/decomp/dec_eco_evap.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.dec_eco_evap import TabelaEcoEvap +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo +from idecomp.decomp.modelos.dec_eco_evap import TabelaEcoEvap class DecEcoEvap(ArquivoCSV): @@ -15,7 +14,7 @@ class DecEcoEvap(ArquivoCSV): BLOCKS = [VersaoModelo, TabelaEcoEvap] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_eco_qlat.py b/idecomp/decomp/dec_eco_qlat.py index 7c73c1e9..43346380 100644 --- a/idecomp/decomp/dec_eco_qlat.py +++ b/idecomp/decomp/dec_eco_qlat.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.dec_eco_qlat import TabelaEcoQlat +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo +from idecomp.decomp.modelos.dec_eco_qlat import TabelaEcoQlat class DecEcoQlat(ArquivoCSV): @@ -15,7 +14,7 @@ class DecEcoQlat(ArquivoCSV): BLOCKS = [VersaoModelo, TabelaEcoQlat] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_estatevap.py b/idecomp/decomp/dec_estatevap.py index f86624af..651bad24 100644 --- a/idecomp/decomp/dec_estatevap.py +++ b/idecomp/decomp/dec_estatevap.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.dec_estatevap import TabelaEstatEvap +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo +from idecomp.decomp.modelos.dec_estatevap import TabelaEstatEvap class DecEstatEvap(ArquivoCSV): @@ -15,7 +14,7 @@ class DecEstatEvap(ArquivoCSV): BLOCKS = [VersaoModelo, TabelaEstatEvap] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_estatfpha.py b/idecomp/decomp/dec_estatfpha.py index 9ca6ff80..5a5ecadc 100644 --- a/idecomp/decomp/dec_estatfpha.py +++ b/idecomp/decomp/dec_estatfpha.py @@ -1,10 +1,12 @@ +from typing import TypeVar + +import pandas as pd # type: ignore +from cfinterface.files.blockfile import BlockFile + +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo from idecomp.decomp.modelos.dec_estatfpha import ( BlocoDesvios, ) -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from cfinterface.files.blockfile import BlockFile -from typing import Optional, Type, TypeVar -import pandas as pd # type: ignore class DecEstatFpha(BlockFile): @@ -20,7 +22,7 @@ class DecEstatFpha(BlockFile): ENCODING = "iso-8859-1" T = TypeVar("T") - def _bloco_por_tipo(self, bloco: Type[T], indice: int) -> Optional[T]: + def _bloco_por_tipo(self, bloco: type[T], indice: int) -> T | None: """ Obtém um gerador de blocos de um tipo, se houver algum no arquivo. @@ -33,15 +35,13 @@ def _bloco_por_tipo(self, bloco: Type[T], indice: int) -> Optional[T]: """ try: return next( - b - for i, b in enumerate(self.data.of_type(bloco)) - if i == indice + b for i, b in enumerate(self.data.of_type(bloco)) if i == indice ) except StopIteration: return None @property - def versao(self) -> Optional[str]: + def versao(self) -> str | None: """ A versão do modelo utilizada para executar o caso. diff --git a/idecomp/decomp/dec_fcf_cortes.py b/idecomp/decomp/dec_fcf_cortes.py index 1400d444..ab82669e 100644 --- a/idecomp/decomp/dec_fcf_cortes.py +++ b/idecomp/decomp/dec_fcf_cortes.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.dec_fcf_cortes import TabelaFcfCortes +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo +from idecomp.decomp.modelos.dec_fcf_cortes import TabelaFcfCortes class DecFcfCortes(ArquivoCSV): @@ -14,7 +13,7 @@ class DecFcfCortes(ArquivoCSV): BLOCKS = [VersaoModelo, TabelaFcfCortes] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_oper_evap.py b/idecomp/decomp/dec_oper_evap.py index c1e5f22d..fc584155 100644 --- a/idecomp/decomp/dec_oper_evap.py +++ b/idecomp/decomp/dec_oper_evap.py @@ -1,13 +1,12 @@ +import pandas as pd # type: ignore + +from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo from idecomp.decomp.modelos.dec_oper_evap import ( - TabelaOperEvapv31, TabelaOperEvap, + TabelaOperEvapv31, ) -from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore - class DecOperEvap(ArquivoCSV): """ @@ -21,7 +20,7 @@ class DecOperEvap(ArquivoCSV): } @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_oper_gnl.py b/idecomp/decomp/dec_oper_gnl.py index e7f99ce2..8faccfc2 100644 --- a/idecomp/decomp/dec_oper_gnl.py +++ b/idecomp/decomp/dec_oper_gnl.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.dec_oper_gnl import TabelaOperGnl, TabelaOperGnlv31 +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo +from idecomp.decomp.modelos.dec_oper_gnl import TabelaOperGnl, TabelaOperGnlv31 class DecOperGnl(ArquivoCSV): @@ -19,7 +18,7 @@ class DecOperGnl(ArquivoCSV): } @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_oper_interc.py b/idecomp/decomp/dec_oper_interc.py index 918e3059..2350cf14 100644 --- a/idecomp/decomp/dec_oper_interc.py +++ b/idecomp/decomp/dec_oper_interc.py @@ -1,13 +1,12 @@ +import pandas as pd # type: ignore + +from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo from idecomp.decomp.modelos.dec_oper_interc import ( TabelaOperInterc, TabelaOperIntercv31, ) -from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore - class DecOperInterc(ArquivoCSV): """ @@ -21,7 +20,7 @@ class DecOperInterc(ArquivoCSV): } @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_oper_ree.py b/idecomp/decomp/dec_oper_ree.py index 65fb909d..ff32c010 100644 --- a/idecomp/decomp/dec_oper_ree.py +++ b/idecomp/decomp/dec_oper_ree.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.dec_oper_ree import TabelaOperRee, TabelaOperReev31 +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo +from idecomp.decomp.modelos.dec_oper_ree import TabelaOperRee, TabelaOperReev31 class DecOperRee(ArquivoCSV): @@ -18,7 +17,7 @@ class DecOperRee(ArquivoCSV): } @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_oper_rhesoft.py b/idecomp/decomp/dec_oper_rhesoft.py index 30d110e3..eafd5a1c 100644 --- a/idecomp/decomp/dec_oper_rhesoft.py +++ b/idecomp/decomp/dec_oper_rhesoft.py @@ -1,13 +1,12 @@ +import pandas as pd # type: ignore + +from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo from idecomp.decomp.modelos.dec_oper_rhesoft import ( - TabelaOperRheSoftv31, TabelaOperRheSoft, + TabelaOperRheSoftv31, ) -from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore - class DecOperRheSoft(ArquivoCSV): """ @@ -22,7 +21,7 @@ class DecOperRheSoft(ArquivoCSV): } @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_oper_sist.py b/idecomp/decomp/dec_oper_sist.py index 889aad56..b1c2bcd8 100644 --- a/idecomp/decomp/dec_oper_sist.py +++ b/idecomp/decomp/dec_oper_sist.py @@ -1,13 +1,12 @@ +import pandas as pd # type: ignore + +from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo from idecomp.decomp.modelos.dec_oper_sist import ( TabelaOperSist, TabelaOperSistv31, ) -from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore - class DecOperSist(ArquivoCSV): """ @@ -21,7 +20,7 @@ class DecOperSist(ArquivoCSV): } @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_oper_usie.py b/idecomp/decomp/dec_oper_usie.py index 29da477e..bdcc7c92 100644 --- a/idecomp/decomp/dec_oper_usie.py +++ b/idecomp/decomp/dec_oper_usie.py @@ -1,13 +1,12 @@ +import pandas as pd # type: ignore + +from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo from idecomp.decomp.modelos.dec_oper_usie import ( TabelaOperUsie, TabelaOperUsiev31, ) -from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore - class DecOperUsie(ArquivoCSV): """ @@ -21,7 +20,7 @@ class DecOperUsie(ArquivoCSV): } @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_oper_usih.py b/idecomp/decomp/dec_oper_usih.py index 6dc3aceb..a5f4b7ec 100644 --- a/idecomp/decomp/dec_oper_usih.py +++ b/idecomp/decomp/dec_oper_usih.py @@ -1,13 +1,12 @@ +import pandas as pd # type: ignore + +from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo from idecomp.decomp.modelos.dec_oper_usih import ( - TabelaOperUsihv31, TabelaOperUsih, + TabelaOperUsihv31, ) -from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore - class DecOperUsih(ArquivoCSV): """ @@ -21,7 +20,7 @@ class DecOperUsih(ArquivoCSV): } @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/dec_oper_usit.py b/idecomp/decomp/dec_oper_usit.py index 064b92db..0d09b303 100644 --- a/idecomp/decomp/dec_oper_usit.py +++ b/idecomp/decomp/dec_oper_usit.py @@ -1,13 +1,12 @@ +import pandas as pd # type: ignore + +from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo from idecomp.decomp.modelos.dec_oper_usit import ( TabelaOperUsit, TabelaOperUsitv31, ) -from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore - class DecOperUsit(ArquivoCSV): """ @@ -21,7 +20,7 @@ class DecOperUsit(ArquivoCSV): } @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/decomptim.py b/idecomp/decomp/decomptim.py index d9d4af96..889961e0 100644 --- a/idecomp/decomp/decomptim.py +++ b/idecomp/decomp/decomptim.py @@ -1,8 +1,9 @@ -from idecomp.decomp.modelos.decomptim import BlocoTemposEtapas +from typing import Any, TypeVar +import pandas as pd # type: ignore[import-untyped] from cfinterface.files.blockfile import BlockFile -from typing import TypeVar, Optional -import pandas as pd # type: ignore + +from idecomp.decomp.modelos.decomptim import BlocoTemposEtapas class Decomptim(BlockFile): @@ -21,11 +22,11 @@ class Decomptim(BlockFile): BlocoTemposEtapas, ] - def __init__(self, data=...) -> None: + def __init__(self, data: Any = ...) -> None: super().__init__(data) @property - def tempos_etapas(self) -> Optional[pd.DataFrame]: + def tempos_etapas(self) -> pd.DataFrame | None: """ Obtém a tabela dos tempos de execução do DECOMP existente no :class:`Decomptim` diff --git a/idecomp/decomp/eco_fpha.py b/idecomp/decomp/eco_fpha.py index ccd5e397..6e282717 100644 --- a/idecomp/decomp/eco_fpha.py +++ b/idecomp/decomp/eco_fpha.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo -from idecomp.decomp.modelos.eco_fpha import TabelaEcoFpha +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModelo +from idecomp.decomp.modelos.eco_fpha import TabelaEcoFpha class EcoFpha(ArquivoCSV): @@ -15,7 +14,7 @@ class EcoFpha(ArquivoCSV): BLOCKS = [VersaoModelo, TabelaEcoFpha] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/fcfnw.py b/idecomp/decomp/fcfnw.py index 8e70442a..cf66a59a 100644 --- a/idecomp/decomp/fcfnw.py +++ b/idecomp/decomp/fcfnw.py @@ -1,8 +1,9 @@ -from idecomp.decomp.modelos.fcfnw import BlocoCortesFCF +from typing import TypeVar -from cfinterface.files.blockfile import BlockFile -from typing import TypeVar, Optional import pandas as pd # type: ignore +from cfinterface.files.blockfile import BlockFile + +from idecomp.decomp.modelos.fcfnw import BlocoCortesFCF class Fcfnw(BlockFile): @@ -20,7 +21,7 @@ class Fcfnw(BlockFile): BLOCKS = [BlocoCortesFCF] @property - def cortes(self) -> Optional[pd.DataFrame]: + def cortes(self) -> pd.DataFrame | None: """ Obtém a tabela de cortes do NEWAVE existente no :class:`Fcfnw`. diff --git a/idecomp/decomp/hidr.py b/idecomp/decomp/hidr.py index c37edee2..7ad7e781 100644 --- a/idecomp/decomp/hidr.py +++ b/idecomp/decomp/hidr.py @@ -1,10 +1,10 @@ -from cfinterface.files.registerfile import RegisterFile -from idecomp.decomp.modelos.hidr import RegistroUHEHidr -from idecomp.config import MESES_ABREV -import pandas as pd # type: ignore +from typing import IO, Any, TypeVar +import pandas as pd # type: ignore[import-untyped] +from cfinterface.files.registerfile import RegisterFile -from typing import TypeVar, List, Optional, Union, IO +from idecomp.config import MESES_ABREV +from idecomp.decomp.modelos.hidr import RegistroUHEHidr class Hidr(RegisterFile): @@ -18,15 +18,15 @@ class Hidr(RegisterFile): REGISTERS = [RegistroUHEHidr] STORAGE = "BINARY" - def __init__(self, data=...) -> None: + def __init__(self, data: Any = ...) -> None: super().__init__(data) - self.__df: Optional[pd.DataFrame] = None + self.__df: pd.DataFrame | None = None - def write(self, to: Union[str, IO], *args, **kwargs): + def write(self, to: str | IO[Any], *args: Any, **kwargs: Any) -> None: self.__atualiza_registros() super().write(to, *args, **kwargs) - def __monta_df_de_registros(self) -> Optional[pd.DataFrame]: + def __monta_df_de_registros(self) -> pd.DataFrame | None: registros = self.data.get_registers_of_type(RegistroUHEHidr) if registros is None: return None @@ -160,8 +160,8 @@ def __monta_df_de_registros(self) -> Optional[pd.DataFrame]: ) return df - def __atualiza_registros(self): - registros: List[RegistroUHEHidr] = [r for r in self.data][1:] + def __atualiza_registros(self) -> None: + registros: list[RegistroUHEHidr] = [r for r in self.data][1:] # type: ignore[assignment] for (_, linha), r in zip(self.cadastro.iterrows(), registros): r.nome = linha["nome_usina"] r.posto = linha["posto"] @@ -279,5 +279,5 @@ def cadastro(self) -> pd.DataFrame: return self.__df @cadastro.setter - def cadastro(self, df: pd.DataFrame): + def cadastro(self, df: pd.DataFrame) -> None: self.__df = df diff --git a/idecomp/decomp/inviabunic.py b/idecomp/decomp/inviabunic.py index 858988a0..62922b95 100644 --- a/idecomp/decomp/inviabunic.py +++ b/idecomp/decomp/inviabunic.py @@ -1,9 +1,12 @@ -from idecomp.decomp.modelos.inviabunic import BlocoInviabilidadesIteracoes -from idecomp.decomp.modelos.inviabunic import BlocoInviabilidadesSimFinal +from typing import Any, TypeVar +import pandas as pd # type: ignore[import-untyped] from cfinterface.files.blockfile import BlockFile -from typing import TypeVar, Optional -import pandas as pd # type: ignore + +from idecomp.decomp.modelos.inviabunic import ( + BlocoInviabilidadesIteracoes, + BlocoInviabilidadesSimFinal, +) class InviabUnic(BlockFile): @@ -22,11 +25,11 @@ class InviabUnic(BlockFile): BlocoInviabilidadesSimFinal, ] - def __init__(self, data=...) -> None: + def __init__(self, data: Any = ...) -> None: super().__init__(data) @property - def inviabilidades_iteracoes(self) -> Optional[pd.DataFrame]: + def inviabilidades_iteracoes(self) -> pd.DataFrame | None: """ Tabela das inviabilidades visitadas pelo modelo durante as iterações. As colunas são: @@ -48,7 +51,7 @@ def inviabilidades_iteracoes(self) -> Optional[pd.DataFrame]: return None @property - def inviabilidades_simulacao_final(self) -> Optional[pd.DataFrame]: + def inviabilidades_simulacao_final(self) -> pd.DataFrame | None: """ Tabela das inviabilidades visitadas pelo modelo durante a simulação final. As colunas são: diff --git a/idecomp/decomp/mapcut.py b/idecomp/decomp/mapcut.py index 7cd07290..e27218db 100644 --- a/idecomp/decomp/mapcut.py +++ b/idecomp/decomp/mapcut.py @@ -1,11 +1,10 @@ -from cfinterface.files.sectionfile import SectionFile -from idecomp.decomp.modelos.mapcut import SecaoDadosMapcut -import pandas as pd # type: ignore -from typing import List from datetime import datetime +from typing import Any, TypeVar +import pandas as pd # type: ignore[import-untyped] +from cfinterface.files.sectionfile import SectionFile -from typing import TypeVar, Optional +from idecomp.decomp.modelos.mapcut import SecaoDadosMapcut class Mapcut(SectionFile): @@ -19,15 +18,15 @@ class Mapcut(SectionFile): SECTIONS = [SecaoDadosMapcut] STORAGE = "BINARY" - def __init__(self, data=...) -> None: + def __init__(self, data: Any = ...) -> None: super().__init__(data) - def __obtem_dados(self) -> Optional[SecaoDadosMapcut]: + def __obtem_dados(self) -> SecaoDadosMapcut | None: s = self.data.get_sections_of_type(SecaoDadosMapcut) return s if not isinstance(s, list) else None @property - def numero_iteracoes(self) -> Optional[int]: + def numero_iteracoes(self) -> int | None: """ O número de iterações. @@ -40,7 +39,7 @@ def numero_iteracoes(self) -> Optional[int]: return None @property - def numero_cortes(self) -> Optional[int]: + def numero_cortes(self) -> int | None: """ O número de cortes de Benders. @@ -53,7 +52,7 @@ def numero_cortes(self) -> Optional[int]: return None @property - def numero_submercados(self) -> Optional[int]: + def numero_submercados(self) -> int | None: """ O número de submercados. @@ -66,7 +65,7 @@ def numero_submercados(self) -> Optional[int]: return None @property - def numero_uhes(self) -> Optional[int]: + def numero_uhes(self) -> int | None: """ O número de usinas hidrelétricas. @@ -79,7 +78,7 @@ def numero_uhes(self) -> Optional[int]: return None @property - def numero_cenarios(self) -> Optional[int]: + def numero_cenarios(self) -> int | None: """ O número de cenarios. @@ -92,7 +91,7 @@ def numero_cenarios(self) -> Optional[int]: return None @property - def registro_ultimo_corte_no(self) -> Optional[pd.DataFrame]: + def registro_ultimo_corte_no(self) -> pd.DataFrame | None: """ Retorna os dados dos índices do último registro de cortes para cada estágio, para leitura do @@ -111,7 +110,7 @@ def registro_ultimo_corte_no(self) -> Optional[pd.DataFrame]: return None @property - def tamanho_corte(self) -> Optional[int]: + def tamanho_corte(self) -> int | None: """ O tamanho do corte (tamanho do registro no arquivo cortdeco). @@ -125,7 +124,7 @@ def tamanho_corte(self) -> Optional[int]: return None @property - def data_inicio(self) -> Optional[datetime]: + def data_inicio(self) -> datetime | None: """ A data de início do estudo. @@ -138,7 +137,7 @@ def data_inicio(self) -> Optional[datetime]: return None @property - def codigos_uhes(self) -> Optional[List[int]]: + def codigos_uhes(self) -> list[int] | None: """ Os códigos das usinas hidráulicas. @@ -151,7 +150,7 @@ def codigos_uhes(self) -> Optional[List[int]]: return None @property - def codigos_uhes_jusante(self) -> Optional[List[int]]: + def codigos_uhes_jusante(self) -> list[int] | None: """ Os códigos das usinas hidráulicas a jusante. @@ -164,7 +163,7 @@ def codigos_uhes_jusante(self) -> Optional[List[int]]: return None @property - def indice_no_arvore(self) -> Optional[list]: + def indice_no_arvore(self) -> list[int] | None: """ Os índice do nó pai na árvore de cenários para cada nó da árvore. @@ -178,7 +177,7 @@ def indice_no_arvore(self) -> Optional[list]: return None @property - def numero_estagios(self) -> Optional[int]: + def numero_estagios(self) -> int | None: """ O número de estágios. @@ -191,7 +190,7 @@ def numero_estagios(self) -> Optional[int]: return None @property - def numero_semanas(self) -> Optional[int]: + def numero_semanas(self) -> int | None: """ O número de semanas. @@ -204,7 +203,7 @@ def numero_semanas(self) -> Optional[int]: return None @property - def numero_uhes_tempo_viagem(self) -> Optional[int]: + def numero_uhes_tempo_viagem(self) -> int | None: """ O número de usinas hidraúlicas com tempo de viagem da água. @@ -218,7 +217,7 @@ def numero_uhes_tempo_viagem(self) -> Optional[int]: return None @property - def maximo_lag_tempo_viagem(self) -> Optional[int]: + def maximo_lag_tempo_viagem(self) -> int | None: """ O máximo lag de tempo de viagem. @@ -231,7 +230,7 @@ def maximo_lag_tempo_viagem(self) -> Optional[int]: return None @property - def indice_primeiro_no_estagio(self) -> Optional[list]: + def indice_primeiro_no_estagio(self) -> list[int] | None: """ O índice do primeiro nó de cada estágio. @@ -244,7 +243,7 @@ def indice_primeiro_no_estagio(self) -> Optional[list]: return None @property - def patamares_por_estagio(self) -> Optional[list]: + def patamares_por_estagio(self) -> list[int] | None: """ O número de patamares de carga por estágio. @@ -257,7 +256,7 @@ def patamares_por_estagio(self) -> Optional[list]: return None @property - def lag_tempo_viagem_por_uhe(self) -> Optional[list]: + def lag_tempo_viagem_por_uhe(self) -> list[Any] | None: """ O lag (em estágios) de uma usina para cada período. @@ -270,7 +269,7 @@ def lag_tempo_viagem_por_uhe(self) -> Optional[list]: return None @property - def codigos_uhes_tempo_viagem(self) -> Optional[List[int]]: + def codigos_uhes_tempo_viagem(self) -> list[int] | None: """ Os códigos das usinas hidráulicas com tempo de viagem. @@ -283,7 +282,7 @@ def codigos_uhes_tempo_viagem(self) -> Optional[List[int]]: return None @property - def dados_tempo_viagem(self) -> Optional[pd.DataFrame]: + def dados_tempo_viagem(self) -> pd.DataFrame | None: """ Obtém a tabela com os dados de tempo de viagem. @@ -302,7 +301,7 @@ def dados_tempo_viagem(self) -> Optional[pd.DataFrame]: return None @property - def codigos_submercados_gnl(self) -> Optional[List[int]]: + def codigos_submercados_gnl(self) -> list[int] | None: """ Os códigos das usinas térmicas com despacho antecipado (GNL). @@ -316,7 +315,7 @@ def codigos_submercados_gnl(self) -> Optional[List[int]]: return None @property - def dados_gnl(self) -> Optional[pd.DataFrame]: + def dados_gnl(self) -> pd.DataFrame | None: """ Obtém a tabela com os dados de usinas GNL. @@ -335,7 +334,7 @@ def dados_gnl(self) -> Optional[pd.DataFrame]: return None @property - def dados_custos(self) -> Optional[pd.DataFrame]: + def dados_custos(self) -> pd.DataFrame | None: """ Obtém a tabela com os dados de custos. diff --git a/idecomp/decomp/modelos/arquivos.py b/idecomp/decomp/modelos/arquivos.py index 32b9e1d5..cf2aca00 100644 --- a/idecomp/decomp/modelos/arquivos.py +++ b/idecomp/decomp/modelos/arquivos.py @@ -1,8 +1,9 @@ -from cfinterface.components.section import Section +from typing import IO, Any + +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from typing import IO, List -import pandas as pd # type: ignore +from cfinterface.components.section import Section class BlocoNomesArquivos(Section): @@ -13,7 +14,9 @@ class BlocoNomesArquivos(Section): __slots__ = ["__linha"] - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__linha = Line([LiteralField(80, 0)]) @@ -32,12 +35,12 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): - def converte_tabela_em_df(): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] + def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(data={"Nome": nomes}) return df - nomes: List[str] = [] + nomes: list[str] = [] while True: linha = file.readline() if len(linha) == 0: @@ -47,7 +50,7 @@ def converte_tabela_em_df(): nomes.append(dados[0]) # Override - def write(self, file: IO, *args, **kwargs): + def write(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] if not isinstance(self.data, pd.DataFrame): raise ValueError("Dados do arquivos não foram lidos") for _, linha in self.data.iterrows(): diff --git a/idecomp/decomp/modelos/arquivoscsv/arquivocsv.py b/idecomp/decomp/modelos/arquivoscsv/arquivocsv.py index e445ca32..c456efa8 100644 --- a/idecomp/decomp/modelos/arquivoscsv/arquivocsv.py +++ b/idecomp/decomp/modelos/arquivoscsv/arquivocsv.py @@ -1,13 +1,14 @@ +from typing import TypeVar + +import pandas as pd # type: ignore +from cfinterface.components.block import Block +from cfinterface.files.blockfile import BlockFile + +from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV, TabelaCSVLibs from idecomp.decomp.modelos.blocos.versaomodelo import ( VersaoModelo, VersaoModeloLibs, ) -from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV, TabelaCSVLibs - -from cfinterface.components.block import Block -from cfinterface.files.blockfile import BlockFile -import pandas as pd # type: ignore -from typing import List, Type, TypeVar, Optional class ArquivoCSV(BlockFile): @@ -23,12 +24,12 @@ class ArquivoCSV(BlockFile): implementado para cada arquivo específico a ser lido. """ - BLOCKS: List[Type[Block]] = [VersaoModelo] + BLOCKS: list[type[Block]] = [VersaoModelo] ENCODING = "iso-8859-1" T = TypeVar("T") - def _bloco_por_tipo(self, bloco: Type[T], indice: int) -> Optional[T]: + def _bloco_por_tipo(self, bloco: type[T], indice: int) -> T | None: """ Obtém um gerador de blocos de um tipo, se houver algum no arquivo. @@ -41,15 +42,13 @@ def _bloco_por_tipo(self, bloco: Type[T], indice: int) -> Optional[T]: """ try: return next( - b - for i, b in enumerate(self.data.of_type(bloco)) - if i == indice + b for i, b in enumerate(self.data.of_type(bloco)) if i == indice ) except StopIteration: return None @property - def versao(self) -> Optional[str]: + def versao(self) -> str | None: """ A versão do modelo utilizada para executar o caso. @@ -64,7 +63,7 @@ def versao(self) -> Optional[str]: return b_libs.data return None - def _tabela(self) -> Optional[pd.DataFrame]: + def _tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/modelos/avl_cortesfpha_dec.py b/idecomp/decomp/modelos/avl_cortesfpha_dec.py index 7d4df9c5..bb9995fd 100644 --- a/idecomp/decomp/modelos/avl_cortesfpha_dec.py +++ b/idecomp/decomp/modelos/avl_cortesfpha_dec.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/blocos/tabelacsv.py b/idecomp/decomp/modelos/blocos/tabelacsv.py index b0f7b9f2..cec2e8c2 100644 --- a/idecomp/decomp/modelos/blocos/tabelacsv.py +++ b/idecomp/decomp/modelos/blocos/tabelacsv.py @@ -1,9 +1,9 @@ +from typing import IO, Any + +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.block import Block from cfinterface.components.line import Line -from typing import IO, List, Dict -import pandas as pd # type: ignore - class TabelaCSV(Block): """ @@ -15,10 +15,10 @@ class TabelaCSV(Block): BEGIN_PATTERN = "-----;------;" LINE_MODEL = Line([]) - COLUMN_NAMES: List[str] = [] + COLUMN_NAMES: list[str] = [] END_PATTERN = "" - def _monta_df(self, dados: dict) -> pd.DataFrame: + def _monta_df(self, dados: dict[str, Any]) -> pd.DataFrame: return pd.DataFrame(data=dados, columns=self.__class__.COLUMN_NAMES) def __eq__(self, o: object) -> bool: @@ -32,7 +32,7 @@ def __eq__(self, o: object) -> bool: else: return self.data.equals(o.data) - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] if len(self.__class__.LINE_MODEL.fields) != len( self.__class__.COLUMN_NAMES ): @@ -51,7 +51,9 @@ def read(self, file: IO, *args, **kwargs): elif len(linha) < 3: return # Lê a tabela - dados: Dict[str, List] = {c: [] for c in self.__class__.COLUMN_NAMES} + dados: dict[str, list[Any]] = { + c: [] for c in self.__class__.COLUMN_NAMES + } while True: linha = file.readline() if len(linha) < 3: @@ -72,10 +74,10 @@ class TabelaCSVLibs(Block): BEGIN_PATTERN = "&IIIIIII;IIIIIII;" LINE_MODEL = Line([]) - COLUMN_NAMES: List[str] = [] + COLUMN_NAMES: list[str] = [] END_PATTERN = "" - def _monta_df(self, dados: dict) -> pd.DataFrame: + def _monta_df(self, dados: dict[str, Any]) -> pd.DataFrame: return pd.DataFrame(data=dados, columns=self.__class__.COLUMN_NAMES) def __eq__(self, o: object) -> bool: @@ -89,7 +91,7 @@ def __eq__(self, o: object) -> bool: else: return self.data.equals(o.data) - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] if len(self.__class__.LINE_MODEL.fields) != len( self.__class__.COLUMN_NAMES ): @@ -102,7 +104,9 @@ def read(self, file: IO, *args, **kwargs): # Lê a tabela linha = file.readline() - dados: Dict[str, List] = {c: [] for c in self.__class__.COLUMN_NAMES} + dados: dict[str, list[Any]] = { + c: [] for c in self.__class__.COLUMN_NAMES + } while True: linha = file.readline() if len(linha) < 3: diff --git a/idecomp/decomp/modelos/blocos/versaomodelo.py b/idecomp/decomp/modelos/blocos/versaomodelo.py index c66988d3..8fa1cccb 100644 --- a/idecomp/decomp/modelos/blocos/versaomodelo.py +++ b/idecomp/decomp/modelos/blocos/versaomodelo.py @@ -1,6 +1,6 @@ -from cfinterface.components.block import Block +from typing import IO, Any -from typing import IO +from cfinterface.components.block import Block class VersaoModelo(Block): @@ -22,9 +22,10 @@ def __eq__(self, o: object) -> bool: return False return self.data == o.data - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[str], *args: Any, **kwargs: Any) -> bool: linha = file.readline() self.data = linha.split("Versao")[1].strip().split("-")[0].strip() + return True class VersaoModeloLibs(Block): @@ -46,6 +47,7 @@ def __eq__(self, o: object) -> bool: return False return self.data == o.data - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[str], *args: Any, **kwargs: Any) -> bool: linha = file.readline() self.data = linha.split("Versão:")[1].strip() + return True diff --git a/idecomp/decomp/modelos/caso.py b/idecomp/decomp/modelos/caso.py index 8176fe58..5e56674f 100644 --- a/idecomp/decomp/modelos/caso.py +++ b/idecomp/decomp/modelos/caso.py @@ -1,7 +1,8 @@ -from cfinterface.components.section import Section +from typing import IO, Any + from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from typing import IO +from cfinterface.components.section import Section class NomeCaso(Section): @@ -12,7 +13,9 @@ class NomeCaso(Section): __slots__ = ["__linha"] - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__linha = Line([LiteralField(80, 0)]) @@ -31,9 +34,9 @@ def __eq__(self, o: object) -> bool: return self.data == bloco.data # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] self.data = self.__linha.read(file.readline())[0] # Override - def write(self, file: IO, *args, **kwargs): + def write(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] file.write(self.__linha.write([self.data])) diff --git a/idecomp/decomp/modelos/cortdeco.py b/idecomp/decomp/modelos/cortdeco.py index ff6e1646..d5dfd332 100644 --- a/idecomp/decomp/modelos/cortdeco.py +++ b/idecomp/decomp/modelos/cortdeco.py @@ -1,7 +1,8 @@ +from typing import IO, Any + +import numpy as np +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.section import Section -from typing import IO, List -import numpy as np # type: ignore -import pandas as pd # type: ignore class SecaoDadosCortdeco(Section): @@ -44,7 +45,7 @@ def __eq__(self, o: object) -> bool: else: return self.data.equals(bloco.data) - def __inicializa_variaveis(self, numero_total_cortes): + def __inicializa_variaveis(self, numero_total_cortes: int) -> None: self.__numero_coeficientes_rhs = 1 self.__numero_coeficientes_varm = int(len(self.__codigos_uhes)) @@ -77,8 +78,12 @@ def __inicializa_variaveis(self, numero_total_cortes): ) def __le_e_atribui_int( - self, file: IO, destino: np.ndarray, tamanho: int, indice: int - ): + self, + file: IO[Any], + destino: np.ndarray, + tamanho: int, + indice: int, + ) -> None: destino[indice, :] = np.frombuffer( file.read(tamanho * 4), dtype=np.int32, @@ -86,8 +91,8 @@ def __le_e_atribui_int( ) def __le_e_atribui_float( - self, file: IO, destino: np.ndarray, tamanho: int, indice: int - ): + self, file: IO[Any], destino: np.ndarray, tamanho: int, indice: int + ) -> None: destino[indice, :] = np.frombuffer( file.read(tamanho * 8), dtype=np.float64, @@ -96,7 +101,7 @@ def __le_e_atribui_float( def __le_registro( self, - file: IO, + file: IO[Any], offset: int, indice: int, ) -> int: @@ -109,7 +114,9 @@ def __le_registro( self.__tabela_int[indice, 0] = indice return indice_proximo_corte - def __converte_array_em_dataframe(self, no: int, estagio: int): + def __converte_array_em_dataframe( + self, no: int, estagio: int + ) -> pd.DataFrame: df_int = pd.DataFrame( self.__tabela_int[:, 0], columns=[ @@ -140,14 +147,14 @@ def __converte_array_em_dataframe(self, no: int, estagio: int): ) df = pd.concat([df_int, df_float], axis=1) - return df.sort_values( - by=["estagio", "no", "indice_corte"] - ).reset_index(drop=True) + return df.sort_values(by=["estagio", "no", "indice_corte"]).reset_index( + drop=True + ) def __le_arquivo( self, - file: IO, - ): + file: IO[Any], + ) -> None: df_cortes_completo = pd.DataFrame() # Realiza leitura para cada no que constroi corte for _, row in self.__registro_ultimo_corte_no.iterrows(): @@ -254,8 +261,8 @@ def __identifica_indices_registros( return df_cortes.sort_values(by=["indice_registro"]) def __atualiza_registros( - self, file: IO, df_registro_ultimo_corte_no: pd.DataFrame - ): + self, file: IO[Any], df_registro_ultimo_corte_no: pd.DataFrame + ) -> None: df_cortes = self.__identifica_indices_registros( df_registro_ultimo_corte_no ) @@ -280,21 +287,21 @@ def __atualiza_registros( ).tobytes() ) - def read( + def read( # type: ignore[override] self, - file: IO, + file: IO[Any], tamanho_registro: int, registro_ultimo_corte_no: pd.DataFrame, numero_total_cortes: int, numero_patamares_carga: int, numero_estagios: int, - codigos_uhes: List[int], - codigos_uhes_tempo_viagem: List[int], - codigos_submercados: List[int], + codigos_uhes: list[int], + codigos_uhes_tempo_viagem: list[int], + codigos_submercados: list[int], lag_maximo_tempo_viagem: int, - *args, - **kwargs, - ): + *args: Any, + **kwargs: Any, + ) -> None: # Atribui variáveis locais self.__tamanho_registro = tamanho_registro self.__numero_total_cortes = numero_total_cortes @@ -313,11 +320,11 @@ def read( # Ignore bytes restantes _ = file.read() - def write( + def write( # type: ignore[override] self, - file: IO, - *args, - **kwargs, - ): + file: IO[Any], + *args: Any, + **kwargs: Any, + ) -> None: df_registro_ultimo_corte_no = kwargs["df_registro_ultimo_corte_no"] self.__atualiza_registros(file, df_registro_ultimo_corte_no) diff --git a/idecomp/decomp/modelos/custos.py b/idecomp/decomp/modelos/custos.py index 0dd0fbfd..9da65db9 100644 --- a/idecomp/decomp/modelos/custos.py +++ b/idecomp/decomp/modelos/custos.py @@ -1,13 +1,14 @@ # Imports do próprio módulo # Imports de módulos externos +from typing import IO, Any + +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.block import Block -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField -import pandas as pd # type: ignore -from typing import IO, List class BlocoRelatorioCustos(Block): @@ -24,7 +25,9 @@ class BlocoRelatorioCustos(Block): BEGIN_PATTERN = r" RELATORIO DAS VARIAVEIS DUAIS NO ESTAGIO" END_PATTERN = "X----X-" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__scenario_line = Line([IntegerField(2, 44), IntegerField(4, 54)]) self.__dual_variables_line = Line( @@ -59,7 +62,7 @@ def __eq__(self, o: object) -> bool: ] ) - def __read_bloco_variaveis_duais(self, file: IO): + def __read_bloco_variaveis_duais(self, file: IO[Any]) -> None: def converte_tabela_para_df() -> pd.DataFrame: cols = [ "usina", @@ -83,8 +86,8 @@ def converte_tabela_para_df() -> pd.DataFrame: file.readline() # Variáveis auxiliares - usinas: List[str] = [] - pihs: List[float] = [] + usinas: list[str] = [] + pihs: list[float] = [] while True: linha: str = file.readline() # Verifica se acabou @@ -95,15 +98,13 @@ def converte_tabela_para_df() -> pd.DataFrame: usinas.append(dados[0]) pihs.append(dados[1]) - def __read_bloco_restricoes_fcf(self, file: IO): + def __read_bloco_restricoes_fcf(self, file: IO[Any]) -> None: def converte_tabela_para_df() -> pd.DataFrame: cols = [ "indice_corte", "parcela_pi", ] - df = pd.DataFrame( - data={"indice_corte": indices, "parcela_pi": pis} - ) + df = pd.DataFrame(data={"indice_corte": indices, "parcela_pi": pis}) cols_adic = [ "estagio", "cenario", @@ -121,8 +122,8 @@ def converte_tabela_para_df() -> pd.DataFrame: file.readline() # Variáveis auxiliares - indices: List[int] = [] - pis: List[float] = [] + indices: list[int] = [] + pis: list[float] = [] while True: linha: str = file.readline() # Verifica se acabou @@ -134,14 +135,14 @@ def converte_tabela_para_df() -> pd.DataFrame: pis.append(dados[1]) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] str_bloco_variaveis_duais = "Aproveitamento Bal.Hidr." str_bloco_restricoes_fcf = "Restricoes da FCF" # Extrai os dados de estágio e cenário self.dados_cenario = self.__scenario_line.read(file.readline()) - self.data: List[pd.DataFrame] = [] + self.data: list[pd.DataFrame] = [] while True: linha = file.readline() if str_bloco_variaveis_duais in linha: diff --git a/idecomp/decomp/modelos/dadger.py b/idecomp/decomp/modelos/dadger.py index 8fe92a9b..2df5801b 100644 --- a/idecomp/decomp/modelos/dadger.py +++ b/idecomp/decomp/modelos/dadger.py @@ -1,11 +1,11 @@ -from typing import IO, List, Optional +from typing import IO, Any from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField from cfinterface.components.register import Register -from numpy import abs # type: ignore +from numpy import abs class TE(Register): @@ -13,14 +13,14 @@ class TE(Register): Registro que contém a usina modificada. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "TE " IDENTIFIER_DIGITS = 4 LINE = Line([LiteralField(75, 4)]) @property - def titulo(self) -> Optional[str]: + def titulo(self) -> str | None: """ O único conteúdo do registro (título do estudo). @@ -30,7 +30,7 @@ def titulo(self) -> Optional[str]: return self.data[0] @titulo.setter - def titulo(self, t: str): + def titulo(self, t: str) -> None: self.data[0] = t @@ -39,14 +39,14 @@ class SB(Register): Registro que contém o cadastro dos submercados. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "SB " IDENTIFIER_DIGITS = 4 LINE = Line([IntegerField(2, 4), LiteralField(2, 9)]) @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O código de cadastro do submercado. @@ -56,11 +56,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[0] @codigo_submercado.setter - def codigo_submercado(self, cod: int): + def codigo_submercado(self, cod: int) -> None: self.data[0] = cod @property - def nome_submercado(self) -> Optional[str]: + def nome_submercado(self) -> str | None: """ O nome de cadastro do submercado. @@ -70,7 +70,7 @@ def nome_submercado(self) -> Optional[str]: return self.data[1] @nome_submercado.setter - def nome_submercado(self, n: str): + def nome_submercado(self, n: str) -> None: self.data[1] = n @@ -80,7 +80,7 @@ class UH(Register): iniciais no estudo. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "UH " IDENTIFIER_DIGITS = 4 @@ -100,7 +100,7 @@ class UH(Register): ) @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código de cadastro da UHE. @@ -110,11 +110,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, cod: int): + def codigo_usina(self, cod: int) -> None: self.data[0] = cod @property - def codigo_ree(self) -> Optional[int]: + def codigo_ree(self) -> int | None: """ O REE de cadastro da UHE. @@ -124,11 +124,11 @@ def codigo_ree(self) -> Optional[int]: return self.data[1] @codigo_ree.setter - def codigo_ree(self, n: int): + def codigo_ree(self, n: int) -> None: self.data[1] = n @property - def volume_inicial(self) -> Optional[float]: + def volume_inicial(self) -> float | None: """ O volume inicial da UHE para o estudo. @@ -138,11 +138,11 @@ def volume_inicial(self) -> Optional[float]: return self.data[2] @volume_inicial.setter - def volume_inicial(self, v: float): + def volume_inicial(self, v: float) -> None: self.data[2] = v @property - def vazao_defluente_minima(self) -> Optional[float]: + def vazao_defluente_minima(self) -> float | None: """ O vazão defluente mínima da usina em m3/s. @@ -152,11 +152,11 @@ def vazao_defluente_minima(self) -> Optional[float]: return self.data[3] @vazao_defluente_minima.setter - def vazao_defluente_minima(self, v: float): + def vazao_defluente_minima(self, v: float) -> None: self.data[3] = v @property - def evaporacao(self) -> Optional[int]: + def evaporacao(self) -> int | None: """ A consideração ou não de evaporação para a UHE. @@ -166,11 +166,11 @@ def evaporacao(self) -> Optional[int]: return self.data[4] @evaporacao.setter - def evaporacao(self, e: int): + def evaporacao(self, e: int) -> None: self.data[4] = e @property - def estagio_inicio_producao(self) -> Optional[int]: + def estagio_inicio_producao(self) -> int | None: """ Estágio a partir da qual a usina começa a produzir energia. @@ -180,11 +180,11 @@ def estagio_inicio_producao(self) -> Optional[int]: return self.data[5] @estagio_inicio_producao.setter - def estagio_inicio_producao(self, e: int): + def estagio_inicio_producao(self, e: int) -> None: self.data[5] = e @property - def volume_morto_inicial(self) -> Optional[float]: + def volume_morto_inicial(self) -> float | None: """ Volume morto inicial da usina. @@ -194,11 +194,11 @@ def volume_morto_inicial(self) -> Optional[float]: return self.data[6] @volume_morto_inicial.setter - def volume_morto_inicial(self, e: float): + def volume_morto_inicial(self, e: float) -> None: self.data[6] = e @property - def limite_superior_vertimento(self) -> Optional[float]: + def limite_superior_vertimento(self) -> float | None: """ O limite superior para vertimento da usina. @@ -208,11 +208,11 @@ def limite_superior_vertimento(self) -> Optional[float]: return self.data[7] @limite_superior_vertimento.setter - def limite_superior_vertimento(self, e: float): + def limite_superior_vertimento(self, e: float) -> None: self.data[7] = e @property - def balanco_hidrico_patamar(self) -> Optional[int]: + def balanco_hidrico_patamar(self) -> int | None: """ Consideração do balanço hídrico por patamar. @@ -222,11 +222,11 @@ def balanco_hidrico_patamar(self) -> Optional[int]: return self.data[8] @balanco_hidrico_patamar.setter - def balanco_hidrico_patamar(self, e: int): + def balanco_hidrico_patamar(self, e: int) -> None: self.data[8] = e @property - def configuracao_newave(self) -> Optional[str]: + def configuracao_newave(self) -> str | None: """ Sinaliza a existência da usina na configuração do NEWAVE, para compatibilização. @@ -237,7 +237,7 @@ def configuracao_newave(self) -> Optional[str]: return self.data[9] @configuracao_newave.setter - def configuracao_newave(self, e: str): + def configuracao_newave(self, e: str) -> None: self.data[9] = e @@ -248,7 +248,7 @@ class CT(Register): """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "CT " IDENTIFIER_DIGITS = 4 @@ -278,10 +278,10 @@ class CT(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -292,7 +292,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código de cadastro da UTE. @@ -302,11 +302,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, codigo: int): + def codigo_usina(self, codigo: int) -> None: self.data[0] = codigo @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O submercado de cadastro da UTE. @@ -316,11 +316,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[1] @codigo_submercado.setter - def codigo_submercado(self, submercado: int): + def codigo_submercado(self, submercado: int) -> None: self.data[1] = submercado @property - def nome_usina(self) -> Optional[str]: + def nome_usina(self) -> str | None: """ O nome de cadastro da UTE. @@ -330,11 +330,11 @@ def nome_usina(self) -> Optional[str]: return self.data[2] @nome_usina.setter - def nome_usina(self, nome: str): + def nome_usina(self, nome: str) -> None: self.data[2] = nome @property - def estagio(self) -> Optional[str]: + def estagio(self) -> str | None: """ O estágio associado às propriedades cadastradas. @@ -344,11 +344,11 @@ def estagio(self) -> Optional[str]: return self.data[3] @estagio.setter - def estagio(self, estagio: int): + def estagio(self, estagio: int) -> None: self.data[3] = estagio @property - def inflexibilidade(self) -> Optional[List[float]]: + def inflexibilidade(self) -> list[float] | None: """ A inflexibilidade da UTE por patamar. @@ -358,11 +358,11 @@ def inflexibilidade(self) -> Optional[List[float]]: return [v for v in self.data[4::3] if v is not None] @inflexibilidade.setter - def inflexibilidade(self, inflex: List[float]): + def inflexibilidade(self, inflex: list[float]) -> None: self.__atualiza_dados_lista(inflex, 4, 3) @property - def disponibilidade(self) -> Optional[List[float]]: + def disponibilidade(self) -> list[float] | None: """ A disponibilidade da UTE por patamar. @@ -372,11 +372,11 @@ def disponibilidade(self) -> Optional[List[float]]: return [v for v in self.data[5::3] if v is not None] @disponibilidade.setter - def disponibilidade(self, disp: List[float]): + def disponibilidade(self, disp: list[float]) -> None: self.__atualiza_dados_lista(disp, 5, 3) @property - def cvu(self) -> Optional[List[float]]: + def cvu(self) -> list[float] | None: """ O CVU da UTE por patamar. @@ -386,7 +386,7 @@ def cvu(self) -> Optional[List[float]]: return [v for v in self.data[6::3] if v is not None] @cvu.setter - def cvu(self, cvu: List[float]): + def cvu(self, cvu: list[float]) -> None: self.__atualiza_dados_lista(cvu, 6, 3) @@ -396,7 +396,7 @@ class UE(Register): (usinas elevatórias). """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "UE " IDENTIFIER_DIGITS = 4 @@ -414,7 +414,7 @@ class UE(Register): ) @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código de cadastro da UE. @@ -424,11 +424,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, cod: int): + def codigo_usina(self, cod: int) -> None: self.data[0] = cod @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O submercado de cadastro da UE, conforme registro SB. @@ -438,11 +438,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[1] @codigo_submercado.setter - def codigo_submercado(self, n: int): + def codigo_submercado(self, n: int) -> None: self.data[1] = n @property - def nome_usina(self) -> Optional[str]: + def nome_usina(self) -> str | None: """ O nome da estação de bombeamento. @@ -452,11 +452,11 @@ def nome_usina(self) -> Optional[str]: return self.data[2] @nome_usina.setter - def nome_usina(self, v: str): + def nome_usina(self, v: str) -> None: self.data[2] = v @property - def codigo_usina_montante(self) -> Optional[int]: + def codigo_usina_montante(self) -> int | None: """ O código da UHE a montante, conforme registro UH. @@ -466,11 +466,11 @@ def codigo_usina_montante(self) -> Optional[int]: return self.data[3] @codigo_usina_montante.setter - def codigo_usina_montante(self, v: int): + def codigo_usina_montante(self, v: int) -> None: self.data[3] = v @property - def codigo_usina_jusante(self) -> Optional[int]: + def codigo_usina_jusante(self) -> int | None: """ O código da UHE a jusante, conforme registro UH. @@ -480,11 +480,11 @@ def codigo_usina_jusante(self) -> Optional[int]: return self.data[4] @codigo_usina_jusante.setter - def codigo_usina_jusante(self, e: int): + def codigo_usina_jusante(self, e: int) -> None: self.data[4] = e @property - def vazao_minima_bombeavel(self) -> Optional[float]: + def vazao_minima_bombeavel(self) -> float | None: """ A vazão mínima bombeável. @@ -494,11 +494,11 @@ def vazao_minima_bombeavel(self) -> Optional[float]: return self.data[5] @vazao_minima_bombeavel.setter - def vazao_minima_bombeavel(self, e: float): + def vazao_minima_bombeavel(self, e: float) -> None: self.data[5] = e @property - def vazao_maxima_bombeavel(self) -> Optional[float]: + def vazao_maxima_bombeavel(self) -> float | None: """ A vazão mínima bombeável. @@ -508,11 +508,11 @@ def vazao_maxima_bombeavel(self) -> Optional[float]: return self.data[6] @vazao_maxima_bombeavel.setter - def vazao_maxima_bombeavel(self, e: float): + def vazao_maxima_bombeavel(self, e: float) -> None: self.data[6] = e @property - def taxa_consumo(self) -> Optional[float]: + def taxa_consumo(self) -> float | None: """ A taxa de consumo. @@ -522,7 +522,7 @@ def taxa_consumo(self) -> Optional[float]: return self.data[7] @taxa_consumo.setter - def taxa_consumo(self, e: float): + def taxa_consumo(self, e: float) -> None: self.data[7] = e @@ -532,7 +532,7 @@ class DP(Register): """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "DP " IDENTIFIER_DIGITS = 4 @@ -556,10 +556,10 @@ class DP(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -570,7 +570,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio associado às durações especificadas. @@ -580,11 +580,11 @@ def estagio(self) -> Optional[int]: return self.data[0] @estagio.setter - def estagio(self, e: int): + def estagio(self, e: int) -> None: self.data[0] = e @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O submercado associado às durações especificadas. @@ -594,11 +594,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[1] @codigo_submercado.setter - def codigo_submercado(self, sub: int): + def codigo_submercado(self, sub: int) -> None: self.data[1] = sub @property - def numero_patamares(self) -> Optional[int]: + def numero_patamares(self) -> int | None: """ O número de patamares. @@ -608,11 +608,11 @@ def numero_patamares(self) -> Optional[int]: return self.data[2] @numero_patamares.setter - def numero_patamares(self, n: int): + def numero_patamares(self, n: int) -> None: self.data[2] = n @property - def carga(self) -> Optional[List[float]]: + def carga(self) -> list[float] | None: """ A carga em Mwmed pata cada patamar de carga @@ -622,11 +622,11 @@ def carga(self) -> Optional[List[float]]: return [v for v in self.data[3::2] if v is not None] @carga.setter - def carga(self, c: List[float]): + def carga(self, c: list[float]) -> None: self.__atualiza_dados_lista(c, 3, 2) @property - def duracao(self) -> Optional[List[float]]: + def duracao(self) -> list[float] | None: """ A duração de cada patamar de carga em horas @@ -636,7 +636,7 @@ def duracao(self) -> Optional[List[float]]: return [v for v in self.data[4::2] if v is not None] @duracao.setter - def duracao(self, d: List[float]): + def duracao(self, d: list[float]) -> None: self.__atualiza_dados_lista(d, 4, 2) @@ -646,7 +646,7 @@ class PQ(Register): """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "PQ " IDENTIFIER_DIGITS = 4 @@ -665,10 +665,10 @@ class PQ(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -679,7 +679,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def nome(self) -> Optional[str]: + def nome(self) -> str | None: """ O nome da geração. @@ -689,11 +689,11 @@ def nome(self) -> Optional[str]: return self.data[0] @nome.setter - def nome(self, nome: str): + def nome(self, nome: str) -> None: self.data[0] = nome @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O submercado associado à geração. @@ -703,11 +703,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[1] @codigo_submercado.setter - def codigo_submercado(self, sub: int): + def codigo_submercado(self, sub: int) -> None: self.data[1] = sub @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio associado à geração. @@ -717,11 +717,11 @@ def estagio(self) -> Optional[int]: return self.data[2] @estagio.setter - def estagio(self, e: int): + def estagio(self, e: int) -> None: self.data[2] = e @property - def geracao(self) -> Optional[List[float]]: + def geracao(self) -> list[float] | None: """ A geração em Mwmed para cada patamar de carga. @@ -731,7 +731,7 @@ def geracao(self) -> Optional[List[float]]: return [v for v in self.data[3:8] if v is not None] @geracao.setter - def geracao(self, c: List[float]): + def geracao(self, c: list[float]) -> None: self.__atualiza_dados_lista(c, 3, 1) @@ -741,7 +741,7 @@ class CD(Register): """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "CD " IDENTIFIER_DIGITS = 4 @@ -766,10 +766,10 @@ class CD(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -780,7 +780,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_curva(self) -> Optional[int]: + def codigo_curva(self) -> int | None: """ O código da curva de déficit. @@ -790,11 +790,11 @@ def codigo_curva(self) -> Optional[int]: return self.data[0] @codigo_curva.setter - def codigo_curva(self, n: int): + def codigo_curva(self, n: int) -> None: self.data[0] = n @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O código do submercado associado. @@ -804,11 +804,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[1] @codigo_submercado.setter - def codigo_submercado(self, s: int): + def codigo_submercado(self, s: int) -> None: self.data[1] = s @property - def nome_curva(self) -> Optional[str]: + def nome_curva(self) -> str | None: """ O nome da curva de déficit @@ -818,11 +818,11 @@ def nome_curva(self) -> Optional[str]: return self.data[2] @nome_curva.setter - def nome_curva(self, n: str): + def nome_curva(self, n: str) -> None: self.data[2] = n @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio de vigência do custo de déficit @@ -832,11 +832,11 @@ def estagio(self) -> Optional[int]: return self.data[3] @estagio.setter - def estagio(self, e: int): + def estagio(self, e: int) -> None: self.data[3] = e @property - def limite_superior(self) -> Optional[List[float]]: + def limite_superior(self) -> list[float] | None: """ O limite superior para consideração dos custos. @@ -846,11 +846,11 @@ def limite_superior(self) -> Optional[List[float]]: return [v for v in self.data[4::2] if v is not None] @limite_superior.setter - def limite_superior(self, lim: List[float]): + def limite_superior(self, lim: list[float]) -> None: self.__atualiza_dados_lista(lim, 4, 2) @property - def custo(self) -> Optional[List[float]]: + def custo(self) -> list[float] | None: """ O custo de déficit. @@ -860,7 +860,7 @@ def custo(self) -> Optional[List[float]]: return [v for v in self.data[5::2] if v is not None] @custo.setter - def custo(self, cus: List[float]): + def custo(self, cus: list[float]) -> None: self.__atualiza_dados_lista(cus, 5, 2) @@ -870,7 +870,7 @@ class RI(Register): """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "RI " IDENTIFIER_DIGITS = 4 @@ -909,10 +909,10 @@ class RI(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -923,7 +923,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da usina de Itaipu. @@ -933,11 +933,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, codigo: int): + def codigo_usina(self, codigo: int) -> None: self.data[0] = codigo @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O índice do estágio. @@ -947,11 +947,11 @@ def estagio(self) -> Optional[int]: return self.data[1] @estagio.setter - def estagio(self, estagio: int): + def estagio(self, estagio: int) -> None: self.data[1] = estagio @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O submercado que representa o Sudeste. @@ -961,11 +961,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[2] @codigo_submercado.setter - def codigo_submercado(self, submercado: int): + def codigo_submercado(self, submercado: int) -> None: self.data[2] = submercado @property - def geracao_minima_60_hz(self) -> Optional[List[float]]: + def geracao_minima_60_hz(self) -> list[float] | None: """ A geração mínima de Itaipu 60 Hz. @@ -975,11 +975,11 @@ def geracao_minima_60_hz(self) -> Optional[List[float]]: return self.data[3::5] @geracao_minima_60_hz.setter - def geracao_minima_60_hz(self, lim: List[float]): + def geracao_minima_60_hz(self, lim: list[float]) -> None: self.__atualiza_dados_lista(lim, 3, 5) @property - def geracao_maxima_60_hz(self) -> Optional[List[float]]: + def geracao_maxima_60_hz(self) -> list[float] | None: """ A geração máxima de Itaipu 60 Hz. @@ -989,11 +989,11 @@ def geracao_maxima_60_hz(self) -> Optional[List[float]]: return self.data[4::5] @geracao_maxima_60_hz.setter - def geracao_maxima_60_hz(self, lim: List[float]): + def geracao_maxima_60_hz(self, lim: list[float]) -> None: self.__atualiza_dados_lista(lim, 4, 5) @property - def geracao_minima_50_hz(self) -> Optional[List[float]]: + def geracao_minima_50_hz(self) -> list[float] | None: """ A geração mínima de Itaipu 50 Hz. @@ -1003,11 +1003,11 @@ def geracao_minima_50_hz(self) -> Optional[List[float]]: return self.data[5::5] @geracao_minima_50_hz.setter - def geracao_minima_50_hz(self, lim: List[float]): + def geracao_minima_50_hz(self, lim: list[float]) -> None: self.__atualiza_dados_lista(lim, 5, 5) @property - def geracao_maxima_50_hz(self) -> Optional[List[float]]: + def geracao_maxima_50_hz(self) -> list[float] | None: """ A geração máxima de Itaipu 50 Hz. @@ -1017,11 +1017,11 @@ def geracao_maxima_50_hz(self) -> Optional[List[float]]: return self.data[6::5] @geracao_maxima_50_hz.setter - def geracao_maxima_50_hz(self, lim: List[float]): + def geracao_maxima_50_hz(self, lim: list[float]) -> None: self.__atualiza_dados_lista(lim, 6, 5) @property - def carga_ande(self) -> Optional[List[float]]: + def carga_ande(self) -> list[float] | None: """ A carga da ANDE. @@ -1031,7 +1031,7 @@ def carga_ande(self) -> Optional[List[float]]: return self.data[7::5] @carga_ande.setter - def carga_ande(self, lim: List[float]): + def carga_ande(self, lim: list[float]) -> None: self.__atualiza_dados_lista(lim, 7, 5) @@ -1041,7 +1041,7 @@ class IA(Register): """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "IA " IDENTIFIER_DIGITS = 4 @@ -1065,7 +1065,7 @@ class IA(Register): ) @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O índice do estágio. @@ -1075,11 +1075,11 @@ def estagio(self) -> Optional[int]: return self.data[0] @estagio.setter - def estagio(self, t: int): + def estagio(self, t: int) -> None: self.data[0] = t @property - def nome_submercado_de(self) -> Optional[str]: + def nome_submercado_de(self) -> str | None: """ O nome do submercado de origem. @@ -1089,11 +1089,11 @@ def nome_submercado_de(self) -> Optional[str]: return self.data[1] @nome_submercado_de.setter - def nome_submercado_de(self, t: str): + def nome_submercado_de(self, t: str) -> None: self.data[1] = t @property - def nome_submercado_para(self) -> Optional[str]: + def nome_submercado_para(self) -> str | None: """ O nome do submercado de destino. @@ -1103,7 +1103,7 @@ def nome_submercado_para(self) -> Optional[str]: return self.data[2] @nome_submercado_para.setter - def nome_submercado_para(self, t: str): + def nome_submercado_para(self, t: str) -> None: self.data[2] = t @@ -1112,7 +1112,7 @@ class TX(Register): Registro que contém a taxa de desconto anual do modelo. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "TX " IDENTIFIER_DIGITS = 4 @@ -1123,7 +1123,7 @@ class TX(Register): ) @property - def taxa(self) -> Optional[float]: + def taxa(self) -> float | None: """ A taxa de desconto em % utilizada no estudo. @@ -1133,7 +1133,7 @@ def taxa(self) -> Optional[float]: return self.data[0] @taxa.setter - def taxa(self, t: float): + def taxa(self, t: float) -> None: self.data[0] = t @@ -1142,7 +1142,7 @@ class GP(Register): Registro que contém o gap de tolerância para convergência. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "GP " IDENTIFIER_DIGITS = 4 @@ -1153,7 +1153,7 @@ class GP(Register): ) @property - def gap(self) -> Optional[float]: + def gap(self) -> float | None: """ O gap considerado para convergência no estudo @@ -1163,7 +1163,7 @@ def gap(self) -> Optional[float]: return self.data[0] @gap.setter - def gap(self, g: float): + def gap(self, g: float) -> None: self.data[0] = g @@ -1172,14 +1172,14 @@ class NI(Register): Registro que contém o número máximo de iterações do modelo. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "NI " IDENTIFIER_DIGITS = 4 LINE = Line([IntegerField(3, 4), IntegerField(1, 8)]) @property - def iteracoes(self) -> Optional[int]: + def iteracoes(self) -> int | None: """ O número máximo de iterações do modelo no estudo @@ -1189,11 +1189,11 @@ def iteracoes(self) -> Optional[int]: return self.data[0] @iteracoes.setter - def iteracoes(self, i: int): + def iteracoes(self, i: int) -> None: self.data[0] = i @property - def tipo_limite(self) -> Optional[int]: + def tipo_limite(self) -> int | None: """ Se o número de interações fornecido é mínimo ou máximo. @@ -1203,7 +1203,7 @@ def tipo_limite(self) -> Optional[int]: return self.data[1] @tipo_limite.setter - def tipo_limite(self, i: int): + def tipo_limite(self, i: int) -> None: self.data[1] = i @@ -1212,7 +1212,7 @@ class DT(Register): Registro que contém a data de referência do estudo. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "DT " IDENTIFIER_DIGITS = 4 @@ -1225,7 +1225,7 @@ class DT(Register): ) @property - def dia(self) -> Optional[int]: + def dia(self) -> int | None: """ O dia de referência para realização do estudo @@ -1235,11 +1235,11 @@ def dia(self) -> Optional[int]: return self.data[0] @dia.setter - def dia(self, d: int): + def dia(self, d: int) -> None: self.data[0] = d @property - def mes(self) -> Optional[int]: + def mes(self) -> int | None: """ O mês de referência para realização do estudo @@ -1249,11 +1249,11 @@ def mes(self) -> Optional[int]: return self.data[1] @mes.setter - def mes(self, m: int): + def mes(self, m: int) -> None: self.data[1] = m @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: """ O ano de referência para realização do estudo @@ -1263,7 +1263,7 @@ def ano(self) -> Optional[int]: return self.data[2] @ano.setter - def ano(self, a: int): + def ano(self, a: int) -> None: self.data[2] = a @@ -1273,7 +1273,7 @@ class MP(Register): """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "MP " IDENTIFIER_DIGITS = 4 @@ -1310,10 +1310,10 @@ class MP(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -1324,7 +1324,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da UHE associada às manutenções programadas. @@ -1333,11 +1333,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def frequencia(self) -> Optional[int]: + def frequencia(self) -> int | None: """ A frequência quando se trata da UHE Itaipu. @@ -1346,11 +1346,11 @@ def frequencia(self) -> Optional[int]: return self.data[1] @frequencia.setter - def frequencia(self, c: int): + def frequencia(self, c: int) -> None: self.data[1] = c @property - def manutencao(self) -> Optional[List[float]]: + def manutencao(self) -> list[float] | None: """ Os fatores de manutenção programada por estágio do estudo. A posição na lista indica a qual estágio @@ -1362,7 +1362,7 @@ def manutencao(self) -> Optional[List[float]]: return [v for v in self.data[2::] if v is not None] @manutencao.setter - def manutencao(self, m: List[float]): + def manutencao(self, m: list[float]) -> None: self.__atualiza_dados_lista(m, 2, 1) @@ -1372,7 +1372,7 @@ class MT(Register): """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "MT " IDENTIFIER_DIGITS = 4 @@ -1409,10 +1409,10 @@ class MT(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -1423,7 +1423,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da UTE associada às manutenções programadas. @@ -1432,11 +1432,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O código do submercado ao qual a UTE pertence. @@ -1445,11 +1445,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[1] @codigo_submercado.setter - def codigo_submercado(self, c: int): + def codigo_submercado(self, c: int) -> None: self.data[1] = c @property - def manutencao(self) -> Optional[List[float]]: + def manutencao(self) -> list[float] | None: """ Os fatores de manutenção programada por estágio do estudo. A posição na lista indica a qual estágio @@ -1461,7 +1461,7 @@ def manutencao(self) -> Optional[List[float]]: return [v for v in self.data[2::] if v is not None] @manutencao.setter - def manutencao(self, m: List[float]): + def manutencao(self, m: list[float]) -> None: self.__atualiza_dados_lista(m, 2, 1) @@ -1471,7 +1471,7 @@ class FD(Register): """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "FD " IDENTIFIER_DIGITS = 4 @@ -1508,10 +1508,10 @@ class FD(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -1522,7 +1522,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da UHE associada aos fatores de disponibilidade. @@ -1531,11 +1531,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def frequencia(self) -> Optional[int]: + def frequencia(self) -> int | None: """ A frequência quando se trata da UHE Itaipu. @@ -1544,11 +1544,11 @@ def frequencia(self) -> Optional[int]: return self.data[1] @frequencia.setter - def frequencia(self, c: int): + def frequencia(self, c: int) -> None: self.data[1] = c @property - def fator(self) -> Optional[List[float]]: + def fator(self) -> list[float] | None: """ Os fatores de disponibilidade por estágio do estudo. A posição na lista indica a qual estágio @@ -1560,7 +1560,7 @@ def fator(self) -> Optional[List[float]]: return [v for v in self.data[2::] if v is not None] @fator.setter - def fator(self, m: List[float]): + def fator(self, m: list[float]) -> None: self.__atualiza_dados_lista(m, 2, 1) @@ -1570,7 +1570,7 @@ class VE(Register): """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "VE " IDENTIFIER_DIGITS = 4 @@ -1606,10 +1606,10 @@ class VE(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -1620,7 +1620,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da usina associada ao volume. @@ -1630,11 +1630,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def volume(self) -> Optional[List[float]]: + def volume(self) -> list[float] | None: """ O volume de espera por estagio. @@ -1644,7 +1644,7 @@ def volume(self) -> Optional[List[float]]: return [v for v in self.data[1:] if v is not None] @volume.setter - def volume(self, cus: List[float]): + def volume(self, cus: list[float]) -> None: self.__atualiza_dados_lista(cus, 1, 1) @@ -1653,7 +1653,7 @@ class RE(Register): Registro que contém os cadastros de restrições elétricas. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "RE " IDENTIFIER_DIGITS = 4 @@ -1666,7 +1666,7 @@ class RE(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código de cadastro para a restrição @@ -1676,11 +1676,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio_inicial(self) -> Optional[int]: + def estagio_inicial(self) -> int | None: """ O estágio inicial para consideração da restrição @@ -1690,11 +1690,11 @@ def estagio_inicial(self) -> Optional[int]: return self.data[1] @estagio_inicial.setter - def estagio_inicial(self, e: int): + def estagio_inicial(self, e: int) -> None: self.data[1] = e @property - def estagio_final(self) -> Optional[int]: + def estagio_final(self) -> int | None: """ O estágio final para consideração da restrição @@ -1704,7 +1704,7 @@ def estagio_final(self) -> Optional[int]: return self.data[2] @estagio_final.setter - def estagio_final(self, e: int): + def estagio_final(self, e: int) -> None: self.data[2] = e @@ -1714,7 +1714,7 @@ class LU(Register): """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "LU " IDENTIFIER_DIGITS = 4 @@ -1737,10 +1737,10 @@ class LU(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -1751,7 +1751,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição RE associada aos limites @@ -1761,11 +1761,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio inicial para consideração dos limites, até que sejam especificados novos limites. @@ -1776,11 +1776,11 @@ def estagio(self) -> Optional[int]: return self.data[1] @estagio.setter - def estagio(self, e: int): + def estagio(self, e: int) -> None: self.data[1] = e @property - def limite_inferior(self) -> Optional[List[float]]: + def limite_inferior(self) -> list[float] | None: """ O limite inferior por patamar para a restrição elétrica @@ -1790,11 +1790,11 @@ def limite_inferior(self) -> Optional[List[float]]: return self.data[2::2] @limite_inferior.setter - def limite_inferior(self, lim: List[float]): + def limite_inferior(self, lim: list[float]) -> None: self.__atualiza_dados_lista(lim, 2, 2) @property - def limite_superior(self) -> Optional[List[float]]: + def limite_superior(self) -> list[float] | None: """ O limite superior por patamar para a restrição elétrica @@ -1804,7 +1804,7 @@ def limite_superior(self) -> Optional[List[float]]: return self.data[3::2] @limite_superior.setter - def limite_superior(self, lim: List[float]): + def limite_superior(self, lim: list[float]) -> None: self.__atualiza_dados_lista(lim, 3, 2) @@ -1814,7 +1814,7 @@ class FU(Register): nas restrições elétricas. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "FU " IDENTIFIER_DIGITS = 4 @@ -1829,7 +1829,7 @@ class FU(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição elétrica, segundo registro RE. @@ -1838,11 +1838,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio associado. @@ -1851,11 +1851,11 @@ def estagio(self) -> Optional[int]: return self.data[1] @estagio.setter - def estagio(self, c: int): + def estagio(self, c: int) -> None: self.data[1] = c @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O número da UHE conforme registro UH. @@ -1864,11 +1864,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[2] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[2] = c @property - def coeficiente(self) -> Optional[float]: + def coeficiente(self) -> float | None: """ O coeficiente de participação da usina na restrição. @@ -1877,11 +1877,11 @@ def coeficiente(self) -> Optional[float]: return self.data[3] @coeficiente.setter - def coeficiente(self, f: float): + def coeficiente(self, f: float) -> None: self.data[3] = f @property - def frequencia(self) -> Optional[int]: + def frequencia(self) -> int | None: """ A frequência para restrição elétrica, valendo 50 ou 60 para Itaipu e 0 para as demais. @@ -1891,7 +1891,7 @@ def frequencia(self) -> Optional[int]: return self.data[4] @frequencia.setter - def frequencia(self, c: int): + def frequencia(self, c: int) -> None: self.data[4] = c @@ -1901,7 +1901,7 @@ class FT(Register): nas restrições elétricas. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "FT " IDENTIFIER_DIGITS = 4 @@ -1916,7 +1916,7 @@ class FT(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição elétrica, segundo registro RE. @@ -1925,11 +1925,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio associado. @@ -1938,11 +1938,11 @@ def estagio(self) -> Optional[int]: return self.data[1] @estagio.setter - def estagio(self, c: int): + def estagio(self, c: int) -> None: self.data[1] = c @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O número da UTE conforme registro CT. @@ -1951,11 +1951,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[2] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[2] = c @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O código do submercado conforme registros CT ou TG. @@ -1964,11 +1964,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[3] @codigo_submercado.setter - def codigo_submercado(self, s: int): + def codigo_submercado(self, s: int) -> None: self.data[3] = s @property - def coeficiente(self) -> Optional[float]: + def coeficiente(self) -> float | None: """ O coeficiente de participação da usina na restrição. @@ -1977,7 +1977,7 @@ def coeficiente(self) -> Optional[float]: return self.data[4] @coeficiente.setter - def coeficiente(self, f: float): + def coeficiente(self, f: float) -> None: self.data[4] = f @@ -1987,7 +1987,7 @@ class FI(Register): entre os subsistemas associados à restrição elétrica. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "FI " IDENTIFIER_DIGITS = 4 @@ -2002,7 +2002,7 @@ class FI(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição elétrica, segundo registro RE. @@ -2011,11 +2011,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio associado. @@ -2024,11 +2024,11 @@ def estagio(self) -> Optional[int]: return self.data[1] @estagio.setter - def estagio(self, c: int): + def estagio(self, c: int) -> None: self.data[1] = c @property - def codigo_submercado_de(self) -> Optional[str]: + def codigo_submercado_de(self) -> str | None: """ O submercado de origem conforme registros SB. @@ -2037,11 +2037,11 @@ def codigo_submercado_de(self) -> Optional[str]: return self.data[2] @codigo_submercado_de.setter - def codigo_submercado_de(self, s: str): + def codigo_submercado_de(self, s: str) -> None: self.data[2] = s @property - def codigo_submercado_para(self) -> Optional[str]: + def codigo_submercado_para(self) -> str | None: """ O submercado de destino conforme registros SB. @@ -2050,11 +2050,11 @@ def codigo_submercado_para(self) -> Optional[str]: return self.data[3] @codigo_submercado_para.setter - def codigo_submercado_para(self, s: str): + def codigo_submercado_para(self, s: str) -> None: self.data[3] = s @property - def coeficiente(self) -> Optional[float]: + def coeficiente(self) -> float | None: """ O coeficiente de participação da interligação. @@ -2063,7 +2063,7 @@ def coeficiente(self) -> Optional[float]: return self.data[4] @coeficiente.setter - def coeficiente(self, f: float): + def coeficiente(self, f: float) -> None: self.data[4] = f @@ -2072,7 +2072,7 @@ class VI(Register): Registro que contém os tempos de viagem da água entre usinas. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "VI " IDENTIFIER_DIGITS = 4 @@ -2094,10 +2094,10 @@ class VI(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -2108,7 +2108,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da UHE a partir do qual é contabilizado o tempo de viagem. @@ -2119,11 +2119,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def duracao(self) -> Optional[int]: + def duracao(self) -> int | None: """ A duração da viagem da água (em horas) entre a UHE do código informado e sua usina à jusante segundo o hidr. @@ -2134,11 +2134,11 @@ def duracao(self) -> Optional[int]: return self.data[1] @duracao.setter - def duracao(self, d: int): + def duracao(self, d: int) -> None: self.data[1] = d @property - def vazao(self) -> Optional[List[float]]: + def vazao(self) -> list[float] | None: """ As vazões defluentes das semanas passadas para a usina do código informado. A posição da vazão na lista indica @@ -2150,7 +2150,7 @@ def vazao(self) -> Optional[List[float]]: return [v for v in self.data[2::] if v is not None] @vazao.setter - def vazao(self, v: List[float]): + def vazao(self, v: list[float]) -> None: self.__atualiza_dados_lista(v, 2, 1) @@ -2160,7 +2160,7 @@ class IR(Register): geração de relatórios de saída. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "IR " IDENTIFIER_DIGITS = 4 @@ -2174,7 +2174,7 @@ class IR(Register): ) @property - def tipo(self) -> Optional[str]: + def tipo(self) -> str | None: """ Mnemônico que contém o tipo de relatório de saída escolhido. @@ -2185,7 +2185,7 @@ def tipo(self) -> Optional[str]: return self.data[0] @tipo.setter - def tipo(self, t: str): + def tipo(self, t: str) -> None: self.data[0] = t @@ -2194,7 +2194,7 @@ class CI(Register): Registro que define contratos de importação de energia. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "CI " IDENTIFIER_DIGITS = 4 @@ -2223,7 +2223,7 @@ class CE(Register): Registro que define contratos de exportação de energia. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "CE " IDENTIFIER_DIGITS = 4 @@ -2253,7 +2253,7 @@ class FC(Register): pelo NEWAVE. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "FC " IDENTIFIER_DIGITS = 4 @@ -2265,7 +2265,7 @@ class FC(Register): ) @property - def tipo(self) -> Optional[str]: + def tipo(self) -> str | None: """ O tipo de arquivo da FCF na forma dos mnemônicos aceitos pelo DECOMP. @@ -2276,7 +2276,7 @@ def tipo(self) -> Optional[str]: return self.data[0] @property - def caminho(self) -> Optional[str]: + def caminho(self) -> str | None: """ O caminho relativo ou completo para o arquivo da FCF. @@ -2287,7 +2287,7 @@ def caminho(self) -> Optional[str]: return self.data[1] @caminho.setter - def caminho(self, c: str): + def caminho(self, c: str) -> None: self.data[1] = c @@ -2296,7 +2296,7 @@ class EA(Register): Registro que a ENA dos meses que antecedem o estudo. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "EA " IDENTIFIER_DIGITS = 4 @@ -2319,10 +2319,10 @@ class EA(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -2333,7 +2333,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_ree(self) -> Optional[int]: + def codigo_ree(self) -> int | None: """ O código do REE @@ -2343,11 +2343,11 @@ def codigo_ree(self) -> Optional[int]: return self.data[0] @codigo_ree.setter - def codigo_ree(self, c: int): + def codigo_ree(self, c: int) -> None: self.data[0] = c @property - def ena(self) -> Optional[List[float]]: + def ena(self) -> list[float] | None: """ A ENA passada para o REE. @@ -2357,7 +2357,7 @@ def ena(self) -> Optional[List[float]]: return [v for v in self.data[1::] if v is not None] @ena.setter - def ena(self, c: List[float]): + def ena(self, c: list[float]) -> None: self.__atualiza_dados_lista(c, 1, 1) self.data[1:] = c @@ -2367,7 +2367,7 @@ class ES(Register): Registro que define a ENA das semanas que antecedem o estudo. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "ES " IDENTIFIER_DIGITS = 4 @@ -2385,10 +2385,10 @@ class ES(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -2399,7 +2399,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_ree(self) -> Optional[int]: + def codigo_ree(self) -> int | None: """ O código do REE @@ -2409,11 +2409,11 @@ def codigo_ree(self) -> Optional[int]: return self.data[0] @codigo_ree.setter - def codigo_ree(self, c: int): + def codigo_ree(self, c: int) -> None: self.data[0] = c @property - def numero_semanas_mes_anterior(self) -> Optional[int]: + def numero_semanas_mes_anterior(self) -> int | None: """ O número de semanas do mês anterior @@ -2423,11 +2423,11 @@ def numero_semanas_mes_anterior(self) -> Optional[int]: return self.data[1] @numero_semanas_mes_anterior.setter - def numero_semanas_mes_anterior(self, c: int): + def numero_semanas_mes_anterior(self, c: int) -> None: self.data[1] = c @property - def ena(self) -> Optional[List[float]]: + def ena(self) -> list[float] | None: """ A ENA passada para o REE. @@ -2437,7 +2437,7 @@ def ena(self) -> Optional[List[float]]: return [v for v in self.data[2::] if v is not None] @ena.setter - def ena(self, c: List[float]): + def ena(self, c: list[float]) -> None: self.__atualiza_dados_lista(c, 1, 1) self.data[2:] = c @@ -2447,7 +2447,7 @@ class QI(Register): Registro que define o tempo de viagem para o cálculo da ENA. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "QI " IDENTIFIER_DIGITS = 4 @@ -2464,10 +2464,10 @@ class QI(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -2478,7 +2478,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da UHE. @@ -2488,11 +2488,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def vazao(self) -> Optional[List[float]]: + def vazao(self) -> list[float] | None: """ As vazões incrementais para cálculo da ENA. @@ -2502,7 +2502,7 @@ def vazao(self) -> Optional[List[float]]: return [v for v in self.data[1::] if v is not None] @vazao.setter - def vazao(self, c: List[float]): + def vazao(self, c: list[float]) -> None: self.__atualiza_dados_lista(c, 1, 1) self.data[1:] = c @@ -2513,7 +2513,7 @@ class RT(Register): vertedouro e de canais de desvio. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "RT " IDENTIFIER_DIGITS = 4 @@ -2524,7 +2524,7 @@ class RT(Register): ) @property - def restricao(self) -> Optional[str]: + def restricao(self) -> str | None: """ O mnemônico da restrição removida. @@ -2534,7 +2534,7 @@ def restricao(self) -> Optional[str]: return self.data[0] @restricao.setter - def restricao(self, m: str): + def restricao(self, m: str) -> None: self.data[0] = m @@ -2577,10 +2577,10 @@ class TI(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -2591,7 +2591,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da UHE associada às taxas de irrigação @@ -2600,11 +2600,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def taxa(self) -> Optional[List[float]]: + def taxa(self) -> list[float] | None: """ As taxas de irrigação por estágio do estudo. A posição da taxa na lista indica a qual estágio @@ -2616,7 +2616,7 @@ def taxa(self) -> Optional[List[float]]: return [v for v in self.data[1::] if v is not None] @taxa.setter - def taxa(self, tx: List[float]): + def taxa(self, tx: list[float]) -> None: self.__atualiza_dados_lista(tx, 1, 1) @@ -2626,7 +2626,7 @@ class DA(Register): (desvios de água) por UHE. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "DA " IDENTIFIER_DIGITS = 4 @@ -2642,7 +2642,7 @@ class DA(Register): ) @property - def codigo_usina_retirada(self) -> Optional[int]: + def codigo_usina_retirada(self) -> int | None: """ O código da UHE a montante da qual será feita a retirada. @@ -2652,11 +2652,11 @@ def codigo_usina_retirada(self) -> Optional[int]: return self.data[0] @codigo_usina_retirada.setter - def codigo_usina_retirada(self, c: int): + def codigo_usina_retirada(self, c: int) -> None: self.data[0] = c @property - def codigo_usina_retorno(self) -> Optional[int]: + def codigo_usina_retorno(self) -> int | None: """ O código da UHE a montante da qual se derá o retorno. @@ -2666,11 +2666,11 @@ def codigo_usina_retorno(self) -> Optional[int]: return self.data[1] @codigo_usina_retorno.setter - def codigo_usina_retorno(self, c: int): + def codigo_usina_retorno(self, c: int) -> None: self.data[1] = c @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio associado à restrição DA. @@ -2680,11 +2680,11 @@ def estagio(self) -> Optional[int]: return self.data[2] @estagio.setter - def estagio(self, c: int): + def estagio(self, c: int) -> None: self.data[2] = c @property - def vazao_desviada(self) -> Optional[float]: + def vazao_desviada(self) -> float | None: """ A vazão a ser desviada em m³/s. @@ -2694,11 +2694,11 @@ def vazao_desviada(self) -> Optional[float]: return self.data[3] @vazao_desviada.setter - def vazao_desviada(self, c: float): + def vazao_desviada(self, c: float) -> None: self.data[3] = c @property - def retorno_percentual(self) -> Optional[float]: + def retorno_percentual(self) -> float | None: """ O retorno em percentual da vazão desviada. @@ -2708,11 +2708,11 @@ def retorno_percentual(self) -> Optional[float]: return self.data[4] @retorno_percentual.setter - def retorno_percentual(self, c: float): + def retorno_percentual(self, c: float) -> None: self.data[4] = c @property - def custo(self) -> Optional[float]: + def custo(self) -> float | None: """ O custo de não antedimento do desvio em $/hm³. @@ -2722,7 +2722,7 @@ def custo(self) -> Optional[float]: return self.data[5] @custo.setter - def custo(self, c: float): + def custo(self, c: float) -> None: self.data[5] = c @@ -2732,7 +2732,7 @@ class FP(Register): função de produção das usinas. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "FP " IDENTIFIER_DIGITS = 4 @@ -2755,7 +2755,7 @@ class FP(Register): ) @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da UHE associada à restrição FP. @@ -2765,11 +2765,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio associado à restrição FP. @@ -2779,11 +2779,11 @@ def estagio(self) -> Optional[int]: return self.data[1] @estagio.setter - def estagio(self, e: int): + def estagio(self, e: int) -> None: self.data[1] = e @property - def tipo_entrada_janela_turbinamento(self) -> Optional[int]: + def tipo_entrada_janela_turbinamento(self) -> int | None: """ O tipo de entrada da janela de turbinamento fornecido na restrição FP. 0 para limites em percentual da vazão turbinada @@ -2795,11 +2795,11 @@ def tipo_entrada_janela_turbinamento(self) -> Optional[int]: return self.data[2] @tipo_entrada_janela_turbinamento.setter - def tipo_entrada_janela_turbinamento(self, t: int): + def tipo_entrada_janela_turbinamento(self, t: int) -> None: self.data[2] = t @property - def numero_pontos_turbinamento(self) -> Optional[int]: + def numero_pontos_turbinamento(self) -> int | None: """ O número de pontos para discretização da janela de turbinamento. Máximo permitido de 1000 pontos. @@ -2810,11 +2810,11 @@ def numero_pontos_turbinamento(self) -> Optional[int]: return self.data[3] @numero_pontos_turbinamento.setter - def numero_pontos_turbinamento(self, n: int): + def numero_pontos_turbinamento(self, n: int) -> None: self.data[3] = n @property - def limite_inferior_janela_turbinamento(self) -> Optional[float]: + def limite_inferior_janela_turbinamento(self) -> float | None: """ O limite inferior da janela de turbinamento. @@ -2824,11 +2824,11 @@ def limite_inferior_janela_turbinamento(self) -> Optional[float]: return self.data[4] @limite_inferior_janela_turbinamento.setter - def limite_inferior_janela_turbinamento(self, lim: float): + def limite_inferior_janela_turbinamento(self, lim: float) -> None: self.data[4] = lim @property - def limite_superior_janela_turbinamento(self) -> Optional[float]: + def limite_superior_janela_turbinamento(self) -> float | None: """ O limite superior da janela de turbinamento. @@ -2838,11 +2838,11 @@ def limite_superior_janela_turbinamento(self) -> Optional[float]: return self.data[5] @limite_superior_janela_turbinamento.setter - def limite_superior_janela_turbinamento(self, lim: float): + def limite_superior_janela_turbinamento(self, lim: float) -> None: self.data[5] = lim @property - def tipo_entrada_janela_volume(self) -> Optional[int]: + def tipo_entrada_janela_volume(self) -> int | None: """ O tipo de entrada da janela de volume fornecido na restrição FP. 0 para limites em percentual do volume útil @@ -2854,11 +2854,11 @@ def tipo_entrada_janela_volume(self) -> Optional[int]: return self.data[6] @tipo_entrada_janela_volume.setter - def tipo_entrada_janela_volume(self, t: int): + def tipo_entrada_janela_volume(self, t: int) -> None: self.data[6] = t @property - def numero_pontos_volume(self) -> Optional[int]: + def numero_pontos_volume(self) -> int | None: """ O número de pontos para discretização da janela de volume. Máximo permitido de 1000 pontos. @@ -2869,11 +2869,11 @@ def numero_pontos_volume(self) -> Optional[int]: return self.data[7] @numero_pontos_volume.setter - def numero_pontos_volume(self, n: int): + def numero_pontos_volume(self, n: int) -> None: self.data[7] = n @property - def limite_inferior_janela_volume(self) -> Optional[float]: + def limite_inferior_janela_volume(self) -> float | None: """ A redução aplicada ao volume útil da usina, para ser utilizado como limite inferior da janela de volume. @@ -2884,11 +2884,11 @@ def limite_inferior_janela_volume(self) -> Optional[float]: return self.data[8] @limite_inferior_janela_volume.setter - def limite_inferior_janela_volume(self, lim: float): + def limite_inferior_janela_volume(self, lim: float) -> None: self.data[8] = lim @property - def limite_superior_janela_volume(self) -> Optional[float]: + def limite_superior_janela_volume(self) -> float | None: """ O acréscimo aplicado ao volume útil da usina, para ser utilizado como limite superior da janela de volume. @@ -2899,7 +2899,7 @@ def limite_superior_janela_volume(self) -> Optional[float]: return self.data[9] @limite_superior_janela_volume.setter - def limite_superior_janela_volume(self, lim: float): + def limite_superior_janela_volume(self, lim: float) -> None: self.data[9] = lim @@ -2909,7 +2909,7 @@ class RQ(Register): mínima histórica para cada REE. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "RQ " IDENTIFIER_DIGITS = 4 @@ -2929,10 +2929,10 @@ class RQ(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -2943,7 +2943,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_ree(self) -> Optional[int]: + def codigo_ree(self) -> int | None: """ O código do REE associado às vazões mínimas. @@ -2953,11 +2953,11 @@ def codigo_ree(self) -> Optional[int]: return self.data[0] @codigo_ree.setter - def codigo_ree(self, r: int): + def codigo_ree(self, r: int) -> None: self.data[0] = r @property - def vazao(self) -> Optional[List[float]]: + def vazao(self) -> list[float] | None: """ As vazões defluentes mínimas (percentuais) para o REE, por estágio [e1, e2, e3, ...]. @@ -2968,7 +2968,7 @@ def vazao(self) -> Optional[List[float]]: return [v for v in self.data[1:] if v is not None] @vazao.setter - def vazao(self, v: List[float]): + def vazao(self, v: list[float]) -> None: self.__atualiza_dados_lista(v, 1, 1) self.data[1:] = v @@ -2979,7 +2979,7 @@ class EZ(Register): volume útil para acoplamento. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "EZ " IDENTIFIER_DIGITS = 4 @@ -2991,7 +2991,7 @@ class EZ(Register): ) @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ Código da UHE associada, conforme registro UH. @@ -3001,11 +3001,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def volume(self) -> Optional[float]: + def volume(self) -> float | None: """ O volume útil considerado para cálculo. @@ -3015,7 +3015,7 @@ def volume(self) -> Optional[float]: return self.data[1] @volume.setter - def volume(self, u: float): + def volume(self, u: float) -> None: self.data[1] = u @@ -3024,7 +3024,7 @@ class HV(Register): Registro que contém os cadastros de restrições de volume armazenado. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "HV " IDENTIFIER_DIGITS = 4 @@ -3037,7 +3037,7 @@ class HV(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição HV. @@ -3047,11 +3047,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio_inicial(self) -> Optional[int]: + def estagio_inicial(self) -> int | None: """ O estágio inicial de consideração da restrição HV. @@ -3061,11 +3061,11 @@ def estagio_inicial(self) -> Optional[int]: return self.data[1] @estagio_inicial.setter - def estagio_inicial(self, e: int): + def estagio_inicial(self, e: int) -> None: self.data[1] = e @property - def estagio_final(self) -> Optional[int]: + def estagio_final(self) -> int | None: """ O estágio final de consideração da restrição HV. @@ -3075,7 +3075,7 @@ def estagio_final(self) -> Optional[int]: return self.data[2] @estagio_final.setter - def estagio_final(self, e: int): + def estagio_final(self, e: int) -> None: self.data[2] = e @@ -3085,7 +3085,7 @@ class LV(Register): restrições de volume armazenado. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "LV " IDENTIFIER_DIGITS = 4 @@ -3099,7 +3099,7 @@ class LV(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição HV associada aos limites @@ -3109,11 +3109,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """' O estágio de consideração dos limites. @@ -3123,11 +3123,11 @@ def estagio(self) -> Optional[int]: return self.data[1] @estagio.setter - def estagio(self, e: int): + def estagio(self, e: int) -> None: self.data[1] = e @property - def limite_inferior(self) -> Optional[float]: + def limite_inferior(self) -> float | None: """ O limite inferior para o armazenamento. @@ -3137,11 +3137,11 @@ def limite_inferior(self) -> Optional[float]: return self.data[2] @limite_inferior.setter - def limite_inferior(self, lim: float): + def limite_inferior(self, lim: float) -> None: self.data[2] = lim @property - def limite_superior(self) -> Optional[float]: + def limite_superior(self) -> float | None: """ O limite superior para o armazenamento. @@ -3151,7 +3151,7 @@ def limite_superior(self) -> Optional[float]: return self.data[3] @limite_superior.setter - def limite_superior(self, lim: float): + def limite_superior(self, lim: float) -> None: self.data[3] = lim @@ -3161,7 +3161,7 @@ class CV(Register): nas restrições de volume armazenado. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "CV " IDENTIFIER_DIGITS = 4 @@ -3176,7 +3176,7 @@ class CV(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição de volume, segundo registro HV. @@ -3185,11 +3185,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio associado. @@ -3198,11 +3198,11 @@ def estagio(self) -> Optional[int]: return self.data[1] @estagio.setter - def estagio(self, c: int): + def estagio(self, c: int) -> None: self.data[1] = c @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O número da UHE ou estação de bombeamento conforme registros UH ou UE. @@ -3211,11 +3211,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[2] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[2] = c @property - def coeficiente(self) -> Optional[float]: + def coeficiente(self) -> float | None: """ O coeficiente da variável na restrição. @@ -3224,11 +3224,11 @@ def coeficiente(self) -> Optional[float]: return self.data[3] @coeficiente.setter - def coeficiente(self, f: float): + def coeficiente(self, f: float) -> None: self.data[3] = f @property - def tipo(self) -> Optional[str]: + def tipo(self) -> str | None: """ O mnemônico de tipo da restrição. @@ -3237,7 +3237,7 @@ def tipo(self) -> Optional[str]: return self.data[4] @tipo.setter - def tipo(self, t: str): + def tipo(self, t: str) -> None: self.data[4] = t @@ -3246,7 +3246,7 @@ class HQ(Register): Registro que contém os cadastros de restrições de vazões. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "HQ " IDENTIFIER_DIGITS = 4 @@ -3259,7 +3259,7 @@ class HQ(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição HQ. @@ -3269,11 +3269,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio_inicial(self) -> Optional[int]: + def estagio_inicial(self) -> int | None: """ O estágio inicial de consideração da restrição HQ. @@ -3283,11 +3283,11 @@ def estagio_inicial(self) -> Optional[int]: return self.data[1] @estagio_inicial.setter - def estagio_inicial(self, e: int): + def estagio_inicial(self, e: int) -> None: self.data[1] = e @property - def estagio_final(self) -> Optional[int]: + def estagio_final(self) -> int | None: """ O estágio final de consideração da restrição HQ. @@ -3297,7 +3297,7 @@ def estagio_final(self) -> Optional[int]: return self.data[2] @estagio_final.setter - def estagio_final(self, e: int): + def estagio_final(self, e: int) -> None: self.data[2] = e @@ -3307,7 +3307,7 @@ class LQ(Register): restrições de vazão. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "LQ " IDENTIFIER_DIGITS = 4 @@ -3330,10 +3330,10 @@ class LQ(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -3344,7 +3344,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição HQ associada aos limites @@ -3354,11 +3354,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio de consideração dos limites. @@ -3368,11 +3368,11 @@ def estagio(self) -> Optional[int]: return self.data[1] @estagio.setter - def estagio(self, e: int): + def estagio(self, e: int) -> None: self.data[1] = e @property - def limite_inferior(self) -> Optional[List[float]]: + def limite_inferior(self) -> list[float] | None: """ O limite inferior por patamar para a vazão. @@ -3382,11 +3382,11 @@ def limite_inferior(self) -> Optional[List[float]]: return self.data[2::2] @limite_inferior.setter - def limite_inferior(self, lim: List[float]): + def limite_inferior(self, lim: list[float]) -> None: self.__atualiza_dados_lista(lim, 2, 2) @property - def limite_superior(self) -> Optional[List[float]]: + def limite_superior(self) -> list[float] | None: """ O limite superior por patamar para a vazão. @@ -3396,7 +3396,7 @@ def limite_superior(self) -> Optional[List[float]]: return self.data[3::2] @limite_superior.setter - def limite_superior(self, lim: List[float]): + def limite_superior(self, lim: list[float]) -> None: self.__atualiza_dados_lista(lim, 3, 2) @@ -3406,7 +3406,7 @@ class CQ(Register): nas restrições de vazão. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "CQ " IDENTIFIER_DIGITS = 4 @@ -3421,7 +3421,7 @@ class CQ(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição de vazão, segundo registro HQ. @@ -3430,11 +3430,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio associado. @@ -3443,11 +3443,11 @@ def estagio(self) -> Optional[int]: return self.data[1] @estagio.setter - def estagio(self, c: int): + def estagio(self, c: int) -> None: self.data[1] = c @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O número da UHE conforme registro UH. @@ -3456,11 +3456,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[2] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[2] = c @property - def coeficiente(self) -> Optional[float]: + def coeficiente(self) -> float | None: """ O coeficiente da variável na restrição. @@ -3469,11 +3469,11 @@ def coeficiente(self) -> Optional[float]: return self.data[3] @coeficiente.setter - def coeficiente(self, f: float): + def coeficiente(self, f: float) -> None: self.data[3] = f @property - def tipo(self) -> Optional[str]: + def tipo(self) -> str | None: """ O mnemônico de tipo da restrição. @@ -3482,7 +3482,7 @@ def tipo(self) -> Optional[str]: return self.data[4] @tipo.setter - def tipo(self, t: str): + def tipo(self, t: str) -> None: self.data[4] = t @@ -3491,7 +3491,7 @@ class AR(Register): Registro que contém as configurações de aversão a risco. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "AR " IDENTIFIER_DIGITS = 4 @@ -3504,7 +3504,7 @@ class AR(Register): ) @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio inicial de aplicação do CVaR. @@ -3514,11 +3514,11 @@ def estagio(self) -> Optional[int]: return self.data[0] @estagio.setter - def estagio(self, p: int): + def estagio(self, p: int) -> None: self.data[0] = p @property - def lamb(self) -> Optional[float]: + def lamb(self) -> float | None: """ O valor de lambda utilizado no CVaR. @@ -3528,11 +3528,11 @@ def lamb(self) -> Optional[float]: return self.data[1] @lamb.setter - def lamb(self, v: float): + def lamb(self, v: float) -> None: self.data[1] = v @property - def alfa(self) -> Optional[float]: + def alfa(self) -> float | None: """ O valor de alfa utilizado no CVaR. @@ -3542,7 +3542,7 @@ def alfa(self) -> Optional[float]: return self.data[2] @alfa.setter - def alfa(self, v: float): + def alfa(self, v: float) -> None: self.data[2] = v @@ -3552,7 +3552,7 @@ class EV(Register): da evaporação. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "EV " IDENTIFIER_DIGITS = 4 @@ -3564,7 +3564,7 @@ class EV(Register): ) @property - def modelo(self) -> Optional[int]: + def modelo(self) -> int | None: """ O modelo de evaporação considerado @@ -3574,11 +3574,11 @@ def modelo(self) -> Optional[int]: return self.data[0] @modelo.setter - def modelo(self, m: int): + def modelo(self, m: int) -> None: self.data[0] = m @property - def volume_referencia(self) -> Optional[str]: + def volume_referencia(self) -> str | None: """ O mnemônico para o volume considerado @@ -3588,7 +3588,7 @@ def volume_referencia(self) -> Optional[str]: return self.data[1] @volume_referencia.setter - def volume_referencia(self, v: str): + def volume_referencia(self, v: str) -> None: self.data[1] = v @@ -3597,7 +3597,7 @@ class FJ(Register): Registro que contém o arquivo de polinômios de jusante. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "FJ " IDENTIFIER_DIGITS = 4 @@ -3618,7 +3618,7 @@ def arquivo(self) -> str: return self.data[0] @arquivo.setter - def arquivo(self, a: str): + def arquivo(self, a: str) -> None: self.data[0] = a @@ -3628,7 +3628,7 @@ class HE(Register): armazenada. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "HE " IDENTIFIER_DIGITS = 4 @@ -3647,7 +3647,7 @@ class HE(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código de cadastro da restrição HE @@ -3657,11 +3657,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def tipo_limite(self) -> Optional[int]: + def tipo_limite(self) -> int | None: """ O tipo de limite especificado na restrição HE, em valor absoluto ou percentual. @@ -3672,11 +3672,11 @@ def tipo_limite(self) -> Optional[int]: return self.data[1] @tipo_limite.setter - def tipo_limite(self, t: int): + def tipo_limite(self, t: int) -> None: self.data[1] = t @property - def limite(self) -> Optional[float]: + def limite(self) -> float | None: """ O limite para a energia armazenada associada ao registro HE. @@ -3687,11 +3687,11 @@ def limite(self) -> Optional[float]: return self.data[2] @limite.setter - def limite(self, lim: float): + def limite(self, lim: float) -> None: self.data[2] = lim @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio para consideração da restrição. @@ -3701,11 +3701,11 @@ def estagio(self) -> Optional[int]: return self.data[3] @estagio.setter - def estagio(self, e: int): + def estagio(self, e: int) -> None: self.data[3] = e @property - def valor_penalidade(self) -> Optional[float]: + def valor_penalidade(self) -> float | None: """ O valor da penalidade para a violação da restrição. @@ -3715,11 +3715,11 @@ def valor_penalidade(self) -> Optional[float]: return self.data[4] @valor_penalidade.setter - def valor_penalidade(self, p: float): + def valor_penalidade(self, p: float) -> None: self.data[4] = p @property - def forma_calculo_produtibilidades(self) -> Optional[int]: + def forma_calculo_produtibilidades(self) -> int | None: """ Flag para indicar a forma de cálculo das produtividades das usinas usadas nas restrição. @@ -3730,11 +3730,11 @@ def forma_calculo_produtibilidades(self) -> Optional[int]: return self.data[5] @forma_calculo_produtibilidades.setter - def forma_calculo_produtibilidades(self, t: int): + def forma_calculo_produtibilidades(self, t: int) -> None: self.data[5] = t @property - def tipo_valores_produtibilidades(self) -> Optional[int]: + def tipo_valores_produtibilidades(self) -> int | None: """ Flag para indicar o tipo dos valores das produtividades das usinas usadas nas restrição. @@ -3745,11 +3745,11 @@ def tipo_valores_produtibilidades(self) -> Optional[int]: return self.data[6] @tipo_valores_produtibilidades.setter - def tipo_valores_produtibilidades(self, t: int): + def tipo_valores_produtibilidades(self, t: int) -> None: self.data[6] = t @property - def tipo_penalidade(self) -> Optional[int]: + def tipo_penalidade(self) -> int | None: """ O tipo de penalidade a ser considerada ao violar a restrição (inviabilidade ou penalização). @@ -3760,11 +3760,11 @@ def tipo_penalidade(self) -> Optional[int]: return self.data[7] @tipo_penalidade.setter - def tipo_penalidade(self, t: int): + def tipo_penalidade(self, t: int) -> None: self.data[7] = t @property - def arquivo_produtibilidades(self) -> Optional[str]: + def arquivo_produtibilidades(self) -> str | None: """ O arquivo com as definições das produtibilidades usadas para o cálculo da restrição RHE. @@ -3775,7 +3775,7 @@ def arquivo_produtibilidades(self) -> Optional[str]: return self.data[8] @arquivo_produtibilidades.setter - def arquivo_produtibilidades(self, t: str): + def arquivo_produtibilidades(self, t: str) -> None: self.data[8] = t @@ -3784,7 +3784,7 @@ class CM(Register): Registro que contém os coeficientes de uma restrição RHE. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "CM " IDENTIFIER_DIGITS = 4 @@ -3801,7 +3801,7 @@ def codigo_restricao(self) -> int: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property @@ -3815,7 +3815,7 @@ def codigo_ree(self) -> int: return self.data[1] @codigo_ree.setter - def codigo_ree(self, e: int): + def codigo_ree(self, e: int) -> None: self.data[1] = e @property @@ -3829,7 +3829,7 @@ def coeficiente(self) -> float: return self.data[2] @coeficiente.setter - def coeficiente(self, c: float): + def coeficiente(self, c: float) -> None: self.data[2] = c @@ -3839,7 +3839,7 @@ class PD(Register): resolução do PL. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "PD " IDENTIFIER_DIGITS = 4 @@ -3850,7 +3850,7 @@ class PD(Register): ) @property - def algoritmo(self) -> Optional[str]: + def algoritmo(self) -> str | None: """ O algoritmo considerado. @@ -3860,7 +3860,7 @@ def algoritmo(self) -> Optional[str]: return self.data[0] @algoritmo.setter - def algoritmo(self, m: str): + def algoritmo(self, m: str) -> None: self.data[0] = m @@ -3870,7 +3870,7 @@ class PU(Register): via PL único. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "PU " IDENTIFIER_DIGITS = 4 @@ -3881,7 +3881,7 @@ class PU(Register): ) @property - def pl(self) -> Optional[int]: + def pl(self) -> int | None: """ O tipo de pl considerado. @@ -3891,7 +3891,7 @@ def pl(self) -> Optional[int]: return self.data[0] @pl.setter - def pl(self, m: int): + def pl(self, m: int) -> None: self.data[0] = m @@ -3900,7 +3900,7 @@ class RC(Register): Registro que inclui restrições do tipo escada. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "RC " IDENTIFIER_DIGITS = 4 @@ -3911,7 +3911,7 @@ class RC(Register): ) @property - def mnemonico(self) -> Optional[str]: + def mnemonico(self) -> str | None: """ O tipo de mnemonico considerado. @@ -3921,7 +3921,7 @@ def mnemonico(self) -> Optional[str]: return self.data[0] @mnemonico.setter - def mnemonico(self, m: str): + def mnemonico(self, m: str) -> None: self.data[0] = m @@ -3931,7 +3931,7 @@ class PE(Register): intercâmbio e desvios. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "PE " IDENTIFIER_DIGITS = 4 @@ -3944,7 +3944,7 @@ class PE(Register): ) @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O código do submercado considerado @@ -3954,11 +3954,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[0] @codigo_submercado.setter - def codigo_submercado(self, m: int): + def codigo_submercado(self, m: int) -> None: self.data[0] = m @property - def tipo(self) -> Optional[int]: + def tipo(self) -> int | None: """ O tipo de penalidade a ser modificado @@ -3968,11 +3968,11 @@ def tipo(self) -> Optional[int]: return self.data[1] @tipo.setter - def tipo(self, m: int): + def tipo(self, m: int) -> None: self.data[1] = m @property - def penalidade(self) -> Optional[float]: + def penalidade(self) -> float | None: """ O novo valor de penalidade @@ -3982,7 +3982,7 @@ def penalidade(self) -> Optional[float]: return self.data[2] @penalidade.setter - def penalidade(self, m: float): + def penalidade(self, m: float) -> None: self.data[2] = m @@ -3991,7 +3991,7 @@ class TS(Register): Registro que altera as tolerâncias do solver. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "TS " IDENTIFIER_DIGITS = 4 @@ -4005,7 +4005,7 @@ class TS(Register): ) @property - def tolerancia_primaria(self) -> Optional[float]: + def tolerancia_primaria(self) -> float | None: """ A nova tolerância primária do solver. @@ -4015,11 +4015,11 @@ def tolerancia_primaria(self) -> Optional[float]: return self.data[0] @tolerancia_primaria.setter - def tolerancia_primaria(self, m: float): + def tolerancia_primaria(self, m: float) -> None: self.data[0] = m @property - def tolerancia_secundaria(self) -> Optional[float]: + def tolerancia_secundaria(self) -> float | None: """ A nova tolerância secundária do solver. @@ -4029,11 +4029,11 @@ def tolerancia_secundaria(self) -> Optional[float]: return self.data[1] @tolerancia_secundaria.setter - def tolerancia_secundaria(self, m: float): + def tolerancia_secundaria(self, m: float) -> None: self.data[1] = m @property - def zera_coeficientes(self) -> Optional[int]: + def zera_coeficientes(self) -> int | None: """ Habilita ou não a funcionalidade de zerar coeficientes em casos de cortes não ótimos. @@ -4044,11 +4044,11 @@ def zera_coeficientes(self) -> Optional[int]: return self.data[2] @zera_coeficientes.setter - def zera_coeficientes(self, m: int): + def zera_coeficientes(self, m: int) -> None: self.data[2] = m @property - def tolerancia_teste_otimalidade(self) -> Optional[float]: + def tolerancia_teste_otimalidade(self) -> float | None: """ A nova tolerância usada no teste de otimalidade da solução do PL. @@ -4059,7 +4059,7 @@ def tolerancia_teste_otimalidade(self) -> Optional[float]: return self.data[3] @tolerancia_teste_otimalidade.setter - def tolerancia_teste_otimalidade(self, m: float): + def tolerancia_teste_otimalidade(self, m: float) -> None: self.data[3] = m @@ -4069,7 +4069,7 @@ class PV(Register): do problema e as tolerâncias para a viabilidade das restrições. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "PV " IDENTIFIER_DIGITS = 4 @@ -4085,7 +4085,7 @@ class PV(Register): ) @property - def penalidade_variaveis_folga(self) -> Optional[float]: + def penalidade_variaveis_folga(self) -> float | None: """ A nova penalidade para as variáveis de folga (R$/MWh). @@ -4095,11 +4095,11 @@ def penalidade_variaveis_folga(self) -> Optional[float]: return self.data[0] @penalidade_variaveis_folga.setter - def penalidade_variaveis_folga(self, m: float): + def penalidade_variaveis_folga(self, m: float) -> None: self.data[0] = m @property - def tolerancia_viabilidade_restricoes(self) -> Optional[float]: + def tolerancia_viabilidade_restricoes(self) -> float | None: """ A nova tolerância para a viabilidade das restrições. @@ -4109,11 +4109,11 @@ def tolerancia_viabilidade_restricoes(self) -> Optional[float]: return self.data[1] @tolerancia_viabilidade_restricoes.setter - def tolerancia_viabilidade_restricoes(self, m: float): + def tolerancia_viabilidade_restricoes(self, m: float) -> None: self.data[1] = m @property - def iteracoes_atualizacao_penalidade(self) -> Optional[int]: + def iteracoes_atualizacao_penalidade(self) -> int | None: """ O número de iterações para atualização da penalidade variável iterativa para as folgas. @@ -4124,11 +4124,11 @@ def iteracoes_atualizacao_penalidade(self) -> Optional[int]: return self.data[2] @iteracoes_atualizacao_penalidade.setter - def iteracoes_atualizacao_penalidade(self, m: int): + def iteracoes_atualizacao_penalidade(self, m: int) -> None: self.data[2] = m @property - def fator_multiplicacao_folga(self) -> Optional[float]: + def fator_multiplicacao_folga(self) -> float | None: """ O fator para multiplicação da folga ao longo das restrições. @@ -4138,11 +4138,11 @@ def fator_multiplicacao_folga(self) -> Optional[float]: return self.data[3] @fator_multiplicacao_folga.setter - def fator_multiplicacao_folga(self, m: float): + def fator_multiplicacao_folga(self, m: float) -> None: self.data[3] = m @property - def valor_inicial_variaveis_folga(self) -> Optional[float]: + def valor_inicial_variaveis_folga(self) -> float | None: """ O valor inicial ou mínimo para as variáveis de folga. @@ -4152,11 +4152,11 @@ def valor_inicial_variaveis_folga(self) -> Optional[float]: return self.data[4] @valor_inicial_variaveis_folga.setter - def valor_inicial_variaveis_folga(self, m: float): + def valor_inicial_variaveis_folga(self, m: float) -> None: self.data[4] = m @property - def valor_final_variaveis_folga(self) -> Optional[float]: + def valor_final_variaveis_folga(self) -> float | None: """ O valor final ou máximo para as variáveis de folga. @@ -4166,7 +4166,7 @@ def valor_final_variaveis_folga(self) -> Optional[float]: return self.data[5] @valor_final_variaveis_folga.setter - def valor_final_variaveis_folga(self, m: float): + def valor_final_variaveis_folga(self, m: float) -> None: self.data[5] = m @@ -4176,7 +4176,7 @@ class CX(Register): complexos no NEWAVE com o DECOMP. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "CX " IDENTIFIER_DIGITS = 4 @@ -4188,7 +4188,7 @@ class CX(Register): ) @property - def codigo_newave(self) -> Optional[int]: + def codigo_newave(self) -> int | None: """ O código da usina no NEWAVE @@ -4198,11 +4198,11 @@ def codigo_newave(self) -> Optional[int]: return self.data[0] @codigo_newave.setter - def codigo_newave(self, m: int): + def codigo_newave(self, m: int) -> None: self.data[0] = m @property - def codigo_decomp(self) -> Optional[int]: + def codigo_decomp(self) -> int | None: """ O código da usina no DECOMP @@ -4212,7 +4212,7 @@ def codigo_decomp(self) -> Optional[int]: return self.data[1] @codigo_decomp.setter - def codigo_decomp(self, m: int): + def codigo_decomp(self, m: int) -> None: self.data[1] = m @@ -4221,7 +4221,7 @@ class FA(Register): Registro que indica o nome do arquivo índice CSV. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "FA " IDENTIFIER_DIGITS = 4 @@ -4232,7 +4232,7 @@ class FA(Register): ) @property - def arquivo(self) -> Optional[str]: + def arquivo(self) -> str | None: """ O nome do arquivo índice CSV. @@ -4242,7 +4242,7 @@ def arquivo(self) -> Optional[str]: return self.data[0] @arquivo.setter - def arquivo(self, m: str): + def arquivo(self, m: str) -> None: self.data[0] = m @@ -4251,7 +4251,7 @@ class VT(Register): Registro que indica o nome do arquivo com cenários de vento. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "VT " IDENTIFIER_DIGITS = 4 @@ -4262,7 +4262,7 @@ class VT(Register): ) @property - def arquivo(self) -> Optional[str]: + def arquivo(self) -> str | None: """ O nome do arquivo com cenários de vento. @@ -4272,7 +4272,7 @@ def arquivo(self) -> Optional[str]: return self.data[0] @arquivo.setter - def arquivo(self, m: str): + def arquivo(self, m: str) -> None: self.data[0] = m @@ -4281,7 +4281,7 @@ class CS(Register): Registro que habilita a consistência de dados. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "CS " IDENTIFIER_DIGITS = 4 @@ -4292,7 +4292,7 @@ class CS(Register): ) @property - def consistencia(self) -> Optional[int]: + def consistencia(self) -> int | None: """ Habilita ou não a consistência de dados. @@ -4302,7 +4302,7 @@ def consistencia(self) -> Optional[int]: return self.data[0] @consistencia.setter - def consistencia(self, m: int): + def consistencia(self, m: int) -> None: self.data[0] = m @@ -4311,7 +4311,7 @@ class ACNUMPOS(Register): Registro AC específico para alteração no número do posto. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) NUMPOS" IDENTIFIER_DIGITS = 15 @@ -4326,7 +4326,9 @@ class ACNUMPOS(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -4338,43 +4340,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def codigo_posto(self) -> Optional[int]: + def codigo_posto(self) -> int | None: return self.data[1] @codigo_posto.setter - def codigo_posto(self, u: int): + def codigo_posto(self, u: int) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -4383,7 +4385,7 @@ class ACNUMJUS(Register): Registro AC específico para alteração na usina de jusante. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) NUMJUS" IDENTIFIER_DIGITS = 15 @@ -4398,7 +4400,9 @@ class ACNUMJUS(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -4410,7 +4414,7 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O número da UHE conforme registro UH. @@ -4419,11 +4423,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def codigo_usina_jusante(self) -> Optional[int]: + def codigo_usina_jusante(self) -> int | None: """ O número da UHE de jusante conforme registro UH. @@ -4432,11 +4436,11 @@ def codigo_usina_jusante(self) -> Optional[int]: return self.data[1] @codigo_usina_jusante.setter - def codigo_usina_jusante(self, u: int): + def codigo_usina_jusante(self, u: int) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: """ O mês de validade da alteração de cadastro. @@ -4445,11 +4449,11 @@ def mes(self) -> Optional[str]: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: """ A semana de validade da alteração de cadastro. @@ -4458,11 +4462,11 @@ def semana(self) -> Optional[int]: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: """ O ano de validade da alteração de cadastro. @@ -4471,7 +4475,7 @@ def ano(self) -> Optional[int]: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -4481,7 +4485,7 @@ class ACDESVIO(Register): para canal de desvio e limite da vazão no canal. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) DESVIO" IDENTIFIER_DIGITS = 15 @@ -4497,7 +4501,9 @@ class ACDESVIO(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -4509,51 +4515,51 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def codigo_usina_jusante(self) -> Optional[int]: + def codigo_usina_jusante(self) -> int | None: return self.data[1] @codigo_usina_jusante.setter - def codigo_usina_jusante(self, u: int): + def codigo_usina_jusante(self, u: int) -> None: self.data[1] = u @property - def limite_vazao(self) -> Optional[float]: + def limite_vazao(self) -> float | None: return self.data[2] @limite_vazao.setter - def limite_vazao(self, u: float): + def limite_vazao(self, u: float) -> None: self.data[2] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -4562,7 +4568,7 @@ class ACVOLMIN(Register): Registro AC específico para alteração de volume mínimo. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) VOLMIN" IDENTIFIER_DIGITS = 15 @@ -4577,7 +4583,9 @@ class ACVOLMIN(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -4589,43 +4597,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def volume(self) -> Optional[float]: + def volume(self) -> float | None: return self.data[1] @volume.setter - def volume(self, u: float): + def volume(self, u: float) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -4634,7 +4642,7 @@ class ACVOLMAX(Register): Registro AC específico para alteração de volume máximo. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) VOLMAX" IDENTIFIER_DIGITS = 15 @@ -4649,7 +4657,9 @@ class ACVOLMAX(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -4661,43 +4671,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def volume(self) -> Optional[float]: + def volume(self) -> float | None: return self.data[1] @volume.setter - def volume(self, u: float): + def volume(self, u: float) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -4707,7 +4717,7 @@ class ACCOTVOL(Register): polinômio cota-volume. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) COTVOL" IDENTIFIER_DIGITS = 15 @@ -4723,7 +4733,9 @@ class ACCOTVOL(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -4735,51 +4747,51 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def ordem(self) -> Optional[int]: + def ordem(self) -> int | None: return self.data[1] @ordem.setter - def ordem(self, u: int): + def ordem(self, u: int) -> None: self.data[1] = u @property - def coeficiente(self) -> Optional[float]: + def coeficiente(self) -> float | None: return self.data[2] @coeficiente.setter - def coeficiente(self, u: float): + def coeficiente(self, u: float) -> None: self.data[2] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -4789,7 +4801,7 @@ class ACCOTARE(Register): polinômio cota-área. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) COTARE" IDENTIFIER_DIGITS = 15 @@ -4797,7 +4809,7 @@ class ACCOTARE(Register): [ IntegerField(3, 4), IntegerField(5, 19), - FloatField(15, 24, 8, 'D'), + FloatField(15, 24, 8, "D"), LiteralField(3, 69), IntegerField(2, 73), IntegerField(4, 76), @@ -4805,7 +4817,9 @@ class ACCOTARE(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -4817,51 +4831,51 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def ordem(self) -> Optional[int]: + def ordem(self) -> int | None: return self.data[1] @ordem.setter - def ordem(self, u: int): + def ordem(self, u: int) -> None: self.data[1] = u @property - def coeficiente(self) -> Optional[float]: + def coeficiente(self) -> float | None: return self.data[2] @coeficiente.setter - def coeficiente(self, u: float): + def coeficiente(self, u: float) -> None: self.data[2] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -4871,7 +4885,7 @@ class ACPROESP(Register): hidráulicas em função da queda bruta (%,m,k). """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) PROESP" IDENTIFIER_DIGITS = 15 @@ -4886,7 +4900,9 @@ class ACPROESP(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -4898,43 +4914,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def produtibilidade(self) -> Optional[float]: + def produtibilidade(self) -> float | None: return self.data[1] @produtibilidade.setter - def produtibilidade(self, u: float): + def produtibilidade(self, u: float) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -4944,7 +4960,7 @@ class ACPERHID(Register): hidráulicas em função da queda bruta (%,m,k). """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) PERHID" IDENTIFIER_DIGITS = 15 @@ -4959,7 +4975,9 @@ class ACPERHID(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -4971,43 +4989,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def coeficiente(self) -> Optional[float]: + def coeficiente(self) -> float | None: return self.data[1] @coeficiente.setter - def coeficiente(self, u: float): + def coeficiente(self, u: float) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5017,7 +5035,7 @@ class ACNCHAVE(Register): (cota-vazão) e nível de jusante da faixa associada (m). """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) NCHAVE" IDENTIFIER_DIGITS = 15 @@ -5033,7 +5051,9 @@ class ACNCHAVE(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5045,51 +5065,51 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def numero_curva(self) -> Optional[int]: + def numero_curva(self) -> int | None: return self.data[1] @numero_curva.setter - def numero_curva(self, u: int): + def numero_curva(self, u: int) -> None: self.data[1] = u @property - def nivel(self) -> Optional[float]: + def nivel(self) -> float | None: return self.data[2] @nivel.setter - def nivel(self, u: float): + def nivel(self, u: float) -> None: self.data[2] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5099,7 +5119,7 @@ class ACCOTVAZ(Register): polinômio cota-vazão. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) COTVAZ" IDENTIFIER_DIGITS = 15 @@ -5116,7 +5136,9 @@ class ACCOTVAZ(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5128,59 +5150,59 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def indice_polimonio(self) -> Optional[int]: + def indice_polimonio(self) -> int | None: return self.data[1] @indice_polimonio.setter - def indice_polimonio(self, u: int): + def indice_polimonio(self, u: int) -> None: self.data[1] = u @property - def ordem(self) -> Optional[int]: + def ordem(self) -> int | None: return self.data[2] @ordem.setter - def ordem(self, u: int): + def ordem(self, u: int) -> None: self.data[2] = u @property - def coeficiente(self) -> Optional[float]: + def coeficiente(self) -> float | None: return self.data[3] @coeficiente.setter - def coeficiente(self, u: float): + def coeficiente(self, u: float) -> None: self.data[3] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5190,7 +5212,7 @@ class ACCOFEVA(Register): mensal para cada mês. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) COFEVA" IDENTIFIER_DIGITS = 15 @@ -5206,7 +5228,9 @@ class ACCOFEVA(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5218,51 +5242,51 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def mes_coeficiente(self) -> Optional[int]: + def mes_coeficiente(self) -> int | None: return self.data[1] @mes_coeficiente.setter - def mes_coeficiente(self, u: int): + def mes_coeficiente(self, u: int) -> None: self.data[1] = u @property - def coeficiente(self) -> Optional[int]: + def coeficiente(self) -> int | None: return self.data[2] @coeficiente.setter - def coeficiente(self, u: int): + def coeficiente(self, u: int) -> None: self.data[2] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5272,7 +5296,7 @@ class ACNUMCON(Register): de máquinas. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) NUMCON" IDENTIFIER_DIGITS = 15 @@ -5287,7 +5311,9 @@ class ACNUMCON(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5299,43 +5325,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def numero_conjuntos(self) -> Optional[int]: + def numero_conjuntos(self) -> int | None: return self.data[1] @numero_conjuntos.setter - def numero_conjuntos(self, u: int): + def numero_conjuntos(self, u: int) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5345,7 +5371,7 @@ class ACNUMMAQ(Register): em cada conjunto de máquinas. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) NUMMAQ" IDENTIFIER_DIGITS = 15 @@ -5361,7 +5387,9 @@ class ACNUMMAQ(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5373,51 +5401,51 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def indice_conjunto(self) -> Optional[int]: + def indice_conjunto(self) -> int | None: return self.data[1] @indice_conjunto.setter - def indice_conjunto(self, u: int): + def indice_conjunto(self, u: int) -> None: self.data[1] = u @property - def numero_maquinas(self) -> Optional[int]: + def numero_maquinas(self) -> int | None: return self.data[2] @numero_maquinas.setter - def numero_maquinas(self, u: int): + def numero_maquinas(self, u: int) -> None: self.data[2] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5427,7 +5455,7 @@ class ACPOTEFE(Register): por unidade geradora em um conjunto de máquinas. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) POTEFE" IDENTIFIER_DIGITS = 15 @@ -5443,7 +5471,9 @@ class ACPOTEFE(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5455,51 +5485,51 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def indice_conjunto(self) -> Optional[int]: + def indice_conjunto(self) -> int | None: return self.data[1] @indice_conjunto.setter - def indice_conjunto(self, u: int): + def indice_conjunto(self, u: int) -> None: self.data[1] = u @property - def potencia(self) -> Optional[float]: + def potencia(self) -> float | None: return self.data[2] @potencia.setter - def potencia(self, u: float): + def potencia(self, u: float) -> None: self.data[2] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5509,7 +5539,7 @@ class ACALTEFE(Register): de queda para um conjunto de máquinas. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) ALTEFE" IDENTIFIER_DIGITS = 15 @@ -5525,7 +5555,9 @@ class ACALTEFE(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5537,35 +5569,35 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5575,7 +5607,7 @@ class ACVAZEFE(Register): para um conjunto de máquinas. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) VAZEFE" IDENTIFIER_DIGITS = 15 @@ -5591,7 +5623,9 @@ class ACVAZEFE(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5603,51 +5637,51 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def indice_conjunto(self) -> Optional[int]: + def indice_conjunto(self) -> int | None: return self.data[1] @indice_conjunto.setter - def indice_conjunto(self, u: int): + def indice_conjunto(self, u: int) -> None: self.data[1] = u @property - def vazao(self) -> Optional[int]: + def vazao(self) -> int | None: return self.data[2] @vazao.setter - def vazao(self, u: int): + def vazao(self, u: int) -> None: self.data[2] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5657,7 +5691,7 @@ class ACJUSMED(Register): de fuga em metros. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) JUSMED" IDENTIFIER_DIGITS = 15 @@ -5672,7 +5706,9 @@ class ACJUSMED(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5684,43 +5720,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def cota(self) -> Optional[float]: + def cota(self) -> float | None: return self.data[1] @cota.setter - def cota(self, u: float): + def cota(self, u: float) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5730,7 +5766,7 @@ class ACVERTJU(Register): no canal de fuga. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) VERTJU" IDENTIFIER_DIGITS = 15 @@ -5745,7 +5781,9 @@ class ACVERTJU(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5757,43 +5795,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def considera_influencia(self) -> Optional[int]: + def considera_influencia(self) -> int | None: return self.data[1] @considera_influencia.setter - def considera_influencia(self, u: int): + def considera_influencia(self, u: int) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5802,7 +5840,7 @@ class ACVAZMIN(Register): Registro AC específico para alteração da vazão mínima. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) VAZMIN" IDENTIFIER_DIGITS = 15 @@ -5817,7 +5855,9 @@ class ACVAZMIN(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5829,43 +5869,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def vazao(self) -> Optional[int]: + def vazao(self) -> int | None: return self.data[1] @vazao.setter - def vazao(self, u: int): + def vazao(self, u: int) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5874,7 +5914,7 @@ class ACTIPERH(Register): Registro AC específico para alteração do tipo de perdas hidráulicas. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) TIPERH" IDENTIFIER_DIGITS = 15 @@ -5889,7 +5929,9 @@ class ACTIPERH(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5901,43 +5943,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def tipo_perda(self) -> Optional[int]: + def tipo_perda(self) -> int | None: return self.data[1] @tipo_perda.setter - def tipo_perda(self, u: int): + def tipo_perda(self, u: int) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -5948,7 +5990,7 @@ class ACJUSENA(Register): armazenada e afluente. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) JUSENA" IDENTIFIER_DIGITS = 15 @@ -5963,7 +6005,9 @@ class ACJUSENA(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -5975,43 +6019,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def codigo_usina_jusante(self) -> Optional[int]: + def codigo_usina_jusante(self) -> int | None: return self.data[1] @codigo_usina_jusante.setter - def codigo_usina_jusante(self, u: int): + def codigo_usina_jusante(self, u: int) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -6021,7 +6065,7 @@ class ACVSVERT(Register): do vertedor. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) VSVERT" IDENTIFIER_DIGITS = 15 @@ -6036,7 +6080,9 @@ class ACVSVERT(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -6048,43 +6094,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def volume(self) -> Optional[float]: + def volume(self) -> float | None: return self.data[1] @volume.setter - def volume(self, u: float): + def volume(self, u: float) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -6094,7 +6140,7 @@ class ACVMDESV(Register): do canal de desvio. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) VMDESV" IDENTIFIER_DIGITS = 15 @@ -6109,7 +6155,9 @@ class ACVMDESV(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -6121,43 +6169,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def volume(self) -> Optional[float]: + def volume(self) -> float | None: return self.data[1] @volume.setter - def volume(self, u: float): + def volume(self, u: float) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -6167,7 +6215,7 @@ class ACNPOSNW(Register): com o NEWAVE. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = r"AC ([\d ]{1,3}) NPOSNW" IDENTIFIER_DIGITS = 15 @@ -6182,7 +6230,9 @@ class ACNPOSNW(Register): ) # Override - def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: + def write( + self, file: IO[Any], storage: str = "", *args: Any, **kwargs: Any + ) -> bool: line = self.__class__.LINE.write(self.data) line = ( self.__class__.IDENTIFIER[:2] # type: ignore @@ -6194,43 +6244,43 @@ def write(self, file: IO, storage: str = "", *args, **kwargs) -> bool: return True @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: return self.data[0] @codigo_usina.setter - def codigo_usina(self, u: int): + def codigo_usina(self, u: int) -> None: self.data[0] = u @property - def codigo_posto(self) -> Optional[int]: + def codigo_posto(self) -> int | None: return self.data[1] @codigo_posto.setter - def codigo_posto(self, u: int): + def codigo_posto(self, u: int) -> None: self.data[1] = u @property - def mes(self) -> Optional[str]: + def mes(self) -> str | None: return self.data[-3] @mes.setter - def mes(self, m: str): + def mes(self, m: str) -> None: self.data[-3] = m @property - def semana(self) -> Optional[int]: + def semana(self) -> int | None: return self.data[-2] @semana.setter - def semana(self, s: int): + def semana(self, s: int) -> None: self.data[-2] = s @property - def ano(self) -> Optional[int]: + def ano(self) -> int | None: return self.data[-1] @ano.setter - def ano(self, m: int): + def ano(self, m: int) -> None: self.data[-1] = m @@ -6240,7 +6290,7 @@ class VL(Register): na cota de jusante. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "VL " IDENTIFIER_DIGITS = 4 @@ -6267,7 +6317,7 @@ class VL(Register): ) @property - def codigo_usina_influenciada(self) -> Optional[int]: + def codigo_usina_influenciada(self) -> int | None: """ O código da UHE influenciada. @@ -6277,11 +6327,11 @@ def codigo_usina_influenciada(self) -> Optional[int]: return self.data[0] @codigo_usina_influenciada.setter - def codigo_usina_influenciada(self, c: int): + def codigo_usina_influenciada(self, c: int) -> None: self.data[0] = c @property - def fator_impacto_defluencia(self) -> Optional[float]: + def fator_impacto_defluencia(self) -> float | None: """ O fator de impacto referente a defluência da usina influenciada. @@ -6291,11 +6341,11 @@ def fator_impacto_defluencia(self) -> Optional[float]: return self.data[1] @fator_impacto_defluencia.setter - def fator_impacto_defluencia(self, c: float): + def fator_impacto_defluencia(self, c: float) -> None: self.data[1] = c @property - def coeficiente_a0(self) -> Optional[float]: + def coeficiente_a0(self) -> float | None: """ O coeficiente de grau 0 do polinômio de jusante. @@ -6305,11 +6355,11 @@ def coeficiente_a0(self) -> Optional[float]: return self.data[2] @coeficiente_a0.setter - def coeficiente_a0(self, c: float): + def coeficiente_a0(self, c: float) -> None: self.data[2] = c @property - def coeficiente_a1(self) -> Optional[float]: + def coeficiente_a1(self) -> float | None: """ O coeficiente de grau 1 do polinômio de jusante. @@ -6319,11 +6369,11 @@ def coeficiente_a1(self) -> Optional[float]: return self.data[3] @coeficiente_a1.setter - def coeficiente_a1(self, c: float): + def coeficiente_a1(self, c: float) -> None: self.data[3] = c @property - def coeficiente_a2(self) -> Optional[float]: + def coeficiente_a2(self) -> float | None: """ O coeficiente de grau 2 do polinômio de jusante. @@ -6333,11 +6383,11 @@ def coeficiente_a2(self) -> Optional[float]: return self.data[4] @coeficiente_a2.setter - def coeficiente_a2(self, c: float): + def coeficiente_a2(self, c: float) -> None: self.data[4] = c @property - def coeficiente_a3(self) -> Optional[float]: + def coeficiente_a3(self) -> float | None: """ O coeficiente de grau 3 do polinômio de jusante. @@ -6347,11 +6397,11 @@ def coeficiente_a3(self) -> Optional[float]: return self.data[5] @coeficiente_a3.setter - def coeficiente_a3(self, c: float): + def coeficiente_a3(self, c: float) -> None: self.data[5] = c @property - def coeficiente_a4(self) -> Optional[float]: + def coeficiente_a4(self) -> float | None: """ O coeficiente de grau 4 do polinômio de jusante. @@ -6361,7 +6411,7 @@ def coeficiente_a4(self) -> Optional[float]: return self.data[6] @coeficiente_a4.setter - def coeficiente_a4(self, c: float): + def coeficiente_a4(self, c: float) -> None: self.data[6] = c @@ -6371,7 +6421,7 @@ class VU(Register): jusante da primeira. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "VU " IDENTIFIER_DIGITS = 4 @@ -6384,7 +6434,7 @@ class VU(Register): ) @property - def codigo_usina_influenciada(self) -> Optional[int]: + def codigo_usina_influenciada(self) -> int | None: """ O código da UHE influenciada. @@ -6394,11 +6444,11 @@ def codigo_usina_influenciada(self) -> Optional[int]: return self.data[0] @codigo_usina_influenciada.setter - def codigo_usina_influenciada(self, c: int): + def codigo_usina_influenciada(self, c: int) -> None: self.data[0] = c @property - def codigo_usina_influenciadora(self) -> Optional[int]: + def codigo_usina_influenciadora(self) -> int | None: """ O código da UHE cuja vazão defluente influencia lateralmente. @@ -6409,11 +6459,11 @@ def codigo_usina_influenciadora(self) -> Optional[int]: return self.data[1] @codigo_usina_influenciadora.setter - def codigo_usina_influenciadora(self, c: int): + def codigo_usina_influenciadora(self, c: int) -> None: self.data[1] = c @property - def fator_impacto_defluencia(self) -> Optional[float]: + def fator_impacto_defluencia(self) -> float | None: """ O fator de impacto referente a defluência da usina influenciadora. @@ -6423,7 +6473,7 @@ def fator_impacto_defluencia(self) -> Optional[float]: return self.data[2] @fator_impacto_defluencia.setter - def fator_impacto_defluencia(self, c: float): + def fator_impacto_defluencia(self, c: float) -> None: self.data[2] = c @@ -6433,7 +6483,7 @@ class VA(Register): jusante da primeira. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "VA " IDENTIFIER_DIGITS = 4 @@ -6446,7 +6496,7 @@ class VA(Register): ) @property - def codigo_usina_influenciada(self) -> Optional[int]: + def codigo_usina_influenciada(self) -> int | None: """ O código da UHE influenciada. @@ -6456,11 +6506,11 @@ def codigo_usina_influenciada(self) -> Optional[int]: return self.data[0] @codigo_usina_influenciada.setter - def codigo_usina_influenciada(self, c: int): + def codigo_usina_influenciada(self, c: int) -> None: self.data[0] = c @property - def codigo_posto_influenciador(self) -> Optional[int]: + def codigo_posto_influenciador(self) -> int | None: """ O código do posto cuja vazão incremental influencia lateralmente. @@ -6471,11 +6521,11 @@ def codigo_posto_influenciador(self) -> Optional[int]: return self.data[1] @codigo_posto_influenciador.setter - def codigo_posto_influenciador(self, c: int): + def codigo_posto_influenciador(self, c: int) -> None: self.data[1] = c @property - def fator_impacto_incremental(self) -> Optional[float]: + def fator_impacto_incremental(self) -> float | None: """ O fator de impacto referente a incremental do posto influenciador. @@ -6485,5 +6535,5 @@ def fator_impacto_incremental(self) -> Optional[float]: return self.data[2] @fator_impacto_incremental.setter - def fator_impacto_incremental(self, c: float): + def fator_impacto_incremental(self, c: float) -> None: self.data[2] = c diff --git a/idecomp/decomp/modelos/dadgnl.py b/idecomp/decomp/modelos/dadgnl.py index 318ff2e7..67247970 100644 --- a/idecomp/decomp/modelos/dadgnl.py +++ b/idecomp/decomp/modelos/dadgnl.py @@ -1,10 +1,10 @@ -from cfinterface.components.register import Register -from cfinterface.components.line import Line +from typing import Any + +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - -from typing import List, Optional +from cfinterface.components.register import Register class TG(Register): @@ -12,7 +12,7 @@ class TG(Register): Registro que contém o cadastro das térmicas a GNL """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "TG " IDENTIFIER_DIGITS = 4 @@ -42,10 +42,10 @@ class TG(Register): def __atualiza_dados_lista( self, - novos_dados: list, + novos_dados: list[Any], indice_inicial: int, espacamento: int, - ): + ) -> None: atuais = len(self.data) ultimo_indice = indice_inicial + espacamento * len(novos_dados) diferenca = (ultimo_indice - atuais) // espacamento @@ -56,7 +56,7 @@ def __atualiza_dados_lista( self.data[indice_inicial::espacamento] = novos_dados @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código de cadastro da UTE. @@ -66,11 +66,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O código do submercado de cadastro da UTE. @@ -79,11 +79,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[1] @codigo_submercado.setter - def codigo_submercado(self, c: int): + def codigo_submercado(self, c: int) -> None: self.data[1] = c @property - def nome(self) -> Optional[str]: + def nome(self) -> str | None: """ O nome de cadastro da UTE. @@ -93,11 +93,11 @@ def nome(self) -> Optional[str]: return self.data[2] @nome.setter - def nome(self, nome: str): + def nome(self, nome: str) -> None: self.data[2] = nome @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio do despacho da UTE. @@ -107,11 +107,11 @@ def estagio(self) -> Optional[int]: return self.data[3] @estagio.setter - def estagio(self, estagio: int): + def estagio(self, estagio: int) -> None: self.data[3] = estagio @property - def inflexibilidade(self) -> List[float]: + def inflexibilidade(self) -> list[float]: """ A inflexibilidade da UTE por patamar. @@ -121,11 +121,11 @@ def inflexibilidade(self) -> List[float]: return [v for v in self.data[4::3] if v is not None] @inflexibilidade.setter - def inflexibilidade(self, inflex: List[float]): + def inflexibilidade(self, inflex: list[float]) -> None: self.__atualiza_dados_lista(inflex, 4, 3) @property - def disponibilidade(self) -> List[float]: + def disponibilidade(self) -> list[float]: """ A disponibilidade da UTE por patamar. @@ -135,11 +135,11 @@ def disponibilidade(self) -> List[float]: return [v for v in self.data[5::3] if v is not None] @disponibilidade.setter - def disponibilidade(self, disp: List[float]): + def disponibilidade(self, disp: list[float]) -> None: self.__atualiza_dados_lista(disp, 5, 3) @property - def cvu(self) -> List[float]: + def cvu(self) -> list[float]: """ Os CVUs da UTE por patamar. @@ -149,7 +149,7 @@ def cvu(self) -> List[float]: return [v for v in self.data[6::3] if v is not None] @cvu.setter - def cvu(self, cvu: List[float]): + def cvu(self, cvu: list[float]) -> None: self.__atualiza_dados_lista(cvu, 6, 3) @@ -159,7 +159,7 @@ class GS(Register): no estudo. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "GS " IDENTIFIER_DIGITS = 4 @@ -171,7 +171,7 @@ class GS(Register): ) @property - def mes(self) -> Optional[int]: + def mes(self) -> int | None: """ O índice do mês associado ao registro GS @@ -181,11 +181,11 @@ def mes(self) -> Optional[int]: return self.data[0] @mes.setter - def mes(self, m: int): + def mes(self, m: int) -> None: self.data[0] = m @property - def semanas(self) -> Optional[int]: + def semanas(self) -> int | None: """ O número de semanas do mês associado ao registro GS @@ -195,7 +195,7 @@ def semanas(self) -> Optional[int]: return self.data[1] @semanas.setter - def semanas(self, s: int): + def semanas(self, s: int) -> None: self.data[1] = s @@ -205,7 +205,7 @@ class NL(Register): de despacho antecipado em cada subsistema. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "NL " IDENTIFIER_DIGITS = 4 @@ -218,7 +218,7 @@ class NL(Register): ) @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da UTE associada ao registro NL @@ -228,11 +228,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O código do submercado de despacho da UTE @@ -242,11 +242,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[1] @codigo_submercado.setter - def codigo_submercado(self, s: int): + def codigo_submercado(self, s: int) -> None: self.data[1] = s @property - def lag(self) -> Optional[int]: + def lag(self) -> int | None: """ O lag de despacho da UTE @@ -256,7 +256,7 @@ def lag(self) -> Optional[int]: return self.data[2] @lag.setter - def lag(self, lag: int): + def lag(self, lag: int) -> None: self.data[2] = lag @@ -265,7 +265,7 @@ class GL(Register): Registro que contém os cadastros de restrições elétricas. """ - __slots__ = [] + __slots__: list[str] = [] IDENTIFIER = "GL " IDENTIFIER_DIGITS = 4 @@ -285,7 +285,7 @@ class GL(Register): ) @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da UTE despachada no registro GL @@ -295,11 +295,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def codigo_submercado(self) -> Optional[int]: + def codigo_submercado(self) -> int | None: """ O código do submercado de despacho da UTE @@ -309,11 +309,11 @@ def codigo_submercado(self) -> Optional[int]: return self.data[1] @codigo_submercado.setter - def codigo_submercado(self, e: int): + def codigo_submercado(self, e: int) -> None: self.data[1] = e @property - def estagio(self) -> Optional[int]: + def estagio(self) -> int | None: """ O estágio de despacho da UTE @@ -323,11 +323,11 @@ def estagio(self) -> Optional[int]: return self.data[2] @estagio.setter - def estagio(self, e: int): + def estagio(self, e: int) -> None: self.data[2] = e @property - def geracao(self) -> List[float]: + def geracao(self) -> list[float]: """ Os valores de geração por patamar para o despacho da UTE @@ -337,7 +337,7 @@ def geracao(self) -> List[float]: return [v for v in self.data[3:8:2] if v is not None] @geracao.setter - def geracao(self, gers: List[float]): + def geracao(self, gers: list[float]) -> None: novos = len(gers) atuais = len(self.geracao) if novos != atuais: @@ -348,7 +348,7 @@ def geracao(self, gers: List[float]): self.data[3:9:2] = gers @property - def duracao(self) -> List[float]: + def duracao(self) -> list[float]: """ As durações de cada patamar para o despacho da UTE @@ -358,7 +358,7 @@ def duracao(self) -> List[float]: return [v for v in self.data[4:9:2] if v is not None] @duracao.setter - def duracao(self, durs: List[float]): + def duracao(self, durs: list[float]) -> None: novos = len(durs) atuais = len(self.duracao) if novos != atuais: @@ -369,7 +369,7 @@ def duracao(self, durs: List[float]): self.data[4:9:2] = durs @property - def data_inicio(self) -> Optional[str]: + def data_inicio(self) -> str | None: """ A data de despacho da UTE @@ -379,5 +379,5 @@ def data_inicio(self) -> Optional[str]: return self.data[9] @data_inicio.setter - def data_inicio(self, d: str): + def data_inicio(self, d: str) -> None: self.data[9] = d diff --git a/idecomp/decomp/modelos/dec_avl_evap.py b/idecomp/decomp/modelos/dec_avl_evap.py index 80adecea..62763ad3 100644 --- a/idecomp/decomp/modelos/dec_avl_evap.py +++ b/idecomp/decomp/modelos/dec_avl_evap.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_cortes_evap.py b/idecomp/decomp/modelos/dec_cortes_evap.py index 473ad655..403267ff 100644 --- a/idecomp/decomp/modelos/dec_cortes_evap.py +++ b/idecomp/decomp/modelos/dec_cortes_evap.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_desvfpha.py b/idecomp/decomp/modelos/dec_desvfpha.py index 9d4daee3..5b65d85b 100644 --- a/idecomp/decomp/modelos/dec_desvfpha.py +++ b/idecomp/decomp/modelos/dec_desvfpha.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_eco_cotajus.py b/idecomp/decomp/modelos/dec_eco_cotajus.py index 51e22380..83ed7f43 100644 --- a/idecomp/decomp/modelos/dec_eco_cotajus.py +++ b/idecomp/decomp/modelos/dec_eco_cotajus.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_eco_discr.py b/idecomp/decomp/modelos/dec_eco_discr.py index b8ebfaa5..2060bc20 100644 --- a/idecomp/decomp/modelos/dec_eco_discr.py +++ b/idecomp/decomp/modelos/dec_eco_discr.py @@ -1,8 +1,7 @@ # Imports de módulos externos -from cfinterface.components.line import Line -from cfinterface.components.integerfield import IntegerField from cfinterface.components.floatfield import FloatField - +from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_eco_evap.py b/idecomp/decomp/modelos/dec_eco_evap.py index ee935171..5459a55b 100644 --- a/idecomp/decomp/modelos/dec_eco_evap.py +++ b/idecomp/decomp/modelos/dec_eco_evap.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_eco_qlat.py b/idecomp/decomp/modelos/dec_eco_qlat.py index aa4a376c..7dff510f 100644 --- a/idecomp/decomp/modelos/dec_eco_qlat.py +++ b/idecomp/decomp/modelos/dec_eco_qlat.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_estatevap.py b/idecomp/decomp/modelos/dec_estatevap.py index b1dfa0c0..f24503c6 100644 --- a/idecomp/decomp/modelos/dec_estatevap.py +++ b/idecomp/decomp/modelos/dec_estatevap.py @@ -1,8 +1,7 @@ # Imports de módulos externos -from cfinterface.components.line import Line -from cfinterface.components.integerfield import IntegerField from cfinterface.components.floatfield import FloatField - +from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_estatfpha.py b/idecomp/decomp/modelos/dec_estatfpha.py index 3bfab3f9..da23088f 100644 --- a/idecomp/decomp/modelos/dec_estatfpha.py +++ b/idecomp/decomp/modelos/dec_estatfpha.py @@ -1,6 +1,7 @@ +from typing import IO, Any + +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.block import Block -from typing import List, IO -import pandas as pd # type: ignore class BlocoDesvios(Block): @@ -27,13 +28,13 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(data={"variavel": variavel, "valor": valores}) return df - variavel: List[str] = [] - valores: List[float] = [] + variavel: list[str] = [] + valores: list[float] = [] while True: linha = file.readline() diff --git a/idecomp/decomp/modelos/dec_fcf_cortes.py b/idecomp/decomp/modelos/dec_fcf_cortes.py index 272e32bb..fe5c6937 100644 --- a/idecomp/decomp/modelos/dec_fcf_cortes.py +++ b/idecomp/decomp/modelos/dec_fcf_cortes.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_oper_evap.py b/idecomp/decomp/modelos/dec_oper_evap.py index 1279082f..a913f68d 100644 --- a/idecomp/decomp/modelos/dec_oper_evap.py +++ b/idecomp/decomp/modelos/dec_oper_evap.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_oper_gnl.py b/idecomp/decomp/modelos/dec_oper_gnl.py index 9938153d..316338da 100644 --- a/idecomp/decomp/modelos/dec_oper_gnl.py +++ b/idecomp/decomp/modelos/dec_oper_gnl.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_oper_interc.py b/idecomp/decomp/modelos/dec_oper_interc.py index c636ec05..0257793e 100644 --- a/idecomp/decomp/modelos/dec_oper_interc.py +++ b/idecomp/decomp/modelos/dec_oper_interc.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_oper_ree.py b/idecomp/decomp/modelos/dec_oper_ree.py index bb0b6710..1cbda167 100644 --- a/idecomp/decomp/modelos/dec_oper_ree.py +++ b/idecomp/decomp/modelos/dec_oper_ree.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_oper_rhesoft.py b/idecomp/decomp/modelos/dec_oper_rhesoft.py index 703ca226..e4e7f2cf 100644 --- a/idecomp/decomp/modelos/dec_oper_rhesoft.py +++ b/idecomp/decomp/modelos/dec_oper_rhesoft.py @@ -1,8 +1,7 @@ # Imports de módulos externos -from cfinterface.components.line import Line -from cfinterface.components.integerfield import IntegerField from cfinterface.components.floatfield import FloatField - +from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_oper_sist.py b/idecomp/decomp/modelos/dec_oper_sist.py index e0f5862a..9b852f72 100644 --- a/idecomp/decomp/modelos/dec_oper_sist.py +++ b/idecomp/decomp/modelos/dec_oper_sist.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_oper_usie.py b/idecomp/decomp/modelos/dec_oper_usie.py index 26251a03..d0adc8ac 100644 --- a/idecomp/decomp/modelos/dec_oper_usie.py +++ b/idecomp/decomp/modelos/dec_oper_usie.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_oper_usih.py b/idecomp/decomp/modelos/dec_oper_usih.py index a14af4d3..71704d6f 100644 --- a/idecomp/decomp/modelos/dec_oper_usih.py +++ b/idecomp/decomp/modelos/dec_oper_usih.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/dec_oper_usit.py b/idecomp/decomp/modelos/dec_oper_usit.py index 391a2f64..f312b03b 100644 --- a/idecomp/decomp/modelos/dec_oper_usit.py +++ b/idecomp/decomp/modelos/dec_oper_usit.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/decomptim.py b/idecomp/decomp/modelos/decomptim.py index cdcd8ad7..ba34eb1b 100644 --- a/idecomp/decomp/modelos/decomptim.py +++ b/idecomp/decomp/modelos/decomptim.py @@ -1,10 +1,11 @@ # Imports de módulos externos +from datetime import timedelta +from typing import IO, Any + +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.block import Block -from cfinterface.components.line import Line from cfinterface.components.integerfield import IntegerField -import pandas as pd # type: ignore -from typing import IO -from datetime import timedelta +from cfinterface.components.line import Line class BlocoTemposEtapas(Block): @@ -18,7 +19,9 @@ class BlocoTemposEtapas(Block): BEGIN_PATTERN = "RELATORIO DE CONVERGENCIA DO PROCESSO ITERATIVO" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__line = Line( [ @@ -47,7 +50,7 @@ def read_line_time(self, linha: str) -> timedelta: return timedelta(hours=data[0], minutes=data[1], seconds=data[2]) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame( diff --git a/idecomp/decomp/modelos/eco_fpha.py b/idecomp/decomp/modelos/eco_fpha.py index 8f0c1b3d..a7d4a1d2 100644 --- a/idecomp/decomp/modelos/eco_fpha.py +++ b/idecomp/decomp/modelos/eco_fpha.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSV diff --git a/idecomp/decomp/modelos/fcfnw.py b/idecomp/decomp/modelos/fcfnw.py index 2b67b3e8..4b599c3d 100644 --- a/idecomp/decomp/modelos/fcfnw.py +++ b/idecomp/decomp/modelos/fcfnw.py @@ -1,13 +1,14 @@ # Imports do próprio módulo # Imports de módulos externos +from typing import IO, Any + +import numpy as np +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.block import Block -from cfinterface.components.line import Line -from cfinterface.components.integerfield import IntegerField from cfinterface.components.floatfield import FloatField -import numpy as np # type: ignore -import pandas as pd # type: ignore -from typing import IO +from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line class BlocoCortesFCF(Block): @@ -36,7 +37,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: if ree: colunas = ["corte", "RHS", "REE", "coef_earm"] + [ @@ -124,7 +125,7 @@ def converte_tabela_em_df() -> pd.DataFrame: # Confere se a leitura não acabou linha = file.readline() if len(linha) < 5: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break diff --git a/idecomp/decomp/modelos/hidr.py b/idecomp/decomp/modelos/hidr.py index 4f196c68..9f556173 100644 --- a/idecomp/decomp/modelos/hidr.py +++ b/idecomp/decomp/modelos/hidr.py @@ -1,9 +1,8 @@ -from cfinterface.components.register import Register +from cfinterface.components.floatfield import FloatField +from cfinterface.components.integerfield import IntegerField from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.integerfield import IntegerField -from cfinterface.components.floatfield import FloatField -from typing import List +from cfinterface.components.register import Register class RegistroUHEHidr(Register): @@ -12,7 +11,7 @@ class RegistroUHEHidr(Register): arquivo HIDR. """ - __slots__ = [] + __slots__: list[str] = [] LINE = Line( [ @@ -146,7 +145,7 @@ def nome(self) -> str: return self.data[0] @nome.setter - def nome(self, v: str): + def nome(self, v: str) -> None: self.data[0] = v @property @@ -154,7 +153,7 @@ def posto(self) -> int: return self.data[1] @posto.setter - def posto(self, v: int): + def posto(self, v: int) -> None: self.data[1] = v @property @@ -162,7 +161,7 @@ def subsistema(self) -> int: return self.data[3] @subsistema.setter - def subsistema(self, v: int): + def subsistema(self, v: int) -> None: self.data[3] = v @property @@ -170,7 +169,7 @@ def empresa(self) -> int: return self.data[4] @empresa.setter - def empresa(self, v: int): + def empresa(self, v: int) -> None: self.data[4] = v @property @@ -178,7 +177,7 @@ def jusante(self) -> int: return self.data[5] @jusante.setter - def jusante(self, v: int): + def jusante(self, v: int) -> None: self.data[5] = v @property @@ -186,7 +185,7 @@ def desvio(self) -> int: return self.data[6] @desvio.setter - def desvio(self, v: int): + def desvio(self, v: int) -> None: self.data[6] = v @property @@ -194,7 +193,7 @@ def volume_minimo(self) -> float: return self.data[7] @volume_minimo.setter - def volume_minimo(self, v: float): + def volume_minimo(self, v: float) -> None: self.data[7] = v @property @@ -202,7 +201,7 @@ def volume_maximo(self) -> float: return self.data[8] @volume_maximo.setter - def volume_maximo(self, v: float): + def volume_maximo(self, v: float) -> None: self.data[8] = v @property @@ -210,7 +209,7 @@ def volume_vertedouro(self) -> float: return self.data[9] @volume_vertedouro.setter - def volume_vertedouro(self, v: float): + def volume_vertedouro(self, v: float) -> None: self.data[9] = v @property @@ -218,7 +217,7 @@ def volume_desvio(self) -> float: return self.data[10] @volume_desvio.setter - def volume_desvio(self, v: float): + def volume_desvio(self, v: float) -> None: self.data[10] = v @property @@ -226,7 +225,7 @@ def cota_minima(self) -> float: return self.data[11] @cota_minima.setter - def cota_minima(self, v: float): + def cota_minima(self, v: float) -> None: self.data[11] = v @property @@ -234,31 +233,31 @@ def cota_maxima(self) -> float: return self.data[12] @cota_maxima.setter - def cota_maxima(self, v: float): + def cota_maxima(self, v: float) -> None: self.data[12] = v @property - def polinomio_volume_cota(self) -> List[float]: + def polinomio_volume_cota(self) -> list[float]: return self.data[13:18] @polinomio_volume_cota.setter - def polinomio_volume_cota(self, v: List[float]): + def polinomio_volume_cota(self, v: list[float]) -> None: self.data[13:18] = v @property - def polinomio_cota_area(self) -> List[float]: + def polinomio_cota_area(self) -> list[float]: return self.data[18:23] @polinomio_cota_area.setter - def polinomio_cota_area(self, v: List[float]): + def polinomio_cota_area(self, v: list[float]) -> None: self.data[18:23] = v @property - def evaporacao(self) -> List[float]: + def evaporacao(self) -> list[float]: return self.data[23:35] @evaporacao.setter - def evaporacao(self, v: List[float]): + def evaporacao(self, v: list[float]) -> None: self.data[23:35] = v @property @@ -266,39 +265,39 @@ def numero_conjuntos_maquinas(self) -> int: return self.data[35] @numero_conjuntos_maquinas.setter - def numero_conjuntos_maquinas(self, v: int): + def numero_conjuntos_maquinas(self, v: int) -> None: self.data[35] = v @property - def numero_maquinas_conjunto(self) -> List[int]: + def numero_maquinas_conjunto(self) -> list[int]: return self.data[36:41] @numero_maquinas_conjunto.setter - def numero_maquinas_conjunto(self, v: List[int]): + def numero_maquinas_conjunto(self, v: list[int]) -> None: self.data[36:41] = v @property - def potef_conjunto(self) -> List[float]: + def potef_conjunto(self) -> list[float]: return self.data[41:46] @potef_conjunto.setter - def potef_conjunto(self, v: List[float]): + def potef_conjunto(self, v: list[float]) -> None: self.data[41:46] = v @property - def hef_conjunto(self) -> List[float]: + def hef_conjunto(self) -> list[float]: return self.data[47:52] @hef_conjunto.setter - def hef_conjunto(self, v: List[float]): + def hef_conjunto(self, v: list[float]) -> None: self.data[47:52] = v @property - def qef_conjunto(self) -> List[float]: + def qef_conjunto(self) -> list[float]: return self.data[52:57] @qef_conjunto.setter - def qef_conjunto(self, v: List[float]): + def qef_conjunto(self, v: list[float]) -> None: self.data[52:57] = v @property @@ -306,7 +305,7 @@ def produtibilidade_especifica(self) -> float: return self.data[57] @produtibilidade_especifica.setter - def produtibilidade_especifica(self, v: float): + def produtibilidade_especifica(self, v: float) -> None: self.data[57] = v @property @@ -314,7 +313,7 @@ def perdas(self) -> float: return self.data[58] @perdas.setter - def perdas(self, v: float): + def perdas(self, v: float) -> None: self.data[58] = v @property @@ -322,15 +321,15 @@ def numero_polinomios_jusante(self) -> int: return self.data[59] @numero_polinomios_jusante.setter - def numero_polinomios_jusante(self, v: int): + def numero_polinomios_jusante(self, v: int) -> None: self.data[59] = v @property - def polinomios_jusante(self) -> List[float]: + def polinomios_jusante(self) -> list[float]: return self.data[60:96] @polinomios_jusante.setter - def polinomios_jusante(self, v: List[float]): + def polinomios_jusante(self, v: list[float]) -> None: self.data[60:96] = v @property @@ -338,7 +337,7 @@ def canal_fuga_medio(self) -> float: return self.data[96] @canal_fuga_medio.setter - def canal_fuga_medio(self, v: float): + def canal_fuga_medio(self, v: float) -> None: self.data[96] = v @property @@ -346,7 +345,7 @@ def influencia_vertimento_canal_fuga(self) -> int: return self.data[97] @influencia_vertimento_canal_fuga.setter - def influencia_vertimento_canal_fuga(self, v: int): + def influencia_vertimento_canal_fuga(self, v: int) -> None: self.data[97] = v @property @@ -354,7 +353,7 @@ def fator_carga_maximo(self) -> float: return self.data[98] @fator_carga_maximo.setter - def fator_carga_maximo(self, v: float): + def fator_carga_maximo(self, v: float) -> None: self.data[98] = v @property @@ -362,7 +361,7 @@ def fator_carga_minimo(self) -> float: return self.data[99] @fator_carga_minimo.setter - def fator_carga_minimo(self, v: float): + def fator_carga_minimo(self, v: float) -> None: self.data[99] = v @property @@ -370,7 +369,7 @@ def vazao_minima_historica(self) -> int: return self.data[100] @vazao_minima_historica.setter - def vazao_minima_historica(self, v: int): + def vazao_minima_historica(self, v: int) -> None: self.data[100] = v @property @@ -378,7 +377,7 @@ def numero_unidades_base(self) -> int: return self.data[101] @numero_unidades_base.setter - def numero_unidades_base(self, v: int): + def numero_unidades_base(self, v: int) -> None: self.data[101] = v @property @@ -386,7 +385,7 @@ def tipo_turbina(self) -> int: return self.data[102] @tipo_turbina.setter - def tipo_turbina(self, v: int): + def tipo_turbina(self, v: int) -> None: self.data[102] = v @property @@ -394,7 +393,7 @@ def representacao_conjunto(self) -> int: return self.data[103] @representacao_conjunto.setter - def representacao_conjunto(self, v: int): + def representacao_conjunto(self, v: int) -> None: self.data[103] = v @property @@ -402,7 +401,7 @@ def teif(self) -> float: return self.data[104] @teif.setter - def teif(self, v: float): + def teif(self, v: float) -> None: self.data[104] = v @property @@ -410,7 +409,7 @@ def ip(self) -> float: return self.data[105] @ip.setter - def ip(self, v: float): + def ip(self, v: float) -> None: self.data[105] = v @property @@ -418,7 +417,7 @@ def tipo_perda(self) -> int: return self.data[106] @tipo_perda.setter - def tipo_perda(self, v: int): + def tipo_perda(self, v: int) -> None: self.data[106] = v @property @@ -426,7 +425,7 @@ def data_referencia(self) -> str: return self.data[107] @data_referencia.setter - def data_referencia(self, v: str): + def data_referencia(self, v: str) -> None: self.data[107] = v @property @@ -434,7 +433,7 @@ def observacao(self) -> str: return self.data[108] @observacao.setter - def observacao(self, v: str): + def observacao(self, v: str) -> None: self.data[108] = v @property @@ -442,7 +441,7 @@ def volume_referencia(self) -> float: return self.data[109] @volume_referencia.setter - def volume_referencia(self, v: float): + def volume_referencia(self, v: float) -> None: self.data[109] = v @property @@ -450,5 +449,5 @@ def tipo_regulacao(self) -> str: return self.data[110] @tipo_regulacao.setter - def tipo_regulacao(self, v: str): + def tipo_regulacao(self, v: str) -> None: self.data[110] = v diff --git a/idecomp/decomp/modelos/inviabunic.py b/idecomp/decomp/modelos/inviabunic.py index ec5c153b..4a5a8d6d 100644 --- a/idecomp/decomp/modelos/inviabunic.py +++ b/idecomp/decomp/modelos/inviabunic.py @@ -1,10 +1,11 @@ +from typing import IO, Any + +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.block import Block -from cfinterface.components.line import Line -from cfinterface.components.integerfield import IntegerField from cfinterface.components.floatfield import FloatField +from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from typing import List, IO -import pandas as pd # type: ignore class BlocoInviabilidadesIteracoes(Block): @@ -18,7 +19,9 @@ class BlocoInviabilidadesIteracoes(Block): BEGIN_PATTERN = "RELATORIO DE VIOLACOES DAS RESTRICOES" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__linha = Line( [ @@ -47,7 +50,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame() df["iteracao"] = iteracoes @@ -62,13 +65,13 @@ def converte_tabela_em_df() -> pd.DataFrame: # Salta linhas de cabeçalho for _ in range(4): file.readline() - iteracoes: List[int] = [] - fwds_bwds: List[int] = [] - estagios: List[int] = [] - cenarios: List[int] = [] - restricoes: List[str] = [] - violacoes: List[float] = [] - unidades: List[str] = [] + iteracoes: list[int] = [] + fwds_bwds: list[int] = [] + estagios: list[int] = [] + cenarios: list[int] = [] + restricoes: list[str] = [] + violacoes: list[float] = [] + unidades: list[str] = [] while True: # Confere se a leitura não acabou linha = file.readline() @@ -97,7 +100,9 @@ class BlocoInviabilidadesSimFinal(Block): BEGIN_PATTERN = "SIMULACAO FINAL:" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__linha = Line( [ @@ -124,7 +129,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame() df["estagio"] = estagios @@ -138,11 +143,11 @@ def converte_tabela_em_df() -> pd.DataFrame: for _ in range(4): file.readline() - estagios: List[int] = [] - cenarios: List[int] = [] - restricoes: List[str] = [] - violacoes: List[float] = [] - unidades: List[str] = [] + estagios: list[int] = [] + cenarios: list[int] = [] + restricoes: list[str] = [] + violacoes: list[float] = [] + unidades: list[str] = [] while True: # Confere se a leitura não acabou linha = file.readline() diff --git a/idecomp/decomp/modelos/mapcut.py b/idecomp/decomp/modelos/mapcut.py index 8383e077..4e7e715a 100644 --- a/idecomp/decomp/modelos/mapcut.py +++ b/idecomp/decomp/modelos/mapcut.py @@ -1,8 +1,9 @@ -from cfinterface.components.section import Section -from typing import IO, List -import numpy as np # type: ignore -import pandas as pd # type: ignore from datetime import datetime +from typing import IO, Any + +import numpy as np +import pandas as pd # type: ignore[import-untyped] +from cfinterface.components.section import Section class SecaoDadosMapcut(Section): @@ -15,7 +16,12 @@ class SecaoDadosMapcut(Section): REGISTER_SIZE = 48020 - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, + previous: Any = None, + next: Any = None, + data: Any = None, + ) -> None: super().__init__(previous, next, data) self.data = { "dados_gerais": [], # registro 1 @@ -44,7 +50,7 @@ def __eq__(self, o: object) -> bool: else: return self.data == bloco.data - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] # Leitura do primeiro registro (dados gerais) self.__le_primeiro_registro(file) # Leitura do segundo registro (dados do caso) @@ -62,7 +68,7 @@ def read(self, file: IO, *args, **kwargs): # Leitura do nono e décimo registro (dados de usinas gnl) self.__le_nono_decimo_registros(file) - def __le_primeiro_registro(self, file: IO): + def __le_primeiro_registro(self, file: IO[Any]) -> None: tamanho_primeiro_bloco = 5 dados_primeiro_bloco = np.frombuffer( file.read(tamanho_primeiro_bloco * 4), @@ -79,7 +85,7 @@ def __le_primeiro_registro(self, file: IO): dados = list(dados_primeiro_bloco) + list(dados_segundo_bloco) self.data["dados_gerais"] = list(dados) - def __le_segundo_registro(self, file: IO): + def __le_segundo_registro(self, file: IO[Any]) -> None: file.seek(self.__contador_registro * self.REGISTER_SIZE) tamanho = 4 dados = np.frombuffer( @@ -90,7 +96,7 @@ def __le_segundo_registro(self, file: IO): self.__contador_registro = self.__contador_registro + 1 self.data["dados_caso"] = list(dados) - def __le_terceiro_registro(self, file: IO): + def __le_terceiro_registro(self, file: IO[Any]) -> None: file.seek(self.__contador_registro * self.REGISTER_SIZE) tamanho = self.numero_uhes dados = np.frombuffer( @@ -101,7 +107,7 @@ def __le_terceiro_registro(self, file: IO): self.__contador_registro = self.__contador_registro + 1 self.data["dados_uhes"] = list(dados) - def __le_quarto_registro(self, file: IO): + def __le_quarto_registro(self, file: IO[Any]) -> None: file.seek(self.__contador_registro * self.REGISTER_SIZE) tamanho = self.numero_uhes dados = np.frombuffer( @@ -112,7 +118,7 @@ def __le_quarto_registro(self, file: IO): self.__contador_registro = self.__contador_registro + 1 self.data["dados_uhes_topologia"] = list(dados) - def __le_quinto_registro(self, file: IO): + def __le_quinto_registro(self, file: IO[Any]) -> None: self.__contador_registro = self.__contador_registro + 14 file.seek(self.__contador_registro * self.REGISTER_SIZE) tamanho = self.numero_cenarios @@ -124,7 +130,7 @@ def __le_quinto_registro(self, file: IO): self.__contador_registro = self.__contador_registro + 1 self.data["dados_arvore"] = list(dados) - def __le_sexto_registro(self, file: IO): + def __le_sexto_registro(self, file: IO[Any]) -> None: file.seek(self.__contador_registro * self.REGISTER_SIZE) tamanho_primeiro_bloco = 5 dados_primeiro_bloco = np.frombuffer( @@ -154,7 +160,7 @@ def __le_sexto_registro(self, file: IO): self.__contador_registro = self.__contador_registro + 1 self.data["dados_estagios"] = list(dados) - def __le_setimo_registro(self, file: IO): + def __le_setimo_registro(self, file: IO[Any]) -> None: file.seek(self.__contador_registro * self.REGISTER_SIZE) tamanho_primeiro_bloco = 3 tamanho_segundo_bloco = 1 @@ -172,7 +178,7 @@ def __le_setimo_registro(self, file: IO): self.__contador_registro = self.__contador_registro + 1 self.data["dados_tempo_viagem"] += list(dados) - def __le_oitavo_registro(self, file: IO): + def __le_oitavo_registro(self, file: IO[Any]) -> None: file.seek(self.__contador_registro * self.REGISTER_SIZE) tamanho = 1 dados_primeiro_bloco = np.frombuffer( @@ -189,7 +195,7 @@ def __le_oitavo_registro(self, file: IO): self.__contador_registro = self.__contador_registro + 1 self.data["dados_tempo_viagem"] += list(dados) - def __le_setimo_oitavo_registros(self, file: IO): + def __le_setimo_oitavo_registros(self, file: IO[Any]) -> None: for uhe in range(1, self.numero_uhes_tempo_viagem + 1, 1): for est in range(1, self.numero_estagios + 1, 1): lags = self.lag_tempo_viagem_por_uhe[(uhe * est) - 1] @@ -199,7 +205,7 @@ def __le_setimo_oitavo_registros(self, file: IO): else: self.__le_oitavo_registro(file) - def __le_nono_registro(self, file: IO): + def __le_nono_registro(self, file: IO[Any]) -> None: file.seek(self.__contador_registro * self.REGISTER_SIZE) tamanho_primeiro_bloco = 1 dados_primeiro_bloco = np.frombuffer( @@ -228,7 +234,7 @@ def __le_nono_registro(self, file: IO): self.__contador_registro = self.__contador_registro + 1 self.data["dados_gnl"] += list(dados) - def __le_decimo_registro(self, file: IO): + def __le_decimo_registro(self, file: IO[Any]) -> None: file.seek(self.__contador_registro * self.REGISTER_SIZE) tamanho = 6 dados = np.frombuffer( @@ -239,7 +245,7 @@ def __le_decimo_registro(self, file: IO): self.__contador_registro = self.__contador_registro + 1 self.data["dados_custos"] += list(dados) - def __le_nono_decimo_registros(self, file: IO): + def __le_nono_decimo_registros(self, file: IO[Any]) -> None: for _ in range(self.numero_estagios): self.__le_nono_registro(file) self.__le_decimo_registro(file) @@ -266,7 +272,7 @@ def numero_cenarios(self) -> int: @property def registro_ultimo_corte_no(self) -> pd.DataFrame: - lista_estagios: List[int] = [] + lista_estagios: list[int] = [] estagio = 1 for no in range(1, self.numero_cenarios + 1): if no in self.indice_primeiro_no_estagio: @@ -297,15 +303,15 @@ def data_inicio(self) -> datetime: return datetime(year=ano, month=mes, day=dia) @property - def codigos_uhes(self) -> list: + def codigos_uhes(self) -> list[Any]: return self.data["dados_uhes"] @property - def codigos_uhes_jusante(self) -> list: + def codigos_uhes_jusante(self) -> list[Any]: return self.data["dados_uhes_topologia"] @property - def indice_no_arvore(self) -> list: + def indice_no_arvore(self) -> list[Any]: return self.data["dados_arvore"] @property @@ -325,14 +331,14 @@ def maximo_lag_tempo_viagem(self) -> int: return self.data["dados_estagios"][4] @property - def indice_primeiro_no_estagio(self) -> list: + def indice_primeiro_no_estagio(self) -> list[Any]: offset = 5 return self.data["dados_estagios"][ offset : (offset + self.numero_estagios) ] @property - def patamares_por_estagio(self) -> list: + def patamares_por_estagio(self) -> list[Any]: offset = 4 + self.numero_estagios + 1 patamares_estagio = self.data["dados_estagios"][ offset : (offset + self.numero_estagios) @@ -340,7 +346,7 @@ def patamares_por_estagio(self) -> list: return patamares_estagio @property - def lag_tempo_viagem_por_uhe(self) -> list: + def lag_tempo_viagem_por_uhe(self) -> list[Any]: return self.data["dados_estagios"][ -(self.numero_uhes_tempo_viagem * self.numero_estagios) : ] @@ -392,11 +398,11 @@ def dados_tempo_viagem(self) -> pd.DataFrame: return df_tempo_viagem.reset_index(drop=True) @property - def codigos_uhes_tempo_viagem(self) -> list: + def codigos_uhes_tempo_viagem(self) -> list[Any]: return self.dados_tempo_viagem["codigo_usina"].unique().tolist() @property - def codigos_submercados_gnl(self) -> list: + def codigos_submercados_gnl(self) -> list[Any]: codigos_submercados = ( self.dados_gnl["codigo_submercado"].unique().tolist() ) diff --git a/idecomp/decomp/modelos/oper_desvio_fpha.py b/idecomp/decomp/modelos/oper_desvio_fpha.py index 72321b0d..b5550918 100644 --- a/idecomp/decomp/modelos/oper_desvio_fpha.py +++ b/idecomp/decomp/modelos/oper_desvio_fpha.py @@ -1,9 +1,8 @@ # Imports de módulos externos -from cfinterface.components.line import Line +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField - from idecomp.decomp.modelos.blocos.tabelacsv import TabelaCSVLibs diff --git a/idecomp/decomp/modelos/postos.py b/idecomp/decomp/modelos/postos.py index fe56dc44..53666920 100644 --- a/idecomp/decomp/modelos/postos.py +++ b/idecomp/decomp/modelos/postos.py @@ -1,8 +1,7 @@ -from cfinterface.components.register import Register +from cfinterface.components.integerfield import IntegerField from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.integerfield import IntegerField -from typing import List +from cfinterface.components.register import Register class RegistroPostos(Register): @@ -24,7 +23,7 @@ class RegistroPostos(Register): ) @classmethod - def set_postos(cls, postos: int): + def set_postos(cls, postos: int) -> None: cls.POSTOS = postos cls.LINE = Line( [ @@ -36,9 +35,9 @@ def set_postos(cls, postos: int): ) @property - def postos(self) -> List[int]: + def postos(self) -> list[int]: return self.data @postos.setter - def postos(self, v: List[int]): + def postos(self, v: list[int]) -> None: self.data = v diff --git a/idecomp/decomp/modelos/relato.py b/idecomp/decomp/modelos/relato.py index 480d1128..9f5496e1 100644 --- a/idecomp/decomp/modelos/relato.py +++ b/idecomp/decomp/modelos/relato.py @@ -1,26 +1,28 @@ # Imports do próprio módulo +from typing import IO, Any + +import numpy as np +import pandas as pd # type: ignore[import-untyped] + +# Imports de módulos externos +from cfinterface.components.block import Block +from cfinterface.components.field import Field +from cfinterface.components.floatfield import FloatField +from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line +from cfinterface.components.literalfield import LiteralField + from idecomp.config import ( MAX_CENARIOS, MAX_ESTAGIOS, MAX_PATAMARES, - MAX_SUBSISTEMAS, MAX_REES, + MAX_SUBSISTEMAS, MAX_UHES, MAX_UTES, MESES_DF, ) -# Imports de módulos externos -from cfinterface.components.block import Block -from cfinterface.components.line import Line -from cfinterface.components.field import Field -from cfinterface.components.integerfield import IntegerField -from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField -import numpy as np # type: ignore -import pandas as pd # type: ignore -from typing import IO, List, Tuple, Dict - class BlocoREEsSubsistemas(Block): """ @@ -33,7 +35,9 @@ class BlocoREEsSubsistemas(Block): BEGIN_PATTERN = "Relatorio dos dados da configuracao dos Reservatorios" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__line = Line( [ @@ -60,7 +64,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame( data={ @@ -74,11 +78,11 @@ def converte_tabela_em_df() -> pd.DataFrame: return df comecou = False - numeros: List[int] = [] - nomes: List[str] = [] - numeros_subsistema: List[int] = [] - nomes_subsistema: List[str] = [] - nomes_newave: List[str] = [] + numeros: list[int] = [] + nomes: list[str] = [] + numeros_subsistema: list[int] = [] + nomes_subsistema: list[str] = [] + nomes_newave: list[str] = [] while True: # Confere se a leitura não acabou linha = file.readline() @@ -112,7 +116,9 @@ class BlocoUHEsREEsSubsistemas(Block): ) END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__line = Line( [ @@ -141,7 +147,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame( data={ @@ -157,13 +163,13 @@ def converte_tabela_em_df() -> pd.DataFrame: return df comecou = False - numeros: List[int] = [] - nomes: List[str] = [] - numeros_rees: List[int] = [] - nomes_rees: List[str] = [] - numeros_subsistema: List[int] = [] - nomes_subsistema: List[str] = [] - nomes_newave: List[str] = [] + numeros: list[int] = [] + nomes: list[str] = [] + numeros_rees: list[int] = [] + nomes_rees: list[str] = [] + numeros_subsistema: list[int] = [] + nomes_subsistema: list[str] = [] + nomes_newave: list[str] = [] while True: # Confere se a leitura não acabou linha = file.readline() @@ -196,7 +202,9 @@ class BlocoConvergenciaRelato(Block): BEGIN_PATTERN = "RELATORIO DE CONVERGENCIA DO PROCESSO ITERATIVO" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__line = Line( [ @@ -229,7 +237,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: colunas = [ "iteracao", @@ -271,7 +279,7 @@ def converte_tabela_em_df() -> pd.DataFrame: # Confere se a leitura não acabou linha = file.readline() if len(linha) < 5: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break if "----" in linha: @@ -300,7 +308,9 @@ class BlocoRelatorioOperacaoRelato(Block): BEGIN_PATTERN = r"RELATORIO DA OPERACAO " END_PATTERN = "X----X-" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__scenario_line = Line( [IntegerField(2, 34), IntegerField(4, 47), FloatField(8, 67, 6)] @@ -347,7 +357,7 @@ def __eq__(self, o: object) -> bool: ] ) - def __read_bloco_operacao_uhe(self, file: IO): + def __read_bloco_operacao_uhe(self, file: IO[Any]) -> None: def converte_tabela_para_df() -> pd.DataFrame: cols = [ "volume_inicial_percentual", @@ -399,12 +409,12 @@ def converte_tabela_para_df() -> pd.DataFrame: file.readline() # Variáveis auxiliares - numeros: List[int] = [] - usinas: List[str] = [] - evaporacao: List[bool] = [] - tv_afluencia: List[bool] = [] - cota_abaixo_crista: List[bool] = [] - def_minima_zero: List[bool] = [] + numeros: list[int] = [] + usinas: list[str] = [] + evaporacao: list[bool] = [] + tv_afluencia: list[bool] = [] + cota_abaixo_crista: list[bool] = [] + def_minima_zero: list[bool] = [] # Salta uma linha e extrai a semana tabela: np.ndarray = np.zeros((MAX_UHES, 15)) i = 0 @@ -426,7 +436,7 @@ def converte_tabela_para_df() -> pd.DataFrame: tabela[i, :] = dados[3:] i += 1 - def __read_bloco_operacao_geral(self, file: IO): + def __read_bloco_operacao_geral(self, file: IO[Any]) -> None: def converte_tabela_para_df() -> pd.DataFrame: df = pd.DataFrame( data={ @@ -456,28 +466,28 @@ def converte_tabela_para_df() -> pd.DataFrame: linha_custo_exp = Line([FloatField(14, 54, 2, format="E")]) linha_custo_subsis = Line([LiteralField(2, 44), FloatField(14, 54, 2)]) - custo_futuro: list = linha_custo.read(file.readline()) + custo_futuro: list[Any] = linha_custo.read(file.readline()) file.readline() file.readline() - custo_estagio: list = linha_custo.read(file.readline()) + custo_estagio: list[Any] = linha_custo.read(file.readline()) file.readline() file.readline() - custo_gt: list = linha_custo.read(file.readline()) + custo_gt: list[Any] = linha_custo.read(file.readline()) file.readline() file.readline() file.readline() file.readline() - custo_desvio: list = linha_custo.read(file.readline()) - custo_vert_reservatorio: list = linha_custo.read(file.readline()) - custo_vert_fio: list = linha_custo.read(file.readline()) - custo_turbinamento_reservatorio: list = linha_custo.read( + custo_desvio: list[Any] = linha_custo.read(file.readline()) + custo_vert_reservatorio: list[Any] = linha_custo.read(file.readline()) + custo_vert_fio: list[Any] = linha_custo.read(file.readline()) + custo_turbinamento_reservatorio: list[Any] = linha_custo.read( file.readline() ) - custo_turbinamento_fio: list = linha_custo.read(file.readline()) - custo_intercambio: list = linha_custo_exp.read(file.readline()) + custo_turbinamento_fio: list[Any] = linha_custo.read(file.readline()) + custo_intercambio: list[Any] = linha_custo_exp.read(file.readline()) file.readline() - cmos: Dict[str, float] = {} + cmos: dict[str, float] = {} while True: linha = file.readline() if len(linha.strip()) < 4: @@ -487,7 +497,7 @@ def converte_tabela_para_df() -> pd.DataFrame: cmos[dados_linha[0]] = dados_linha[1] # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] str_bloco_operacao_uhe = "# Aproveitamento(s) com evaporacao " str_bloco_operacao_geral = "Valor esperado do custo futuro:" # str_bloco_restricoes_rhe = ( @@ -534,7 +544,9 @@ class BlocoRelatorioOperacaoUTERelato(Block): BEGIN_PATTERN = r"RELATORIO DA OPERACAO TERMICA E CONTRATOS" END_PATTERN = "RELATORIO DO BALANCO ENERGETICO" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__scenario_line = Line( [IntegerField(2, 34), IntegerField(4, 47), FloatField(8, 67, 6)] @@ -566,7 +578,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_para_df() -> pd.DataFrame: cols = [f"geracao_patamar{i}" for i in range(1, n_pats + 1)] + [ "custo" @@ -617,7 +629,7 @@ def converte_tabela_para_df() -> pd.DataFrame: linha: str = file.readline() # Verifica se acabou if self.ends(linha): - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] file.seek(posicao_ultima_linha) self.data = converte_tabela_para_df() break @@ -654,7 +666,9 @@ class BlocoBalancoEnergeticoRelato(Block): BEGIN_PATTERN = "RELATORIO DO BALANCO ENERGETICO" END_PATTERN = r"RELATORIO\s+DA\s+OPERACAO" # noqa - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__linha_cenario = Line( [IntegerField(2, 34), IntegerField(4, 47), FloatField(8, 67, 6)] @@ -685,23 +699,23 @@ def __eq__(self, o: object) -> bool: else: return self.data.equals(bloco.data) - def __define_linha_balanco(self, cabecalho: str) -> Tuple[Line, List[str]]: + def __define_linha_balanco(self, cabecalho: str) -> tuple[Line, list[str]]: colunas = [c for c in cabecalho.split(" ") if len(c) > 2] colunas = [c.strip("\n") for c in colunas] if "Interligacao" not in colunas: return Line([]), [] indice_intercambio = colunas.index("Interligacao") - campo_patamar: List[Field] = [LiteralField(5, 4)] - campos_balanco: List[Field] = [ + campo_patamar: list[Field] = [LiteralField(5, 4)] + campos_balanco: list[Field] = [ FloatField(7, 10 + 8 * i, 1) for i in range(indice_intercambio) ] - campo_subsis: List[Field] = [ + campo_subsis: list[Field] = [ LiteralField(2, 10 + 8 * indice_intercambio + 1) ] - campo_interligacao: List[Field] = [ + campo_interligacao: list[Field] = [ FloatField(8, 10 + 8 * indice_intercambio + 4, 1) ] - campos_apos_interligacao: List[Field] = [ + campos_apos_interligacao: list[Field] = [ FloatField(7, 25 + 8 * indice_intercambio + 8 * i, 1) for i in range(2) ] @@ -714,7 +728,7 @@ def __define_linha_balanco(self, cabecalho: str) -> Tuple[Line, List[str]]: ), [c for c in colunas if c != "Interligacao"] # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_para_df() -> pd.DataFrame: tamanho_maior_linha = max([len(lin) for lin in linhas]) tabela = np.zeros((len(linhas), tamanho_maior_linha)) @@ -789,8 +803,8 @@ def converte_tabela_para_df() -> pd.DataFrame: estagio = dados[0] cenario = dados[1] probabilidade = dados[2] - linhas: List[List[float]] = [] - colunas_balanco: List[str] = [] + linhas: list[list[float]] = [] + colunas_balanco: list[str] = [] while True: pos = file.tell() linha = file.readline() @@ -832,10 +846,10 @@ def converte_tabela_para_df() -> pd.DataFrame: indice_subsis = dados.index( [d for d in dados if type(d) is str][1] ) - dados_antes_interligacao: List[float] = [ + dados_antes_interligacao: list[float] = [ d for d in dados[1:indice_subsis] if d is not None ] - dados_apos_interligacao: List[float] = [ + dados_apos_interligacao: list[float] = [ d for d in dados[indice_subsis + 2 :] if d is not None ] linhas.append( @@ -871,7 +885,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(tabela) cols = [f"estagio_{s}" for s in range(1, num_estagios + 1)] @@ -897,13 +911,13 @@ def converte_tabela_em_df() -> pd.DataFrame: - 1 ) num_estagios - campo_subsis: List[Field] = [LiteralField(6, 4)] - campos_cmos: List[Field] = [ + campo_subsis: list[Field] = [LiteralField(6, 4)] + campos_cmos: list[Field] = [ FloatField(10, 11 + i * 11, 2) for i in range(num_estagios) ] self.__linha = Line(campo_subsis + campos_cmos) - subsistemas_distintos: list = [] - patamares_distintos: list = [] + subsistemas_distintos: list[Any] = [] + patamares_distintos: list[Any] = [] tabela = np.zeros((MAX_SUBSISTEMAS * MAX_PATAMARES, num_estagios)) # Salta outra linha file.readline() @@ -912,7 +926,7 @@ def converte_tabela_em_df() -> pd.DataFrame: # Confere se a leitura não acabou linha = file.readline() if "X------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -957,7 +971,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(tabela) cols = [f"estagio_{s}" for s in range(1, num_estagios + 1)] @@ -972,12 +986,12 @@ def converte_tabela_em_df() -> pd.DataFrame: num_estagios = len( [e for e in file.readline().strip().split(" ") if len(e) > 2] ) - campo_parcela: List[Field] = [LiteralField(6, 4)] - campos_custos: List[Field] = [ + campo_parcela: list[Field] = [LiteralField(6, 4)] + campos_custos: list[Field] = [ FloatField(12, 11 + i * 13, 1) for i in range(num_estagios) ] self.__linha = Line(campo_parcela + campos_custos) - parcelas: list = [] + parcelas: list[Any] = [] tabela = np.zeros((2, num_estagios)) # Salta outra linha file.readline() @@ -1015,7 +1029,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(tabela) cols = [f"estagio_{s}" for s in range(1, num_estagios + 1)] @@ -1031,12 +1045,12 @@ def converte_tabela_em_df() -> pd.DataFrame: len([e for e in file.readline().strip().split(" ") if len(e) > 2]) - 1 ) - campo_subsis: List[Field] = [LiteralField(6, 4)] - campos_gt: List[Field] = [ + campo_subsis: list[Field] = [LiteralField(6, 4)] + campos_gt: list[Field] = [ FloatField(10, 11 + i * 11, 1) for i in range(num_estagios) ] self.__linha = Line(campo_subsis + campos_gt) - subsistemas: list = [] + subsistemas: list[Any] = [] tabela = np.zeros((MAX_SUBSISTEMAS * MAX_PATAMARES, num_estagios)) # Salta outra linha file.readline() @@ -1045,7 +1059,7 @@ def converte_tabela_em_df() -> pd.DataFrame: # Confere se a leitura não acabou linha = file.readline() if "X------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -1081,7 +1095,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(tabela) cols = ["inicial"] + [ @@ -1100,17 +1114,17 @@ def converte_tabela_em_df() -> pd.DataFrame: len([e for e in file.readline().strip().split(" ") if len(e) > 2]) - 1 ) - campo_usi: List[Field] = [ + campo_usi: list[Field] = [ IntegerField(3, 4), LiteralField(12, 8), FloatField(7, 22, 1), ] - campos_vu: List[Field] = [ + campos_vu: list[Field] = [ FloatField(6, 30 + i * 7, 1) for i in range(num_estagios) ] self.__linha = Line(campo_usi + campos_vu) - numeros: List[int] = [] - usinas: List[str] = [] + numeros: list[int] = [] + usinas: list[str] = [] tabela = np.zeros((MAX_UHES, num_estagios + 1)) # Salta outra linha file.readline() @@ -1119,7 +1133,7 @@ def converte_tabela_em_df() -> pd.DataFrame: # Confere se a leitura não acabou linha = file.readline() if "X------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -1140,7 +1154,9 @@ class BlocoDadosTermicasRelato(Block): BEGIN_PATTERN = "Relatorio dos Dados de Usinas Termicas" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__line = Line( [ @@ -1175,7 +1191,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: cols = [ "geracao_minima_patamar_1", @@ -1203,10 +1219,10 @@ def converte_tabela_em_df() -> pd.DataFrame: for _ in range(5): file.readline() - numeros: List[int] = [] - usinas: List[str] = [] - subsistemas: List[str] = [] - estagios: List[int] = [] + numeros: list[int] = [] + usinas: list[str] = [] + subsistemas: list[str] = [] + estagios: list[int] = [] tabela = np.zeros((MAX_ESTAGIOS * MAX_UTES, 9)) @@ -1218,7 +1234,7 @@ def converte_tabela_em_df() -> pd.DataFrame: # Confere se a leitura não acabou linha = file.readline() if "X---X----------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -1263,7 +1279,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(tabela) cols = [f"estagio_{s}" for s in range(1, num_estagios + 1)] @@ -1281,16 +1297,16 @@ def converte_tabela_em_df() -> pd.DataFrame: len([e for e in file.readline().strip().split(" ") if len(e) > 2]) - 2 ) - campo_usi: List[Field] = [ + campo_usi: list[Field] = [ IntegerField(3, 4), LiteralField(12, 8), ] - campos_vu: List[Field] = [ + campos_vu: list[Field] = [ FloatField(6, 21 + i * 7, 1) for i in range(num_estagios) ] self.__linha = Line(campo_usi + campos_vu) - numeros: List[int] = [] - usinas: List[str] = [] + numeros: list[int] = [] + usinas: list[str] = [] tabela = np.zeros((MAX_UTES, num_estagios)) # Salta outra linha file.readline() @@ -1299,7 +1315,7 @@ def converte_tabela_em_df() -> pd.DataFrame: # Confere se a leitura não acabou linha = file.readline() if "X------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -1321,7 +1337,9 @@ class BlocoDadosMercadoRelato(Block): BEGIN_PATTERN = "Relatorio dos Dados de Mercado" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__line = Line( [ @@ -1351,7 +1369,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: cols = [ "patamar_1", @@ -1371,8 +1389,8 @@ def converte_tabela_em_df() -> pd.DataFrame: for _ in range(5): file.readline() - estagios: List[int] = [] - subsistemas: List[str] = [] + estagios: list[int] = [] + subsistemas: list[str] = [] tabela = np.zeros((MAX_ESTAGIOS * MAX_SUBSISTEMAS, 6)) @@ -1382,7 +1400,7 @@ def converte_tabela_em_df() -> pd.DataFrame: # Confere se a leitura não acabou linha = file.readline() if "X---------X------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -1422,7 +1440,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def le_tabela(linha: str) -> np.ndarray: indice_ree = int(linha.split("REE: ")[1].split("-")[0].strip()) ree = linha.split("REE: ")[1].split("/")[0].split("-")[1].strip() @@ -1433,8 +1451,8 @@ def le_tabela(linha: str) -> np.ndarray: estagios = [s for s in linha.split(" ") if len(s) > 2] num_estagios = len(estagios) - 1 file.readline() - campo_cenario: List[Field] = [IntegerField(3, 4)] - campos_enas: List[Field] = [ + campo_cenario: list[Field] = [IntegerField(3, 4)] + campos_enas: list[Field] = [ FloatField(8, 8 + 9 * i, 1) for i in range(num_estagios) ] linha_tabela = Line(campo_cenario + campos_enas) @@ -1444,7 +1462,7 @@ def le_tabela(linha: str) -> np.ndarray: while True: linha = file.readline() if len(linha) < 4: - tab = tab[:i, :] # type: ignore + tab = tab[:i, :] break tab[i, :] = linha_tabela.read(linha) indices_rees.append(indice_ree) @@ -1470,9 +1488,9 @@ def converte_tabela_em_df() -> pd.DataFrame: df = df.astype({"cenario": np.int64}) return df - indices_rees: List[int] = [] - rees: List[str] = [] - subsistemas: List[str] = [] + indices_rees: list[int] = [] + rees: list[str] = [] + subsistemas: list[str] = [] tabela = None while True: # Confere se a leitura não acabou @@ -1516,7 +1534,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(tabela) cols = ["inicial"] + [ @@ -1537,19 +1555,19 @@ def converte_tabela_em_df() -> pd.DataFrame: - 3 ) - campos_ree: List[Field] = [ + campos_ree: list[Field] = [ LiteralField(12, 4), IntegerField(4, 17), IntegerField(4, 22), FloatField(7, 27, 1), ] - campos_vu: List[Field] = [ + campos_vu: list[Field] = [ FloatField(6, 35 + i * 7, 1) for i in range(num_estagios) ] self.__linha = Line(campos_ree + campos_vu) - rees: List[str] = [] - numeros: List[int] = [] - subsistemas: List[int] = [] + rees: list[str] = [] + numeros: list[int] = [] + subsistemas: list[int] = [] tabela = np.zeros((MAX_REES, num_estagios + 1)) # Salta outra linha file.readline() @@ -1558,7 +1576,7 @@ def converte_tabela_em_df() -> pd.DataFrame: # Confere se a leitura não acabou linha = file.readline() if "X------------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -1596,7 +1614,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(tabela) cols = ["inicial"] + [ @@ -1616,17 +1634,17 @@ def converte_tabela_em_df() -> pd.DataFrame: - 2 ) - campos_ree: List[Field] = [ + campos_ree: list[Field] = [ LiteralField(12, 4), IntegerField(4, 17), FloatField(7, 22, 1), ] - campos_vu: List[Field] = [ + campos_vu: list[Field] = [ FloatField(6, 30 + i * 7, 1) for i in range(num_estagios) ] self.__linha = Line(campos_ree + campos_vu) - subsistemas: List[int] = [] - numeros: List[int] = [] + subsistemas: list[int] = [] + numeros: list[int] = [] tabela = np.zeros((MAX_REES, num_estagios + 1)) # Salta outra linha file.readline() @@ -1635,7 +1653,7 @@ def converte_tabela_em_df() -> pd.DataFrame: # Confere se a leitura não acabou linha = file.readline() if "X------------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -1657,15 +1675,17 @@ class BlocoENAPreEstudoMensalREERelato(Block): BEGIN_PATTERN = r"ENERGIA NATURAL AFLUENTE POR REE \(MESES" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) - campos_ree: List[Field] = [ + campos_ree: list[Field] = [ LiteralField(14, 4), IntegerField(4, 19), IntegerField(4, 24), FloatField(8, 29, 1), ] - campos_ena: List[Field] = [ + campos_ena: list[Field] = [ FloatField(8, 38 + i * 9, 1) for i in range(len(MESES_DF) - 1) ] self.__line = Line(campos_ree + campos_ena) @@ -1685,7 +1705,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(tabela) cols = ["energia_armazenada_maxima"] + [ @@ -1700,14 +1720,14 @@ def converte_tabela_em_df() -> pd.DataFrame: for _ in range(5): file.readline() - rees: List[str] = [] + rees: list[str] = [] tabela = np.zeros((MAX_REES, len(MESES_DF))) i = 0 while True: # Confere se a leitura não acabou linha = file.readline() if "X--------------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -1730,14 +1750,16 @@ class BlocoENAPreEstudoMensalSubsistemaRelato(Block): BEGIN_PATTERN = r"ENERGIA NATURAL AFLUENTE POR SUBSISTEMA \(MESES" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) - campos_subsis: List[Field] = [ + campos_subsis: list[Field] = [ LiteralField(14, 4), IntegerField(4, 19), FloatField(8, 24, 1), ] - campos_ena: List[Field] = [ + campos_ena: list[Field] = [ FloatField(8, 33 + i * 9, 1) for i in range(len(MESES_DF) - 1) ] self.__line = Line(campos_subsis + campos_ena) @@ -1757,7 +1779,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(tabela) cols = ["energia_armazenada_maxima"] + [ @@ -1772,14 +1794,14 @@ def converte_tabela_em_df() -> pd.DataFrame: for _ in range(5): file.readline() - subsistemas: List[str] = [] + subsistemas: list[str] = [] tabela = np.zeros((MAX_SUBSISTEMAS, len(MESES_DF))) i = 0 while True: # Confere se a leitura não acabou linha = file.readline() if "X--------------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -1802,15 +1824,17 @@ class BlocoENAPreEstudoSemanalREERelato(Block): BEGIN_PATTERN = r"DADOS DE ENERGIA NATURAL AFLUENTE POR REE \(SEMANAS" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) - campos_ree: List[Field] = [ + campos_ree: list[Field] = [ LiteralField(14, 4), IntegerField(4, 19), IntegerField(4, 24), FloatField(8, 29, 1), ] - campos_ena: List[Field] = [ + campos_ena: list[Field] = [ FloatField(8, 38 + i * 9, 1) for i in range(5) ] self.__line = Line(campos_ree + campos_ena) @@ -1830,7 +1854,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(tabela) cols = ["energia_armazenada_maxima"] + [ @@ -1849,14 +1873,14 @@ def converte_tabela_em_df() -> pd.DataFrame: for _ in range(5): file.readline() - rees: List[str] = [] + rees: list[str] = [] tabela = np.zeros((MAX_REES, 6)) i = 0 while True: # Confere se a leitura não acabou linha = file.readline() if "X--------------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -1879,14 +1903,16 @@ class BlocoENAPreEstudoSemanalSubsistemaRelato(Block): BEGIN_PATTERN = r"NATURAL AFLUENTE POR SUBSISTEMA\(SEMANAS" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) - campos_subsis: List[Field] = [ + campos_subsis: list[Field] = [ LiteralField(14, 4), IntegerField(4, 19), FloatField(8, 24, 1), ] - campos_ena: List[Field] = [ + campos_ena: list[Field] = [ FloatField(8, 33 + i * 9, 1) for i in range(5) ] self.__line = Line(campos_subsis + campos_ena) @@ -1906,7 +1932,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: df = pd.DataFrame(tabela) cols = ["energia_armazenada_maxima"] + [ @@ -1925,14 +1951,14 @@ def converte_tabela_em_df() -> pd.DataFrame: for _ in range(5): file.readline() - subsistemas: List[str] = [] + subsistemas: list[str] = [] tabela = np.zeros((MAX_SUBSISTEMAS, 6)) i = 0 while True: # Confere se a leitura não acabou linha = file.readline() if "X--------------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -1955,7 +1981,9 @@ class BlocoDiasExcluidosSemanas(Block): BEGIN_PATTERN = " Mes inicial do periodo de estudos" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__line = Line([IntegerField(2, 53)]) @@ -1975,7 +2003,7 @@ def __eq__(self, o: object) -> bool: return self.data == bloco.data # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] file.readline() dias_semana_inicial = self.__line.read(file.readline())[0] dias_semana_final = self.__line.read(file.readline())[0] diff --git a/idecomp/decomp/modelos/relgnl.py b/idecomp/decomp/modelos/relgnl.py index c703d97d..fb1a59ff 100644 --- a/idecomp/decomp/modelos/relgnl.py +++ b/idecomp/decomp/modelos/relgnl.py @@ -1,16 +1,18 @@ # Imports do próprio módulo -from idecomp.config import MAX_ESTAGIOS, MAX_UTES +from typing import IO, Any + +import numpy as np +import pandas as pd # type: ignore[import-untyped] # Imports de módulos externos from cfinterface.components.block import Block -from cfinterface.components.line import Line from cfinterface.components.field import Field +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField -import numpy as np # type: ignore -import pandas as pd # type: ignore -from typing import IO, List + +from idecomp.config import MAX_ESTAGIOS, MAX_UTES class BlocoDadosUsinasRelgnl(Block): @@ -24,7 +26,9 @@ class BlocoDadosUsinasRelgnl(Block): BEGIN_PATTERN = "Relatorio dos Dados de Usinas Termicas GNL" END_PATTERN = "" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__line = Line( [ @@ -59,7 +63,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: cols = [ "geracao_minima_patamar_1", @@ -87,10 +91,10 @@ def converte_tabela_em_df() -> pd.DataFrame: for _ in range(5): file.readline() - numeros: List[int] = [] - usinas: List[str] = [] - subsistemas: List[str] = [] - estagios: List[int] = [] + numeros: list[int] = [] + usinas: list[str] = [] + subsistemas: list[str] = [] + estagios: list[int] = [] tabela = np.zeros((MAX_ESTAGIOS * MAX_UTES, 9)) @@ -102,7 +106,7 @@ def converte_tabela_em_df() -> pd.DataFrame: # Confere se a leitura não acabou linha = file.readline() if "X---X----------X" in linha: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break # Senão, lê mais uma linha @@ -147,7 +151,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: colunas = ["patamar_1", "patamar_2", "patamar_3"] df = pd.DataFrame(tabela, columns=colunas) @@ -175,28 +179,28 @@ def converte_tabela_em_df() -> pd.DataFrame: ) file.readline() file.readline() - campo_usi: List[Field] = [ + campo_usi: list[Field] = [ IntegerField(3, 3), LiteralField(11, 8), IntegerField(3, 20), LiteralField(6, 24), LiteralField(11, 31), ] - campos_cmos: List[Field] = [ + campos_cmos: list[Field] = [ FloatField(11, 43 + i * 11, 2) for i in range(num_estagios) ] self.__linha = Line(campo_usi + campos_cmos) - numeros: List[int] = [] - usinas: List[str] = [] - lags: List[int] = [] - subsistemas: List[str] = [] - semanas: List[str] = [] + numeros: list[int] = [] + usinas: list[str] = [] + lags: list[int] = [] + subsistemas: list[str] = [] + semanas: list[str] = [] tabela = np.zeros((MAX_UTES * MAX_ESTAGIOS, num_estagios)) i = 0 while True: linha: str = file.readline() if len(linha) < 3: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break dados = self.__linha.read(linha) @@ -235,7 +239,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_em_df() -> pd.DataFrame: colunas = ["patamar_1", "patamar_2", "patamar_3"] df = pd.DataFrame(tabela, columns=colunas) @@ -264,28 +268,28 @@ def converte_tabela_em_df() -> pd.DataFrame: ) file.readline() file.readline() - campo_usi: List[Field] = [ + campo_usi: list[Field] = [ IntegerField(3, 3), LiteralField(11, 8), IntegerField(3, 20), LiteralField(6, 24), IntegerField(9, 31), ] - campos_cmos: List[Field] = [ + campos_cmos: list[Field] = [ FloatField(11, 41 + i * 11, 2) for i in range(num_estagios) ] self.__linha = Line(campo_usi + campos_cmos) - numeros: List[int] = [] - usinas: List[str] = [] - lags: List[int] = [] - subsistemas: List[str] = [] - semanas: List[str] = [] + numeros: list[int] = [] + usinas: list[str] = [] + lags: list[int] = [] + subsistemas: list[str] = [] + semanas: list[str] = [] tabela = np.zeros((MAX_UTES * MAX_ESTAGIOS, num_estagios)) i = 0 while True: linha: str = file.readline() if len(linha) < 3: - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_em_df() break dados = self.__linha.read(linha) @@ -309,7 +313,9 @@ class BlocoRelatorioOperacaoRelgnl(Block): BEGIN_PATTERN = "RELATORIO DA OPERACAO TERMICA E CONTRATOS" END_PATTERN = "RELATORIO DA OPERACAO TERMICA E CONTRATOS" - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, previous: Any = None, next: Any = None, data: Any = None + ) -> None: super().__init__(previous, next, data) self.__linha_cenario = Line( [IntegerField(2, 34), IntegerField(4, 47), FloatField(8, 67, 6)] @@ -346,7 +352,7 @@ def __eq__(self, o: object) -> bool: return self.data.equals(bloco.data) # Override - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] def converte_tabela_para_df() -> pd.DataFrame: df = pd.DataFrame(tabela) cols = [ @@ -385,11 +391,11 @@ def converte_tabela_para_df() -> pd.DataFrame: # Variáveis auxiliares str_tabela = "Sinalizacao de Despacho antecipado em k meses" - subsistemas: List[str] = [] - usinas: List[str] = [] - lags: List[int] = [] - estagios: List[str] = [] - inicio_semanas: List[str] = [] + subsistemas: list[str] = [] + usinas: list[str] = [] + lags: list[int] = [] + estagios: list[str] = [] + inicio_semanas: list[str] = [] # Salta duas linhas e extrai o estágio / cenário file.readline() @@ -408,7 +414,7 @@ def converte_tabela_para_df() -> pd.DataFrame: # Verifica se acabou if self.ends(linha) or len(linha) == 0: file.seek(ultima_linha) - tabela = tabela[:i, :] # type: ignore + tabela = tabela[:i, :] self.data = converte_tabela_para_df() break # Senão, procura a linha que identifica o subsistema diff --git a/idecomp/decomp/modelos/vazoes.py b/idecomp/decomp/modelos/vazoes.py index 5502d9a2..5305715f 100644 --- a/idecomp/decomp/modelos/vazoes.py +++ b/idecomp/decomp/modelos/vazoes.py @@ -1,6 +1,6 @@ -from typing import IO, List +from typing import IO, Any -import numpy as np # type: ignore +import numpy as np from cfinterface.components.section import Section @@ -9,11 +9,16 @@ class SecaoVazoesPostos(Section): Registro com os dados associados às vazões dos postos. """ - __slots__ = [] + __slots__: list[str] = [] TAMANHO_REGISTRO = 320 - def __init__(self, previous=None, next=None, data=None) -> None: + def __init__( + self, + previous: Any = None, + next: Any = None, + data: Any = None, + ) -> None: super().__init__(previous, next, data) self.data = { "dados_gerais": [], @@ -32,15 +37,17 @@ def __eq__(self, o: object) -> bool: if not isinstance(o, SecaoVazoesPostos): return False bloco: SecaoVazoesPostos = o - if not all([ - isinstance(self.data, dict), - isinstance(o.data, dict), - ]): + if not all( + [ + isinstance(self.data, dict), + isinstance(o.data, dict), + ] + ): return False else: return self.data == bloco.data - def read(self, file: IO, *args, **kwargs): + def read(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] # Leitura do primeiro registro (dados gerais) self.__le_primeiro_registro(file) # Leitura do segundo registro (códigos UHEs) @@ -68,7 +75,7 @@ def read(self, file: IO, *args, **kwargs): # semanais observadas) self.__le_decimo_registro(file) - def __le_primeiro_registro(self, file: IO): + def __le_primeiro_registro(self, file: IO[Any]) -> None: dados = np.frombuffer( file.read(SecaoVazoesPostos.TAMANHO_REGISTRO * 4), dtype=np.int32, @@ -76,7 +83,7 @@ def __le_primeiro_registro(self, file: IO): ) self.data["dados_gerais"] = list(dados) - def __le_segundo_registro(self, file: IO): + def __le_segundo_registro(self, file: IO[Any]) -> None: dados = np.frombuffer( file.read( SecaoVazoesPostos.TAMANHO_REGISTRO @@ -89,7 +96,7 @@ def __le_segundo_registro(self, file: IO): ) self.data["codigos_uhes"] = list(dados) - def __le_terceiro_registro(self, file: IO): + def __le_terceiro_registro(self, file: IO[Any]) -> None: dados_caso = np.frombuffer( file.read(SecaoVazoesPostos.TAMANHO_REGISTRO * 4), dtype=np.int32, @@ -97,7 +104,7 @@ def __le_terceiro_registro(self, file: IO): ) self.data["dados_caso"] = list(dados_caso) - def __le_quarto_registro(self, file: IO): + def __le_quarto_registro(self, file: IO[Any]) -> None: dados_cenarios = np.frombuffer( file.read( SecaoVazoesPostos.TAMANHO_REGISTRO @@ -110,7 +117,7 @@ def __le_quarto_registro(self, file: IO): ) self.data["dados_cenarios"] = list(dados_cenarios) - def __le_quinto_registro(self, file: IO): + def __le_quinto_registro(self, file: IO[Any]) -> None: for _ in range(self.numero_semanas_completas): dados_cenarios = np.frombuffer( file.read(SecaoVazoesPostos.TAMANHO_REGISTRO * 4), @@ -119,7 +126,7 @@ def __le_quinto_registro(self, file: IO): ) self.data["previsoes"] += list(dados_cenarios) - def __le_sexto_registro(self, file: IO): + def __le_sexto_registro(self, file: IO[Any]) -> None: for _ in range(self.numero_cenarios_estocasticos): dados_cenarios = np.frombuffer( file.read(SecaoVazoesPostos.TAMANHO_REGISTRO * 4), @@ -128,7 +135,7 @@ def __le_sexto_registro(self, file: IO): ) self.data["cenarios_gerados"] += list(dados_cenarios) - def __le_setimo_registro(self, file: IO): + def __le_setimo_registro(self, file: IO[Any]) -> None: for _ in range(self.numero_semanas_completas): dados_cenarios = np.frombuffer( file.read(SecaoVazoesPostos.TAMANHO_REGISTRO * 4), @@ -139,7 +146,7 @@ def __le_setimo_registro(self, file: IO): dados_cenarios ) - def __le_oitavo_registro(self, file: IO): + def __le_oitavo_registro(self, file: IO[Any]) -> None: for _ in range(self.numero_cenarios_estocasticos): dados_cenarios = np.frombuffer( file.read(SecaoVazoesPostos.TAMANHO_REGISTRO * 4), @@ -150,7 +157,7 @@ def __le_oitavo_registro(self, file: IO): dados_cenarios ) - def __le_nono_registro(self, file: IO): + def __le_nono_registro(self, file: IO[Any]) -> None: for _ in range(self.numero_meses_observados): dados_cenarios = np.frombuffer( file.read(SecaoVazoesPostos.TAMANHO_REGISTRO * 4), @@ -159,7 +166,7 @@ def __le_nono_registro(self, file: IO): ) self.data["observacoes_mensais"] += list(dados_cenarios) - def __le_decimo_registro(self, file: IO): + def __le_decimo_registro(self, file: IO[Any]) -> None: for _ in range(self.numero_semanas_observadas): dados_cenarios = np.frombuffer( file.read(SecaoVazoesPostos.TAMANHO_REGISTRO * 4), @@ -168,7 +175,7 @@ def __le_decimo_registro(self, file: IO): ) self.data["observacoes_semanais"] += list(dados_cenarios) - def write(self, file: IO, *args, **kwargs): + def write(self, file: IO[Any], *args: Any, **kwargs: Any) -> None: # type: ignore[override] # Escrita do primeiro registro (dados gerais) self.__escreve_primeiro_registro(file) # Escrita do segundo registro (códigos UHEs) @@ -196,20 +203,20 @@ def write(self, file: IO, *args, **kwargs): # semanais observadas) self.__escreve_decimo_registro(file) - def __escreve_primeiro_registro(self, file: IO): + def __escreve_primeiro_registro(self, file: IO[Any]) -> None: file.write( np.array(self.data["dados_gerais"], dtype=np.int32).tobytes() ) - def __escreve_segundo_registro(self, file: IO): + def __escreve_segundo_registro(self, file: IO[Any]) -> None: file.write( np.array(self.data["codigos_uhes"], dtype=np.int32).tobytes() ) - def __escreve_terceiro_registro(self, file: IO): + def __escreve_terceiro_registro(self, file: IO[Any]) -> None: file.write(np.array(self.data["dados_caso"], dtype=np.int32).tobytes()) - def __escreve_quarto_registro(self, file: IO): + def __escreve_quarto_registro(self, file: IO[Any]) -> None: num_entradas = len(self.data["dados_cenarios"]) num_valores = ( self.__numero_blocos_cenarios() * SecaoVazoesPostos.TAMANHO_REGISTRO @@ -220,22 +227,22 @@ def __escreve_quarto_registro(self, file: IO): np.array(self.data["dados_cenarios"], dtype=np.float32).tobytes() ) - def __escreve_quinto_registro(self, file: IO): + def __escreve_quinto_registro(self, file: IO[Any]) -> None: file.write(np.array(self.data["previsoes"], dtype=np.int32).tobytes()) - def __escreve_sexto_registro(self, file: IO): + def __escreve_sexto_registro(self, file: IO[Any]) -> None: file.write( np.array(self.data["cenarios_gerados"], dtype=np.int32).tobytes() ) - def __escreve_setimo_registro(self, file: IO): + def __escreve_setimo_registro(self, file: IO[Any]) -> None: file.write( np.array( self.data["previsoes_com_postos_artificiais"], dtype=np.int32 ).tobytes() ) - def __escreve_oitavo_registro(self, file: IO): + def __escreve_oitavo_registro(self, file: IO[Any]) -> None: file.write( np.array( self.data["cenarios_calculados_com_postos_artificiais"], @@ -243,12 +250,12 @@ def __escreve_oitavo_registro(self, file: IO): ).tobytes() ) - def __escreve_nono_registro(self, file: IO): + def __escreve_nono_registro(self, file: IO[Any]) -> None: file.write( np.array(self.data["observacoes_mensais"], dtype=np.int32).tobytes() ) - def __escreve_decimo_registro(self, file: IO): + def __escreve_decimo_registro(self, file: IO[Any]) -> None: file.write( np.array( self.data["observacoes_semanais"], dtype=np.int32 @@ -279,7 +286,7 @@ def numero_uhes(self) -> int: return self.data["dados_gerais"][0] @numero_uhes.setter - def numero_uhes(self, n: int): + def numero_uhes(self, n: int) -> None: self.data["dados_gerais"][0] = n @property @@ -287,15 +294,15 @@ def numero_estagios(self) -> int: return self.data["dados_gerais"][1] @numero_estagios.setter - def numero_estagios(self, n: int): + def numero_estagios(self, n: int) -> None: self.data["dados_gerais"][1] = n @property - def numero_aberturas_estagios(self) -> List[int]: + def numero_aberturas_estagios(self) -> list[int]: return self.data["dados_gerais"][2 : 2 + self.numero_estagios] @numero_aberturas_estagios.setter - def numero_aberturas_estagios(self, n: List[int]): + def numero_aberturas_estagios(self, n: list[int]) -> None: self.data["dados_gerais"][2 : 2 + self.numero_estagios] = n @property @@ -304,15 +311,15 @@ def numero_postos(self) -> int: return 320 if valor_arquivo == 0 else valor_arquivo @numero_postos.setter - def numero_postos(self, n: int): + def numero_postos(self, n: int) -> None: self.data["dados_gerais"][2 + self.numero_estagios] = n @property - def codigos_uhes(self) -> List[int]: + def codigos_uhes(self) -> list[int]: return self.data["codigos_uhes"][: self.numero_uhes] @codigos_uhes.setter - def codigos_uhes(self, n: List[int]): + def codigos_uhes(self, n: list[int]) -> None: self.data["codigos_uhes"][: self.numero_uhes] = n @property @@ -344,59 +351,61 @@ def versao_modelo(self) -> int: return self.data["dados_caso"][5] @property - def probabilidades_nos(self) -> List[float]: + def probabilidades_nos(self) -> list[float]: return self.data["dados_cenarios"][ : sum(self.numero_aberturas_estagios) ] @probabilidades_nos.setter - def probabilidades_nos(self, probs: List[float]): + def probabilidades_nos(self, probs: list[float]) -> None: self.data["dados_cenarios"] = probs @property - def previsoes(self) -> List[int]: + def previsoes(self) -> list[int]: return self.data["previsoes"] @previsoes.setter - def previsoes(self, prevs: List[int]): + def previsoes(self, prevs: list[int]) -> None: self.data["previsoes"] = prevs @property - def cenarios_gerados(self) -> List[int]: + def cenarios_gerados(self) -> list[int]: return self.data["cenarios_gerados"] @cenarios_gerados.setter - def cenarios_gerados(self, cens: List[int]): + def cenarios_gerados(self, cens: list[int]) -> None: self.data["cenarios_gerados"] = cens @property - def previsoes_com_postos_artificiais(self) -> List[int]: + def previsoes_com_postos_artificiais(self) -> list[int]: return self.data["previsoes_com_postos_artificiais"] @previsoes_com_postos_artificiais.setter - def previsoes_com_postos_artificiais(self, prevs: List[int]): + def previsoes_com_postos_artificiais(self, prevs: list[int]) -> None: self.data["previsoes_com_postos_artificiais"] = prevs @property - def cenarios_calculados_com_postos_artificiais(self) -> List[int]: + def cenarios_calculados_com_postos_artificiais(self) -> list[int]: return self.data["cenarios_calculados_com_postos_artificiais"] @cenarios_calculados_com_postos_artificiais.setter - def cenarios_calculados_com_postos_artificiais(self, cens: List[int]): + def cenarios_calculados_com_postos_artificiais( + self, cens: list[int] + ) -> None: self.data["cenarios_calculados_com_postos_artificiais"] = cens @property - def observacoes_mensais(self) -> List[int]: + def observacoes_mensais(self) -> list[int]: return self.data["observacoes_mensais"] @observacoes_mensais.setter - def observacoes_mensais(self, obs: List[int]): + def observacoes_mensais(self, obs: list[int]) -> None: self.data["observacoes_mensais"] = obs @property - def observacoes_semanais(self) -> List[int]: + def observacoes_semanais(self) -> list[int]: return self.data["observacoes_semanais"] @observacoes_semanais.setter - def observacoes_semanais(self, obs: List[int]): + def observacoes_semanais(self, obs: list[int]) -> None: self.data["observacoes_semanais"] = obs diff --git a/idecomp/decomp/oper_desvio_fpha.py b/idecomp/decomp/oper_desvio_fpha.py index 43a7b32c..6d3807be 100644 --- a/idecomp/decomp/oper_desvio_fpha.py +++ b/idecomp/decomp/oper_desvio_fpha.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModeloLibs -from idecomp.decomp.modelos.oper_desvio_fpha import TabelaOperDesvioFpha +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModeloLibs +from idecomp.decomp.modelos.oper_desvio_fpha import TabelaOperDesvioFpha class OperDesvioFpha(ArquivoCSV): @@ -14,7 +13,7 @@ class OperDesvioFpha(ArquivoCSV): BLOCKS = [VersaoModeloLibs, TabelaOperDesvioFpha] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/oper_disp_usih.py b/idecomp/decomp/oper_disp_usih.py index 631c26f6..51b4e8c1 100644 --- a/idecomp/decomp/oper_disp_usih.py +++ b/idecomp/decomp/oper_disp_usih.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModeloLibs -from idecomp.decomp.modelos.oper_disp_usih import TabelaOperDispUsih +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModeloLibs +from idecomp.decomp.modelos.oper_disp_usih import TabelaOperDispUsih class OperDispUsih(ArquivoCSV): @@ -14,7 +13,7 @@ class OperDispUsih(ArquivoCSV): BLOCKS = [VersaoModeloLibs, TabelaOperDispUsih] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/oper_disp_usih_ree.py b/idecomp/decomp/oper_disp_usih_ree.py index c795ed9e..4601343a 100644 --- a/idecomp/decomp/oper_disp_usih_ree.py +++ b/idecomp/decomp/oper_disp_usih_ree.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModeloLibs -from idecomp.decomp.modelos.oper_disp_usih_ree import TabelaOperDispUsihRee +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModeloLibs +from idecomp.decomp.modelos.oper_disp_usih_ree import TabelaOperDispUsihRee class OperDispUsihRee(ArquivoCSV): @@ -15,7 +14,7 @@ class OperDispUsihRee(ArquivoCSV): BLOCKS = [VersaoModeloLibs, TabelaOperDispUsihRee] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/oper_disp_usih_subm.py b/idecomp/decomp/oper_disp_usih_subm.py index 29fc95b8..be111545 100644 --- a/idecomp/decomp/oper_disp_usih_subm.py +++ b/idecomp/decomp/oper_disp_usih_subm.py @@ -1,9 +1,8 @@ -from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModeloLibs -from idecomp.decomp.modelos.oper_disp_usih_subm import TabelaOperDispUsihSubm +import pandas as pd # type: ignore from idecomp.decomp.modelos.arquivoscsv.arquivocsv import ArquivoCSV -from typing import Optional -import pandas as pd # type: ignore +from idecomp.decomp.modelos.blocos.versaomodelo import VersaoModeloLibs +from idecomp.decomp.modelos.oper_disp_usih_subm import TabelaOperDispUsihSubm class OperDispUsihSubm(ArquivoCSV): @@ -15,7 +14,7 @@ class OperDispUsihSubm(ArquivoCSV): BLOCKS = [VersaoModeloLibs, TabelaOperDispUsihSubm] @property - def tabela(self) -> Optional[pd.DataFrame]: + def tabela(self) -> pd.DataFrame | None: """ A tabela de dados que está contida no arquivo. diff --git a/idecomp/decomp/postos.py b/idecomp/decomp/postos.py index 226bba2c..9a0c6ecf 100644 --- a/idecomp/decomp/postos.py +++ b/idecomp/decomp/postos.py @@ -1,9 +1,9 @@ -from cfinterface.files.registerfile import RegisterFile -from idecomp.decomp.modelos.postos import RegistroPostos -import pandas as pd # type: ignore +from typing import IO, Any, TypeVar +import pandas as pd # type: ignore[import-untyped] +from cfinterface.files.registerfile import RegisterFile -from typing import TypeVar, List, Optional, Union, IO +from idecomp.decomp.modelos.postos import RegistroPostos class Postos(RegisterFile): @@ -18,24 +18,27 @@ class Postos(RegisterFile): POSTOS = 320 STORAGE = "BINARY" - def __init__(self, data=...) -> None: + def __init__(self, data: Any = ...) -> None: super().__init__(data) - self.__df: Optional[pd.DataFrame] = None + self.__df: pd.DataFrame | None = None RegistroPostos.set_postos(self.POSTOS) - def write(self, to: Union[str, IO], *args, **kwargs): + def write(self, to: str | IO[Any], *args: Any, **kwargs: Any) -> None: self.__atualiza_registros() super().write(to, *args, **kwargs) - def __monta_df_de_registros(self) -> Optional[pd.DataFrame]: - registros: List[RegistroPostos] = [ + def __monta_df_de_registros(self) -> pd.DataFrame | None: + registros: list[RegistroPostos] = [ r for r in self.data.of_type(RegistroPostos) ] if len(registros) == 0: return None df = pd.DataFrame( data={ - "nome": [r.data[0] if r.data[0] is not None else "" for r in registros], + "nome": [ + r.data[0] if r.data[0] is not None else "" + for r in registros + ], "ano_inicio_historico": [r.data[1] for r in registros], "ano_fim_historico": [r.data[2] for r in registros], } @@ -50,8 +53,8 @@ def __monta_df_de_registros(self) -> Optional[pd.DataFrame]: ) return df - def __atualiza_registros(self): - registros: List[RegistroPostos] = [r for r in self.data][1:] + def __atualiza_registros(self) -> None: + registros: list[RegistroPostos] = [r for r in self.data][1:] # type: ignore[assignment] n_registros = len(registros) n_meses = self.postos.shape[0] # Deleta os registros que sobraram @@ -82,5 +85,5 @@ def postos(self) -> pd.DataFrame: return self.__df @postos.setter - def postos(self, df: pd.DataFrame): + def postos(self, df: pd.DataFrame) -> None: self.__df = df diff --git a/idecomp/decomp/relato.py b/idecomp/decomp/relato.py index 014c4abd..a355321f 100644 --- a/idecomp/decomp/relato.py +++ b/idecomp/decomp/relato.py @@ -1,35 +1,32 @@ -from idecomp.decomp.modelos.relato import BlocoREEsSubsistemas -from idecomp.decomp.modelos.relato import BlocoUHEsREEsSubsistemas -from idecomp.decomp.modelos.relato import BlocoConvergenciaRelato -from idecomp.decomp.modelos.relato import BlocoRelatorioOperacaoRelato -from idecomp.decomp.modelos.relato import BlocoRelatorioOperacaoUTERelato -from idecomp.decomp.modelos.relato import BlocoBalancoEnergeticoRelato -from idecomp.decomp.modelos.relato import BlocoCMORelato -from idecomp.decomp.modelos.relato import BlocoGeracaoTermicaSubsistemaRelato -from idecomp.decomp.modelos.relato import BlocoCustoOperacaoValorEsperadoRelato -from idecomp.decomp.modelos.relato import BlocoENAAcoplamentoREERelato -from idecomp.decomp.modelos.relato import BlocoVolumeUtilReservatorioRelato -from idecomp.decomp.modelos.relato import BlocoDadosTermicasRelato -from idecomp.decomp.modelos.relato import BlocoDisponibilidadesTermicasRelato -from idecomp.decomp.modelos.relato import BlocoDadosMercadoRelato -from idecomp.decomp.modelos.relato import BlocoEnergiaArmazenadaREERelato -from idecomp.decomp.modelos.relato import ( - BlocoEnergiaArmazenadaSubsistemaRelato, -) # noqa -from idecomp.decomp.modelos.relato import BlocoENAPreEstudoMensalREERelato -from idecomp.decomp.modelos.relato import ( - BlocoENAPreEstudoMensalSubsistemaRelato, -) # noqa -from idecomp.decomp.modelos.relato import BlocoENAPreEstudoSemanalREERelato -from idecomp.decomp.modelos.relato import ( - BlocoENAPreEstudoSemanalSubsistemaRelato, -) # noqa -from idecomp.decomp.modelos.relato import BlocoDiasExcluidosSemanas +from typing import Any, TypeVar +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.block import Block from cfinterface.files.blockfile import BlockFile -from typing import Union, List, TypeVar, Optional -import pandas as pd # type: ignore + +from idecomp.decomp.modelos.relato import ( + BlocoBalancoEnergeticoRelato, + BlocoCMORelato, + BlocoConvergenciaRelato, + BlocoCustoOperacaoValorEsperadoRelato, + BlocoDadosMercadoRelato, + BlocoDadosTermicasRelato, + BlocoDiasExcluidosSemanas, + BlocoDisponibilidadesTermicasRelato, + BlocoENAAcoplamentoREERelato, + BlocoENAPreEstudoMensalREERelato, + BlocoENAPreEstudoMensalSubsistemaRelato, + BlocoENAPreEstudoSemanalREERelato, + BlocoENAPreEstudoSemanalSubsistemaRelato, + BlocoEnergiaArmazenadaREERelato, + BlocoEnergiaArmazenadaSubsistemaRelato, + BlocoGeracaoTermicaSubsistemaRelato, + BlocoREEsSubsistemas, + BlocoRelatorioOperacaoRelato, + BlocoRelatorioOperacaoUTERelato, + BlocoUHEsREEsSubsistemas, + BlocoVolumeUtilReservatorioRelato, +) # noqa # noqa # noqa class Relato(BlockFile): @@ -69,7 +66,7 @@ class Relato(BlockFile): BlocoDiasExcluidosSemanas, ] - def __init__(self, data=...) -> None: + def __init__(self, data: Any = ...) -> None: super().__init__(data) self.__relatorios_operacao_ute = None self.__relatorios_operacao_uhe = None @@ -77,8 +74,8 @@ def __init__(self, data=...) -> None: self.__balanco_energetico = None def __concatena_blocos( - self, blocos: Union[T, List[T]], indice_data=None - ) -> Optional[pd.DataFrame]: + self, blocos: T | list[T], indice_data: int | None = None + ) -> pd.DataFrame | None: df = None if not isinstance(blocos, list): blocos = [blocos] @@ -93,7 +90,7 @@ def __concatena_blocos( return None @property - def rees_submercados(self) -> Optional[pd.DataFrame]: + def rees_submercados(self) -> pd.DataFrame | None: """ Obtém a tabela de relação entre os REEs e os submercados do DECOMP existente no :class:`Relato` @@ -113,7 +110,7 @@ def rees_submercados(self) -> Optional[pd.DataFrame]: return None @property - def uhes_rees_submercados(self) -> Optional[pd.DataFrame]: + def uhes_rees_submercados(self) -> pd.DataFrame | None: """ Obtém a tabela de relação entre as UHEs, REEs e os submercados do DECOMP existente no :class:`Relato` @@ -135,7 +132,7 @@ def uhes_rees_submercados(self) -> Optional[pd.DataFrame]: return None @property - def convergencia(self) -> Optional[pd.DataFrame]: + def convergencia(self) -> pd.DataFrame | None: """ Obtém a tabela de convergência do DECOMP existente no :class:`Relato` @@ -161,7 +158,7 @@ def convergencia(self) -> Optional[pd.DataFrame]: return None @property - def relatorio_operacao_custos(self) -> Optional[pd.DataFrame]: + def relatorio_operacao_custos(self) -> pd.DataFrame | None: """ Obtém a tabela de operação de cada UHE por estágio do DECOMP existente no :class:`Relato` @@ -186,7 +183,7 @@ def relatorio_operacao_custos(self) -> Optional[pd.DataFrame]: :rtype: pd.DataFrame | None """ if self.__relatorios_operacao_custos is None: - blocos_custos: List[BlocoRelatorioOperacaoRelato] = [] + blocos_custos: list[BlocoRelatorioOperacaoRelato] = [] for b in self.data.of_type(BlocoRelatorioOperacaoRelato): if b.data[0] == "GERAL": blocos_custos.append(b) @@ -196,7 +193,7 @@ def relatorio_operacao_custos(self) -> Optional[pd.DataFrame]: return self.__relatorios_operacao_custos @property - def relatorio_operacao_uhe(self) -> Optional[pd.DataFrame]: + def relatorio_operacao_uhe(self) -> pd.DataFrame | None: """ Obtém a tabela de operação de cada UHE por estágio do DECOMP existente no :class:`Relato` @@ -230,7 +227,7 @@ def relatorio_operacao_uhe(self) -> Optional[pd.DataFrame]: :rtype: pd.DataFrame | None """ if self.__relatorios_operacao_uhe is None: - blocos_uhe: List[BlocoRelatorioOperacaoRelato] = [] + blocos_uhe: list[BlocoRelatorioOperacaoRelato] = [] for b in self.data.of_type(BlocoRelatorioOperacaoRelato): if b.data[0] == "UHE": blocos_uhe.append(b) @@ -240,7 +237,7 @@ def relatorio_operacao_uhe(self) -> Optional[pd.DataFrame]: return self.__relatorios_operacao_uhe @property - def relatorio_operacao_ute(self) -> Optional[pd.DataFrame]: + def relatorio_operacao_ute(self) -> pd.DataFrame | None: """ Obtém a tabela de operação de cada UTE por estágio do DECOMP existente no :class:`Relato` @@ -268,7 +265,7 @@ def relatorio_operacao_ute(self) -> Optional[pd.DataFrame]: return self.__relatorios_operacao_ute @property - def balanco_energetico(self) -> Optional[pd.DataFrame]: + def balanco_energetico(self) -> pd.DataFrame | None: """ Obtém a tabela de balanço energético entre os patamares para cada estágio do DECOMP existente no :class:`Relato` @@ -307,7 +304,7 @@ def balanco_energetico(self) -> Optional[pd.DataFrame]: return self.__balanco_energetico @property - def cmo_medio_submercado(self) -> Optional[pd.DataFrame]: + def cmo_medio_submercado(self) -> pd.DataFrame | None: """ Obtém a tabela de CMO existente no :class:`Relato` @@ -327,7 +324,7 @@ def cmo_medio_submercado(self) -> Optional[pd.DataFrame]: return None @property - def geracao_termica_submercado(self) -> Optional[pd.DataFrame]: + def geracao_termica_submercado(self) -> pd.DataFrame | None: """ Obtém a tabela de Geração Térmica existente no :class:`Relato` @@ -346,7 +343,7 @@ def geracao_termica_submercado(self) -> Optional[pd.DataFrame]: return None @property - def custo_operacao_valor_esperado(self) -> Optional[pd.DataFrame]: + def custo_operacao_valor_esperado(self) -> pd.DataFrame | None: """ Obtém a tabela de Custo de Operação existente no :class:`Relato` @@ -365,7 +362,7 @@ def custo_operacao_valor_esperado(self) -> Optional[pd.DataFrame]: return None @property - def energia_armazenada_ree(self) -> Optional[pd.DataFrame]: + def energia_armazenada_ree(self) -> pd.DataFrame | None: """ Obtém a tabela de Energia Armazenada por REE (em %) existente no :class:`Relato` @@ -387,7 +384,7 @@ def energia_armazenada_ree(self) -> Optional[pd.DataFrame]: return None @property - def energia_armazenada_submercado(self) -> Optional[pd.DataFrame]: + def energia_armazenada_submercado(self) -> pd.DataFrame | None: """ Obtém a tabela de Energia Armazenada por Submercado (em %) existente no :class:`Relato` @@ -408,7 +405,7 @@ def energia_armazenada_submercado(self) -> Optional[pd.DataFrame]: return None @property - def volume_util_reservatorios(self) -> Optional[pd.DataFrame]: + def volume_util_reservatorios(self) -> pd.DataFrame | None: """ Obtém a tabela de Volumes Úteis por reservatório (em %) existente no :class:`Relato` @@ -430,7 +427,7 @@ def volume_util_reservatorios(self) -> Optional[pd.DataFrame]: return None @property - def dados_termicas(self) -> Optional[pd.DataFrame]: + def dados_termicas(self) -> pd.DataFrame | None: """ Obtém a tabela de dados cadastrais das usinas térmicas existente no :class:`Relato`. @@ -458,7 +455,7 @@ def dados_termicas(self) -> Optional[pd.DataFrame]: return None @property - def disponibilidades_termicas(self) -> Optional[pd.DataFrame]: + def disponibilidades_termicas(self) -> pd.DataFrame | None: """ Obtém a tabela de disponibilidades das usinas térmicas existente no :class:`Relato`. @@ -479,7 +476,7 @@ def disponibilidades_termicas(self) -> Optional[pd.DataFrame]: return None @property - def dados_mercado(self) -> Optional[pd.DataFrame]: + def dados_mercado(self) -> pd.DataFrame | None: """ Obtém a tabela de dados do mercado de energia existente no :class:`Relato`. @@ -501,7 +498,7 @@ def dados_mercado(self) -> Optional[pd.DataFrame]: return None @property - def ena_acoplamento_ree(self) -> Optional[pd.DataFrame]: + def ena_acoplamento_ree(self) -> pd.DataFrame | None: """ Obtém a tabela de ENA para acoplamento com o longo prazo (em MWmed) existente no :class:`Relato` @@ -523,7 +520,7 @@ def ena_acoplamento_ree(self) -> Optional[pd.DataFrame]: return None @property - def ena_pre_estudo_mensal_ree(self) -> Optional[pd.DataFrame]: + def ena_pre_estudo_mensal_ree(self) -> pd.DataFrame | None: """ Obtém a tabela de ENA Pré-Estudo Mensal por REE existente no :class:`Relato` @@ -545,7 +542,7 @@ def ena_pre_estudo_mensal_ree(self) -> Optional[pd.DataFrame]: return None @property - def ena_pre_estudo_mensal_submercado(self) -> Optional[pd.DataFrame]: + def ena_pre_estudo_mensal_submercado(self) -> pd.DataFrame | None: """ Obtém a tabela de ENA Pré-Estudo Mensal por Submercado existente no :class:`Relato` @@ -569,7 +566,7 @@ def ena_pre_estudo_mensal_submercado(self) -> Optional[pd.DataFrame]: return None @property - def ena_pre_estudo_semanal_ree(self) -> Optional[pd.DataFrame]: + def ena_pre_estudo_semanal_ree(self) -> pd.DataFrame | None: """ Obtém a tabela de ENA Pré-Estudo Semanal por REE existente no :class:`Relato` @@ -591,7 +588,7 @@ def ena_pre_estudo_semanal_ree(self) -> Optional[pd.DataFrame]: return None @property - def ena_pre_estudo_semanal_submercado(self) -> Optional[pd.DataFrame]: + def ena_pre_estudo_semanal_submercado(self) -> pd.DataFrame | None: """ Obtém a tabela de ENA Pré-Estudo Semanal por Submercado existente no :class:`Relato` @@ -615,7 +612,7 @@ def ena_pre_estudo_semanal_submercado(self) -> Optional[pd.DataFrame]: return None @property - def energia_armazenada_maxima_submercado(self) -> Optional[pd.DataFrame]: + def energia_armazenada_maxima_submercado(self) -> pd.DataFrame | None: """ Obtém a tabela de Energia Armazenada Máxima (EARMax) em MWmes por submercado existente no :class:`Relato` @@ -635,7 +632,7 @@ def energia_armazenada_maxima_submercado(self) -> Optional[pd.DataFrame]: return None @property - def dias_excluidos_semana_inicial(self) -> Optional[int]: + def dias_excluidos_semana_inicial(self) -> int | None: """ Obtém o número de dias excluídos da semana inicial. @@ -648,7 +645,7 @@ def dias_excluidos_semana_inicial(self) -> Optional[int]: return None @property - def dias_excluidos_semana_final(self) -> Optional[int]: + def dias_excluidos_semana_final(self) -> int | None: """ Obtém o número de dias excluídos da semana final. diff --git a/idecomp/decomp/relgnl.py b/idecomp/decomp/relgnl.py index d88a02b5..f6ac71bc 100644 --- a/idecomp/decomp/relgnl.py +++ b/idecomp/decomp/relgnl.py @@ -1,11 +1,15 @@ -from idecomp.decomp.modelos.relgnl import BlocoDadosUsinasRelgnl -from idecomp.decomp.modelos.relgnl import BlocoComandosUsinasAjustesTGRelgnl -from idecomp.decomp.modelos.relgnl import BlocoComandosUsinasAjustesRERelgnl -from idecomp.decomp.modelos.relgnl import BlocoRelatorioOperacaoRelgnl +from typing import Any, TypeVar + +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.block import Block from cfinterface.files.blockfile import BlockFile -from typing import Type, List, TypeVar, Optional -import pandas as pd # type: ignore + +from idecomp.decomp.modelos.relgnl import ( + BlocoComandosUsinasAjustesRERelgnl, + BlocoComandosUsinasAjustesTGRelgnl, + BlocoDadosUsinasRelgnl, + BlocoRelatorioOperacaoRelgnl, +) class Relgnl(BlockFile): @@ -28,11 +32,11 @@ class Relgnl(BlockFile): BlocoRelatorioOperacaoRelgnl, ] - def __init__(self, data=...) -> None: + def __init__(self, data: Any = ...) -> None: super().__init__(data) self.__relatorio_operacao_gnl = None - def __concatena_blocos(self, bloco: Type[T]) -> Optional[pd.DataFrame]: + def __concatena_blocos(self, bloco: type[T]) -> pd.DataFrame | None: """ Adiciona uma coluna com os estágios de cada amostra e outra com o estágio de cada uma, assumindo @@ -43,7 +47,7 @@ def __concatena_blocos(self, bloco: Type[T]) -> Optional[pd.DataFrame]: :rtype: pd.DataFrame """ - col_estagio: List[int] = [] + col_estagio: list[int] = [] df = None for i, b in enumerate(self.data.of_type(bloco)): if not isinstance(b, Block): @@ -61,7 +65,7 @@ def __concatena_blocos(self, bloco: Type[T]) -> Optional[pd.DataFrame]: return None @property - def usinas_termicas(self) -> Optional[pd.DataFrame]: + def usinas_termicas(self) -> pd.DataFrame | None: """ Tabela de informações das usinas térmicas GNL. @@ -88,7 +92,7 @@ def usinas_termicas(self) -> Optional[pd.DataFrame]: return None @property - def comandos_usinas_registros_tg(self) -> Optional[pd.DataFrame]: + def comandos_usinas_registros_tg(self) -> pd.DataFrame | None: """ Tabela de comandos das usinas térmicas GNL com ajustes devido aos registros TG. @@ -111,7 +115,7 @@ def comandos_usinas_registros_tg(self) -> Optional[pd.DataFrame]: return None @property - def comandos_usinas_restricoes_eletricas(self) -> Optional[pd.DataFrame]: + def comandos_usinas_restricoes_eletricas(self) -> pd.DataFrame | None: """ Tabela de comandos das usinas térmicas GNL com ajustes devido a restrições elétricas especiais. @@ -134,7 +138,7 @@ def comandos_usinas_restricoes_eletricas(self) -> Optional[pd.DataFrame]: return None @property - def relatorio_operacao_termica(self) -> Optional[pd.DataFrame]: + def relatorio_operacao_termica(self) -> pd.DataFrame | None: """ Tabela com o relatório do despacho sinalizado para as usinas térmicas GNL. diff --git a/idecomp/decomp/vazoes.py b/idecomp/decomp/vazoes.py index 089d145e..3f7e6c47 100644 --- a/idecomp/decomp/vazoes.py +++ b/idecomp/decomp/vazoes.py @@ -1,7 +1,7 @@ -from typing import List, Optional, TypeVar +from typing import Any, TypeVar -import numpy as np # type: ignore -import pandas as pd # type: ignore +import numpy as np +import pandas as pd # type: ignore[import-untyped] from cfinterface.files.sectionfile import SectionFile from idecomp.decomp.modelos.vazoes import SecaoVazoesPostos @@ -18,26 +18,26 @@ class Vazoes(SectionFile): SECTIONS = [SecaoVazoesPostos] STORAGE = "BINARY" - def __init__(self, data=...) -> None: + def __init__(self, data: Any = ...) -> None: super().__init__(data) - self.__df_probabilidades: Optional[pd.DataFrame] = None - self.__df_previsoes_semanais: Optional[pd.DataFrame] = None - self.__df_cenarios_mensais_gerados: Optional[pd.DataFrame] = None - self.__df_previsoes_semanais_com_postos_artificiais: Optional[ - pd.DataFrame - ] = None - self.__df_cenarios_mensais_calculados_com_postos_artificiais: Optional[ - pd.DataFrame - ] = None - self.__df_observacoes_mensais: Optional[pd.DataFrame] = None - self.__df_observacoes_semanais: Optional[pd.DataFrame] = None - - def __obtem_secao_vazoes(self) -> Optional[SecaoVazoesPostos]: + self.__df_probabilidades: pd.DataFrame | None = None + self.__df_previsoes_semanais: pd.DataFrame | None = None + self.__df_cenarios_mensais_gerados: pd.DataFrame | None = None + self.__df_previsoes_semanais_com_postos_artificiais: ( + pd.DataFrame | None + ) = None + self.__df_cenarios_mensais_calculados_com_postos_artificiais: ( + pd.DataFrame | None + ) = None + self.__df_observacoes_mensais: pd.DataFrame | None = None + self.__df_observacoes_semanais: pd.DataFrame | None = None + + def __obtem_secao_vazoes(self) -> SecaoVazoesPostos | None: s = self.data.get_sections_of_type(SecaoVazoesPostos) return s if not isinstance(s, list) else None @property - def numero_aberturas_estagios(self) -> Optional[List[int]]: + def numero_aberturas_estagios(self) -> list[int] | None: """ Obtém a lista com o número de aberturas por estágio da árvore. @@ -51,13 +51,13 @@ def numero_aberturas_estagios(self) -> Optional[List[int]]: return None @numero_aberturas_estagios.setter - def numero_aberturas_estagios(self, a: List[int]): + def numero_aberturas_estagios(self, a: list[int]) -> None: dados = self.__obtem_secao_vazoes() if dados is not None: dados.numero_aberturas_estagios = a @property - def probabilidades(self) -> Optional[pd.DataFrame]: + def probabilidades(self) -> pd.DataFrame | None: """ Obtém a tabela com as probabilidades de cada nó da árvore de cenários que foi gerada para o modelo. @@ -95,14 +95,14 @@ def probabilidades(self) -> Optional[pd.DataFrame]: return self.__df_probabilidades @probabilidades.setter - def probabilidades(self, df: pd.DataFrame): + def probabilidades(self, df: pd.DataFrame) -> None: dados = self.__obtem_secao_vazoes() if dados is not None: dados.probabilidades_nos = df["probabilidade"].tolist() self.__df_probabilidades = None @property - def previsoes(self) -> Optional[pd.DataFrame]: + def previsoes(self) -> pd.DataFrame | None: """ Obtém a tabela com as vazões previstas de cada nó da árvore de cenários, para a etapa determinística da execução, por posto. @@ -131,7 +131,7 @@ def previsoes(self) -> Optional[pd.DataFrame]: return self.__df_previsoes_semanais @previsoes.setter - def previsoes(self, df: pd.DataFrame): + def previsoes(self, df: pd.DataFrame) -> None: dados = self.__obtem_secao_vazoes() if dados is not None: n_postos = dados.numero_postos @@ -146,7 +146,7 @@ def previsoes(self, df: pd.DataFrame): self.__df_previsoes_semanais = None @property - def previsoes_com_postos_artificiais(self) -> Optional[pd.DataFrame]: + def previsoes_com_postos_artificiais(self) -> pd.DataFrame | None: """ Obtém a tabela com as vazões previstas de cada nó da árvore de cenários, para a etapa determinística da execução, por posto. @@ -178,7 +178,7 @@ def previsoes_com_postos_artificiais(self) -> Optional[pd.DataFrame]: return self.__df_previsoes_semanais_com_postos_artificiais @previsoes_com_postos_artificiais.setter - def previsoes_com_postos_artificiais(self, df: pd.DataFrame): + def previsoes_com_postos_artificiais(self, df: pd.DataFrame) -> None: dados = self.__obtem_secao_vazoes() if dados is not None: n_postos = dados.numero_postos @@ -195,7 +195,7 @@ def previsoes_com_postos_artificiais(self, df: pd.DataFrame): self.__df_previsoes_semanais_com_postos_artificiais = None @property - def cenarios_gerados(self) -> Optional[pd.DataFrame]: + def cenarios_gerados(self) -> pd.DataFrame | None: """ Obtém a tabela com as cenários gerados de cada nó da árvore de cenários, para a etapa estocástica da execução, por posto. @@ -237,7 +237,7 @@ def cenarios_gerados(self) -> Optional[pd.DataFrame]: return self.__df_cenarios_mensais_gerados @cenarios_gerados.setter - def cenarios_gerados(self, df: pd.DataFrame): + def cenarios_gerados(self, df: pd.DataFrame) -> None: dados = self.__obtem_secao_vazoes() if dados is not None: n_postos = dados.numero_postos @@ -250,7 +250,7 @@ def cenarios_gerados(self, df: pd.DataFrame): @property def cenarios_calculados_com_postos_artificiais( self, - ) -> Optional[pd.DataFrame]: + ) -> pd.DataFrame | None: """ Obtém a tabela com as cenários gerados de cada nó da árvore de cenários, para a etapa estocástica da execução, por posto. @@ -293,7 +293,9 @@ def cenarios_calculados_com_postos_artificiais( return self.__df_cenarios_mensais_calculados_com_postos_artificiais @cenarios_calculados_com_postos_artificiais.setter - def cenarios_calculados_com_postos_artificiais(self, df: pd.DataFrame): + def cenarios_calculados_com_postos_artificiais( + self, df: pd.DataFrame + ) -> None: dados = self.__obtem_secao_vazoes() if dados is not None: n_postos = dados.numero_postos @@ -304,7 +306,7 @@ def cenarios_calculados_com_postos_artificiais(self, df: pd.DataFrame): self.__df_cenarios_mensais_calculados_com_postos_artificiais = None @property - def observacoes_semanais(self) -> Optional[pd.DataFrame]: + def observacoes_semanais(self) -> pd.DataFrame | None: """ Obtém a tabela com as observações semanais de cada nó da árvore de cenários, por posto. @@ -333,7 +335,7 @@ def observacoes_semanais(self) -> Optional[pd.DataFrame]: return self.__df_observacoes_semanais @observacoes_semanais.setter - def observacoes_semanais(self, df: pd.DataFrame): + def observacoes_semanais(self, df: pd.DataFrame) -> None: dados = self.__obtem_secao_vazoes() if dados is not None: n_postos = dados.numero_postos @@ -350,7 +352,7 @@ def observacoes_semanais(self, df: pd.DataFrame): self.__df_observacoes_semanais = None @property - def observacoes_mensais(self) -> Optional[pd.DataFrame]: + def observacoes_mensais(self) -> pd.DataFrame | None: """ Obtém a tabela com as observações mensais de cada nó da árvore de cenários, por posto. @@ -379,7 +381,7 @@ def observacoes_mensais(self) -> Optional[pd.DataFrame]: return self.__df_observacoes_mensais @observacoes_mensais.setter - def observacoes_mensais(self, df: pd.DataFrame): + def observacoes_mensais(self, df: pd.DataFrame) -> None: dados = self.__obtem_secao_vazoes() if dados is not None: n_postos = dados.numero_postos diff --git a/idecomp/libs/modelos/restricoes.py b/idecomp/libs/modelos/restricoes.py index 5bd0fdc5..fe94b43d 100644 --- a/idecomp/libs/modelos/restricoes.py +++ b/idecomp/libs/modelos/restricoes.py @@ -1,11 +1,12 @@ -from typing import Optional -from cfinterface.components.register import Register -from cfinterface.components.line import Line +from datetime import datetime + +from cfinterface.components.datetimefield import DatetimeField +from cfinterface.components.floatfield import FloatField from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField -from cfinterface.components.floatfield import FloatField -from cfinterface.components.datetimefield import DatetimeField -from datetime import datetime +from cfinterface.components.register import Register + from idecomp.config import FORMATO_CAMPOS_DATA_LIBS @@ -30,7 +31,7 @@ class RegistroRestricaoEletricaHorizontePeriodo(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -40,11 +41,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio_inicio(self) -> Optional[int]: + def estagio_inicio(self) -> int | None: """ O estágio de início da validade da restrição. @@ -54,11 +55,11 @@ def estagio_inicio(self) -> Optional[int]: return self.data[1] @estagio_inicio.setter - def estagio_inicio(self, c: int): + def estagio_inicio(self, c: int) -> None: self.data[1] = c @property - def estagio_fim(self) -> Optional[int]: + def estagio_fim(self) -> int | None: """ O estágio de fim da validade da restrição. @@ -68,7 +69,7 @@ def estagio_fim(self) -> Optional[int]: return self.data[2] @estagio_fim.setter - def estagio_fim(self, n: int): + def estagio_fim(self, n: int) -> None: self.data[2] = n @@ -93,7 +94,7 @@ class RegistroRestricaoEletricaHorizonteData(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -103,11 +104,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def data_inicio(self) -> Optional[datetime]: + def data_inicio(self) -> datetime | None: """ A data de início da validade da restrição. @@ -117,11 +118,11 @@ def data_inicio(self) -> Optional[datetime]: return self.data[1] @data_inicio.setter - def data_inicio(self, c: datetime): + def data_inicio(self, c: datetime) -> None: self.data[1] = c @property - def data_fim(self) -> Optional[datetime]: + def data_fim(self) -> datetime | None: """ A data de fim da validade da restrição. @@ -131,7 +132,7 @@ def data_fim(self) -> Optional[datetime]: return self.data[2] @data_fim.setter - def data_fim(self, n: datetime): + def data_fim(self, n: datetime) -> None: self.data[2] = n @@ -154,7 +155,7 @@ class RegistroRestricaoEletricaFormula(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -164,11 +165,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def formula(self) -> Optional[str]: + def formula(self) -> str | None: """ A fórmula da restrição. @@ -178,7 +179,7 @@ def formula(self) -> Optional[str]: return self.data[1] @formula.setter - def formula(self, n: str): + def formula(self, n: str) -> None: self.data[1] = n @@ -205,7 +206,7 @@ class RegistroRestricaoEletricaFormulaPeriodoPatamar(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -215,11 +216,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio_inicio(self) -> Optional[int]: + def estagio_inicio(self) -> int | None: """ O estágio de início da restrição. @@ -229,11 +230,11 @@ def estagio_inicio(self) -> Optional[int]: return self.data[1] @estagio_inicio.setter - def estagio_inicio(self, c: int): + def estagio_inicio(self, c: int) -> None: self.data[1] = c @property - def estagio_fim(self) -> Optional[int]: + def estagio_fim(self) -> int | None: """ O estágio de fim da restrição. @@ -243,11 +244,11 @@ def estagio_fim(self) -> Optional[int]: return self.data[2] @estagio_fim.setter - def estagio_fim(self, c: int): + def estagio_fim(self, c: int) -> None: self.data[2] = c @property - def patamar(self) -> Optional[int]: + def patamar(self) -> int | None: """ O índice do patamar de carga. @@ -257,11 +258,11 @@ def patamar(self) -> Optional[int]: return self.data[3] @patamar.setter - def patamar(self, c: int): + def patamar(self, c: int) -> None: self.data[3] = c @property - def formula(self) -> Optional[str]: + def formula(self) -> str | None: """ A fórmula da restrição. @@ -271,7 +272,7 @@ def formula(self) -> Optional[str]: return self.data[4] @formula.setter - def formula(self, n: str): + def formula(self, n: str) -> None: self.data[4] = n @@ -298,7 +299,7 @@ class RegistroRestricaoEletricaFormulaDataPatamar(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -308,11 +309,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def data_inicio(self) -> Optional[datetime]: + def data_inicio(self) -> datetime | None: """ A data de início da restrição. @@ -322,11 +323,11 @@ def data_inicio(self) -> Optional[datetime]: return self.data[1] @data_inicio.setter - def data_inicio(self, c: datetime): + def data_inicio(self, c: datetime) -> None: self.data[1] = c @property - def data_fim(self) -> Optional[datetime]: + def data_fim(self) -> datetime | None: """ A data de fim da restrição. @@ -336,11 +337,11 @@ def data_fim(self) -> Optional[datetime]: return self.data[2] @data_fim.setter - def data_fim(self, c: datetime): + def data_fim(self, c: datetime) -> None: self.data[2] = c @property - def patamar(self) -> Optional[int]: + def patamar(self) -> int | None: """ O índice do patamar de carga. @@ -350,11 +351,11 @@ def patamar(self) -> Optional[int]: return self.data[3] @patamar.setter - def patamar(self, c: int): + def patamar(self, c: int) -> None: self.data[3] = c @property - def formula(self) -> Optional[str]: + def formula(self) -> str | None: """ A fórmula da restrição. @@ -364,7 +365,7 @@ def formula(self) -> Optional[str]: return self.data[4] @formula.setter - def formula(self, n: str): + def formula(self, n: str) -> None: self.data[4] = n @@ -392,7 +393,7 @@ class RegistroRestricaoEletricaLimitesFormulaPeriodoPatamar(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -402,11 +403,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio_inicio(self) -> Optional[int]: + def estagio_inicio(self) -> int | None: """ O estágio de início da validade dos limites da restrição. @@ -416,11 +417,11 @@ def estagio_inicio(self) -> Optional[int]: return self.data[1] @estagio_inicio.setter - def estagio_inicio(self, c: int): + def estagio_inicio(self, c: int) -> None: self.data[1] = c @property - def estagio_fim(self) -> Optional[int]: + def estagio_fim(self) -> int | None: """ O estágio de fim da validade dos limites da restrição. @@ -430,11 +431,11 @@ def estagio_fim(self) -> Optional[int]: return self.data[2] @estagio_fim.setter - def estagio_fim(self, v: int): + def estagio_fim(self, v: int) -> None: self.data[2] = v @property - def patamar(self) -> Optional[int]: + def patamar(self) -> int | None: """ O índice do patamar para os limites. @@ -444,11 +445,11 @@ def patamar(self) -> Optional[int]: return self.data[3] @patamar.setter - def patamar(self, v: int): + def patamar(self, v: int) -> None: self.data[3] = v @property - def limite_inferior(self) -> Optional[str]: + def limite_inferior(self) -> str | None: """ A equação que da o limite inferior da restrição. @@ -458,11 +459,11 @@ def limite_inferior(self) -> Optional[str]: return self.data[4] @limite_inferior.setter - def limite_inferior(self, v: str): + def limite_inferior(self, v: str) -> None: self.data[4] = v @property - def limite_superior(self) -> Optional[str]: + def limite_superior(self) -> str | None: """ A equação que da o limite superior da restrição. @@ -472,7 +473,7 @@ def limite_superior(self) -> Optional[str]: return self.data[5] @limite_superior.setter - def limite_superior(self, v: str): + def limite_superior(self, v: str) -> None: self.data[5] = v @@ -500,7 +501,7 @@ class RegistroRestricaoEletricaLimitesFormulaDataPatamar(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -510,11 +511,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def data_inicio(self) -> Optional[datetime]: + def data_inicio(self) -> datetime | None: """ A data de início da validade dos limites da restrição. @@ -524,11 +525,11 @@ def data_inicio(self) -> Optional[datetime]: return self.data[1] @data_inicio.setter - def data_inicio(self, c: datetime): + def data_inicio(self, c: datetime) -> None: self.data[1] = c @property - def data_fim(self) -> Optional[datetime]: + def data_fim(self) -> datetime | None: """ A data de fim da validade dos limites da restrição. @@ -538,11 +539,11 @@ def data_fim(self) -> Optional[datetime]: return self.data[2] @data_fim.setter - def data_fim(self, v: datetime): + def data_fim(self, v: datetime) -> None: self.data[2] = v @property - def patamar(self) -> Optional[int]: + def patamar(self) -> int | None: """ O índice do patamar para os limites. @@ -552,11 +553,11 @@ def patamar(self) -> Optional[int]: return self.data[3] @patamar.setter - def patamar(self, v: int): + def patamar(self, v: int) -> None: self.data[3] = v @property - def limite_inferior(self) -> Optional[str]: + def limite_inferior(self) -> str | None: """ A equação que da o limite inferior da restrição. @@ -566,11 +567,11 @@ def limite_inferior(self) -> Optional[str]: return self.data[4] @limite_inferior.setter - def limite_inferior(self, v: str): + def limite_inferior(self, v: str) -> None: self.data[4] = v @property - def limite_superior(self) -> Optional[str]: + def limite_superior(self) -> str | None: """ A equação que da o limite superior da restrição. @@ -580,7 +581,7 @@ def limite_superior(self) -> Optional[str]: return self.data[5] @limite_superior.setter - def limite_superior(self, v: str): + def limite_superior(self, v: str) -> None: self.data[5] = v @@ -603,7 +604,7 @@ class RegistroAliasEletrico(Register): ) @property - def codigo_alias(self) -> Optional[int]: + def codigo_alias(self) -> int | None: """ O código do alias. @@ -613,11 +614,11 @@ def codigo_alias(self) -> Optional[int]: return self.data[0] @codigo_alias.setter - def codigo_alias(self, c: int): + def codigo_alias(self, c: int) -> None: self.data[0] = c @property - def identificador_alias(self) -> Optional[str]: + def identificador_alias(self) -> str | None: """ O identificador do alias elétrico personalizado. @@ -627,7 +628,7 @@ def identificador_alias(self) -> Optional[str]: return self.data[1] @identificador_alias.setter - def identificador_alias(self, n: str): + def identificador_alias(self, n: str) -> None: self.data[1] = n @@ -654,7 +655,7 @@ class RegistroAliasEletricoValorPeriodoPatamar(Register): ) @property - def codigo_alias(self) -> Optional[int]: + def codigo_alias(self) -> int | None: """ O código do alias. @@ -664,11 +665,11 @@ def codigo_alias(self) -> Optional[int]: return self.data[0] @codigo_alias.setter - def codigo_alias(self, c: int): + def codigo_alias(self, c: int) -> None: self.data[0] = c @property - def estagio_inicio(self) -> Optional[int]: + def estagio_inicio(self) -> int | None: """ O estágio de início da validade do dado. @@ -678,11 +679,11 @@ def estagio_inicio(self) -> Optional[int]: return self.data[1] @estagio_inicio.setter - def estagio_inicio(self, c: int): + def estagio_inicio(self, c: int) -> None: self.data[1] = c @property - def estagio_fim(self) -> Optional[int]: + def estagio_fim(self) -> int | None: """ O estágio de fim da validade do dado. @@ -692,11 +693,11 @@ def estagio_fim(self) -> Optional[int]: return self.data[2] @estagio_fim.setter - def estagio_fim(self, v: int): + def estagio_fim(self, v: int) -> None: self.data[2] = v @property - def patamar(self) -> Optional[int]: + def patamar(self) -> int | None: """ O índice do patamar. @@ -706,11 +707,11 @@ def patamar(self) -> Optional[int]: return self.data[3] @patamar.setter - def patamar(self, v: int): + def patamar(self, v: int) -> None: self.data[3] = v @property - def valor(self) -> Optional[float]: + def valor(self) -> float | None: """ O valor do alias elétrico. @@ -720,7 +721,7 @@ def valor(self) -> Optional[float]: return self.data[4] @valor.setter - def valor(self, v: float): + def valor(self, v: float) -> None: self.data[4] = v @@ -744,7 +745,7 @@ class RegistroRestricaoEletricaRegraAtivacao(Register): ) @property - def codigo_regra_ativacao(self) -> Optional[int]: + def codigo_regra_ativacao(self) -> int | None: """ O código da regra de ativação. @@ -754,11 +755,11 @@ def codigo_regra_ativacao(self) -> Optional[int]: return self.data[0] @codigo_regra_ativacao.setter - def codigo_regra_ativacao(self, c: int): + def codigo_regra_ativacao(self, c: int) -> None: self.data[0] = c @property - def regra_ativacao(self) -> Optional[str]: + def regra_ativacao(self) -> str | None: """ A regra condicional para ativação. @@ -768,7 +769,7 @@ def regra_ativacao(self) -> Optional[str]: return self.data[1] @regra_ativacao.setter - def regra_ativacao(self, n: str): + def regra_ativacao(self, n: str) -> None: self.data[1] = n @@ -792,7 +793,7 @@ class RegistroRestricaoEletricaHabilita(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -802,11 +803,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def codigo_regra_ativacao(self) -> Optional[int]: + def codigo_regra_ativacao(self) -> int | None: """ O código da regra de ativação. @@ -816,7 +817,7 @@ def codigo_regra_ativacao(self) -> Optional[int]: return self.data[1] @codigo_regra_ativacao.setter - def codigo_regra_ativacao(self, n: int): + def codigo_regra_ativacao(self, n: int) -> None: self.data[1] = n @@ -841,7 +842,7 @@ class RegistroRestricaoEletricaTratamentoViolacao(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -851,11 +852,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def tipo_violacao(self) -> Optional[str]: + def tipo_violacao(self) -> str | None: """ O tipo de violação. @@ -865,11 +866,11 @@ def tipo_violacao(self) -> Optional[str]: return self.data[1] @tipo_violacao.setter - def tipo_violacao(self, n: str): + def tipo_violacao(self, n: str) -> None: self.data[1] = n @property - def custo_violacao(self) -> Optional[float]: + def custo_violacao(self) -> float | None: """ O custo de violação. @@ -879,7 +880,7 @@ def custo_violacao(self) -> Optional[float]: return self.data[2] @custo_violacao.setter - def custo_violacao(self, n: float): + def custo_violacao(self, n: float) -> None: self.data[2] = n @@ -907,7 +908,7 @@ class RegistroRestricaoEletricaTratamentoViolacaoPeriodo(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -917,11 +918,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio_inicio(self) -> Optional[int]: + def estagio_inicio(self) -> int | None: """ O estágio de início. @@ -931,11 +932,11 @@ def estagio_inicio(self) -> Optional[int]: return self.data[1] @estagio_inicio.setter - def estagio_inicio(self, c: int): + def estagio_inicio(self, c: int) -> None: self.data[1] = c @property - def estagio_fim(self) -> Optional[int]: + def estagio_fim(self) -> int | None: """ O estágio de fim. @@ -945,11 +946,11 @@ def estagio_fim(self) -> Optional[int]: return self.data[2] @estagio_fim.setter - def estagio_fim(self, c: int): + def estagio_fim(self, c: int) -> None: self.data[2] = c @property - def tipo_violacao(self) -> Optional[str]: + def tipo_violacao(self) -> str | None: """ O tipo de violação. @@ -959,11 +960,11 @@ def tipo_violacao(self) -> Optional[str]: return self.data[3] @tipo_violacao.setter - def tipo_violacao(self, n: str): + def tipo_violacao(self, n: str) -> None: self.data[3] = n @property - def custo_violacao(self) -> Optional[float]: + def custo_violacao(self) -> float | None: """ O custo de violação. @@ -973,7 +974,7 @@ def custo_violacao(self) -> Optional[float]: return self.data[4] @custo_violacao.setter - def custo_violacao(self, n: float): + def custo_violacao(self, n: float) -> None: self.data[4] = n @@ -998,7 +999,7 @@ class RegistroReHorizPer(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -1008,11 +1009,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio_inicio(self) -> Optional[int]: + def estagio_inicio(self) -> int | None: """ O estágio de início da validade da restrição. @@ -1022,11 +1023,11 @@ def estagio_inicio(self) -> Optional[int]: return self.data[1] @estagio_inicio.setter - def estagio_inicio(self, c: int): + def estagio_inicio(self, c: int) -> None: self.data[1] = c @property - def estagio_fim(self) -> Optional[int]: + def estagio_fim(self) -> int | None: """ O estágio de fim da validade da restrição. @@ -1036,7 +1037,7 @@ def estagio_fim(self) -> Optional[int]: return self.data[2] @estagio_fim.setter - def estagio_fim(self, n: int): + def estagio_fim(self, n: int) -> None: self.data[2] = n @@ -1061,7 +1062,7 @@ class RegistroReHorizData(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -1071,11 +1072,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def data_inicio(self) -> Optional[datetime]: + def data_inicio(self) -> datetime | None: """ A data de início da validade da restrição. @@ -1085,11 +1086,11 @@ def data_inicio(self) -> Optional[datetime]: return self.data[1] @data_inicio.setter - def data_inicio(self, c: datetime): + def data_inicio(self, c: datetime) -> None: self.data[1] = c @property - def data_fim(self) -> Optional[datetime]: + def data_fim(self) -> datetime | None: """ A data de fim da validade da restrição. @@ -1099,7 +1100,7 @@ def data_fim(self) -> Optional[datetime]: return self.data[2] @data_fim.setter - def data_fim(self, n: datetime): + def data_fim(self, n: datetime) -> None: self.data[2] = n @@ -1122,7 +1123,7 @@ class RegistroRe(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -1132,11 +1133,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def formula(self) -> Optional[str]: + def formula(self) -> str | None: """ A fórmula da restrição. @@ -1146,7 +1147,7 @@ def formula(self) -> Optional[str]: return self.data[1] @formula.setter - def formula(self, n: str): + def formula(self, n: str) -> None: self.data[1] = n @@ -1173,7 +1174,7 @@ class RegistroRePerPat(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -1183,11 +1184,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio_inicio(self) -> Optional[int]: + def estagio_inicio(self) -> int | None: """ O estágio de início da restrição. @@ -1197,11 +1198,11 @@ def estagio_inicio(self) -> Optional[int]: return self.data[1] @estagio_inicio.setter - def estagio_inicio(self, c: int): + def estagio_inicio(self, c: int) -> None: self.data[1] = c @property - def estagio_fim(self) -> Optional[int]: + def estagio_fim(self) -> int | None: """ O estágio de fim da restrição. @@ -1211,11 +1212,11 @@ def estagio_fim(self) -> Optional[int]: return self.data[2] @estagio_fim.setter - def estagio_fim(self, c: int): + def estagio_fim(self, c: int) -> None: self.data[2] = c @property - def patamar(self) -> Optional[int]: + def patamar(self) -> int | None: """ O índice do patamar de carga. @@ -1225,11 +1226,11 @@ def patamar(self) -> Optional[int]: return self.data[3] @patamar.setter - def patamar(self, c: int): + def patamar(self, c: int) -> None: self.data[3] = c @property - def formula(self) -> Optional[str]: + def formula(self) -> str | None: """ A fórmula da restrição. @@ -1239,7 +1240,7 @@ def formula(self) -> Optional[str]: return self.data[4] @formula.setter - def formula(self, n: str): + def formula(self, n: str) -> None: self.data[4] = n @@ -1266,7 +1267,7 @@ class RegistroReDataPat(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -1276,11 +1277,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def data_inicio(self) -> Optional[datetime]: + def data_inicio(self) -> datetime | None: """ A data de início da restrição. @@ -1290,11 +1291,11 @@ def data_inicio(self) -> Optional[datetime]: return self.data[1] @data_inicio.setter - def data_inicio(self, c: datetime): + def data_inicio(self, c: datetime) -> None: self.data[1] = c @property - def data_fim(self) -> Optional[datetime]: + def data_fim(self) -> datetime | None: """ A data de fim da restrição. @@ -1304,11 +1305,11 @@ def data_fim(self) -> Optional[datetime]: return self.data[2] @data_fim.setter - def data_fim(self, c: datetime): + def data_fim(self, c: datetime) -> None: self.data[2] = c @property - def patamar(self) -> Optional[int]: + def patamar(self) -> int | None: """ O índice do patamar de carga. @@ -1318,11 +1319,11 @@ def patamar(self) -> Optional[int]: return self.data[3] @patamar.setter - def patamar(self, c: int): + def patamar(self, c: int) -> None: self.data[3] = c @property - def formula(self) -> Optional[str]: + def formula(self) -> str | None: """ A fórmula da restrição. @@ -1332,7 +1333,7 @@ def formula(self) -> Optional[str]: return self.data[4] @formula.setter - def formula(self, n: str): + def formula(self, n: str) -> None: self.data[4] = n @@ -1360,7 +1361,7 @@ class RegistroReLimFormPerPat(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -1370,11 +1371,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio_inicio(self) -> Optional[int]: + def estagio_inicio(self) -> int | None: """ O estágio de início da validade dos limites da restrição. @@ -1384,11 +1385,11 @@ def estagio_inicio(self) -> Optional[int]: return self.data[1] @estagio_inicio.setter - def estagio_inicio(self, c: int): + def estagio_inicio(self, c: int) -> None: self.data[1] = c @property - def estagio_fim(self) -> Optional[int]: + def estagio_fim(self) -> int | None: """ O estágio de fim da validade dos limites da restrição. @@ -1398,11 +1399,11 @@ def estagio_fim(self) -> Optional[int]: return self.data[2] @estagio_fim.setter - def estagio_fim(self, v: int): + def estagio_fim(self, v: int) -> None: self.data[2] = v @property - def patamar(self) -> Optional[int]: + def patamar(self) -> int | None: """ O índice do patamar para os limites. @@ -1412,11 +1413,11 @@ def patamar(self) -> Optional[int]: return self.data[3] @patamar.setter - def patamar(self, v: int): + def patamar(self, v: int) -> None: self.data[3] = v @property - def limite_inferior(self) -> Optional[str]: + def limite_inferior(self) -> str | None: """ A equação que da o limite inferior da restrição. @@ -1426,11 +1427,11 @@ def limite_inferior(self) -> Optional[str]: return self.data[4] @limite_inferior.setter - def limite_inferior(self, v: str): + def limite_inferior(self, v: str) -> None: self.data[4] = v @property - def limite_superior(self) -> Optional[str]: + def limite_superior(self) -> str | None: """ A equação que da o limite superior da restrição. @@ -1440,7 +1441,7 @@ def limite_superior(self) -> Optional[str]: return self.data[5] @limite_superior.setter - def limite_superior(self, v: str): + def limite_superior(self, v: str) -> None: self.data[5] = v @@ -1468,7 +1469,7 @@ class RegistroReLimFormDataPat(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -1478,11 +1479,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def data_inicio(self) -> Optional[datetime]: + def data_inicio(self) -> datetime | None: """ A data de início da validade dos limites da restrição. @@ -1492,11 +1493,11 @@ def data_inicio(self) -> Optional[datetime]: return self.data[1] @data_inicio.setter - def data_inicio(self, c: datetime): + def data_inicio(self, c: datetime) -> None: self.data[1] = c @property - def data_fim(self) -> Optional[datetime]: + def data_fim(self) -> datetime | None: """ A data de fim da validade dos limites da restrição. @@ -1506,11 +1507,11 @@ def data_fim(self) -> Optional[datetime]: return self.data[2] @data_fim.setter - def data_fim(self, v: datetime): + def data_fim(self, v: datetime) -> None: self.data[2] = v @property - def patamar(self) -> Optional[int]: + def patamar(self) -> int | None: """ O índice do patamar para os limites. @@ -1520,11 +1521,11 @@ def patamar(self) -> Optional[int]: return self.data[3] @patamar.setter - def patamar(self, v: int): + def patamar(self, v: int) -> None: self.data[3] = v @property - def limite_inferior(self) -> Optional[str]: + def limite_inferior(self) -> str | None: """ A equação que da o limite inferior da restrição. @@ -1534,11 +1535,11 @@ def limite_inferior(self) -> Optional[str]: return self.data[4] @limite_inferior.setter - def limite_inferior(self, v: str): + def limite_inferior(self, v: str) -> None: self.data[4] = v @property - def limite_superior(self) -> Optional[str]: + def limite_superior(self) -> str | None: """ A equação que da o limite superior da restrição. @@ -1548,7 +1549,7 @@ def limite_superior(self) -> Optional[str]: return self.data[5] @limite_superior.setter - def limite_superior(self, v: str): + def limite_superior(self, v: str) -> None: self.data[5] = v @@ -1571,7 +1572,7 @@ class RegistroAliasElet(Register): ) @property - def codigo_alias(self) -> Optional[int]: + def codigo_alias(self) -> int | None: """ O código do alias. @@ -1581,11 +1582,11 @@ def codigo_alias(self) -> Optional[int]: return self.data[0] @codigo_alias.setter - def codigo_alias(self, c: int): + def codigo_alias(self, c: int) -> None: self.data[0] = c @property - def identificador_alias(self) -> Optional[str]: + def identificador_alias(self) -> str | None: """ O identificador do alias elétrico personalizado. @@ -1595,7 +1596,7 @@ def identificador_alias(self) -> Optional[str]: return self.data[1] @identificador_alias.setter - def identificador_alias(self, n: str): + def identificador_alias(self, n: str) -> None: self.data[1] = n @@ -1622,7 +1623,7 @@ class RegistroAliasEletValPerPat(Register): ) @property - def codigo_alias(self) -> Optional[int]: + def codigo_alias(self) -> int | None: """ O código do alias. @@ -1632,11 +1633,11 @@ def codigo_alias(self) -> Optional[int]: return self.data[0] @codigo_alias.setter - def codigo_alias(self, c: int): + def codigo_alias(self, c: int) -> None: self.data[0] = c @property - def estagio_inicio(self) -> Optional[int]: + def estagio_inicio(self) -> int | None: """ O estágio de início da validade do dado. @@ -1646,11 +1647,11 @@ def estagio_inicio(self) -> Optional[int]: return self.data[1] @estagio_inicio.setter - def estagio_inicio(self, c: int): + def estagio_inicio(self, c: int) -> None: self.data[1] = c @property - def estagio_fim(self) -> Optional[int]: + def estagio_fim(self) -> int | None: """ O estágio de fim da validade do dado. @@ -1660,11 +1661,11 @@ def estagio_fim(self) -> Optional[int]: return self.data[2] @estagio_fim.setter - def estagio_fim(self, v: int): + def estagio_fim(self, v: int) -> None: self.data[2] = v @property - def patamar(self) -> Optional[int]: + def patamar(self) -> int | None: """ O índice do patamar. @@ -1674,11 +1675,11 @@ def patamar(self) -> Optional[int]: return self.data[3] @patamar.setter - def patamar(self, v: int): + def patamar(self, v: int) -> None: self.data[3] = v @property - def valor(self) -> Optional[float]: + def valor(self) -> float | None: """ O valor do alias elétrico. @@ -1688,7 +1689,7 @@ def valor(self) -> Optional[float]: return self.data[4] @valor.setter - def valor(self, v: float): + def valor(self, v: float) -> None: self.data[4] = v @@ -1712,7 +1713,7 @@ class RegistroReRegraAtiva(Register): ) @property - def codigo_regra_ativacao(self) -> Optional[int]: + def codigo_regra_ativacao(self) -> int | None: """ O código da regra de ativação. @@ -1722,11 +1723,11 @@ def codigo_regra_ativacao(self) -> Optional[int]: return self.data[0] @codigo_regra_ativacao.setter - def codigo_regra_ativacao(self, c: int): + def codigo_regra_ativacao(self, c: int) -> None: self.data[0] = c @property - def regra_ativacao(self) -> Optional[str]: + def regra_ativacao(self) -> str | None: """ A regra condicional para ativação. @@ -1736,7 +1737,7 @@ def regra_ativacao(self) -> Optional[str]: return self.data[1] @regra_ativacao.setter - def regra_ativacao(self, n: str): + def regra_ativacao(self, n: str) -> None: self.data[1] = n @@ -1760,7 +1761,7 @@ class RegistroReHabilita(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -1770,11 +1771,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def codigo_regra_ativacao(self) -> Optional[int]: + def codigo_regra_ativacao(self) -> int | None: """ O código da regra de ativação. @@ -1784,7 +1785,7 @@ def codigo_regra_ativacao(self) -> Optional[int]: return self.data[1] @codigo_regra_ativacao.setter - def codigo_regra_ativacao(self, n: int): + def codigo_regra_ativacao(self, n: int) -> None: self.data[1] = n @@ -1809,7 +1810,7 @@ class RegistroReTratViol(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -1819,11 +1820,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def tipo_violacao(self) -> Optional[str]: + def tipo_violacao(self) -> str | None: """ O tipo de violação. @@ -1833,11 +1834,11 @@ def tipo_violacao(self) -> Optional[str]: return self.data[1] @tipo_violacao.setter - def tipo_violacao(self, n: str): + def tipo_violacao(self, n: str) -> None: self.data[1] = n @property - def custo_violacao(self) -> Optional[float]: + def custo_violacao(self) -> float | None: """ O custo de violação. @@ -1847,7 +1848,7 @@ def custo_violacao(self) -> Optional[float]: return self.data[2] @custo_violacao.setter - def custo_violacao(self, n: float): + def custo_violacao(self, n: float) -> None: self.data[2] = n @@ -1875,7 +1876,7 @@ class RegistroReTratViolPer(Register): ) @property - def codigo_restricao(self) -> Optional[int]: + def codigo_restricao(self) -> int | None: """ O código da restrição. @@ -1885,11 +1886,11 @@ def codigo_restricao(self) -> Optional[int]: return self.data[0] @codigo_restricao.setter - def codigo_restricao(self, c: int): + def codigo_restricao(self, c: int) -> None: self.data[0] = c @property - def estagio_inicio(self) -> Optional[int]: + def estagio_inicio(self) -> int | None: """ O estágio de início. @@ -1899,11 +1900,11 @@ def estagio_inicio(self) -> Optional[int]: return self.data[1] @estagio_inicio.setter - def estagio_inicio(self, c: int): + def estagio_inicio(self, c: int) -> None: self.data[1] = c @property - def estagio_fim(self) -> Optional[int]: + def estagio_fim(self) -> int | None: """ O estágio de fim. @@ -1913,11 +1914,11 @@ def estagio_fim(self) -> Optional[int]: return self.data[2] @estagio_fim.setter - def estagio_fim(self, c: int): + def estagio_fim(self, c: int) -> None: self.data[2] = c @property - def tipo_violacao(self) -> Optional[str]: + def tipo_violacao(self) -> str | None: """ O tipo de violação. @@ -1927,11 +1928,11 @@ def tipo_violacao(self) -> Optional[str]: return self.data[3] @tipo_violacao.setter - def tipo_violacao(self, n: str): + def tipo_violacao(self, n: str) -> None: self.data[3] = n @property - def custo_violacao(self) -> Optional[float]: + def custo_violacao(self) -> float | None: """ O custo de violação. @@ -1941,5 +1942,5 @@ def custo_violacao(self) -> Optional[float]: return self.data[4] @custo_violacao.setter - def custo_violacao(self, n: float): + def custo_violacao(self, n: float) -> None: self.data[4] = n diff --git a/idecomp/libs/modelos/usinas_hidreletricas.py b/idecomp/libs/modelos/usinas_hidreletricas.py index 97f96c5d..1a0a2da0 100644 --- a/idecomp/libs/modelos/usinas_hidreletricas.py +++ b/idecomp/libs/modelos/usinas_hidreletricas.py @@ -1,10 +1,8 @@ -from cfinterface.components.register import Register -from cfinterface.components.line import Line -from cfinterface.components.integerfield import IntegerField from cfinterface.components.floatfield import FloatField +from cfinterface.components.integerfield import IntegerField +from cfinterface.components.line import Line from cfinterface.components.literalfield import LiteralField - -from typing import Optional +from cfinterface.components.register import Register class HidreletricaCurvaJusante(Register): @@ -24,7 +22,7 @@ class HidreletricaCurvaJusante(Register): ) @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da usina hidrelétrica relacionada ao polinômio. @@ -34,11 +32,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def indice_familia(self) -> Optional[int]: + def indice_familia(self) -> int | None: """ O índice da família de polinômios. @@ -48,11 +46,11 @@ def indice_familia(self) -> Optional[int]: return self.data[1] @indice_familia.setter - def indice_familia(self, c: int): + def indice_familia(self, c: int) -> None: self.data[1] = c @property - def nivel_montante_referencia(self) -> Optional[float]: + def nivel_montante_referencia(self) -> float | None: """ O nível de montante da usina de jusante de referência. @@ -63,7 +61,7 @@ def nivel_montante_referencia(self) -> Optional[float]: return self.data[2] @nivel_montante_referencia.setter - def nivel_montante_referencia(self, c: float): + def nivel_montante_referencia(self, c: float) -> None: self.data[2] = c @@ -84,7 +82,7 @@ class HidreletricaCurvaJusantePolinomioPorPartes(Register): ) @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da usina hidrelétrica relacionada ao polinômio. @@ -94,11 +92,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def indice_familia(self) -> Optional[int]: + def indice_familia(self) -> int | None: """ O índice da família de polinômios. @@ -108,11 +106,11 @@ def indice_familia(self) -> Optional[int]: return self.data[1] @indice_familia.setter - def indice_familia(self, c: int): + def indice_familia(self, c: int) -> None: self.data[1] = c @property - def numero_polinomios(self) -> Optional[int]: + def numero_polinomios(self) -> int | None: """ O número de polinômios existentes na família. @@ -122,7 +120,7 @@ def numero_polinomios(self) -> Optional[int]: return self.data[2] @numero_polinomios.setter - def numero_polinomios(self, c: int): + def numero_polinomios(self, c: int) -> None: self.data[2] = c @@ -150,7 +148,7 @@ class HidreletricaCurvaJusantePolinomioPorPartesSegmento(Register): ) @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da usina hidrelétrica relacionada ao polinômio. @@ -160,11 +158,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def indice_familia(self) -> Optional[int]: + def indice_familia(self) -> int | None: """ O índice da família de polinômios. @@ -174,11 +172,11 @@ def indice_familia(self) -> Optional[int]: return self.data[1] @indice_familia.setter - def indice_familia(self, c: int): + def indice_familia(self, c: int) -> None: self.data[1] = c @property - def indice_polinomio(self) -> Optional[int]: + def indice_polinomio(self) -> int | None: """ O índice do polinômio da respectiva família. @@ -188,11 +186,11 @@ def indice_polinomio(self) -> Optional[int]: return self.data[2] @indice_polinomio.setter - def indice_polinomio(self, c: int): + def indice_polinomio(self, c: int) -> None: self.data[2] = c @property - def limite_inferior_vazao_jusante(self) -> Optional[float]: + def limite_inferior_vazao_jusante(self) -> float | None: """ O limite inferior de vazão de jusante (defluência mais lateral) para janela de validade do polinômio. @@ -203,11 +201,11 @@ def limite_inferior_vazao_jusante(self) -> Optional[float]: return self.data[3] @limite_inferior_vazao_jusante.setter - def limite_inferior_vazao_jusante(self, c: float): + def limite_inferior_vazao_jusante(self, c: float) -> None: self.data[3] = c @property - def limite_superior_vazao_jusante(self) -> Optional[float]: + def limite_superior_vazao_jusante(self) -> float | None: """ O limite superior de vazão de jusante (defluência mais lateral) para janela de validade do polinômio. @@ -218,11 +216,11 @@ def limite_superior_vazao_jusante(self) -> Optional[float]: return self.data[4] @limite_superior_vazao_jusante.setter - def limite_superior_vazao_jusante(self, c: float): + def limite_superior_vazao_jusante(self, c: float) -> None: self.data[4] = c @property - def coeficiente_a0(self) -> Optional[float]: + def coeficiente_a0(self) -> float | None: """ O coeficiente de grau 0 do polinômio. @@ -232,11 +230,11 @@ def coeficiente_a0(self) -> Optional[float]: return self.data[5] @coeficiente_a0.setter - def coeficiente_a0(self, c: float): + def coeficiente_a0(self, c: float) -> None: self.data[5] = c @property - def coeficiente_a1(self) -> Optional[float]: + def coeficiente_a1(self) -> float | None: """ O coeficiente de grau 1 do polinômio. @@ -246,11 +244,11 @@ def coeficiente_a1(self) -> Optional[float]: return self.data[6] @coeficiente_a1.setter - def coeficiente_a1(self, c: float): + def coeficiente_a1(self, c: float) -> None: self.data[6] = c @property - def coeficiente_a2(self) -> Optional[float]: + def coeficiente_a2(self) -> float | None: """ O coeficiente de grau 2 do polinômio. @@ -260,11 +258,11 @@ def coeficiente_a2(self) -> Optional[float]: return self.data[7] @coeficiente_a2.setter - def coeficiente_a2(self, c: float): + def coeficiente_a2(self, c: float) -> None: self.data[7] = c @property - def coeficiente_a3(self) -> Optional[float]: + def coeficiente_a3(self) -> float | None: """ O coeficiente de grau 3 do polinômio. @@ -274,11 +272,11 @@ def coeficiente_a3(self) -> Optional[float]: return self.data[8] @coeficiente_a3.setter - def coeficiente_a3(self, c: float): + def coeficiente_a3(self, c: float) -> None: self.data[8] = c @property - def coeficiente_a4(self) -> Optional[float]: + def coeficiente_a4(self) -> float | None: """ O coeficiente de grau 4 do polinômio. @@ -288,7 +286,7 @@ def coeficiente_a4(self) -> Optional[float]: return self.data[9] @coeficiente_a4.setter - def coeficiente_a4(self, c: float): + def coeficiente_a4(self, c: float) -> None: self.data[9] = c @@ -308,7 +306,7 @@ class HidreletricaCurvaJusanteAfogamentoExplicitoUsina(Register): ) @property - def codigo_usina(self) -> Optional[int]: + def codigo_usina(self) -> int | None: """ O código da usina hidrelétrica relacionada ao polinômio. @@ -318,11 +316,11 @@ def codigo_usina(self) -> Optional[int]: return self.data[0] @codigo_usina.setter - def codigo_usina(self, c: int): + def codigo_usina(self, c: int) -> None: self.data[0] = c @property - def considera_afogamento(self) -> Optional[str]: + def considera_afogamento(self) -> str | None: """ Habilitação do afogamento explícito. @@ -332,7 +330,7 @@ def considera_afogamento(self) -> Optional[str]: return self.data[1] @considera_afogamento.setter - def considera_afogamento(self, c: str): + def considera_afogamento(self, c: str) -> None: self.data[1] = c @@ -351,7 +349,7 @@ class HidreletricaCurvaJusanteAfogamentoExplicitoPadrao(Register): ) @property - def considera_afogamento(self) -> Optional[str]: + def considera_afogamento(self) -> str | None: """ Habilitação do afogamento explícito. @@ -361,5 +359,5 @@ def considera_afogamento(self) -> Optional[str]: return self.data[0] @considera_afogamento.setter - def considera_afogamento(self, c: str): + def considera_afogamento(self, c: str) -> None: self.data[0] = c diff --git a/idecomp/libs/restricoes.py b/idecomp/libs/restricoes.py index c775414a..0bc5b68b 100644 --- a/idecomp/libs/restricoes.py +++ b/idecomp/libs/restricoes.py @@ -1,24 +1,24 @@ -from typing import Type, TypeVar, List, Optional, Union from datetime import datetime -import pandas as pd # type: ignore +from typing import Any, TypeVar + +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.register import Register from cfinterface.files.registerfile import RegisterFile + from idecomp.libs.modelos.restricoes import ( + RegistroAliasElet, + RegistroAliasEletrico, + RegistroAliasEletricoValorPeriodoPatamar, + RegistroAliasEletValPerPat, RegistroRe, - RegistroReHorizPer, - RegistroReHorizData, - RegistroRePerPat, RegistroReDataPat, - RegistroReLimFormPerPat, + RegistroReHabilita, + RegistroReHorizData, + RegistroReHorizPer, RegistroReLimFormDataPat, + RegistroReLimFormPerPat, + RegistroRePerPat, RegistroReRegraAtiva, - RegistroReHabilita, - RegistroReTratViol, - RegistroReTratViolPer, - RegistroAliasElet, - RegistroAliasEletValPerPat, -) -from idecomp.libs.modelos.restricoes import ( RegistroRestricaoEletricaFormula, RegistroRestricaoEletricaFormulaDataPatamar, RegistroRestricaoEletricaFormulaPeriodoPatamar, @@ -30,8 +30,8 @@ RegistroRestricaoEletricaRegraAtivacao, RegistroRestricaoEletricaTratamentoViolacao, RegistroRestricaoEletricaTratamentoViolacaoPeriodo, - RegistroAliasEletrico, - RegistroAliasEletricoValorPeriodoPatamar, + RegistroReTratViol, + RegistroReTratViolPer, ) @@ -72,9 +72,12 @@ class Restricoes(RegisterFile): RegistroRe, ] + def __init__(self, data: Any = ...) -> None: + super().__init__(data) + def __registros_ou_df( - self, t: Type[T], **kwargs - ) -> Optional[Union[T, List[T], pd.DataFrame]]: + self, t: type[T], **kwargs: Any + ) -> T | list[T] | pd.DataFrame | None: if kwargs.get("df"): return self._as_df(t) else: @@ -83,16 +86,15 @@ def __registros_ou_df( def restricao_eletrica_formula( self, - codigo_restricao: Optional[int] = None, - formula: Optional[str] = None, + codigo_restricao: int | None = None, + formula: str | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroRestricaoEletricaFormula, - List[RegistroRestricaoEletricaFormula], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroRestricaoEletricaFormula + | list[RegistroRestricaoEletricaFormula] + | pd.DataFrame + | None + ): """ Obtém um registro que cadastra uma restrição elétrica (RE), definido através do nome completo do card. @@ -114,10 +116,10 @@ def restricao_eletrica_formula( def re( self, - codigo_restricao: Optional[int] = None, - formula: Optional[str] = None, + codigo_restricao: int | None = None, + formula: str | None = None, df: bool = False, - ) -> Optional[Union[RegistroRe, List[RegistroRe], pd.DataFrame]]: + ) -> RegistroRe | list[RegistroRe] | pd.DataFrame | None: """ Obtém um registro que cadastra uma restrição elétrica (RE), definido através do nome alternativo (apelido) do card. @@ -139,17 +141,16 @@ def re( def restricao_eletrica_horizonte_periodo( self, - codigo_restricao: Optional[int] = None, - estagio_inicio: Optional[int] = None, - estagio_fim: Optional[int] = None, + codigo_restricao: int | None = None, + estagio_inicio: int | None = None, + estagio_fim: int | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroRestricaoEletricaHorizontePeriodo, - List[RegistroRestricaoEletricaHorizontePeriodo], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroRestricaoEletricaHorizontePeriodo + | list[RegistroRestricaoEletricaHorizontePeriodo] + | pd.DataFrame + | None + ): """ Obtém um registro que cadastra o horizonte de validade de uma restrição elétrica com intervalo de estágios, @@ -175,13 +176,11 @@ def restricao_eletrica_horizonte_periodo( def re_horiz_per( self, - codigo_restricao: Optional[int] = None, - estagio_inicio: Optional[int] = None, - estagio_fim: Optional[int] = None, + codigo_restricao: int | None = None, + estagio_inicio: int | None = None, + estagio_fim: int | None = None, df: bool = False, - ) -> Optional[ - Union[RegistroReHorizPer, List[RegistroReHorizPer], pd.DataFrame] - ]: + ) -> RegistroReHorizPer | list[RegistroReHorizPer] | pd.DataFrame | None: """ Obtém um registro que cadastra o horizonte de validade de uma restrição elétrica com intervalo de estágios, @@ -207,17 +206,16 @@ def re_horiz_per( def restricao_eletrica_horizonte_data( self, - codigo_restricao: Optional[int] = None, - data_inicio: Optional[datetime] = None, - data_fim: Optional[datetime] = None, + codigo_restricao: int | None = None, + data_inicio: datetime | None = None, + data_fim: datetime | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroRestricaoEletricaHorizonteData, - List[RegistroRestricaoEletricaHorizonteData], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroRestricaoEletricaHorizonteData + | list[RegistroRestricaoEletricaHorizonteData] + | pd.DataFrame + | None + ): """ Obtém um registro que cadastra o horizonte de validade de uma restrição elétrica com intervalo de data, @@ -243,13 +241,11 @@ def restricao_eletrica_horizonte_data( def re_horiz_data( self, - codigo_restricao: Optional[int] = None, - data_inicio: Optional[datetime] = None, - data_fim: Optional[datetime] = None, + codigo_restricao: int | None = None, + data_inicio: datetime | None = None, + data_fim: datetime | None = None, df: bool = False, - ) -> Optional[ - Union[RegistroReHorizData, List[RegistroReHorizData], pd.DataFrame] - ]: + ) -> RegistroReHorizData | list[RegistroReHorizData] | pd.DataFrame | None: """ Obtém um registro que cadastra o horizonte de validade de uma restrição elétrica com intervalo de data, @@ -275,19 +271,18 @@ def re_horiz_data( def restricao_eletrica_formula_periodo_patamar( self, - codigo_restricao: Optional[int] = None, - estagio_inicio: Optional[int] = None, - estagio_fim: Optional[int] = None, - patamar: Optional[int] = None, - formula: Optional[str] = None, + codigo_restricao: int | None = None, + estagio_inicio: int | None = None, + estagio_fim: int | None = None, + patamar: int | None = None, + formula: str | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroRestricaoEletricaFormulaPeriodoPatamar, - List[RegistroRestricaoEletricaFormulaPeriodoPatamar], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroRestricaoEletricaFormulaPeriodoPatamar + | list[RegistroRestricaoEletricaFormulaPeriodoPatamar] + | pd.DataFrame + | None + ): """ Obtém um registro que cadastra uma restrição elétrica (RE) que varia ao longo do tempo, informada por intervalo de estágios, @@ -320,15 +315,13 @@ def restricao_eletrica_formula_periodo_patamar( def re_per_pat( self, - codigo_restricao: Optional[int] = None, - estagio_inicio: Optional[int] = None, - estagio_fim: Optional[int] = None, - patamar: Optional[int] = None, - formula: Optional[str] = None, + codigo_restricao: int | None = None, + estagio_inicio: int | None = None, + estagio_fim: int | None = None, + patamar: int | None = None, + formula: str | None = None, df: bool = False, - ) -> Optional[ - Union[RegistroRePerPat, List[RegistroRePerPat], pd.DataFrame] - ]: + ) -> RegistroRePerPat | list[RegistroRePerPat] | pd.DataFrame | None: """ Obtém um registro que cadastra uma restrição elétrica (RE) que varia ao longo do tempo, informada por intervalo de estágios, @@ -361,19 +354,18 @@ def re_per_pat( def restricao_eletrica_formula_data_patamar( self, - codigo_restricao: Optional[int] = None, - data_inicio: Optional[datetime] = None, - data_fim: Optional[datetime] = None, - patamar: Optional[int] = None, - formula: Optional[str] = None, + codigo_restricao: int | None = None, + data_inicio: datetime | None = None, + data_fim: datetime | None = None, + patamar: int | None = None, + formula: str | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroRestricaoEletricaFormulaDataPatamar, - List[RegistroRestricaoEletricaFormulaDataPatamar], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroRestricaoEletricaFormulaDataPatamar + | list[RegistroRestricaoEletricaFormulaDataPatamar] + | pd.DataFrame + | None + ): """ Obtém um registro que cadastra uma restrição elétrica (RE) que varia ao longo do tempo, informada por intervalo de data, @@ -406,15 +398,13 @@ def restricao_eletrica_formula_data_patamar( def re_data_pat( self, - codigo_restricao: Optional[int] = None, - data_inicio: Optional[datetime] = None, - data_fim: Optional[datetime] = None, - patamar: Optional[int] = None, - formula: Optional[str] = None, + codigo_restricao: int | None = None, + data_inicio: datetime | None = None, + data_fim: datetime | None = None, + patamar: int | None = None, + formula: str | None = None, df: bool = False, - ) -> Optional[ - Union[RegistroReDataPat, List[RegistroReDataPat], pd.DataFrame] - ]: + ) -> RegistroReDataPat | list[RegistroReDataPat] | pd.DataFrame | None: """ Obtém um registro que cadastra uma restrição elétrica (RE) que varia ao longo do tempo, informada por intervalo de data, @@ -447,20 +437,19 @@ def re_data_pat( def restricao_eletrica_limites_formula_data_patamar( self, - codigo_restricao: Optional[int] = None, - data_inicio: Optional[datetime] = None, - data_fim: Optional[datetime] = None, - patamar: Optional[int] = None, - limite_inferior: Optional[float] = None, - limite_superior: Optional[float] = None, + codigo_restricao: int | None = None, + data_inicio: datetime | None = None, + data_fim: datetime | None = None, + patamar: int | None = None, + limite_inferior: float | None = None, + limite_superior: float | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroRestricaoEletricaLimitesFormulaDataPatamar, - List[RegistroRestricaoEletricaLimitesFormulaDataPatamar], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroRestricaoEletricaLimitesFormulaDataPatamar + | list[RegistroRestricaoEletricaLimitesFormulaDataPatamar] + | pd.DataFrame + | None + ): """ Obtém um registro que cadastra os limites por horizonte, definido por intervalo de data, e por patamar para uma restrição elétrica, @@ -496,20 +485,19 @@ def restricao_eletrica_limites_formula_data_patamar( def re_lim_form_data_pat( self, - codigo_restricao: Optional[int] = None, - data_inicio: Optional[datetime] = None, - data_fim: Optional[datetime] = None, - patamar: Optional[int] = None, - limite_inferior: Optional[float] = None, - limite_superior: Optional[float] = None, + codigo_restricao: int | None = None, + data_inicio: datetime | None = None, + data_fim: datetime | None = None, + patamar: int | None = None, + limite_inferior: float | None = None, + limite_superior: float | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroReLimFormDataPat, - List[RegistroReLimFormDataPat], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroReLimFormDataPat + | list[RegistroReLimFormDataPat] + | pd.DataFrame + | None + ): """ Obtém um registro que cadastra os limites por horizonte, definido por intervalo de data, e por patamar para uma restrição elétrica, @@ -544,20 +532,19 @@ def re_lim_form_data_pat( def restricao_eletrica_limite_formula_periodo_patamar( self, - codigo_restricao: Optional[int] = None, - estagio_inicio: Optional[int] = None, - estagio_fim: Optional[int] = None, - patamar: Optional[int] = None, - limite_inferior: Optional[float] = None, - limite_superior: Optional[float] = None, + codigo_restricao: int | None = None, + estagio_inicio: int | None = None, + estagio_fim: int | None = None, + patamar: int | None = None, + limite_inferior: float | None = None, + limite_superior: float | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroRestricaoEletricaLimitesFormulaPeriodoPatamar, - List[RegistroRestricaoEletricaLimitesFormulaPeriodoPatamar], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroRestricaoEletricaLimitesFormulaPeriodoPatamar + | list[RegistroRestricaoEletricaLimitesFormulaPeriodoPatamar] + | pd.DataFrame + | None + ): """ Obtém um registro que cadastra os limites por horizonte, definido por intervalo de estágios, e por patamar para uma restrição elétrica, @@ -593,20 +580,19 @@ def restricao_eletrica_limite_formula_periodo_patamar( def re_lim_form_per_pat( self, - codigo_restricao: Optional[int] = None, - estagio_inicio: Optional[int] = None, - estagio_fim: Optional[int] = None, - patamar: Optional[int] = None, - limite_inferior: Optional[float] = None, - limite_superior: Optional[float] = None, + codigo_restricao: int | None = None, + estagio_inicio: int | None = None, + estagio_fim: int | None = None, + patamar: int | None = None, + limite_inferior: float | None = None, + limite_superior: float | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroReLimFormPerPat, - List[RegistroReLimFormPerPat], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroReLimFormPerPat + | list[RegistroReLimFormPerPat] + | pd.DataFrame + | None + ): """ Obtém um registro que cadastra os limites por horizonte, definido por intervalo de estágios, e por patamar para uma restrição elétrica, @@ -641,12 +627,15 @@ def re_lim_form_per_pat( def alias_eletrico( self, - codigo_alias: Optional[int] = None, - identificador_alias: Optional[str] = None, + codigo_alias: int | None = None, + identificador_alias: str | None = None, df: bool = False, - ) -> Optional[ - Union[RegistroAliasEletrico, List[RegistroAliasEletrico], pd.DataFrame] - ]: + ) -> ( + RegistroAliasEletrico + | list[RegistroAliasEletrico] + | pd.DataFrame + | None + ): """ Obtém um registro que cadastra um alias elétrico, definido através do nome completo do card. @@ -668,12 +657,10 @@ def alias_eletrico( def alias_elet( self, - codigo_alias: Optional[int] = None, - identificador_alias: Optional[str] = None, + codigo_alias: int | None = None, + identificador_alias: str | None = None, df: bool = False, - ) -> Optional[ - Union[RegistroAliasElet, List[RegistroAliasElet], pd.DataFrame] - ]: + ) -> RegistroAliasElet | list[RegistroAliasElet] | pd.DataFrame | None: """ Obtém um registro que cadastra um alias elétrico, definido através do nome alternativo (apelido) do card. @@ -695,19 +682,18 @@ def alias_elet( def alias_eletrico_valor_periodo_patamar( self, - codigo_alias: Optional[int] = None, - estagio_inicio: Optional[int] = None, - estagio_fim: Optional[int] = None, - patamar: Optional[int] = None, - valor: Optional[float] = None, + codigo_alias: int | None = None, + estagio_inicio: int | None = None, + estagio_fim: int | None = None, + patamar: int | None = None, + valor: float | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroAliasEletricoValorPeriodoPatamar, - List[RegistroAliasEletricoValorPeriodoPatamar], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroAliasEletricoValorPeriodoPatamar + | list[RegistroAliasEletricoValorPeriodoPatamar] + | pd.DataFrame + | None + ): """ Obtém um registro que contém os valores assumidos pelo alias para cada período e patamar, @@ -739,19 +725,18 @@ def alias_eletrico_valor_periodo_patamar( def alias_elet_val_per_pat( self, - codigo_alias: Optional[int] = None, - estagio_inicio: Optional[int] = None, - estagio_fim: Optional[int] = None, - patamar: Optional[int] = None, - valor: Optional[float] = None, + codigo_alias: int | None = None, + estagio_inicio: int | None = None, + estagio_fim: int | None = None, + patamar: int | None = None, + valor: float | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroAliasEletValPerPat, - List[RegistroAliasEletValPerPat], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroAliasEletValPerPat + | list[RegistroAliasEletValPerPat] + | pd.DataFrame + | None + ): """ Obtém um registro que contém os valores assumidos pelo alias para cada período e patamar, @@ -783,16 +768,15 @@ def alias_elet_val_per_pat( def restricao_eletrica_regra_ativacao( self, - codigo_regra_ativacao: Optional[int] = None, - regra_ativacao: Optional[str] = None, + codigo_regra_ativacao: int | None = None, + regra_ativacao: str | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroRestricaoEletricaRegraAtivacao, - List[RegistroRestricaoEletricaRegraAtivacao], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroRestricaoEletricaRegraAtivacao + | list[RegistroRestricaoEletricaRegraAtivacao] + | pd.DataFrame + | None + ): """ Obtém um registro que define uma regra para ativação e desativação de restrições elétricas, @@ -815,12 +799,12 @@ def restricao_eletrica_regra_ativacao( def re_regra_ativa( self, - codigo_regra_ativacao: Optional[int] = None, - regra_ativacao: Optional[str] = None, + codigo_regra_ativacao: int | None = None, + regra_ativacao: str | None = None, df: bool = False, - ) -> Optional[ - Union[RegistroReRegraAtiva, List[RegistroReRegraAtiva], pd.DataFrame] - ]: + ) -> ( + RegistroReRegraAtiva | list[RegistroReRegraAtiva] | pd.DataFrame | None + ): """ Obtém um registro que define uma regra para ativação e desativação de restrições elétricas, @@ -843,16 +827,15 @@ def re_regra_ativa( def restricao_eletrica_habilita( self, - codigo_restricao: Optional[int] = None, - codigo_regra_ativacao: Optional[int] = None, + codigo_restricao: int | None = None, + codigo_regra_ativacao: int | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroRestricaoEletricaHabilita, - List[RegistroRestricaoEletricaHabilita], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroRestricaoEletricaHabilita + | list[RegistroRestricaoEletricaHabilita] + | pd.DataFrame + | None + ): """ Obtém um registro que contém a associação entre uma regra de ativação e uma restrição elétrica, @@ -875,12 +858,10 @@ def restricao_eletrica_habilita( def re_habilita( self, - codigo_restricao: Optional[int] = None, - codigo_regra_ativacao: Optional[int] = None, + codigo_restricao: int | None = None, + codigo_regra_ativacao: int | None = None, df: bool = False, - ) -> Optional[ - Union[RegistroReHabilita, List[RegistroReHabilita], pd.DataFrame] - ]: + ) -> RegistroReHabilita | list[RegistroReHabilita] | pd.DataFrame | None: """ Obtém um registro que contém a associação entre uma regra de ativação e uma restrição elétrica, @@ -903,17 +884,16 @@ def re_habilita( def restricao_eletrica_tratamento_violacao( self, - codigo_restricao: Optional[int] = None, - tipo_violacao: Optional[str] = None, - custo_violacao: Optional[float] = None, + codigo_restricao: int | None = None, + tipo_violacao: str | None = None, + custo_violacao: float | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroRestricaoEletricaTratamentoViolacao, - List[RegistroRestricaoEletricaTratamentoViolacao], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroRestricaoEletricaTratamentoViolacao + | list[RegistroRestricaoEletricaTratamentoViolacao] + | pd.DataFrame + | None + ): """ Obtém um registro que contém definição do tipo de violação e o valor do custo de violação de uma restrição elétrica, @@ -939,13 +919,11 @@ def restricao_eletrica_tratamento_violacao( def re_trat_viol( self, - codigo_restricao: Optional[int] = None, - tipo_violacao: Optional[str] = None, - custo_violacao: Optional[float] = None, + codigo_restricao: int | None = None, + tipo_violacao: str | None = None, + custo_violacao: float | None = None, df: bool = False, - ) -> Optional[ - Union[RegistroReTratViol, List[RegistroReTratViol], pd.DataFrame] - ]: + ) -> RegistroReTratViol | list[RegistroReTratViol] | pd.DataFrame | None: """ Obtém um registro que contém definição do tipo de violação e o valor do custo de violação de uma restrição elétrica, @@ -971,19 +949,18 @@ def re_trat_viol( def restricao_eletrica_tratamento_violacao_periodo( self, - codigo_restricao: Optional[int] = None, - estagio_inicio: Optional[int] = None, - estagio_fim: Optional[int] = None, - tipo_violacao: Optional[str] = None, - custo_violacao: Optional[float] = None, + codigo_restricao: int | None = None, + estagio_inicio: int | None = None, + estagio_fim: int | None = None, + tipo_violacao: str | None = None, + custo_violacao: float | None = None, df: bool = False, - ) -> Optional[ - Union[ - RegistroRestricaoEletricaTratamentoViolacaoPeriodo, - List[RegistroRestricaoEletricaTratamentoViolacaoPeriodo], - pd.DataFrame, - ] - ]: + ) -> ( + RegistroRestricaoEletricaTratamentoViolacaoPeriodo + | list[RegistroRestricaoEletricaTratamentoViolacaoPeriodo] + | pd.DataFrame + | None + ): """ Obtém um registro que contém definição do tipo de violação e o valor do custo de violação de uma restrição elétrica definida para um @@ -1017,15 +994,18 @@ def restricao_eletrica_tratamento_violacao_periodo( def re_trat_viol_per( self, - codigo_restricao: Optional[int] = None, - estagio_inicio: Optional[int] = None, - estagio_fim: Optional[int] = None, - tipo_violacao: Optional[str] = None, - custo_violacao: Optional[float] = None, + codigo_restricao: int | None = None, + estagio_inicio: int | None = None, + estagio_fim: int | None = None, + tipo_violacao: str | None = None, + custo_violacao: float | None = None, df: bool = False, - ) -> Optional[ - Union[RegistroReTratViolPer, List[RegistroReTratViolPer], pd.DataFrame] - ]: + ) -> ( + RegistroReTratViolPer + | list[RegistroReTratViolPer] + | pd.DataFrame + | None + ): """ Obtém um registro que contém definição do tipo de violação e o valor do custo de violação de uma restrição elétrica definida para um diff --git a/idecomp/libs/usinas_hidreletricas.py b/idecomp/libs/usinas_hidreletricas.py index f3b63e59..daace4dc 100644 --- a/idecomp/libs/usinas_hidreletricas.py +++ b/idecomp/libs/usinas_hidreletricas.py @@ -1,13 +1,15 @@ -from typing import Type, TypeVar, Optional, List, Union +from typing import Any, TypeVar + +import pandas as pd # type: ignore[import-untyped] from cfinterface.components.register import Register from cfinterface.files.registerfile import RegisterFile -import pandas as pd # type: ignore + from idecomp.libs.modelos.usinas_hidreletricas import ( HidreletricaCurvaJusante, + HidreletricaCurvaJusanteAfogamentoExplicitoPadrao, + HidreletricaCurvaJusanteAfogamentoExplicitoUsina, HidreletricaCurvaJusantePolinomioPorPartes, HidreletricaCurvaJusantePolinomioPorPartesSegmento, - HidreletricaCurvaJusanteAfogamentoExplicitoUsina, - HidreletricaCurvaJusanteAfogamentoExplicitoPadrao, ) @@ -27,9 +29,12 @@ class UsinasHidreletricas(RegisterFile): HidreletricaCurvaJusante, ] + def __init__(self, data: Any = ...) -> None: + super().__init__(data) + def __registros_ou_df( - self, t: Type[T], **kwargs - ) -> Optional[Union[T, List[T], pd.DataFrame]]: + self, t: type[T], **kwargs: Any + ) -> T | list[T] | pd.DataFrame | None: if kwargs.get("df"): return self._as_df(t) else: @@ -38,17 +43,16 @@ def __registros_ou_df( def hidreletrica_curvajusante( self, - codigo_usina: Optional[int] = None, - indice_familia: Optional[int] = None, - nivel_montante_referencia: Optional[float] = None, + codigo_usina: int | None = None, + indice_familia: int | None = None, + nivel_montante_referencia: float | None = None, df: bool = False, - ) -> Optional[ - Union[ - HidreletricaCurvaJusante, - List[HidreletricaCurvaJusante], - pd.DataFrame, - ] - ]: + ) -> ( + HidreletricaCurvaJusante + | list[HidreletricaCurvaJusante] + | pd.DataFrame + | None + ): """ Obtém registros que cadastram uma família de curvas de jusante para uma usina hidrelétrica. Opcionalmente, @@ -79,17 +83,16 @@ def hidreletrica_curvajusante( def hidreletrica_curvajusante_polinomio( self, - codigo_usina: Optional[int] = None, - indice_familia: Optional[int] = None, - numero_polinomios: Optional[int] = None, + codigo_usina: int | None = None, + indice_familia: int | None = None, + numero_polinomios: int | None = None, df: bool = False, - ) -> Optional[ - Union[ - HidreletricaCurvaJusantePolinomioPorPartes, - List[HidreletricaCurvaJusantePolinomioPorPartes], - pd.DataFrame, - ] - ]: + ) -> ( + HidreletricaCurvaJusantePolinomioPorPartes + | list[HidreletricaCurvaJusantePolinomioPorPartes] + | pd.DataFrame + | None + ): """ Obtém registros que cadastram uma família de curvas de jusante para uma usina hidrelétrica. Opcionalmente, @@ -119,24 +122,23 @@ def hidreletrica_curvajusante_polinomio( def hidreletrica_curvajusante_polinomio_segmento( self, - codigo_usina: Optional[int] = None, - indice_familia: Optional[int] = None, - indice_polinomio: Optional[int] = None, - limite_inferior_vazao_jusante: Optional[float] = None, - limite_superior_vazao_jusante: Optional[float] = None, - coeficiente_a0: Optional[float] = None, - coeficiente_a1: Optional[float] = None, - coeficiente_a2: Optional[float] = None, - coeficiente_a3: Optional[float] = None, - coeficiente_a4: Optional[float] = None, + codigo_usina: int | None = None, + indice_familia: int | None = None, + indice_polinomio: int | None = None, + limite_inferior_vazao_jusante: float | None = None, + limite_superior_vazao_jusante: float | None = None, + coeficiente_a0: float | None = None, + coeficiente_a1: float | None = None, + coeficiente_a2: float | None = None, + coeficiente_a3: float | None = None, + coeficiente_a4: float | None = None, df: bool = False, - ) -> Optional[ - Union[ - HidreletricaCurvaJusantePolinomioPorPartesSegmento, - List[HidreletricaCurvaJusantePolinomioPorPartesSegmento], - pd.DataFrame, - ] - ]: + ) -> ( + HidreletricaCurvaJusantePolinomioPorPartesSegmento + | list[HidreletricaCurvaJusantePolinomioPorPartesSegmento] + | pd.DataFrame + | None + ): """ Obtém registros que cadastram os polinômios para cada família de curvas de jusante para uma usina hidrelétrica. Opcionalmente, @@ -190,16 +192,15 @@ def hidreletrica_curvajusante_polinomio_segmento( def hidreletrica_curvajusante_afogamentoexplicito_usina( self, - codigo_usina: Optional[int] = None, - considera_afogamento: Optional[str] = None, + codigo_usina: int | None = None, + considera_afogamento: str | None = None, df: bool = False, - ) -> Optional[ - Union[ - HidreletricaCurvaJusanteAfogamentoExplicitoUsina, - List[HidreletricaCurvaJusanteAfogamentoExplicitoUsina], - pd.DataFrame, - ] - ]: + ) -> ( + HidreletricaCurvaJusanteAfogamentoExplicitoUsina + | list[HidreletricaCurvaJusanteAfogamentoExplicitoUsina] + | pd.DataFrame + | None + ): """ Obtém registros que habilitam ou desabilitam a consideração do tratamento do afogamento explícito por usina. Opcionalmente, @@ -223,14 +224,13 @@ def hidreletrica_curvajusante_afogamentoexplicito_usina( ) def hidreletrica_curvajusante_afogamentoexplicito_padrao( - self, considera_afogamento: Optional[str] = None, df: bool = False - ) -> Optional[ - Union[ - HidreletricaCurvaJusanteAfogamentoExplicitoPadrao, - List[HidreletricaCurvaJusanteAfogamentoExplicitoPadrao], - pd.DataFrame, - ] - ]: + self, considera_afogamento: str | None = None, df: bool = False + ) -> ( + HidreletricaCurvaJusanteAfogamentoExplicitoPadrao + | list[HidreletricaCurvaJusanteAfogamentoExplicitoPadrao] + | pd.DataFrame + | None + ): """ Obtém registros que habilitam ou desabilitam a consideração do tratamento do afogamento explícito padrão. diff --git a/pyproject.toml b/pyproject.toml index d7696ef2..1d4e3146 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,39 +6,42 @@ build-backend = "hatchling.build" name = "idecomp" dynamic = ["version"] dependencies = [ - "cfinterface>=1.8,<=1.8.3", - "numpy>=2.0", - "pandas>=2.2", + "cfinterface>=1.9.0", + "numpy>=2.2.1", + "pandas>=3.0.0", ] -requires-python = ">= 3.10" +requires-python = ">= 3.11" authors = [ {name = "Rogerio Alves", email = "rogerioalves.ee@gmail.com"}, {name = "Mariana Noel", email = "marianasimoesnoel@gmail.com"}, ] -description = "idecomp" +description = "Pacote para manipulacao dos arquivos do DECOMP" readme = "README.md" license = {file = "LICENSE.md"} classifiers = [ "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", - "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "Typing :: Typed", "Operating System :: OS Independent", ] [project.optional-dependencies] -dev = [ - "pytest", - "pytest-cov", - "ruff", - "mypy", - "sphinx-rtd-theme", - "sphinx-gallery", +test = ["pytest", "pytest-cov", "pytest-xdist"] +lint = ["mypy", "pre-commit", "ruff"] +docs = [ "sphinx", + "furo", + "sphinx-gallery", "numpydoc", "plotly", "matplotlib", ] +dev = ["idecomp[test,lint,docs]"] [project.urls] Documentation = "https://rjmalves.github.io/idecomp/" @@ -54,3 +57,20 @@ include = [ [tool.ruff] line-length = 80 + +[tool.ruff.lint] +per-file-ignores = { "examples/*.py" = ["E402"] } + +[tool.mypy] +warn_return_any = false +warn_unused_ignores = true + +[[tool.mypy.overrides]] +module = [ + "idecomp", + "idecomp.decomp", + "idecomp.decomp.*", + "idecomp.libs.*", +] +strict = true +warn_return_any = false diff --git a/tests/libs/test_restricoes.py b/tests/libs/test_restricoes.py index a6c63f9b..9a94195d 100644 --- a/tests/libs/test_restricoes.py +++ b/tests/libs/test_restricoes.py @@ -683,7 +683,7 @@ def test_neq_restricoes(): with patch("builtins.open", m): cf1 = Restricoes.read(ARQ_TESTE) cf2 = Restricoes.read(ARQ_TESTE) - cf2.data.remove(cf1.re_horiz_per()[0]) + cf2.data.remove(cf2.re_horiz_per()[0]) assert cf1 != cf2