insect-audio-features 0.1.0__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,12 @@
1
+ include PACKAGE_README.md
2
+ include pyproject.toml
3
+ include main.py
4
+ recursive-include insect_audio_features *.py
5
+ recursive-include src/extractors *.py
6
+ recursive-include src/utils *.py
7
+ recursive-include tests *.py
8
+ prune data
9
+ prune features
10
+ prune results
11
+ prune documentoIC
12
+ prune src/classification
@@ -0,0 +1,58 @@
1
+ # Insect Audio Features
2
+
3
+ Biblioteca Python para extração de atributos de sinais optoacústicos de insetos. Oferece dois métodos: `librosa` e `padrao` (referência do laboratório).
4
+
5
+ ## Instalação
6
+
7
+ Após publicação no PyPI:
8
+
9
+ ```bash
10
+ pip install insect-audio-features
11
+ ```
12
+
13
+ Para desenvolvimento, na raiz do repositório:
14
+
15
+ ```bash
16
+ pip install -e .
17
+ ```
18
+
19
+ ## Uso
20
+
21
+ ```python
22
+ from insect_audio_features import extract_features, get_feature_columns_librosa
23
+
24
+ print(get_feature_columns_librosa())
25
+
26
+ df = extract_features(
27
+ path_dataset='Aedes aegypti (female).zip',
28
+ path_output='resultados/librosa.csv',
29
+ biblioteca='librosa',
30
+ )
31
+ print(df.head())
32
+ ```
33
+
34
+ A entrada pode ser um ZIP, uma pasta contendo ZIPs ou uma lista de caminhos. Cada ZIP contém arquivos WAV, inclusive em subpastas. O resultado é salvo em CSV e também retornado como `pandas.DataFrame`.
35
+
36
+ As três primeiras colunas são `zip_name`, `file_path` e `label`. O rótulo é inferido pelo pipeline a partir do nome do ZIP ou, conforme sua estrutura, da pasta do áudio. Confira a rotulagem antes de utilizar os resultados.
37
+
38
+ ## Métodos
39
+
40
+ - **Librosa:** RMS, cruzamento por zero, centroide, largura de banda, planicidade, roll-off, sete bandas de contraste e 13 MFCCs (26 atributos).
41
+ - **Padrão:** temperatura quando disponível, frequência de batimento das asas, complexidade, duração, inarmonicidade, picos e energias harmônicas. Consulte `get_feature_columns()` para a lista exata.
42
+
43
+ Também é possível processar um WAV individual:
44
+
45
+ ```python
46
+ from insect_audio_features import extract_features_librosa
47
+ features = extract_features_librosa('audio.wav')
48
+ ```
49
+
50
+ Os algoritmos mantêm os parâmetros do projeto de pesquisa, incluindo taxa de 44,1 kHz e janela de 1.024 amostras. Não há remoção automática de silêncio. A extração individual pode falhar em áudios inválidos ou incompatíveis; no processamento em lote, essas falhas são informadas no terminal e as amostras são omitidas. Um CSV existente no destino é sobrescrito.
51
+
52
+ ## Escopo
53
+
54
+ O pacote contém apenas extração e processamento de arquivos. Não inclui base de áudios, resultados experimentais, classificadores ou interface web. Dependências numéricas e de áudio são instaladas separadamente pelo pip; sua compatibilidade depende da plataforma e da versão do Python. A validação inicial foi realizada em Linux com Python 3.13.
55
+
56
+ ## Organização preservada
57
+
58
+ Os arquivos originais continuam em `main.py`, `src/extractors` e `src/utils`, com os mesmos imports e funções. `insect_audio_features/__init__.py` apenas disponibiliza essas funções para importação pelo nome do pacote. Não há outra implementação de extração. O pacote mantém os nomes de módulos originais `main` e `src`; instale-o em um ambiente virtual dedicado para evitar conflitos com outros projetos que utilizem esses mesmos nomes.
@@ -0,0 +1,75 @@
1
+ Metadata-Version: 2.4
2
+ Name: insect-audio-features
3
+ Version: 0.1.0
4
+ Summary: Python feature extraction for insect optoacoustic signals
5
+ Author: Gabriel Cavalcante Velasquez
6
+ Project-URL: Repository, https://github.com/GabrielCavalcanteVelasquez/insect-audio-feature-benchmark
7
+ Project-URL: Issues, https://github.com/GabrielCavalcanteVelasquez/insect-audio-feature-benchmark/issues
8
+ Keywords: insects,optoacoustic,audio,feature-extraction,librosa
9
+ Requires-Python: >=3.10
10
+ Description-Content-Type: text/markdown
11
+ Requires-Dist: numpy<3,>=1.24
12
+ Requires-Dist: pandas<4,>=2
13
+ Requires-Dist: scipy<2,>=1.10
14
+ Requires-Dist: librosa<2,>=0.11
15
+ Requires-Dist: audioflux<0.2,>=0.1.9
16
+ Requires-Dist: audio-metadata<0.12,>=0.11.1
17
+
18
+ # Insect Audio Features
19
+
20
+ Biblioteca Python para extração de atributos de sinais optoacústicos de insetos. Oferece dois métodos: `librosa` e `padrao` (referência do laboratório).
21
+
22
+ ## Instalação
23
+
24
+ Após publicação no PyPI:
25
+
26
+ ```bash
27
+ pip install insect-audio-features
28
+ ```
29
+
30
+ Para desenvolvimento, na raiz do repositório:
31
+
32
+ ```bash
33
+ pip install -e .
34
+ ```
35
+
36
+ ## Uso
37
+
38
+ ```python
39
+ from insect_audio_features import extract_features, get_feature_columns_librosa
40
+
41
+ print(get_feature_columns_librosa())
42
+
43
+ df = extract_features(
44
+ path_dataset='Aedes aegypti (female).zip',
45
+ path_output='resultados/librosa.csv',
46
+ biblioteca='librosa',
47
+ )
48
+ print(df.head())
49
+ ```
50
+
51
+ A entrada pode ser um ZIP, uma pasta contendo ZIPs ou uma lista de caminhos. Cada ZIP contém arquivos WAV, inclusive em subpastas. O resultado é salvo em CSV e também retornado como `pandas.DataFrame`.
52
+
53
+ As três primeiras colunas são `zip_name`, `file_path` e `label`. O rótulo é inferido pelo pipeline a partir do nome do ZIP ou, conforme sua estrutura, da pasta do áudio. Confira a rotulagem antes de utilizar os resultados.
54
+
55
+ ## Métodos
56
+
57
+ - **Librosa:** RMS, cruzamento por zero, centroide, largura de banda, planicidade, roll-off, sete bandas de contraste e 13 MFCCs (26 atributos).
58
+ - **Padrão:** temperatura quando disponível, frequência de batimento das asas, complexidade, duração, inarmonicidade, picos e energias harmônicas. Consulte `get_feature_columns()` para a lista exata.
59
+
60
+ Também é possível processar um WAV individual:
61
+
62
+ ```python
63
+ from insect_audio_features import extract_features_librosa
64
+ features = extract_features_librosa('audio.wav')
65
+ ```
66
+
67
+ Os algoritmos mantêm os parâmetros do projeto de pesquisa, incluindo taxa de 44,1 kHz e janela de 1.024 amostras. Não há remoção automática de silêncio. A extração individual pode falhar em áudios inválidos ou incompatíveis; no processamento em lote, essas falhas são informadas no terminal e as amostras são omitidas. Um CSV existente no destino é sobrescrito.
68
+
69
+ ## Escopo
70
+
71
+ O pacote contém apenas extração e processamento de arquivos. Não inclui base de áudios, resultados experimentais, classificadores ou interface web. Dependências numéricas e de áudio são instaladas separadamente pelo pip; sua compatibilidade depende da plataforma e da versão do Python. A validação inicial foi realizada em Linux com Python 3.13.
72
+
73
+ ## Organização preservada
74
+
75
+ Os arquivos originais continuam em `main.py`, `src/extractors` e `src/utils`, com os mesmos imports e funções. `insect_audio_features/__init__.py` apenas disponibiliza essas funções para importação pelo nome do pacote. Não há outra implementação de extração. O pacote mantém os nomes de módulos originais `main` e `src`; instale-o em um ambiente virtual dedicado para evitar conflitos com outros projetos que utilizem esses mesmos nomes.
@@ -0,0 +1,174 @@
1
+ # Insect Audio Feature Benchmark
2
+
3
+ Benchmark e avaliação de bibliotecas Python para extração de atributos acústicos em sinais optoacústicos de insetos alados (vetores de doenças como *Aedes aegypti*, *Culex*, *Anopheles*, entre outros).
4
+
5
+ O objetivo deste projeto de Iniciação Científica (IC) é comparar a performance computacional, precisão e qualidade dos atributos gerados por diferentes bibliotecas de áudio em relação ao método padrão (baseline) do laboratório, visando aplicações em Machine Learning para classificação taxonômica de espécies e sexagem.
6
+
7
+ ---
8
+
9
+ ## 📋 Bibliotecas Avaliadas
10
+
11
+ O benchmark abrange e compara diversas bibliotecas do ecossistema de processamento de áudio em Python:
12
+
13
+ * **Padrão (Baseline do Laboratório)**: Método de referência com 38 atributos espectrais e temporais (frequência de batimento de asas - WBF via Cepstrum, temperatura dos sensores, complexidade do sinal, harmônicos `eh_1` a `eh_26`, inarmonicidade e picos de frequência).
14
+ * **Librosa**: Biblioteca padrão de mercado para recuperação de informação musical e análise acústica.
15
+ * **AudioFlux**: Biblioteca de alta performance em C/Python focada em representações tempo-frequência.
16
+ * **Essentia**: Algoritmos C++ de alta performance para análise e extração de descritores de áudio.
17
+ * **OpenSMILE**: Padrão na extração de features para reconhecimento de voz e paralinguística.
18
+ * **TSFEL**: Biblioteca voltada para extração de atributos em séries temporais.
19
+ * **PyAudioAnalysis**, **TorchAudio**, **SPAFE**, **Surfboard**, entre outras.
20
+
21
+ ---
22
+
23
+ ## 📂 Estrutura do Repositório
24
+
25
+ ```
26
+ insect-audio-feature-benchmark/
27
+ ├── data/
28
+ │ ├── raw/
29
+ │ │ └── females/ # Áudios ZIP de fêmeas (Aedes, Culex, etc.)
30
+ │ └── others/
31
+ │ └── males/ # Áudios ZIP de machos
32
+ ├── features/ # CSVs gerados com os atributos por biblioteca
33
+ │ ├── padrao/
34
+ │ │ └── padrao.csv # Atributos extraídos pelo método baseline
35
+ │ ├── librosa/
36
+ │ ├── audioflux/
37
+ │ └── ...
38
+ ├── src/
39
+ │ ├── extractors/ # Módulos puros de extração (1 áudio -> dicionário)
40
+ │ │ └── padrao.py # Baseline com os 38 atributos do laboratório
41
+ │ ├── utils/
42
+ │ │ └── auxiliares.py # Pipeline de dados (busca ZIPs, extração e CSV)
43
+ │ ├── preprocessing/ # Pré-processamento e filtragem de sinais
44
+ │ ├── classification/ # Modelos de Machine Learning para classificação
45
+ │ └── evaluation/ # Métricas comparativas de acurácia e tempo
46
+ ├── main.py # Ponto de entrada do benchmark
47
+ ├── requirements.txt # Dependências do projeto
48
+ └── README.md
49
+ ```
50
+
51
+ ---
52
+
53
+ ## 🏗️ Arquitetura e Filosofia do Projeto
54
+
55
+ O projeto adota uma arquitetura modular com separação clara de responsabilidades:
56
+
57
+ 1. **Extratores Puros (`src/extractors/`)**:
58
+ - Cada biblioteca possui seu próprio arquivo (ex.: `padrao.py`, futuro `librosa_ext.py`).
59
+ - O extrator é responsável **exclusivamente** pelo processamento de sinal: recebe o caminho de **1 arquivo `.wav`** e devolve um dicionário Python contendo as features numéricas calculadas.
60
+ - Não se preocupa com pastas, descompactação de ZIPs ou geração de CSV.
61
+
62
+ 2. **Orquestração de Dados (`src/utils/auxiliares.py`)**:
63
+ - Descobre automaticamente os arquivos `.zip` no disco.
64
+ - Extrai o nome da espécie/sexo diretamente do nome do arquivo (`get_labels`).
65
+ - Descompacta os áudios temporariamente em memória/disco seguro (`get_wav_members`).
66
+ - Executa a função do extrator escolhido para cada áudio e salva os resultados em lote no CSV final (`process_dataset`).
67
+
68
+ 3. **Interface do Usuário (`main.py`)**:
69
+ - Ponto de entrada simplificado. O usuário define qual dataset processar, o arquivo de saída e a biblioteca desejada via `extract_features(...)`.
70
+
71
+ ---
72
+
73
+ ## 🚀 Como Executar
74
+
75
+ ### 1. Pré-requisitos
76
+ * Python 3.10 ou superior (recomendado Python 3.13)
77
+ * Ambiente virtual configurado
78
+
79
+ ### 2. Instalação do Ambiente
80
+
81
+ Crie e ative um ambiente virtual:
82
+
83
+ ```bash
84
+ python -m venv .venv
85
+ source .venv/bin/activate # No Linux/macOS
86
+ # ou: .venv\Scripts\activate no Windows
87
+ ```
88
+
89
+ Instale as dependências:
90
+
91
+ ```bash
92
+ pip install -r requirements.txt
93
+ ```
94
+
95
+ *(Opcional - Usando [uv](https://github.com/astral-sh/uv) para instalação ultra-rápida):*
96
+ ```bash
97
+ uv venv --python 3.13 .venv
98
+ source .venv/bin/activate
99
+ uv pip install -r requirements.txt
100
+ ```
101
+
102
+ ### 3. Executando a Extração
103
+
104
+ Para rodar a extração dos atributos de todas as amostras, basta executar:
105
+
106
+ ```bash
107
+ python main.py
108
+ ```
109
+
110
+ Exemplo de uso via código em `main.py`:
111
+
112
+ ```python
113
+ from main import extract_features
114
+
115
+ df = extract_features(
116
+ path_dataset="data/raw/females",
117
+ path_output="features/padrao/padrao.csv",
118
+ biblioteca="padrao",
119
+ )
120
+
121
+ print(f"Total de áudios processados: {len(df)}")
122
+ print(df.head())
123
+ ```
124
+
125
+ ---
126
+
127
+ ## 📊 Dataset
128
+
129
+ Os dados consistem em arquivos `.zip` gravados por sensores optoacústicos ópticos (dispositivos de barreira de luz infravermelha), contendo arquivos `.wav` individuais:
130
+
131
+ * **Espécies presentes**:
132
+ * *Aedes aegypti* (fêmeas e machos)
133
+ * *Aedes albopictus* (fêmeas e machos)
134
+ * *Anopheles aquasalis* (fêmeas e machos)
135
+ * *Culex quinquefasciatus* (fêmeas e machos)
136
+ * *Culex tarsalis* (fêmeas e machos)
137
+ * *Drosophila suzukii* (fêmeas e machos)
138
+ * **Metadados gravados**:
139
+ * Temperatura (°C) registrada no momento da captura presente nos comentários do cabeçalho WAV (`T=...`).
140
+ * Taxa de amostragem padrão: 44.1 kHz.
141
+
142
+ ---
143
+
144
+ ## 🧩 Como Adicionar uma Nova Biblioteca
145
+
146
+ Para adicionar uma nova biblioteca ao benchmark (por exemplo, `librosa`):
147
+
148
+ 1. Crie o módulo em `src/extractors/librosa_ext.py`:
149
+ ```python
150
+ import librosa
151
+
152
+ def extract_features_librosa(audio_path: str) -> dict[str, float]:
153
+ audio, sr = librosa.load(audio_path, sr=44100)
154
+
155
+ # Exemplo de atributos
156
+ mfccs = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=13)
157
+ centroid = librosa.feature.spectral_centroid(y=audio, sr=sr)
158
+
159
+ return {
160
+ "spectral_centroid_mean": float(centroid.mean()),
161
+ **{f"mfcc_{i+1}": float(mfccs[i].mean()) for i in range(13)},
162
+ }
163
+ ```
164
+
165
+ 2. Adicione a chamada no `main.py`:
166
+ ```python
167
+ elif biblioteca_norm == "librosa":
168
+ return process_dataset(
169
+ data_dirs=path_dataset,
170
+ output_csv=path_output,
171
+ extract_one_func=extract_features_librosa,
172
+ )
173
+ ```
174
+ O pipeline cuidará de descompactar, rotular e gerar o CSV correspondente em `features/librosa/librosa.csv`.
@@ -0,0 +1,10 @@
1
+ """Acesso às funções originais do projeto de extração."""
2
+ from main import extract_features
3
+ from src.extractors.librosa import extract_features_librosa, get_feature_columns_librosa
4
+ from src.extractors.padrao import extract_features_padrao, get_feature_columns
5
+
6
+ __all__ = [
7
+ 'extract_features',
8
+ 'extract_features_librosa', 'get_feature_columns_librosa',
9
+ 'extract_features_padrao', 'get_feature_columns',
10
+ ]
@@ -0,0 +1,75 @@
1
+ Metadata-Version: 2.4
2
+ Name: insect-audio-features
3
+ Version: 0.1.0
4
+ Summary: Python feature extraction for insect optoacoustic signals
5
+ Author: Gabriel Cavalcante Velasquez
6
+ Project-URL: Repository, https://github.com/GabrielCavalcanteVelasquez/insect-audio-feature-benchmark
7
+ Project-URL: Issues, https://github.com/GabrielCavalcanteVelasquez/insect-audio-feature-benchmark/issues
8
+ Keywords: insects,optoacoustic,audio,feature-extraction,librosa
9
+ Requires-Python: >=3.10
10
+ Description-Content-Type: text/markdown
11
+ Requires-Dist: numpy<3,>=1.24
12
+ Requires-Dist: pandas<4,>=2
13
+ Requires-Dist: scipy<2,>=1.10
14
+ Requires-Dist: librosa<2,>=0.11
15
+ Requires-Dist: audioflux<0.2,>=0.1.9
16
+ Requires-Dist: audio-metadata<0.12,>=0.11.1
17
+
18
+ # Insect Audio Features
19
+
20
+ Biblioteca Python para extração de atributos de sinais optoacústicos de insetos. Oferece dois métodos: `librosa` e `padrao` (referência do laboratório).
21
+
22
+ ## Instalação
23
+
24
+ Após publicação no PyPI:
25
+
26
+ ```bash
27
+ pip install insect-audio-features
28
+ ```
29
+
30
+ Para desenvolvimento, na raiz do repositório:
31
+
32
+ ```bash
33
+ pip install -e .
34
+ ```
35
+
36
+ ## Uso
37
+
38
+ ```python
39
+ from insect_audio_features import extract_features, get_feature_columns_librosa
40
+
41
+ print(get_feature_columns_librosa())
42
+
43
+ df = extract_features(
44
+ path_dataset='Aedes aegypti (female).zip',
45
+ path_output='resultados/librosa.csv',
46
+ biblioteca='librosa',
47
+ )
48
+ print(df.head())
49
+ ```
50
+
51
+ A entrada pode ser um ZIP, uma pasta contendo ZIPs ou uma lista de caminhos. Cada ZIP contém arquivos WAV, inclusive em subpastas. O resultado é salvo em CSV e também retornado como `pandas.DataFrame`.
52
+
53
+ As três primeiras colunas são `zip_name`, `file_path` e `label`. O rótulo é inferido pelo pipeline a partir do nome do ZIP ou, conforme sua estrutura, da pasta do áudio. Confira a rotulagem antes de utilizar os resultados.
54
+
55
+ ## Métodos
56
+
57
+ - **Librosa:** RMS, cruzamento por zero, centroide, largura de banda, planicidade, roll-off, sete bandas de contraste e 13 MFCCs (26 atributos).
58
+ - **Padrão:** temperatura quando disponível, frequência de batimento das asas, complexidade, duração, inarmonicidade, picos e energias harmônicas. Consulte `get_feature_columns()` para a lista exata.
59
+
60
+ Também é possível processar um WAV individual:
61
+
62
+ ```python
63
+ from insect_audio_features import extract_features_librosa
64
+ features = extract_features_librosa('audio.wav')
65
+ ```
66
+
67
+ Os algoritmos mantêm os parâmetros do projeto de pesquisa, incluindo taxa de 44,1 kHz e janela de 1.024 amostras. Não há remoção automática de silêncio. A extração individual pode falhar em áudios inválidos ou incompatíveis; no processamento em lote, essas falhas são informadas no terminal e as amostras são omitidas. Um CSV existente no destino é sobrescrito.
68
+
69
+ ## Escopo
70
+
71
+ O pacote contém apenas extração e processamento de arquivos. Não inclui base de áudios, resultados experimentais, classificadores ou interface web. Dependências numéricas e de áudio são instaladas separadamente pelo pip; sua compatibilidade depende da plataforma e da versão do Python. A validação inicial foi realizada em Linux com Python 3.13.
72
+
73
+ ## Organização preservada
74
+
75
+ Os arquivos originais continuam em `main.py`, `src/extractors` e `src/utils`, com os mesmos imports e funções. `insect_audio_features/__init__.py` apenas disponibiliza essas funções para importação pelo nome do pacote. Não há outra implementação de extração. O pacote mantém os nomes de módulos originais `main` e `src`; instale-o em um ambiente virtual dedicado para evitar conflitos com outros projetos que utilizem esses mesmos nomes.
@@ -0,0 +1,15 @@
1
+ MANIFEST.in
2
+ PACKAGE_README.md
3
+ README.md
4
+ main.py
5
+ pyproject.toml
6
+ insect_audio_features/__init__.py
7
+ insect_audio_features.egg-info/PKG-INFO
8
+ insect_audio_features.egg-info/SOURCES.txt
9
+ insect_audio_features.egg-info/dependency_links.txt
10
+ insect_audio_features.egg-info/requires.txt
11
+ insect_audio_features.egg-info/top_level.txt
12
+ src/extractors/librosa.py
13
+ src/extractors/padrao.py
14
+ src/utils/dataset_processor.py
15
+ tests/test_package.py
@@ -0,0 +1,6 @@
1
+ numpy<3,>=1.24
2
+ pandas<4,>=2
3
+ scipy<2,>=1.10
4
+ librosa<2,>=0.11
5
+ audioflux<0.2,>=0.1.9
6
+ audio-metadata<0.12,>=0.11.1
@@ -0,0 +1,3 @@
1
+ insect_audio_features
2
+ main
3
+ src
@@ -0,0 +1,68 @@
1
+ from pathlib import Path
2
+ import pandas as pd
3
+
4
+ from src.extractors.padrao import extract_features_padrao, get_feature_columns
5
+ from src.extractors.librosa import extract_features_librosa, get_feature_columns_librosa
6
+ from src.utils.dataset_processor import process_dataset
7
+
8
+
9
+ def extract_features(
10
+ path_dataset: str | Path | list[str | Path],
11
+ path_output: str | Path,
12
+ biblioteca: str = "",
13
+ ):
14
+ """Extrai atributos acústicos do dataset usando a biblioteca de extração especificada.
15
+
16
+ Parâmetros:
17
+ path_dataset: Caminho da pasta ou lista de arquivos ZIP contendo os áudios.
18
+ path_output: Caminho do arquivo CSV de saída.
19
+ biblioteca: Nome do método/biblioteca de extração ('padrao', 'librosa', 'audioflux').
20
+ """
21
+ biblioteca_norm = biblioteca.strip().lower()
22
+
23
+ if biblioteca_norm == "padrao":
24
+ return process_dataset(
25
+ data_dirs=path_dataset,
26
+ output_csv=path_output,
27
+ extract_one_func=extract_features_padrao,
28
+ feature_columns=get_feature_columns(),
29
+ )
30
+ elif biblioteca_norm == "librosa":
31
+ return process_dataset(
32
+ data_dirs=path_dataset,
33
+ output_csv=path_output,
34
+ extract_one_func=extract_features_librosa,
35
+ feature_columns=get_feature_columns_librosa(),
36
+ )
37
+ else:
38
+ raise ValueError(
39
+ f"Biblioteca '{biblioteca}' não reconhecida! Opções disponíveis: ['padrao', 'librosa']"
40
+ )
41
+
42
+
43
+ def main():
44
+ extratores = {
45
+ "librosa": {
46
+ "path_dataset": "data/raw/females",
47
+ "path_output": "features/librosa/librosa.csv",
48
+ },
49
+ "padrao": {
50
+ "path_dataset": "data/raw/females",
51
+ "path_output": "features/padrao/padrao.csv",
52
+ },
53
+ }
54
+
55
+ extratores_rodar = ["librosa", "padrao"]
56
+
57
+ for biblioteca in extratores_rodar:
58
+ dados_extracao = extratores[biblioteca]
59
+ extract_features(
60
+ path_dataset=dados_extracao["path_dataset"],
61
+ path_output=dados_extracao["path_output"],
62
+ biblioteca=biblioteca,
63
+ )
64
+ print("\nExtração concluída!")
65
+
66
+
67
+ if __name__ == "__main__":
68
+ main()
@@ -0,0 +1,33 @@
1
+ [build-system]
2
+ requires = ["setuptools>=77"]
3
+ build-backend = "setuptools.build_meta"
4
+
5
+ [project]
6
+ name = "insect-audio-features"
7
+ version = "0.1.0"
8
+ description = "Python feature extraction for insect optoacoustic signals"
9
+ readme = "PACKAGE_README.md"
10
+ requires-python = ">=3.10"
11
+ authors = [{name = "Gabriel Cavalcante Velasquez"}]
12
+ keywords = ["insects", "optoacoustic", "audio", "feature-extraction", "librosa"]
13
+ dependencies = [
14
+ "numpy>=1.24,<3",
15
+ "pandas>=2,<4",
16
+ "scipy>=1.10,<2",
17
+ "librosa>=0.11,<2",
18
+ "audioflux>=0.1.9,<0.2",
19
+ "audio-metadata>=0.11.1,<0.12",
20
+ ]
21
+
22
+ [project.urls]
23
+ Repository = "https://github.com/GabrielCavalcanteVelasquez/insect-audio-feature-benchmark"
24
+ Issues = "https://github.com/GabrielCavalcanteVelasquez/insect-audio-feature-benchmark/issues"
25
+
26
+ [tool.setuptools]
27
+ py-modules = ["main"]
28
+ include-package-data = false
29
+
30
+ [tool.setuptools.packages.find]
31
+ where = ["."]
32
+ include = ["insect_audio_features", "src.extractors", "src.utils"]
33
+ namespaces = true
@@ -0,0 +1,4 @@
1
+ [egg_info]
2
+ tag_build =
3
+ tag_date = 0
4
+
@@ -0,0 +1,124 @@
1
+ """Extrator de atributos acústicos utilizando a biblioteca Librosa.
2
+
3
+ Atributos implementados:
4
+ - Temporais:
5
+ - rms: Root-Mean-Square energy por frame
6
+ - zero_crossing_rate: Taxa de cruzamento por zero
7
+ - Espectrais:
8
+ - spectral_centroid: Centróide espectral
9
+ - spectral_bandwidth: Largura de banda espectral
10
+ - spectral_contrast: Contraste espectral (7 bandas)
11
+ - spectral_flatness: Planicidade espectral
12
+ - spectral_rolloff: Frequência de decaimento espectral (roll-off)
13
+ - poly_features: Coeficientes polinomiais sobre o espectrograma (ordem 1)
14
+ - Tonal / Chroma:
15
+ - chroma_stft: Cromagrama via STFT (12 classes de pitch)
16
+ - chroma_cqt: Cromagrama via Constant-Q (12 classes de pitch)
17
+ - chroma_cens: Chroma Energy Normalized Statistics (CENS, 12 classes)
18
+ - chroma_vqt: Cromagrama via Variable-Q (12 classes de pitch)
19
+ - tonnetz: Características do centróide tonal (6 dimensões)
20
+ - Ceptrais e Banco de Filtros:
21
+ - mfcc: Coeficientes cepstrais na escala Mel (20 coeficientes)
22
+ - melspectrogram: Espectrograma em escala Mel (128 bandas)
23
+ """
24
+
25
+
26
+
27
+
28
+
29
+ from pathlib import Path
30
+ import librosa
31
+ import numpy as np
32
+
33
+ SAMPLE_RATE = 44100
34
+ N_FFT = 1024
35
+ HOP_LENGTH = 512
36
+ N_MFCC = 13
37
+ N_CONTRAST_BANDS = 6
38
+
39
+
40
+ def get_feature_columns_librosa() -> list[str]:
41
+ """Retorna os nomes das colunas de características geradas pelo Librosa."""
42
+ columns = [
43
+ "rms",
44
+ "zcr",
45
+ "spectral_centroid",
46
+ "spectral_bandwidth",
47
+ "spectral_flatness",
48
+ "spectral_rolloff",
49
+ ]
50
+ for i in range(N_CONTRAST_BANDS + 1):
51
+ columns.append(f"spectral_contrast_band_{i + 1:02d}")
52
+ for i in range(N_MFCC):
53
+ columns.append(f"mfcc_{i + 1:02d}")
54
+ return columns
55
+
56
+
57
+ def extract_features_librosa(audio_path: str | Path) -> dict[str, float]:
58
+ """Extrai atributos acústicos brutos (temporais, espectrais e cepstrais) via Librosa.
59
+
60
+ Parâmetros:
61
+ audio_path: Caminho do arquivo de áudio WAV capturado pelo sensor óptico.
62
+ Retorna: Dicionário com os atributos nativos simplificados para a matriz de ML.
63
+ """
64
+ y, sr = librosa.load(str(audio_path), sr=SAMPLE_RATE, mono=True)
65
+
66
+ features: dict[str, float] = {}
67
+
68
+ # Atributos Temporais Brutos
69
+ features["rms"] = float(
70
+ np.mean(librosa.feature.rms(y=y, frame_length=N_FFT, hop_length=HOP_LENGTH))
71
+ )
72
+ features["zcr"] = float(
73
+ np.mean(
74
+ librosa.feature.zero_crossing_rate(
75
+ y=y, frame_length=N_FFT, hop_length=HOP_LENGTH
76
+ )
77
+ )
78
+ )
79
+
80
+ # Atributos Espectrais Brutos
81
+ features["spectral_centroid"] = float(
82
+ np.mean(
83
+ librosa.feature.spectral_centroid(
84
+ y=y, sr=sr, n_fft=N_FFT, hop_length=HOP_LENGTH
85
+ )
86
+ )
87
+ )
88
+ features["spectral_bandwidth"] = float(
89
+ np.mean(
90
+ librosa.feature.spectral_bandwidth(
91
+ y=y, sr=sr, n_fft=N_FFT, hop_length=HOP_LENGTH
92
+ )
93
+ )
94
+ )
95
+ features["spectral_flatness"] = float(
96
+ np.mean(
97
+ librosa.feature.spectral_flatness(
98
+ y=y, n_fft=N_FFT, hop_length=HOP_LENGTH
99
+ )
100
+ )
101
+ )
102
+ features["spectral_rolloff"] = float(
103
+ np.mean(
104
+ librosa.feature.spectral_rolloff(
105
+ y=y, sr=sr, n_fft=N_FFT, hop_length=HOP_LENGTH
106
+ )
107
+ )
108
+ )
109
+
110
+ # Spectral Contrast (6 bandas de frequência -> 7 bandas no total)
111
+ contrast = librosa.feature.spectral_contrast(
112
+ y=y, sr=sr, n_fft=N_FFT, hop_length=HOP_LENGTH, n_bands=N_CONTRAST_BANDS
113
+ )
114
+ for i in range(contrast.shape[0]):
115
+ features[f"spectral_contrast_band_{i + 1:02d}"] = float(np.mean(contrast[i]))
116
+
117
+ # Atributos Cepstrais Brutos (13 MFCCs)
118
+ mfcc = librosa.feature.mfcc(
119
+ y=y, sr=sr, n_mfcc=N_MFCC, n_fft=N_FFT, hop_length=HOP_LENGTH
120
+ )
121
+ for i in range(N_MFCC):
122
+ features[f"mfcc_{i + 1:02d}"] = float(np.mean(mfcc[i]))
123
+
124
+ return features
@@ -0,0 +1,162 @@
1
+ """Extração de atributos acústicos a partir de arquivos de áudio WAV (Método Padrão do Laboratório)."""
2
+
3
+ from __future__ import annotations
4
+
5
+ from pathlib import Path
6
+
7
+ import audio_metadata
8
+ import audioflux as af
9
+ import numpy as np
10
+ from scipy.fft import fft
11
+
12
+ # Constantes do método de extração acústica
13
+ SAMPLE_RATE = 44100
14
+ WINDOW_SIZE = 1024
15
+ PEAK_COUNT = 6
16
+
17
+ def hanning_window(size: int) -> np.ndarray:
18
+ """Gera a janela de ponderação de Hanning."""
19
+ return 0.5 - 0.5 * np.cos(2 * np.pi * np.arange(size) / (size - 1))
20
+
21
+
22
+ def normalize_znorm(values: np.ndarray) -> np.ndarray:
23
+ """Normalização estatística Z-score para blocos de complexidade."""
24
+ std = np.std(values)
25
+ return (values - np.mean(values)) / std if std > 0 else values
26
+
27
+
28
+ def get_temperature(file_path: Path | str) -> float | None:
29
+ """Extrai a temperatura gravada nos metadados do áudio (tag T=...)."""
30
+ try:
31
+ metadata = audio_metadata.load(str(file_path))
32
+ comments = metadata.get("tags", {}).get("comment", [])
33
+ if comments:
34
+ for part in comments[0].split(","):
35
+ if part.startswith("T="):
36
+ return float(part.split("=", 1)[1])
37
+ except Exception:
38
+ pass
39
+ return None
40
+
41
+
42
+ def wingbeat_frequency(
43
+ audio: np.ndarray,
44
+ sample_rate: int = SAMPLE_RATE,
45
+ f0_min: int = 200,
46
+ f0_max: int = 1200,
47
+ ) -> float:
48
+ """Estima a frequência fundamental (batimento de asas) via Cepstrum."""
49
+ cepstrum = fft(np.log(np.abs(fft(audio, sample_rate)) + 1e-12))
50
+ start = int(np.floor(sample_rate / f0_max))
51
+ end = min(int(np.ceil(sample_rate / f0_min)), len(cepstrum))
52
+ peak = np.argmax(np.abs(cepstrum[start:end]))
53
+ return float(sample_rate / (peak + start))
54
+
55
+
56
+ def get_feature_columns() -> list[str]:
57
+ """Retorna os nomes das colunas de características geradas."""
58
+ harmonic_count = (
59
+ int((1200 / SAMPLE_RATE) * WINDOW_SIZE)
60
+ - int((100 / SAMPLE_RATE) * WINDOW_SIZE)
61
+ + 1
62
+ )
63
+ return (
64
+ [
65
+ "temperature",
66
+ "wbf",
67
+ "complexity",
68
+ "complexity_znorm",
69
+ "time_length",
70
+ "inharmonicity",
71
+ ]
72
+ + [f"peaks_freq_{i}" for i in range(1, PEAK_COUNT + 1)]
73
+ + [f"eh_{i}" for i in range(1, harmonic_count + 1)]
74
+ )
75
+
76
+
77
+ def extract_features_padrao(audio_path: Path | str) -> dict[str, float | None]:
78
+ """Extrai os 38 atributos acústicos de um único arquivo de áudio WAV usando o método padrão."""
79
+ audio_path = Path(audio_path)
80
+ audio, actual_sample_rate = af.read(str(audio_path), samplate=SAMPLE_RATE)
81
+ audio = np.asarray(audio, dtype=np.float32).squeeze()
82
+
83
+ if audio.ndim != 1:
84
+ raise ValueError(f"Áudio não mono: formato {audio.shape}")
85
+ if audio.size < WINDOW_SIZE:
86
+ raise ValueError(f"Áudio possui menos de {WINDOW_SIZE} amostras ({audio.size})")
87
+
88
+ # 1. Espectro FFT com janelas sobrepostas
89
+ step = WINDOW_SIZE // 2
90
+ window_count = (audio.size // step) - (WINDOW_SIZE // step) + 1
91
+ spectrum = np.zeros(WINDOW_SIZE)
92
+ window = hanning_window(WINDOW_SIZE)
93
+
94
+ for index in range(window_count):
95
+ chunk = audio[index * step : index * step + WINDOW_SIZE]
96
+ if len(chunk) < WINDOW_SIZE:
97
+ chunk = np.pad(chunk, (0, WINDOW_SIZE - len(chunk)), "constant")
98
+ spectrum += np.abs(fft(chunk * window))
99
+ spectrum /= window_count
100
+ spectrum_log = 20 * np.log(spectrum + 1e-12)
101
+
102
+ # 2. Detecção dos picos de frequência
103
+ peak_bins = [
104
+ index
105
+ for index in range(1, WINDOW_SIZE // 2 - 1)
106
+ if spectrum_log[index] > spectrum_log[index - 1]
107
+ and spectrum_log[index] > spectrum_log[index + 1]
108
+ ]
109
+ peak_bins = sorted(peak_bins, key=lambda idx: spectrum_log[idx], reverse=True)[
110
+ :PEAK_COUNT
111
+ ]
112
+
113
+ peak_frequencies: list[float] = []
114
+ for peak in peak_bins:
115
+ left, center, right = spectrum[peak - 1 : peak + 2]
116
+ offset = (right - left) / (left + center + right + 1e-12)
117
+ peak_frequencies.append(float(SAMPLE_RATE / WINDOW_SIZE * (peak + offset)))
118
+
119
+ # 3. Energia dos harmônicos
120
+ first_bin = int(np.floor(100 / SAMPLE_RATE * WINDOW_SIZE))
121
+ last_bin = int(np.floor(1200 / SAMPLE_RATE * WINDOW_SIZE))
122
+ harmonic_energies: list[float] = []
123
+ for bin_index in range(first_bin, last_bin + 1):
124
+ harmonic_energies.append(
125
+ float(
126
+ sum(
127
+ spectrum[index]
128
+ for harmonic in range(4)
129
+ if (index := bin_index + harmonic * bin_index) < (WINDOW_SIZE // 2)
130
+ )
131
+ )
132
+ )
133
+
134
+ # 4. Complexidade do sinal
135
+ complexity = complexity_znorm = 0.0
136
+ complexity_chunks = 0
137
+ for index in range(0, audio.size - 512, 512):
138
+ chunk = audio[index : index + 512].astype(float)
139
+ complexity += float(np.sqrt(np.sum(np.diff(chunk) ** 2)))
140
+ complexity_znorm += float(np.sqrt(np.sum(np.diff(normalize_znorm(chunk)) ** 2)))
141
+ complexity_chunks += 1
142
+ if complexity_chunks:
143
+ complexity /= complexity_chunks
144
+ complexity_znorm /= complexity_chunks
145
+
146
+ # 5. Dicionário consolidado de features
147
+ features: dict[str, float | None] = {
148
+ "temperature": get_temperature(audio_path),
149
+ "wbf": wingbeat_frequency(audio, SAMPLE_RATE),
150
+ "complexity": float(complexity),
151
+ "complexity_znorm": float(complexity_znorm),
152
+ "time_length": float(len(audio) / actual_sample_rate),
153
+ "inharmonicity": float(np.std(peak_frequencies)) if peak_frequencies else 0.0,
154
+ }
155
+ for index in range(PEAK_COUNT):
156
+ features[f"peaks_freq_{index + 1}"] = (
157
+ float(peak_frequencies[index]) if index < len(peak_frequencies) else None
158
+ )
159
+ for index, energy in enumerate(harmonic_energies, start=1):
160
+ features[f"eh_{index}"] = float(energy)
161
+
162
+ return features
@@ -0,0 +1,176 @@
1
+ """Funções auxiliares para busca, inspeção e processamento de arquivos do dataset."""
2
+
3
+ from __future__ import annotations
4
+
5
+ import csv
6
+ import re
7
+ import sys
8
+ import tempfile
9
+ import zipfile
10
+ from pathlib import Path, PurePosixPath
11
+ from typing import Callable
12
+
13
+ import pandas as pd
14
+
15
+
16
+ def find_zip_archives(data_dirs: str | Path | list[str | Path]) -> list[Path]:
17
+ """Busca e retorna todos os arquivos .zip a partir de uma pasta, arquivo ou lista de caminhos."""
18
+ if isinstance(data_dirs, (str, Path)):
19
+ dirs_list = [data_dirs]
20
+ else:
21
+ dirs_list = list(data_dirs)
22
+
23
+ archives: list[Path] = []
24
+ for item in dirs_list:
25
+ if not item:
26
+ continue
27
+ path_item = Path(item)
28
+ if path_item.is_dir():
29
+ archives.extend(sorted(path_item.glob("*.zip")))
30
+ elif path_item.is_file() and path_item.suffix.lower() == ".zip":
31
+ archives.append(path_item)
32
+
33
+ if not archives:
34
+ raise FileNotFoundError(f"Nenhum arquivo .zip encontrado nos caminhos: {dirs_list}")
35
+
36
+ return archives
37
+
38
+
39
+ def get_labels(archive_path: Path | str) -> tuple[str, str, str]:
40
+ """Extrai (label_completo, especie, sexo) a partir do nome do arquivo ZIP.
41
+
42
+ Exemplo: 'Aedes aegypti (female)-...zip' -> ('Aedes aegypti (female)', 'Aedes aegypti', 'female')
43
+ """
44
+ archive_path = Path(archive_path)
45
+ label_pattern = re.compile(
46
+ r"^(?P<species>.+?)\s+\((?P<sex>female|male)\)", re.IGNORECASE
47
+ )
48
+ match = label_pattern.match(archive_path.stem)
49
+ if not match:
50
+ stem = archive_path.stem
51
+ label = stem.split("-")[0].strip() if "-" in stem else stem
52
+ return label, label, ""
53
+ species = match.group("species").strip()
54
+ sex = match.group("sex").lower()
55
+ return f"{species} ({sex})", species, sex
56
+
57
+
58
+ def get_wav_members(archive: zipfile.ZipFile) -> list[zipfile.ZipInfo]:
59
+ """Filtra apenas arquivos .wav válidos dentro de um arquivo ZIP (ignora __MACOSX)."""
60
+ members: list[zipfile.ZipInfo] = []
61
+ for info in archive.infolist():
62
+ path = PurePosixPath(info.filename)
63
+ if path.is_absolute() or ".." in path.parts:
64
+ raise ValueError(f"Caminho inseguro dentro do ZIP: {info.filename!r}")
65
+ if (
66
+ not info.is_dir()
67
+ and path.suffix.lower() == ".wav"
68
+ and not info.filename.startswith("__MACOSX")
69
+ ):
70
+ members.append(info)
71
+ return members
72
+
73
+
74
+ def process_archive(
75
+ archive_path: Path | str,
76
+ extract_one_func: Callable[[Path | str], dict],
77
+ writer: csv.DictWriter | None = None,
78
+ ) -> pd.DataFrame | tuple[int, int]:
79
+ """Processa um único arquivo ZIP aplicando a função extract_one em cada áudio WAV.
80
+
81
+ Se `writer` for fornecido, grava diretamente no CSV e retorna (processados, falhas).
82
+ Se `writer` for None, retorna um pd.DataFrame com os resultados daquele ZIP.
83
+ """
84
+ archive_path = Path(archive_path)
85
+ class_name, _, _ = get_labels(archive_path)
86
+ print(f"-> Processando: {archive_path.name} [Classe: {class_name}]")
87
+
88
+ processed = failures = 0
89
+ records: list[dict] = []
90
+
91
+ with zipfile.ZipFile(archive_path) as archive, tempfile.TemporaryDirectory(
92
+ prefix="benchmark_"
93
+ ) as temp_dir:
94
+ for member in get_wav_members(archive):
95
+ extracted_path = Path(temp_dir) / member.filename
96
+ try:
97
+ archive.extract(member, temp_dir)
98
+ features = extract_one_func(extracted_path)
99
+ row = {
100
+ "zip_name": archive_path.name,
101
+ "file_path": member.filename,
102
+ "label": class_name,
103
+ **features,
104
+ }
105
+ if writer is not None:
106
+ writer.writerow(row)
107
+ else:
108
+ records.append(row)
109
+ processed += 1
110
+ except Exception as exc:
111
+ failures += 1
112
+ print(
113
+ f"Aviso: falha em {archive_path.name}/{member.filename}: {exc}",
114
+ file=sys.stderr,
115
+ )
116
+ finally:
117
+ if extracted_path.exists():
118
+ try:
119
+ extracted_path.unlink()
120
+ except OSError:
121
+ pass
122
+
123
+ if writer is None:
124
+ return pd.DataFrame(records)
125
+ return processed, failures
126
+
127
+
128
+ def process_dataset(
129
+ data_dirs: str | Path | list[str | Path],
130
+ output_csv: str | Path,
131
+ extract_one_func: Callable[[Path | str], dict],
132
+ feature_columns: list[str] | None = None,
133
+ ) -> pd.DataFrame:
134
+ """Processa todos os arquivos ZIP de um dataset, aplicando extract_one_func em cada áudio e salvando em CSV.
135
+
136
+ Parâmetros:
137
+ data_dirs: Pasta, arquivo ou lista contendo os arquivos .zip do dataset.
138
+ output_csv: Caminho do arquivo CSV de saída para salvar os atributos extraídos.
139
+ extract_one_func: Função de extração que recebe o caminho de um único áudio e retorna um dicionário.
140
+ feature_columns: Lista com os nomes dos atributos (opcional; se None, deduz a partir da primeira extração).
141
+ """
142
+ archives = find_zip_archives(data_dirs)
143
+ output_path = Path(output_csv)
144
+ output_path.parent.mkdir(parents=True, exist_ok=True)
145
+
146
+ if feature_columns is None:
147
+ # Descobre as colunas de atributos a partir do primeiro áudio disponível
148
+ first_archive = archives[0]
149
+ with zipfile.ZipFile(first_archive) as arc, tempfile.TemporaryDirectory(
150
+ prefix="benchmark_sample_"
151
+ ) as tmp:
152
+ wavs = get_wav_members(arc)
153
+ if not wavs:
154
+ raise ValueError(f"Nenhum arquivo WAV encontrado no arquivo {first_archive}")
155
+ sample_path = Path(tmp) / wavs[0].filename
156
+ arc.extract(wavs[0], tmp)
157
+ sample_features = extract_one_func(sample_path)
158
+ feature_columns = list(sample_features.keys())
159
+
160
+ fieldnames = ["zip_name", "file_path", "label", *feature_columns]
161
+
162
+ total_processed = total_failures = 0
163
+ with output_path.open("w", newline="", encoding="utf-8") as output_file:
164
+ writer = csv.DictWriter(output_file, fieldnames=fieldnames)
165
+ writer.writeheader()
166
+
167
+ for archive_path in archives:
168
+ p, f = process_archive(archive_path, extract_one_func, writer=writer)
169
+ total_processed += p
170
+ total_failures += f
171
+
172
+ print(
173
+ f"\nDataset processado: {total_processed} áudios extraídos com sucesso, "
174
+ f"{total_failures} falhas. Salvo em: {output_path}"
175
+ )
176
+ return pd.read_csv(str(output_path))
@@ -0,0 +1,48 @@
1
+ """Integração da API instalada com ZIP e WAV sintéticos."""
2
+ import csv
3
+ import io
4
+ import math
5
+ import tempfile
6
+ import unittest
7
+ import wave
8
+ import zipfile
9
+ from pathlib import Path
10
+
11
+ import numpy as np
12
+ import insect_audio_features as api
13
+
14
+
15
+ class PackageTests(unittest.TestCase):
16
+ def test_public_api(self):
17
+ self.assertEqual(len(api.get_feature_columns_librosa()), 26)
18
+ with self.assertRaises(ValueError):
19
+ api.extract_features('unused.zip', 'unused.csv', 'invalid')
20
+
21
+ def test_zip_extraction(self):
22
+ samples = (np.sin(2 * np.pi * 440 * np.arange(22050) / 44100) * 12000).astype('<i2')
23
+ audio = io.BytesIO()
24
+ with wave.open(audio, 'wb') as stream:
25
+ stream.setparams((1, 2, 44100, 0, 'NONE', 'not compressed'))
26
+ stream.writeframes(samples.tobytes())
27
+ with tempfile.TemporaryDirectory() as temp:
28
+ root = Path(temp)
29
+ archive = root / 'Aedes aegypti (female).zip'
30
+ with zipfile.ZipFile(archive, 'w') as zipped:
31
+ zipped.writestr('signal.wav', audio.getvalue())
32
+ for method in ('padrao', 'librosa'):
33
+ output = root / method / 'attributes.csv'
34
+ frame = api.extract_features(archive, output, method)
35
+ self.assertEqual(len(frame), 1)
36
+ self.assertEqual(list(frame.columns), ['zip_name', 'file_path', 'label'] + (api.get_feature_columns() if method == 'padrao' else api.get_feature_columns_librosa()))
37
+ self.assertEqual(frame.iloc[0]['label'], 'Aedes aegypti (female)')
38
+ with output.open() as stream:
39
+ self.assertEqual(len(list(csv.DictReader(stream))), 1)
40
+ if method == 'librosa':
41
+ self.assertAlmostEqual(frame.iloc[0]['rms'], 12000 / 32768 / math.sqrt(2), delta=.02)
42
+ else:
43
+ self.assertAlmostEqual(frame.iloc[0]['time_length'], .5)
44
+ self.assertTrue(math.isfinite(frame.iloc[0]['wbf']))
45
+
46
+
47
+ if __name__ == '__main__':
48
+ unittest.main()