insect-audio-features 0.1.0__py3-none-any.whl

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,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,9 @@
1
+ main.py,sha256=Pcud5GPOJ5JV1DFt4EekyG_o2dh0N-Om7v3YoHzl5Gc,2190
2
+ insect_audio_features/__init__.py,sha256=_7nOzHt-TVD5l4wxzdNrBIezUUOkrM8TSXR2OEDMKbM,421
3
+ src/extractors/librosa.py,sha256=sLq-qDm_MD2sdhWVxfGaups4YUx041Q4k_4qi6Pe6EA,3968
4
+ src/extractors/padrao.py,sha256=8pPw1COJDp1-3HNradL8iuZNXwNe6bhKaLnhu0-su2w,5890
5
+ src/utils/dataset_processor.py,sha256=_Yeta-p18GlAqxLDDK2a8RLL_4Ejsn_VCbKFxMawgnw,6603
6
+ insect_audio_features-0.1.0.dist-info/METADATA,sha256=Kv7pSAzASVpgFpmdN9G-F7pc0BWuVQyXUAaz88ohPmU,3565
7
+ insect_audio_features-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
8
+ insect_audio_features-0.1.0.dist-info/top_level.txt,sha256=C08I_-eZJ5sIqTPnC0wl3xozoPqMDEPrWrIN8_C8zE0,31
9
+ insect_audio_features-0.1.0.dist-info/RECORD,,
@@ -0,0 +1,5 @@
1
+ Wheel-Version: 1.0
2
+ Generator: setuptools (84.2.1)
3
+ Root-Is-Purelib: true
4
+ Tag: py3-none-any
5
+
@@ -0,0 +1,3 @@
1
+ insect_audio_features
2
+ main
3
+ src
main.py ADDED
@@ -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,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))