SleePyPhases 0.2.1__tar.gz → 0.3.1__tar.gz

{sleepyphases-0.2.1 → sleepyphases-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SleePyPhases
-Version: 0.2.1
+Version: 0.3.1
 Summary: A framwork for creating deep learning pipelines for sleep data
 Home-page: https://gitlab.com/sleep-is-all-you-need/sleepyphases
 Author: Franz Ehrlich

{sleepyphases-0.2.1 → sleepyphases-0.3.1}/SleePyPhases/MultiScorer.py

@@ -42,19 +42,27 @@ class MultiScorer(Scorer):
             if isinstance(predictions, list) or isinstance(predictions, tuple):
                 p = predictions[i]
             elif predictions.shape[-1] == len(self.multiClassNums):
+                if len(predictions.shape) == 3:
+                    predictions = predictions.reshape(-1, predictions.shape[-1])
                 p = predictions[:, i]
             else:
                 start = sum(self.multiClassNums[:i])
                 end = start + self.multiClassNums[i]
+                if len(predictions.shape) == 3:
+                    predictions = predictions.reshape(-1, predictions.shape[-1])
                 p = predictions[:, start:end]
             
             if isinstance(truth, list) or isinstance(truth, tuple):
                 t = truth[i]
             elif truth.shape[-1] == len(self.multiClassNums):
+                if len(truth.shape) == 3:
+                    truth = truth.reshape(-1, truth.shape[-1])
                 t = truth[:, i]
             else:
                 start = sum(self.multiClassNums[:i])
                 end = start + self.multiClassNums[i]
+                if len(truth.shape) == 3:
+                    truth = truth.reshape(-1, truth.shape[-1])
                 t = truth[:, start:end]
 
             

{sleepyphases-0.2.1 → sleepyphases-0.3.1}/SleePyPhases/Plugin.py

@@ -3,6 +3,7 @@ from pyPhasesRecordloader import RecordLoader
 
 from SleepHarmonizer.recordwriter.RecordWriter import RecordWriter
 
+from SleePyPhases.phases.ExtractFeatures import ExtractFeatures
 from SleePyPhases.phases.Extract import Extract
 from SleePyPhases.phases.Setup import Setup
 from SleePyPhases.phases.BuildDataset import BuildDataset
@@ -12,6 +13,7 @@ from SleePyPhases.phases.Eval import Eval
 from SleePyPhases.phases.EvalReport import EvalReport
 from SleePyPhases.phases.ThresholdOptimisation import ThresholdOptimisation
 from SleePyPhases.phases.TestRun import TestRun
+from SleePyPhases.phases.ExtractFeatures import ExtractFeatures
 
 
 from pyPhases.exporter.PickleExporter import PickleExporter
@@ -33,8 +35,8 @@ class Plugin(PluginAdapter):
             "ThresholdOptimisation": (ThresholdOptimisation, ["threshold", "validationResult"]),
             "Eval": (Eval, ["evalResults", "eventResults"]),
             "EvalReport": (EvalReport, []),
-            "TestRun": (TestRun, [])
-
+            "ExtractFeatures": (ExtractFeatures, ["features"]),
+            "TestRun": (TestRun, []),
         }
         dataMap = {
             "features": ["metadata"],
@@ -69,8 +71,5 @@ class Plugin(PluginAdapter):
         project.registerExporter(ModelExporter({"basePath": dataPath}))
         project.registerExporter(MemmapRecordExporter({"basePath": dataPath}))
 
-        
-    def initPlugin(self):
-        RecordLoader.registerRecordLoader("RecordLoaderTSM", "SleePyPhases.recordloaders")
 
 

{sleepyphases-0.2.1 → sleepyphases-0.3.1}/SleePyPhases/RecordFeatureExtraction.py

@@ -1,17 +1,16 @@
-import pandas as pd
 from typing import List
 
 import numpy as np
+import pandas as pd
 from pandas import DataFrame
+from pyPhases import Swappable
 from pyPhasesML import FeatureExtraction as pyPhasesFeatureExtraction
-from pyPhasesRecordloader import RecordSignal, Signal, Event, ChannelsNotPresent
+from pyPhasesRecordloader import ChannelsNotPresent, Event, RecordSignal, Signal
 
 from SleePyPhases.PSGEventManager import PSGEventManager
 
-class RecordFeatureExtraction(pyPhasesFeatureExtraction):
-    """batchManipulation for the physionet challenge 2023
-    segmentSignal: Recordsignal of the segment with 18 EEG channels
-    """
+
+class RecordFeatureExtraction(pyPhasesFeatureExtraction, Swappable):
 
     def step(self, stepname: str, recordSignal: RecordSignal, eventlist: List[Event], channel=None, **options) -> Signal:
         if hasattr(self, stepname):
@@ -271,68 +270,4 @@ class RecordFeatureExtraction(pyPhasesFeatureExtraction):
         # ret[f"cycle-{cycleNumber}-rem-duration"] = remTime
 
         return ret
-    
-    def spindles(self, segmentSignal: RecordSignal, eventlist: List[Event], channel: str):
-        from .external.sumo.sumo.scripts.a7.butter_filter import butter_bandpass_filter, downsample
-        # from .external.sumo.a7.detect_spindles import detect_spindle
-        from .external.sumo.sumo.scripts.predict_plain_data import SimpleDataset
-        # from .external.sumo.sumo.predict_plain_data import A7
-        import pytorch_lightning as pl
-        from torch.utils.data import Dataset, DataLoader
-        import torch
-        from .external.sumo.sumo.model.sumo import SUMO
-        from .external.sumo.sumo.config.config import Config
-        # from .external.sumo.model.data import spindle_vect_to_indices
-
-        config = Config('predict', create_dirs=False)
-
-        def get_model(p):
-            # p = Path(p)
-
-            model_checkpoint = torch.load(p)
-
-            model = SUMO(config)
-            model.load_state_dict(model_checkpoint['state_dict'])
-
-            return model
-
-        eegSignal = segmentSignal.getSignalByName(channel)
-        resample_rate = 100
-        model_path = "SleePyPhases/external/sumo/sumo/output/final.ckpt"
-        
-        if len(eegSignal.signal) == 0:
-            return None
-
-        eegs = []
-        eegSignal = downsample(butter_bandpass_filter(eegSignal.signal, 0.3, 30.0, eegSignal.frequency, 10), eegSignal.frequency, resample_rate)
-        eegs.append(eegSignal)
-
-        dataset = SimpleDataset(eegs)
-        dataloader = DataLoader(dataset)
-        model = get_model(model_path)
-        trainer = pl.Trainer(num_sanity_val_steps=0, logger=False)
-        predictions = trainer.predict(model, dataloader)
-        pred = predictions[0]
-
-        # spindles_a7 = A7(x, resample_rate)
-        spindle_vect = pred[0].numpy()
-        
-        diff = np.diff(np.r_[0, spindle_vect, 0])  # be able to detect spindles at the start and end of vector
-        spindles = np.c_[np.argwhere(diff == 1), np.argwhere(diff == -1)]  / resample_rate
-        # spindles = spindle_vect_to_indices(spindle_vect) / resample_rate
-
-
-        # frequencies, psd = signal.welch(eegs[0][s.start:s.end()], 
-        #                                 fs=100,
-        #                                 nperseg=min(256, s.duration),
-        #                                 scaling='spectrum')
-        # dominant_freq = frequencies[np.argmax(psd)]
-
-        spindles = [Event("spindle", s[0], s[1] - s[0]) for s in spindles]
-
-        
-        return {
-            "spindles-count": len(spindles),
-            "spindles-mean-druation": np.array([s.duration for s in spindles]).mean()
-        }
-    
+    

{sleepyphases-0.2.1 → sleepyphases-0.3.1}/SleePyPhases/phases/Eval.py

@@ -81,7 +81,7 @@ class Eval(Phase):
 
         # setup data and scorer
         
-        classNums = self.getConfig("model.multiclassificationSize", [2])
+        classNums = self.getConfig("numClasses", [2])
         labelNames = self.getConfig("classification.labelNames")
         ignoreIndex = self.getConfig("classification.ignoreIndex", -1)
         metrics = self.getConfig("trainingParameter.validationMetrics")
@@ -99,16 +99,10 @@ class Eval(Phase):
 
         for data in tqdm(testData):
             x, truth = data
-            # make sure to have a batchsize if batchSize == 1
-            x = x.reshape(batchSize, x.shape[0], x.shape[1])
-            truth = truth.reshape(batchSize, truth.shape[0], truth.shape[1])
 
-            prediction = model.predict(x, get_likelihood=True, returnNumpy=False)
+            prediction = model.predict(x, returnNumpy=False)
             prediction, truth = da((prediction, truth))
 
-            # prediction = prediction.reshape(-1, prediction.shape[2])
-            # truth = truth.reshape(-1, truth.shape[2])
-
             scorer.score(truth, prediction, trace=True)
 
         result = scorer.scoreAllRecords()
@@ -152,7 +146,7 @@ class Eval(Phase):
             self.project.config.update(self.getConfig("eventEval", {}))
 
             evalMetrics = self.getConfig("eval.metrics")
-            classNums = self.getConfig("model.multiclassificationSize", [2])
+            classNums = self.getConfig("numClasses", [2])
             labelNames = self.getConfig("classification.labelNames")
             predictionNames = self.getConfig("classification.predictionSignals")
             predictionFrequencies = self.getConfig("classification.predictionFrequencies")
@@ -193,7 +187,7 @@ class Eval(Phase):
                     x = x.reshape([1] + list(x.shape))
                     truth = truth.reshape([1] + list(truth.shape))
 
-                prediction = model.predict(x, get_likelihood=True, returnNumpy=False)
+                prediction = model.predict(x, returnNumpy=False)
                 prediction, truth = da((prediction, truth))
 
                 # for labelIndex, labelName in enumerate(recordResults.keys()):

{sleepyphases-0.2.1 → sleepyphases-0.3.1}/SleePyPhases/phases/EvalReport.py

@@ -10,7 +10,6 @@ from pyPhasesRecordloader import RecordSignal, Signal
 
 from SleePyPhases import Plot
 from SleePyPhases.DataManipulation import DataManipulation
-from SleePyPhases.Reporter import Reporter
 
 
 class EvalReport(Phase):
@@ -244,8 +243,8 @@ class EvalReport(Phase):
     def copyRawData(self):
         modelConfigString = self.project.getDataFromName("modelState").getTagString()
         trainingLogPath = f"logs/{modelConfigString}/"
-        shutil.copyfile(trainingLogPath + "log.csv", Reporter.basePath + "training.log")
-        shutil.copyfile(trainingLogPath + "project.config", Reporter.basePath + "project.json")
+        shutil.copyfile(trainingLogPath + "log.csv", self.evalPath + "training.log")
+        shutil.copyfile(trainingLogPath + "project.config", self.evalPath + "project.json")
 
     def trainingPlot(self, logFile):
         import matplotlib.pyplot as plt

{sleepyphases-0.2.1 → sleepyphases-0.3.1}/SleePyPhases/phases/ExtractFeatures.py

@@ -76,7 +76,7 @@ class ExtractFeatures(Phase):
         try:
             recordSignal = recordLoader.getHarmonizedSignal(recordId)
 
-            events: List[Event] = RecordFeatureExtraction(self.project).step(name, recordSignal, *options)
+            events: List[Event] = RecordFeatureExtraction.getInstance().step(name, recordSignal, *options)
 
             if channelType is not None:
                 channelType = [s.name for s in recordSignal.signals if s.typeStr == channelType]
@@ -192,7 +192,7 @@ class ExtractFeatures(Phase):
                 try:
                     idx = (recordId, c)
                     featureStep = featureConfig["type"]
-                    RecordFeatureExtraction(self.project).updateMetadataByStep(featureStep, recordSignal, eventlist, metadata=self.features, channel=c)
+                    RecordFeatureExtraction.getInstance().updateMetadataByStep(featureStep, recordSignal, eventlist, metadata=self.features, channel=c)
                 except ChannelsNotPresent as e:
                     self.logError(f"channels not present: {e.channels}")
 
@@ -209,18 +209,15 @@ class ExtractFeatures(Phase):
         self.features = None
         metadata = self.project.getData("metadata", pd.DataFrame)
         recordIds = metadata["recordId"]
+        forceCalculation = self.getConfig("featureExtraction.features", True)
 
         reqFeatures = {f["name"]: True for f in self.getConfig("featureExtraction.features", [])}
 
-        # groupedRecords = {"pid_202436073": "acq_237478592"}
         for recordId in tqdm(recordIds.iloc):
-            # tryToGenerate has no meaning, it is just known to be not in the metadata, so the record will always be recalculated
-            # self.getData("features", pd.DataFrame, recordId=recordId, tryToGenerate=True, **reqFeatures)
+            if forceCalculation:
+                # the parameter forced has no meaning, it is just known to be not in the metadata, so the record will always be recalculated
+                reqFeatures["forced"] = True # should never be found
             rows = self.getData("features", pd.DataFrame, recordId=recordId, **reqFeatures)
             if len(rows) == 0:
                 self.logError(f"no features for {recordId}")
                 
-
-        # get a single feature:
-        # feat = {"swa": True}
-        # x = self.getData("features", pd.DataFrame, recordId="shhs1-200002", channel="EEG", **feat)   

{sleepyphases-0.2.1 → sleepyphases-0.3.1}/SleePyPhases/phases/Setup.py

@@ -4,36 +4,20 @@ from pyPhases import Phase
 from pyPhasesML import DataversionManager, Scorer
 from pyPhasesRecordloader import RecordLoader
 
-from SleePyPhases.recordloaders.MedicalDB import MedicalDB
 
 
 class Setup(Phase):
     def prepareConfig(self):
-        numLabels = len(self.getConfig("classification.labelNames"))
+        numLabels = len(self.getConfig("classification.labelNames", []))
         self.setConfig("numLabels", numLabels)
 
-        numClasses = [len(c) for c in self.getConfig("classification.classNames")]
+        numClasses = [len(c) for c in self.getConfig("classification.classNames", [])]
         self.setConfig("numClasses", numClasses)
         
-        defaultValidationbatchManipulation = self.getConfig("segmentManipulationEval", self.getConfig("segmentManipulation"))
+        defaultValidationbatchManipulation = self.getConfig("segmentManipulationEval", self.getConfig("segmentManipulation", []))
         self.setConfig("segmentManipulationEval", defaultValidationbatchManipulation)
-        
-        # alice loader
-        RecordLoader.registerRecordLoader("RecordLoaderTest", "SleePyPhases.recordloaders")
-        RecordLoader.registerRecordLoader("RecordLoaderTSM", "SleePyPhases.recordloaders")
-        tsmPath = self.getConfig("tsm-path", False)
-        if tsmPath is not False:
-            tsmPath = Path(tsmPath)
-            self.project.setConfig("loader.tsm.filePath", tsmPath.as_posix())
-            self.project.setConfig("loader.tsm.dataset.downloader.basePath", tsmPath.as_posix())
-
-        tsmPath = self.getConfig("tsm-domino-path", False)
-        if tsmPath is not False:
-            tsmPath = Path(tsmPath)
-            self.project.setConfig("loader.tsm-domino.filePath", tsmPath.as_posix())
-            self.project.setConfig("loader.tsm-domino.dataset.downloader.basePath", tsmPath.as_posix())
-
-        preprocessingConfig = self.getConfig("preprocessing")
+
+        preprocessingConfig = self.getConfig("preprocessing", {})
         if "combineChannels" in preprocessingConfig:
             RecordLoader.get().addCombinedChannels(preprocessingConfig["combineChannels"])
 
@@ -62,9 +46,6 @@ class Setup(Phase):
             return kappa
         Scorer.registerMetric("reduceAndKappa", reduceKappa, combineReduceKappa)
         
-        MedicalDB.config = self.getConfig("medicalDB", {})
-
-            
     def getDataVersionManager(self):
         groupedRecords = self.project.getData("allDBRecordIds", list)
         seed = self.getConfig("dataversion.seed", None)

{sleepyphases-0.2.1 → sleepyphases-0.3.1}/SleePyPhases/phases/Training.py

@@ -77,6 +77,8 @@ class Training(Phase):
 
         gridOutputs = []
         for fold in range(startfold, endfold):
+            # save model state (random initialisation or pretrained)
+            startState = ModelManager.getModel().model.state_dict()
             self.setConfig("fold", fold)
             # only train if it doesnt allready exist
             self.getData("modelState", Model)
@@ -85,6 +87,8 @@ class Training(Phase):
                 self.project.unregister("modelState")
                 self.project.unregister("modelStateConfig")
             gridOutputs.append(self.gridOutput)
+            # reset model state
+            ModelManager.getModel().model.load_state_dict(startState)
 
         self.project.gridOutput = {
             "epochs": str(np.mean([m["epochs"] for m in gridOutputs])),

{sleepyphases-0.2.1 → sleepyphases-0.3.1}/SleePyPhases.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SleePyPhases
-Version: 0.2.1
+Version: 0.3.1
 Summary: A framwork for creating deep learning pipelines for sleep data
 Home-page: https://gitlab.com/sleep-is-all-you-need/sleepyphases
 Author: Franz Ehrlich

{sleepyphases-0.2.1 → sleepyphases-0.3.1}/SleePyPhases.egg-info/SOURCES.txt

@@ -4,7 +4,6 @@ pyproject.toml
 setup.py
 SleePyPhases/DataManipulation.py
 SleePyPhases/EventScorer.py
-SleePyPhases/FeatureExtraction copy.py
 SleePyPhases/FeatureExtraction.py
 SleePyPhases/MultiScorer.py
 SleePyPhases/PSGEventManager.py
@@ -40,9 +39,6 @@ SleePyPhases/phases/Training.py
 SleePyPhases/phases/Validation.py
 SleePyPhases/phases/VisualizeConfig.py
 SleePyPhases/phases/__init__.py
-SleePyPhases/recordloaders/MedicalDB.py
-SleePyPhases/recordloaders/RecordLoaderTSM.py
-SleePyPhases/recordloaders/__init__.py
 tests/__init__.py
 tests/conftest.py
 tests/unit/__init__.py

{sleepyphases-0.2.1 → sleepyphases-0.3.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="SleePyPhases",
-    version="v0.2.1"[1:],
+    version="v0.3.1"[1:],
     author="Franz Ehrlich",
     author_email="fehrlichd@gmail.com",
     description="A framwork for creating deep learning pipelines for sleep data",

sleepyphases-0.2.1/SleePyPhases/FeatureExtraction copy.py

@@ -1,116 +0,0 @@
-from typing import List
-
-import numpy as np
-from pyPhasesML import FeatureExtraction as pyPhasesFeatureExtraction
-from pyPhasesML import ModelManager
-from pyPhasesRecordloader import RecordSignal, Event
-
-from .DataAugmentation import DataAugmentation
-
-
-class FeatureExtraction(pyPhasesFeatureExtraction):
-    """augmentation for the physionet challenge 2023
-    segmentSignal: Recordsignal of the segment with 18 EEG channels
-    """
-
-    def __init__(self, project) -> None:
-        super().__init__()
-        self.project = project
-
-    def time(self, segmentSignal: RecordSignal):
-        segmentLength = segmentSignal.getShape()[1]
-        # segmentLengthInHOurs = segmentLength / segmentSignal.targetFrequency / 3600
-        # hour, minutes = segmentSignal.start.split(":")
-        # startTimeInHours = int(hour) + int(minutes) / 60
-        # endTimeInHours = startTimeInHours + segmentLengthInHOurs
-        hour = segmentSignal.start
-        endTimeInHours = hour + 1
-        return np.linspace(hour, endTimeInHours, segmentLength)
-
-    def featureModel(self, segmentSignal: RecordSignal, featureName: str, xChannels: List[str]):
-        import torch
-        useGPU = torch.cuda.is_available() and False
-        with self.project:
-            config = self.project.config["featureConfigs", featureName]
-            self.project.config.update(config)
-            self.project.addConfig(config)
-
-            self.project.trigger("configChanged", None)
-            self.project.setConfig("trainingParameter.batchSize", 1)
-            self.project.setConfig("recordWise", True)
-
-            modelPath = self.project.getConfig("featureModel", torch)
-
-            # this is needed for mutlithreading
-            ModelManager.loadModel(self.project)
-            # get feature model
-            model = ModelManager.getModel(True)
-            model.useGPU = useGPU
-            state = model.load(modelPath)
-            model.loadState(state)
-            featureModel = model.model.eval()
-
-            featureModel = featureModel.cuda() if useGPU else featureModel.cpu()
-
-            # we assum that the segment is already preprocessed for the model
-            array = segmentSignal.getSignalArray(xChannels, transpose=True)
-
-            da = DataAugmentation(self.project.config, self.project.getConfig("datasetSplit"), recordAnnotations={})
-            array, _ = da.augmentSegment(array, None)
-            array = array.transpose(2, 1, 0)
-
-            features = model.predict(array, get_likelihood=True)
-            _, features = da.restoreLength(None, features, length=segmentSignal.getShape()[1])
-            features = features[:, :, 1]
-
-        return features
-
-    def spindles(self, segmentSignal: RecordSignal): #xChannels: List[str]
-        from .external.sumo.a7.butter_filter import butter_bandpass_filter, downsample
-        # from .external.sumo.a7.detect_spindles import detect_spindle
-        from .external.sumo.predict_plain_data import SimpleDataset
-        from .external.sumo.predict_plain_data import A7
-        import pytorch_lightning as pl
-        from torch.utils.data import Dataset, DataLoader
-        import torch
-        from .external.sumo.model.sumo import SUMO
-        from .external.sumo.model.config import Config
-        # from .external.sumo.model.data import spindle_vect_to_indices
-
-        config = Config('predict', create_dirs=False)
-
-        def get_model(p):
-            # p = Path(p)
-
-            model_checkpoint = torch.load(p)
-
-            model = SUMO(config)
-            model.load_state_dict(model_checkpoint['state_dict'])
-
-            return model
-
-        eegSignals = [s for s in segmentSignal.signals if s.typeStr == "eeg"]
-        resample_rate = 100
-        model_path = "SleePyPhases/external/sumo/model/final.ckpt"
-        
-        eegs = []
-        for eegSignal in eegSignals:
-            eegSignal = downsample(butter_bandpass_filter(eegSignal.signal, 0.3, 30.0, eegSignal.frequency, 10), eegSignal.frequency, resample_rate)
-            eegs.append(eegSignal)
-
-        dataset = SimpleDataset(eegs)
-        dataloader = DataLoader(dataset)
-        model = get_model(model_path)
-        trainer = pl.Trainer(num_sanity_val_steps=0, logger=False)
-        predictions = trainer.predict(model, dataloader)
-
-        for x, pred in zip(eegs, predictions):
-            # spindles_a7 = A7(x, resample_rate)
-            spindle_vect = pred[0].numpy()
-            
-            diff = np.diff(np.r_[0, spindle_vect, 0])  # be able to detect spindles at the start and end of vector
-            spindles = np.c_[np.argwhere(diff == 1), np.argwhere(diff == -1)]  / resample_rate
-            # spindles = spindle_vect_to_indices(spindle_vect) / resample_rate
-
-        
-        return [Event("spindle-slow", 500, 10)]

sleepyphases-0.2.1/SleePyPhases/recordloaders/MedicalDB.py

@@ -1,124 +0,0 @@
-import sys
-
-from pyPhases.util.Logger import classLogger
-from pypika import Table, PostgreSQLQuery as Query
-from pypika.queries import QueryBuilder
-
-
-@classLogger
-class MedicalDB:
-    connection = None
-    client = None
-    assocCursor = None
-    _instance = None
-
-    config = {
-        "user": "root",
-        "password": "example",
-        "host": "localhost",
-        "port": 5432,
-        "database": "data",
-    }
-
-    @classmethod
-    def get(cls) -> "MedicalDB":
-        if cls._instance is None:
-            cls._instance = cls.__new__(cls)
-            cls._instance.connect()
-        return cls._instance
-
-    def connect(self):
-
-        import psycopg2
-
-        try:
-            c = MedicalDB.config
-            conn = psycopg2.connect(
-                "host=%s port=%i dbname=%s user=%s password=%s"
-                % (
-                    c["host"],
-                    c["port"],
-                    c["database"],
-                    c["user"],
-                    c["password"],
-                )
-            )
-
-        except psycopg2.Error as e:
-            self.logError(f"Error connecting to Postgres Platform: {e}")
-            sys.exit(1)
-        self.conn = conn
-        self.cursor = conn.cursor()
-
-    def execute(self, sql, **vars):
-        if isinstance(sql, QueryBuilder):
-            sql = sql.get_sql()
-        return self.cursor.execute(sql, **vars)
-
-    def executeAndFetch(self, sql, **vars):
-        self.execute(sql, **vars)
-        return self.cursor.fetchall()
-
-    def commit(self):
-        self.conn.commit()
-    
-    def executeAndFetchOne(self, sql, **vars):
-        self.execute(sql, **vars)
-        return self.cursor.fetchone()
-
-    def close(self):
-        if self.connection is not None:
-            self.connection.close()
-
-    def fillRecordId(self, id):
-        return id
-
-    def getRecordData(self, recordId):
-        record = Table("record", schema=self.config["schema"])
-        patient = Table("patient", schema=self.config["schema"])
-        medCase = Table("medical_case", schema=self.config["schema"])
-        q = (
-            Query.from_(record)
-            .select(patient.id_patient, record.id_medical_case, record.start, patient.date_of_birth, patient.gender)
-            .join(medCase).on(record.id_medical_case == medCase.id_medical_case)
-            .join(patient).on(patient.id_patient == medCase.id_patient)
-            .where(record.id_record == recordId)
-        )
-        row = self.executeAndFetchOne(q)
-
-        if row is None:
-            return None
-        
-        row = list(row)
-        age = None if row[2] or row[3] is None else row[2] - row[3]
-        row[3] = age
-
-        return row
-
-    def getDiagnoses(self, recordId):
-        diag = Table("diagnosis", schema=self.config["schema"])
-        record = Table("record", schema=self.config["schema"])
-        medCase = Table("medical_case", schema=self.config["schema"])
-        q = Query.from_(diag)\
-            .select("diagnosis_category_id", "diagnosis")\
-            .join(medCase).on(diag.id_medical_case == medCase.id_medical_case)\
-            .join(record).on(medCase.id_medical_case == record.id_medical_case)\
-            .where(record.id_record == recordId)\
-            .get_sql()
-        
-        diagnoses = self.executeAndFetch(q)
-
-        diagnoseCats = {d[0]: d[1] for d in diagnoses}
-        return diagnoseCats
-
-    def getPSGType(self, recordId):
-
-        record = Table("record", schema=self.config["schema"])
-        q = (
-            Query.from_(record)
-            .select("psg_config")
-            .where(record.id_record == recordId)
-        )
-        r = self.executeAndFetchOne(q)
-
-        return r[0] if bool(r) else ""

sleepyphases-0.2.1/SleePyPhases/recordloaders/RecordLoaderTSM.py

@@ -1,34 +0,0 @@
-from SleePyPhases.recordloaders.MedicalDB import MedicalDB
-from SleepHarmonizer import RecordLoaderAlice
-
-
-class RecordLoaderTSM(RecordLoaderAlice):
-    config = {}
-
-    def getMetaData(self, recordName):
-        metadata = super().getMetaData(recordName)
-        del metadata["patientName"]
-        del metadata["patientCode"]
-        del metadata["patientAdd"]
-        del metadata["technician"]
-
-        db = MedicalDB.get()
-        row = db.getRecordData(recordName)
-        diagnoses = db.getDiagnoses(recordName)
-        metadata["psg_type"] = db.getPSGType(recordName)
-
-        if row is not None:
-            patient_id, case_id, recordDate, patientAge, gender = row
-
-            metadata["patient"] = patient_id
-            metadata["case"] = case_id
-            metadata["age"] = patientAge
-            metadata["gender"] = gender
-            metadata["startRecord"] = recordDate
-
-        if diagnoses is not None:
-            metadata.update(diagnoses)
-        
-        db.close()
-
-        return metadata