def setup(self): self.sink.mkdir(exist_ok=True, parents=True) # Create a place to store microcached results self.cache = self.sink / ".cache" self.cache.mkdir(exist_ok=True) # Setup logging and meta path self.metapath = self.sink / "metadata.json" logfile_path = self.sink / "logfile.log" # Read in previous metadata if exists try: self.prev_meta = read_json(self.metapath) except FileNotFoundError: self.prev_meta = None self.logger.setLevel(logging.DEBUG) if logfile_path.exists(): logfile_path.unlink() logfile_handler = logging.FileHandler(logfile_path) formatter = logging.Formatter( "%(asctime)s : %(levelname)s : %(name)s : %(message)s") logfile_handler.setFormatter(formatter) self.logger.addHandler(logfile_handler) self.logger.debug("Logging initialised")
def setup(self) -> None: self.metadata["time"] = datetime.datetime.now().strftime( "%H:%M:%S | %B %d, %Y") self.sink.mkdir(exist_ok=True, parents=True) # Microcache self.cache = self.sink / ".cache" self.cache.mkdir(exist_ok=True) # Setup logging and meta path self.metapath = self.sink / "metadata.json" logfile_path = self.sink / "logfile.log" # Load previous meta data if around if self.metapath.exists() and self.metapath.is_file(): self.prev_meta = read_json(self.metapath) # Init loggin self.logger.setLevel(logging.DEBUG) if logfile_path.exists(): logfile_path.unlink() logfile_handler = logging.FileHandler(logfile_path) formatter = logging.Formatter( "%(asctime)s : %(levelname)s : %(name)s : %(message)s") logfile_handler.setFormatter(formatter) self.logger.addHandler(logfile_handler) self.logger.debug("Logging initialised")
def update_success(self, status: bool) -> None: try: existing_metadata = read_json(self.process.metapath) except FileNotFoundError: existing_metadata = {} try: success = existing_metadata["success"] # extract the progress dict except KeyError: success = {} # progress doesnt exist yet success[self.identity[ "hash"]] = status # update the status of this analyser # join any existing data into the metadata self.process.metadata["success"] = success # modify the original write_json(self.process.metapath, self.process.metadata)
def load_cache(self): self.output = read_json(self.dump_path)
def load_cache(self): d = read_json(self.dump_path) self.output = [x for x in d["corpus_items"]]
# Description """ Analyse each item belonging to a cluster so that they can be ranked in order of a descriptor. """ from ftis.analyser import Flux from ftis.process import FTISProcess as Chain from ftis.common.io import read_json import numpy as np src = "outputs/segments/2_ExplodeAudio" folder = "outputs/metacluster_analysis" process = Chain(source=src, folder=folder) flux = Flux(cache=True) process.add(flux) if __name__ == "__main__": process.run() # print(flux.output) clusters = read_json("outputs/classification/3_AGCluster") for k in clusters.keys(): buf = [] for v in clusters[k]: for point in flux.output[v]: buf.append(point) print(f"Cluster {k}: {np.median(buf)}")
from pydub import AudioSegment from ftis.common.io import read_json, write_json from random import choice, uniform CLUSTERS = read_json("outputs/micro_clustering/5_HDBSCLUSTER.json") urn = list(CLUSTERS["37"]) num_choices = 10 # how many individual samples to use # Generate selection pool selection_pool = [] for x in range(num_choices): r = choice(urn) selection_pool.append(r) urn.remove(r) # Setup constraints max_length = 10 * 1000 # maximum length of the final result min_length = 2 * 1000 # minimum length of the final result length = uniform(min_length, max_length) # generate a random length between min/max repeat_chance = 0.1 # ten percent max_repeats = 4 repeat = 0 #Should we repeat? memory = 4 # way of mitigating the loop from occuring within a certain window of samples mem = [] # STICK THIS IN A FOR LOOP TO DO MANY GENERATIONS # Create audiosegment containers for x in range(100): container = AudioSegment.empty() # the container to append to