spectre-core 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

spectre_core/receivers/validators.py

@@ -1,231 +0,0 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
-# This file is part of SPECTRE
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-from logging import getLogger
-_LOGGER = getLogger(__name__)
-
-from math import floor
-import warnings
-
-from scipy.signal import get_window
-
-
-def closed_upper_bound_RF_gain(RF_gain: float, 
-                               RF_gain_upper_bound: float) -> None:
-    if not (RF_gain <= RF_gain_upper_bound):
-        raise ValueError((f"RF gain must be less than or equal to {RF_gain_upper_bound} [dB]. "
-                          f"Got {RF_gain} [dB]"))
-
-
-def closed_upper_bound_IF_gain(IF_gain: float, 
-                               IF_gain_upper_bound: float) -> None:
-    if not (IF_gain <= IF_gain_upper_bound):
-        raise ValueError((f"IF gain must be less than or equal to {IF_gain_upper_bound} [dB]. "
-                          f"Got {IF_gain} [dB]"))
-
-
-def closed_confine_center_freq(center_freq: float, 
-                               center_freq_lower_bound: float, 
-                               center_freq_upper_bound: float) -> None:
-    if not (center_freq_lower_bound <= center_freq <= center_freq_upper_bound):
-        raise ValueError((f"Center frequency must be between {center_freq_lower_bound*1e-3} [kHz] and {center_freq_upper_bound*1e-9} [GHz]. "
-                          f"Got {center_freq*1e-6} [MHz]"))
-    
-
-def closed_confine_samp_rate(samp_rate: int, 
-                             samp_rate_lower_bound: int, 
-                             samp_rate_upper_bound: int) -> None:
-    if not (samp_rate_lower_bound <= samp_rate <= samp_rate_upper_bound):
-        raise ValueError((f"Sampling rate must be between {samp_rate_lower_bound*1e-6} [MHz] and {samp_rate_upper_bound*1e-6} [MHz]. "
-                          f"Got {samp_rate*1e-6} [MHz]"))
-    
-
-def closed_confine_bandwidth(bandwidth: float, 
-                             bandwidth_lower_bound: float, 
-                             bandwidth_upper_bound: float) -> None:
-    if not (bandwidth_lower_bound <= bandwidth <= bandwidth_upper_bound):
-        raise ValueError((f"Bandwidth must be between {bandwidth_lower_bound*1e-3} [kHz] and {bandwidth_upper_bound*1e-6} [MHz]. "
-                          f"Got {bandwidth*1e-6} [MHz]"))
-    
-    
-def is_power_of_two(n):
-    return (n != 0) and (n & (n-1) == 0)
-
-
-def window(window_type: str, 
-           window_kwargs: dict, 
-           window_size: int,
-           chunk_size: int,
-           samp_rate: float) -> None:
-    
-    if not is_power_of_two(window_size):
-        raise ValueError((f"Window size must be some power of two. "
-                          f"Got {window_size} [samples]"))
-    
-    window_interval = window_size*(1/samp_rate)
-    if window_interval > chunk_size:
-        raise ValueError((f"The windowing interval must be strictly less than the chunk size. "
-                          f"Computed the windowing interval to be {window_interval} [s], "
-                          f"but the chunk size is {chunk_size} [s]"))
-    
-    try:
-        window_params = (window_type, 
-                         *window_kwargs.values())
-        _ = get_window(window_params, window_size)
-    except Exception as e:
-        raise Exception((f"An error has occurred while validating the window. "
-                         f"Got {str(e)}"))
-    
-
-def hop(hop: int):
-    if hop < 0:
-        raise ValueError((f"Window hop must be strictly positive. "
-                          f"Got {hop} [samples]"))
-    
-    
-def center_freq_strictly_positive(center_freq: float):
-    if center_freq <= 0:
-        raise ValueError((f"Center frequency must be strictly positive. "
-                          f"Got {center_freq*1e-6} [MHz]"))
-    
-
-def bandwidth_strictly_positive(bandwidth: float) -> None:
-    if bandwidth < 0:
-        raise ValueError((f"Bandwidth must be non-negative. "
-                          f"Got {bandwidth*1e-6} [MHz]"))
-    
-
-def nyquist_criterion(samp_rate: int, 
-                      bandwidth: float) -> None:
-    if samp_rate < bandwidth:
-        raise ValueError((f"Sample rate must be greater than or equal to the bandwidth. "
-                          f"Got sample rate {samp_rate} [Hz], and bandwidth {bandwidth} [Hz]"))
-    
-
-def samp_rate_strictly_positive(samp_rate: int) -> None:
-    if samp_rate <= 0:
-        raise ValueError((f"Sample rate must be strictly positive. "
-                          f"Got {samp_rate} [Hz]"))
-    
-
-def chunk_size_strictly_positive(chunk_size: int) -> None:
-    if chunk_size <= 0:
-        raise ValueError((f"Chunk size must be strictly positive. "
-                          f"Got {chunk_size} [s]"))
-    
-
-def time_resolution(time_resolution: float, 
-                    chunk_size: int) -> None:
-    if time_resolution < 0:
-        raise ValueError((f"Time resolution must be non-negative. "
-                          f"Got {time_resolution} [s]"))
-    
-    if time_resolution > chunk_size:
-        raise ValueError(f"Time resolution must be less than or equal to chunk size. "
-                         f"Got time resolution {time_resolution} [s], "
-                         f"and chunk size {chunk_size} [s]")
-    
-
-def frequency_resolution(frequency_resolution: float,
-                         bandwidth: float = None) -> None:
-    if frequency_resolution < 0:
-        raise ValueError((f"Frequency resolution must be non-negative. "
-                          f"Got {frequency_resolution} [Hz]"))
-    
-    if bandwidth is not None and frequency_resolution >= bandwidth:
-        raise ValueError((f"Frequency resolution must be less than the bandwidth. "
-                          f"Got frequency resolution to be {frequency_resolution} [Hz], "
-                          f"with bandwidth {bandwidth} [Hz]"))
-    
-
-def chunk_key(chunk_key: str, 
-              expected_chunk_key: str) -> None:
-    if chunk_key != expected_chunk_key:
-        raise ValueError((f"Expected {expected_chunk_key} for the chunk key. "
-                          f"Got {chunk_key}"))
-    
-
-def event_handler_key(event_handler_key: str, 
-                      expected_event_handler_key: str) -> None:
-    if event_handler_key != expected_event_handler_key:
-        raise ValueError((f"Expected {expected_event_handler_key} for the event handler key. "
-                          f"Got {event_handler_key}"))
-    
-
-def gain_is_negative(gain: float) -> None:
-    if gain > 0:
-        raise ValueError(f"Gain must be non-positive. "
-                         f"Got {gain} [dB]")
-    
-
-def _compute_num_steps_per_sweep(min_freq: float, 
-                                 max_freq: float,
-                                 samp_rate: int,
-                                 freq_step: float) -> int:
-     return floor((max_freq - min_freq + samp_rate/2) / freq_step)
-
-
-def num_steps_per_sweep(min_freq: float, 
-                        max_freq: float, 
-                        samp_rate: int, 
-                        freq_step: float) -> None:
-    num_steps_per_sweep = _compute_num_steps_per_sweep(min_freq, 
-                                                       max_freq, 
-                                                       samp_rate, 
-                                                       freq_step)
-    if num_steps_per_sweep <= 1:
-        raise ValueError((f"We need strictly greater than one step per sweep. "
-                          f"Computed {num_steps_per_sweep} step per sweep"))
-    
-
-def sweep_interval(min_freq: float, 
-                  max_freq: float, 
-                  samp_rate: int, 
-                  freq_step: float,
-                  samples_per_step: int,
-                  chunk_size: float) -> None: 
-    num_steps_per_sweep = _compute_num_steps_per_sweep(min_freq, 
-                                                       max_freq, 
-                                                       samp_rate, 
-                                                       freq_step)
-    num_samples_per_sweep = num_steps_per_sweep * samples_per_step
-    sweep_interval = num_samples_per_sweep * 1/samp_rate
-    if sweep_interval > chunk_size:
-        raise ValueError((f"Sweep interval must be less than the chunk size. "
-                          f"The computed sweep interval is {sweep_interval} [s], "
-                          f"but the given chunk size is {chunk_size} [s]"))
-    
-
-def num_samples_per_step(samples_per_step: int, 
-                         window_size: int) -> None:
-    if window_size >= samples_per_step:
-        raise ValueError((f"Window size must be strictly less than the number of samples per step. "
-                          f"Got window size {window_size} [samples], which is more than or equal "
-                          f"to the number of samples per step {samples_per_step}"))
-    
-
-def non_overlapping_steps(freq_step: float, 
-                          samp_rate: int) -> None:
-    if freq_step < samp_rate:
-        raise NotImplementedError(f"SPECTRE does not yet support spectral steps overlapping in frequency. "
-                                  f"Got frequency step {freq_step/1e6} [MHz] which is less than the sample "
-                                  f"rate {samp_rate/1e6} [MHz]")
-    
-
-def step_interval(samples_per_step: int, 
-                  samp_rate: int, 
-                  api_latency: float) -> None:
-    step_interval = samples_per_step * 1/samp_rate # [s]
-    if step_interval < api_latency:
-        warning_message = (f"The computed step interval of {step_interval} [s] is of the order of empirically "
-                           f"derived api latency {api_latency} [s]; you may experience undefined behaviour!")
-        warnings.warn(warning_message)
-        _LOGGER.warning(warning_message)
-    
-
-def watch_extension(watch_extension: str,
-                    target_extension: str) -> None:
-    if watch_extension != target_extension:
-        raise ValueError((f"Expected {target_extension} for the watch extension. "
-                          f"Got {watch_extension}"))

spectre_core/web_fetch/callisto.py

@@ -1,101 +0,0 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
-# This file is part of SPECTRE
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import os
-import subprocess
-import shutil
-import gzip
-from datetime import datetime
-from typing import Optional
-
-from spectre_core.cfg import (
-    DEFAULT_DATETIME_FORMAT,
-    CALLISTO_INSTRUMENT_CODES
-)
-from spectre_core.cfg import get_chunks_dir_path
-
-temp_dir = os.path.join(os.environ['SPECTRE_DATA_DIR_PATH'], "tmp")
-
-def get_chunk_name(station: str, date: str, time: str, instrument_code: str) -> str:
-    dt = datetime.strptime(f"{date}T{time}", '%Y%m%dT%H%M%S')
-    formatted_time = dt.strftime(DEFAULT_DATETIME_FORMAT)
-    return f"{formatted_time}_callisto-{station.lower()}-{instrument_code}.fits"
-
-
-def get_chunk_components(gz_path: str):
-    file_name = os.path.basename(gz_path)
-    if not file_name.endswith(".fit.gz"):
-        raise ValueError(f"Unexpected file extension in {file_name}. Expected .fit.gz")
-    
-    file_base_name = file_name.rstrip(".fit.gz")
-    parts = file_base_name.split('_')
-    if len(parts) != 4:
-        raise ValueError("Filename does not conform to the expected format of [station]_[date]_[time]_[instrument_code]")
-    
-    return parts
-
-
-def get_chunk_path(gz_path: str) -> str:
-    station, date, time, instrument_code = get_chunk_components(gz_path)
-    fits_chunk_name = get_chunk_name(station, date, time, instrument_code)
-    chunk_start_time = fits_chunk_name.split('_')[0]
-    chunk_start_datetime = datetime.strptime(chunk_start_time, DEFAULT_DATETIME_FORMAT)
-    chunk_parent_path = get_chunks_dir_path(year = chunk_start_datetime.year,
-                                            month = chunk_start_datetime.month,
-                                            day = chunk_start_datetime.day)
-    if not os.path.exists(chunk_parent_path):
-        os.makedirs(chunk_parent_path)
-    return os.path.join(chunk_parent_path, fits_chunk_name)
-
-
-def unzip_file_to_chunks(gz_path: str):
-    fits_path = get_chunk_path(gz_path)
-    with gzip.open(gz_path, 'rb') as f_in, open(fits_path, 'wb') as f_out:
-        shutil.copyfileobj(f_in, f_out)
-
-
-def unzip_to_chunks():
-    for entry in os.scandir(temp_dir):
-        if entry.is_file() and entry.name.endswith('.gz'):
-            unzip_file_to_chunks(entry.path)
-            os.remove(entry.path)
-
-
-def download_callisto_data(instrument_code: str, 
-                           year: int, 
-                           month: int, 
-                           day: int):
-    date_str = f"{year:04d}/{month:02d}/{day:02d}"
-    base_url = f"http://soleil.i4ds.ch/solarradio/data/2002-20yy_Callisto/{date_str}/"
-    command = [
-        'wget', '-r', '-l1', '-nd', '-np', 
-        '-R', '.tmp',
-        '-A', f'{instrument_code}*.fit.gz',
-        '-P', temp_dir,
-        base_url
-    ]
-
-    try:
-        subprocess.run(command, check=True)
-    except subprocess.CalledProcessError as e:
-        print(f"An error occurred: {e}")
-
-def fetch_chunks(instrument_code: Optional[str], 
-                 year: Optional[int], 
-                 month: Optional[int], 
-                 day: Optional[int]):
-
-
-    if (year is None) or (month is None) or (day is None):
-        raise ValueError(f"All of year, month and day should be specified")
-    
-    if not os.path.exists(temp_dir):
-        os.mkdir(temp_dir)
-
-    if instrument_code not in CALLISTO_INSTRUMENT_CODES:
-        raise ValueError(f"No match found for '{instrument_code}'. Expected one of {CALLISTO_INSTRUMENT_CODES}")
-
-    download_callisto_data(instrument_code, year, month, day)
-    unzip_to_chunks()
-    shutil.rmtree(temp_dir)

spectre_core-0.0.9.dist-info/RECORD

@@ -1,74 +0,0 @@
-spectre_core/__init__.py,sha256=oFSWmGoXQLK5X5xHvWzTdNr9amuaiiGjZirXZVogACU,154
-spectre_core/cfg.py,sha256=v9_yxV63rHMcSAsAFbWFBRDeElgcrDdY3yzGXFGJyxQ,3155
-spectre_core/dynamic_imports.py,sha256=hZbFA9QSVUmAA779qrwHe6RylpjeAG_L2KTVrRZE-Qk,987
-spectre_core/exceptions.py,sha256=i1uLL64DLESdzXTAPTsqc4Yg6LeU-ItOm5rhDlrDv7w,663
-spectre_core/logging.py,sha256=wxhi9UubjfKtd5lpG3tklr8lJDDR0cUoA3y4GLK6wE8,6486
-spectre_core/chunks/__init__.py,sha256=KqEz43Ifjbw_1cMdxt4s7iEUCOGmFruNN63qU2mgcmY,7148
-spectre_core/chunks/base.py,sha256=wl2jqPTcmpK8uxnl85lDcEmpOrvZ55AvdmCdtphI3xs,5096
-spectre_core/chunks/chunk_register.py,sha256=sS-T6d59zbh8_trr_7bYlq2O9Ak7k_XXHM6-yalwxaE,435
-spectre_core/chunks/factory.py,sha256=gi0x7nsZZR8HUBxnpEfwZG5fI1jSzM2OVPwGR8i45YE,1133
-spectre_core/chunks/library/__init__.py,sha256=w2G2Ew_yLK1q--1pwN-UsDSSa73Z6VHnn3jC-XXQNWE,272
-spectre_core/chunks/library/callisto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/chunks/library/callisto/chunk.py,sha256=J_xZIL_9YChLZSK1pMjQZmNoUpcENPXeLlu7x7TbPZI,3931
-spectre_core/chunks/library/fixed/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/chunks/library/fixed/chunk.py,sha256=ckBiEtSa6_S06d_H9LQ0ske5JT2ycF-LstWbDX1oo1c,6941
-spectre_core/chunks/library/sweep/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/chunks/library/sweep/chunk.py,sha256=bXpC43kylsaAc88VEc0lnLy8AFXZivejqXUyovDz51U,21219
-spectre_core/file_handlers/base.py,sha256=PbZkgCeZnkkO0TstuFf39oXh8VQDzwlEhwMWzplUDB0,1727
-spectre_core/file_handlers/configs.py,sha256=5V_egP1R5uXsCbbG_NcHorpY6wJCderBk0KBT3LM3OI,8483
-spectre_core/file_handlers/json.py,sha256=PBwjtM29jqfa9ozeRIuarkCJBD8uYIKyDCbM1V2GmtE,1230
-spectre_core/file_handlers/text.py,sha256=K84BIab_qmbR5igCVJZu3uE47ykpM_bnsasd3WGNEuo,677
-spectre_core/plotting/__init__.py,sha256=ZRQmBzZ0HWcVDaM5a8AneGbyHwx7dhtBs2z5H8VVspc,192
-spectre_core/plotting/base.py,sha256=4HhPPP7BNe5_SUAl1Ee52_QP62Zzh3kmNJwLzCHKG3c,4808
-spectre_core/plotting/factory.py,sha256=pYil7PbTs3e08ek6nq-y8mSEtNu7DI6uloiCwsuIoOw,940
-spectre_core/plotting/format.py,sha256=Et-uc4juDl_2spLRZOzqaUVBP8-J3LPnV5M6CllM74E,512
-spectre_core/plotting/panel_register.py,sha256=rsmG2hXnvVOy6vfWsEZlZQAXej7bRtqtvjnXObyUCg4,351
-spectre_core/plotting/panel_stack.py,sha256=fB1kz9NgsnMl4l41cncNPaVmg5DtYRRvO4lhX8OLOOo,5239
-spectre_core/plotting/library/__init__.py,sha256=lQhj4kme2eKb-JSrHvLWkAjI7eVqexOxxUguo8LUXno,270
-spectre_core/plotting/library/frequency_cuts/panel.py,sha256=LtCWNad4Z1gxBOxi_Ni1d6KZxsgoR5Mbm2tWXN7VDqI,2772
-spectre_core/plotting/library/integral_over_frequency/panel.py,sha256=tvro2MCtY4Q0q7WdMUz9eW5Cvrweeqqse20q3x4D4fM,1274
-spectre_core/plotting/library/spectrogram/panel.py,sha256=CAaPz7sDYoWZ3-4Jb1kVRu9bvJYaBRiXvoMkV7QXWqk,3556
-spectre_core/plotting/library/time_cuts/panel.py,sha256=u9Sbnwy6ex61y5Jl-D77HlYvuuXdK8_YB-o2gCovCTY,2947
-spectre_core/post_processing/__init__.py,sha256=pRzy46C32j9sfQjbCJKuVw0tQjuOErfrievq2m1Vx8c,239
-spectre_core/post_processing/base.py,sha256=h0qtoigD6ZBkHm0_wV1lJX55AwppKC5htfXVWUWMMLQ,5403
-spectre_core/post_processing/event_handler_register.py,sha256=DwlkU92IFkZ1_qvGfhep_OfuqTOIR_efY5qFpn1perw,498
-spectre_core/post_processing/factory.py,sha256=7KZBysPymsYhpW4KI4H1jvjssmZY1mIvhkln91joeUM,1133
-spectre_core/post_processing/post_processor.py,sha256=dQX71pUh83i6mNedTk-EVAYnxjAUs6S2Q8HkCXkiwns,1428
-spectre_core/post_processing/library/__init__.py,sha256=vEwAnAV-sv7WcNYOdnjr1JVqZYr29Wr2cv01eoxwdmg,282
-spectre_core/post_processing/library/fixed/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/post_processing/library/fixed/event_handler.py,sha256=wfOdahnY78Movu0ESbuUy-QmpBbXhNk6_DKzsXS9G0Y,1394
-spectre_core/post_processing/library/sweep/event_handler.py,sha256=ap7K8hOxgb8wsX9uJfEDW7lYXCyNKFlsva7vinW_6Ak,2194
-spectre_core/receivers/__init__.py,sha256=kKfhqrGs9sSPGLbrpTqScv816iPZOvT3ry3zSMcqLkM,227
-spectre_core/receivers/base.py,sha256=szW7BfJEQiZ7dEiD_Oyk2lG16Kns3zKmnl_lIqKHP1o,16478
-spectre_core/receivers/factory.py,sha256=aE-Yw_cnlkhRe5HxK0JqhDzd2AwZcKmB2QkAKwaq27Y,873
-spectre_core/receivers/receiver_register.py,sha256=xHcRnT-3NQxyIWL3nyT3P9qT14Wl5liM9HbflOvOUAM,617
-spectre_core/receivers/validators.py,sha256=ZWnFsZJsbHBB-ZIrp3WK8BPqb4ev7TYm6VPQPbljTE4,9965
-spectre_core/receivers/library/__init__.py,sha256=xmtF5p3_ZkGfso_pKnxSgUcXXFLEBwERGPq1Pek7cOU,274
-spectre_core/receivers/library/rsp1a/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/receivers/library/rsp1a/receiver.py,sha256=xs_aNMhwIYD83KwutizjBziyu9XsfHqGqvQXOFcglz4,2224
-spectre_core/receivers/library/rsp1a/gr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/receivers/library/rsp1a/gr/fixed.py,sha256=P39JwuOe-ydk9m8BNOHFDpzaqjenRnTIA7tpECshfUM,3369
-spectre_core/receivers/library/rsp1a/gr/sweep.py,sha256=9ZAoI0u1814lOM_cVwJnLUNSgM3VMstfvWKP67dVEV4,4741
-spectre_core/receivers/library/rspduo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/receivers/library/rspduo/receiver.py,sha256=EMBFWwFjoIP2buwwamyb3uaYqMQwQHMzNi-we7_OfcU,3377
-spectre_core/receivers/library/rspduo/gr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/receivers/library/rspduo/gr/tuner_1_fixed.py,sha256=xO9F_GBwgNnebrxoZYPwbXLL2HmH0CNLrVlpQ6Z7bx0,3887
-spectre_core/receivers/library/rspduo/gr/tuner_1_sweep.py,sha256=gR5arbjvJBJjCdQnpAdwNd7bEtnvDbhL_ttUhKk0Zss,5066
-spectre_core/receivers/library/rspduo/gr/tuner_2_fixed.py,sha256=O86R3tuJ-7cZXfVECuZkds-wCxKdBKJ8MhVACJFgzeo,4130
-spectre_core/receivers/library/rspduo/gr/tuner_2_sweep.py,sha256=4JgJ2QRO5DFPfqUTHBojj8ERR_4QpHyTBqnAXhOzykE,4747
-spectre_core/receivers/library/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/receivers/library/test/receiver.py,sha256=hr6t8jpUwVEP2zMpjORKpzqLaBllxmbqF1fQE1DLWQw,9329
-spectre_core/receivers/library/test/gr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/receivers/library/test/gr/cosine_signal_1.py,sha256=6XgYjYMh-QNPs_UUGUQcU_VQFr6BG4OLdsW-M-RU5Ww,2943
-spectre_core/receivers/library/test/gr/tagged_staircase.py,sha256=5rJHbB-3vdXjqT8DrcAGUSebaAqZ5RQtYHBWgH9iU2E,3465
-spectre_core/spectrograms/__init__.py,sha256=OFW82_itCktN8dFm_UO5gbgmzFs51v9KEHrSZWLuIUY,155
-spectre_core/spectrograms/analytical.py,sha256=c5X40YgLlutP8sbz6dqODZaCmZ98sAjubO3PtWj7ZZw,8657
-spectre_core/spectrograms/array_operations.py,sha256=6qKd3y2z6Pmu_U8yxTR4FN4eMhS10KgZ8rH60B_IXqw,2577
-spectre_core/spectrograms/spectrogram.py,sha256=EqeQyvjzjoKaXou4vJbPbRx85BeMPB9iiJtFZcCyimI,19488
-spectre_core/spectrograms/transform.py,sha256=xo7ch2lrRkJ54cfIqbkaTHNo_AptBuK0zRELPf7SfIE,13860
-spectre_core/web_fetch/callisto.py,sha256=yW0NkmHqfUf2uYgJjSRxou6e65_mYciPhHwQIvKLK_w,3630
-spectre_core-0.0.9.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-spectre_core-0.0.9.dist-info/METADATA,sha256=15Uh828ojJg6w-HCrIv7nka9wT_eVhv9svE33hmHI7k,42150
-spectre_core-0.0.9.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-spectre_core-0.0.9.dist-info/top_level.txt,sha256=-UsyjpFohXgZpgcZ9QbVeXhsIyF3Am8RxNFNDV_Ta2Y,13
-spectre_core-0.0.9.dist-info/RECORD,,