SleePyPhases 0.6.0__tar.gz → 0.6.2__tar.gz

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SleePyPhases
-Version: 0.6.0
+Version: 0.6.2
 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.6.0 → sleepyphases-0.6.2}/SleePyPhases/EventScorer.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from pyPhasesML import Scorer
-from SleePyPhases.PSGEventManager import PSGEventManager
+from SleepHarmonizer.PSGEventManager import PSGEventManager
 
 
 class EventScorer(Scorer):

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/SleePyPhases/Plugin.py

@@ -13,6 +13,8 @@ from SleePyPhases.phases.EvalReport import EvalReport
 from SleePyPhases.phases.ThresholdOptimisation import ThresholdOptimisation
 from SleePyPhases.phases.TestRun import TestRun
 from SleePyPhases.phases.Predict import Predict
+from SleePyPhases.phases.ExtractEvents import ExtractEvents
+
 
 
 from pyPhases.exporter.PickleExporter import PickleExporter
@@ -39,10 +41,12 @@ class Plugin(PluginAdapter):
             "LogOverview": (LogOverview, []),
             "LogCleanup": (LogCleanup, []),
             "Predict": (Predict, ["prediction"]),
+            "ExtractEvents": (ExtractEvents, ["events", "eventDF"])
         }
         dataMap = {
             "features": ["metadata"],
             "events": ["allDBRecordIds"],
+            "eventDF": ["events"],
             "data-processed": ["allDBRecordIds", "preprocessing", "labelChannels"],
             "record-preprocessed": ["recordId", "data-processed"],
             "record-data": [],

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/SleePyPhases/RecordFeatureExtraction.py

@@ -7,7 +7,7 @@ from pyPhases import Swappable
 from pyPhasesML import FeatureExtraction as pyPhasesFeatureExtraction
 from pyPhasesRecordloader import ChannelsNotPresent, Event, RecordSignal, Signal
 
-from SleePyPhases.PSGEventManager import PSGEventManager
+from SleepHarmonizer.PSGEventManager import PSGEventManager
 
 
 class RecordFeatureExtraction(pyPhasesFeatureExtraction, Swappable):

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/SleePyPhases/SleepMetaData.py

@@ -2,7 +2,7 @@ import numpy as np
 
 from pyPhases.util.Logger import classLogger
 
-from SleePyPhases.PSGEventManager import PSGEventManager
+from SleepHarmonizer.PSGEventManager import PSGEventManager
 
 
 @classLogger

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/SleePyPhases/phases/BuildDataset.py

@@ -20,7 +20,6 @@ class BuildDataset(Phase):
         splitName = self.getConfig("datasetSplit")
 
         datasetVersions = self.getConfig("datafold.datasets", {"config": {}})
-        datasetVersions = {"config": {}}
         datasetVersions = datasetVersions if isinstance(datasetVersions, list) else [datasetVersions]
 
         seed = self.getConfig("datafold.seed", 2024)

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/SleePyPhases/phases/DataReport.py

@@ -1,7 +1,7 @@
 from pathlib import Path
 
 import numpy as np
-from SleePyPhases.PSGEventManager import PSGEventManager
+from SleepHarmonizer.PSGEventManager import PSGEventManager
 from pyPhases import Phase
 from pyPhasesRecordloader import RecordLoader, RecordSignal, Signal
 

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/SleePyPhases/phases/Extract.py

@@ -6,7 +6,7 @@ from pyPhasesRecordloader import AnnotationNotFound, AnnotationInvalid, Channels
 
 from SleePyPhases.FeatureExtraction import FeatureExtraction
 from SleePyPhases.PreManipulation import PreManipulation
-from SleePyPhases.PSGEventManager import PSGEventManager
+from SleepHarmonizer import PSGEventManager
 from SleePyPhases.SignalPreprocessing import SignalPreprocessing
 
 
@@ -59,13 +59,12 @@ class RecordProcessor:
         elif name in ["SleepApnea", "RespEvents"]:
             if "apnea" in eventSignal:
                 evs = eventSignal["apnea"]
-                labelSignalArray[evs == PSGEventManager.INDEX_APNEA_OBSTRUCTIVE] = 1
-                labelSignalArray[evs == PSGEventManager.INDEX_APNEA_MIXED] = 2
-                labelSignalArray[evs == PSGEventManager.INDEX_APNEA_CENTRAL] = 3
-                labelSignalArray[evs == PSGEventManager.INDEX_APNEA_HYPO] = 4
-            if "arousal" in eventSignal and name == "RespEvents":
-                evs = eventSignal["arousal"]
-                labelSignalArray[evs == PSGEventManager.INDEX_AROUSAL_RERA] = 5
+                labelSignalArray[evs == PSGEventManager.INDEX_RESPEVENT_OBSTRUCTIVE] = 1
+                labelSignalArray[evs == PSGEventManager.INDEX_RESPEVENT_MIXED] = 2
+                labelSignalArray[evs == PSGEventManager.INDEX_RESPEVENT_CENTRAL] = 3
+                labelSignalArray[evs == PSGEventManager.INDEX_RESPEVENT_HYPO] = 4
+                if name == "RespEvents":
+                    labelSignalArray[evs == PSGEventManager.INDEX_RESPEVENT_INDEX_RERA] = 5
         elif name == "SleepLegMovements":
             if "limb" in eventSignal:
                 eventSignal = eventSignal["limb"]

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/SleePyPhases/phases/ExtractEvents.py

@@ -2,7 +2,10 @@
 import pandas as pd
 from pyPhases import Phase
 from pyPhases.util import BatchProgress
-from pyPhasesRecordloader import AnnotationNotFound, RecordLoader
+from pyPhasesRecordloader import AnnotationNotFound, RecordLoader, AnnotationInvalid, ParseError
+from pyPhasesML import DataversionManager
+from SleePyPhases.PreManipulation import PreManipulation
+
 import tqdm
 
 
@@ -12,36 +15,54 @@ class ExtractEvents(Phase):
     """
 
     useMultiThreading = True
-    threads = None
+    threads = 8
     validatDataset = True
+    manipulationSteps = None
 
     def getEventList(self, recordId):
         rl = RecordLoader.get()
         try:
-            return rl.getEventList(recordId)
+            eventList = rl.getEventList(recordId)
+
+            if self.manipulationSteps is not None:
+                dataManipulation = PreManipulation.getInstance(self.manipulationSteps)
+                _, eventList = dataManipulation(None, eventList)
+
+            recordDf = pd.DataFrame(eventList)
+            recordDf["recordId"] = recordId
+            return recordDf
         except AnnotationNotFound:
             return None
+        except AnnotationInvalid:
+            return None
+        except ParseError:
+            return None
 
 
     def getEvents(self, records, force=False):
         rl = RecordLoader.get()
-        
+
         bp = BatchProgress(records)
         bp.useMultiThreading = self.useMultiThreading
         if self.threads is not None:
             bp.threads = self.threads
+            
+
+        def combine(recordDfs, index):
 
-        def combine(events, index):
-            combine.events.append([e for e in events if e is not None])
+            # combine.df.append([e for e in events if e is not None])
+            df = pd.concat(recordDfs, ignore_index=True)
+            combine.df = pd.concat([combine.df, df], ignore_index=True)
+            # pd.concat(recordDfs, ignore_index=True)
         # def combineFlatten(events, index):
         #     combine.events += [e for ev in events if ev is not None for e in ev]
         # def getEventList(recordId):
         #     rl.getEventList(recordId)
-        combine.events = []
+        combine.df = pd.DataFrame()
 
         # bp.asyncQueue(rl.getEventList, records, combine)
         bp.start(self.getEventList, records, combine)
-        return combine.events
+        return combine.df
     
     def appendDataframe(self, df, dfToAppend, colMap, offsetStart=None, offsetEnd=None):
         cols = {n: [] for n in colMap}
@@ -60,42 +81,41 @@ class ExtractEvents(Phase):
 
     def generateData(self, name):
         if name == "events":
-            groupedRecords = self.project.getData("allDBRecordIds", list)
+            # groupedRecords = self.project.getData("allDBRecordIds", list)
+            dm = self.getData("dataversionmanager", DataversionManager)
+            groupedRecords = dm.groupedRecords
+            
             flatten = [r for records in groupedRecords.values() for r in records]
             # extract the data
             events = self.getEvents(flatten)
             self.registerData("events", events)
         if name == "eventDF":
-            allRecordEventsBatches = self.getData("events", list)
-            events = []
-            recordIndex = 0
-            for allRecordEvents in tqdm.tqdm(allRecordEventsBatches):
-                for recordEvents in allRecordEvents:
-                    for event in recordEvents:
-                        events.append({
-                            "recordIndex": recordIndex,
-                            "name": event.name,
-                            "start": event.start,
-                            "duration": event.duration,
-                        })
-                    recordIndex += 1
-            df = pd.DataFrame.from_dict(events)
+            # allRecordEventsBatches = self.getData("events", list)
+            df = self.getData("events", pd.DataFrame)
+            # events = []
+            # recordIndex = 0
+            # for allRecordEvents in tqdm.tqdm(allRecordEventsBatches):
+            #     for recordEvents in allRecordEvents:
+            #         for event in recordEvents:
+            #             events.append({
+            #                 "recordIndex": recordIndex,
+            #                 "name": event.name,
+            #                 "start": event.start,
+            #                 "duration": event.duration,
+            #             })
+            #         recordIndex += 1
+            # df = pd.DataFrame.from_dict(events)
             df["end"] = df["start"] + df["duration"]
             dfSleepStage = df.query("name in ['W', 'N1', 'N2', 'N3', 'R']")
             dfArousal = df.query("name in ('arousal', 'arousal_rera')")
             dfLM = df.query("name in ('LegMovement-Left', 'LegMovement-Right')")
             eventResp = df.query("name in ('resp_hypopnea', 'resp_centralapnea', 'resp_obstructiveapnea', 'resp_mixedapnea', 'resp_cheynestokesbreath')")
 
-            self.registerData("eventArousal", dfArousal)
-            self.registerData("eventLM", dfLM)
-            self.registerData("eventSleep", dfSleepStage)
-            self.registerData("eventResp", eventResp)
-
-            self.appendDataframe(dfArousal, dfSleepStage, {"sleepStage": "name"}, offsetStart=-0.5, offsetEnd=0.5)
-            self.appendDataframe(dfArousal, dfLM, {"legmovements": "name"}, offsetStart=-0.5, offsetEnd=0.5)
-            self.appendDataframe(dfArousal, eventResp, {"resp_event": "name"}, offsetStart=-0.5, offsetEnd=0.5)
+            # self.appendDataframe(dfArousal, dfSleepStage, {"sleepStage": "name"}, offsetStart=-0.5, offsetEnd=0.5)
+            # self.appendDataframe(dfArousal, dfLM, {"legmovements": "name"}, offsetStart=-0.5, offsetEnd=0.5)
+            # self.appendDataframe(dfArousal, eventResp, {"resp_event": "name"}, offsetStart=-0.5, offsetEnd=0.5)
 
-            self.registerData("eventDF", dfArousal)
+            self.registerData("eventDF", df)
             
             return dfArousal
     
@@ -105,10 +125,10 @@ class ExtractEvents(Phase):
             offsetStart = 0
         if offsetEnd is None:
             offsetEnd = 0
-        for e in tqdm.tqdm(df.iloc):
+        for e in tqdm.tqdm(df.iloc, total=len(df)):
             start = e.start + offsetStart
             end = e.end + offsetEnd
-            possibleEvents = dfToAppend.query("recordIndex == %i and start < %f and end > %f" % (e.recordIndex, end, start))
+            possibleEvents = dfToAppend.query(f"recordId == '{e.recordId}' and start < {end} and end > {start}")
             for name in cols:
                 cols[name].append(",".join([ev[colMap[name]] for ev in possibleEvents.iloc]))
         for name in cols:
@@ -133,58 +153,62 @@ class ExtractEvents(Phase):
         
         # df = self.getData("eventDF")
         df = self.getData("eventDF", list)
+
+        df["site"] = df["recordId"].str[:5]
         
         modelConfigString = self.project.getDataFromName("eventDF").getTagString()
         logPath = f"eval/{modelConfigString}/"
         self.logPath = logPath
         plot = Plot(logPath)
         plot.createLogFolder()
-        plot.plotClassDistribution(df.groupby("name")["recordIndex"].count(), "Arousal/Rera")
+        dfArousal = df.query("name.str.contains('arousal')")
+        dfLeg = df.query("name.str.contains('Leg')")
+        plot.plotClassDistribution(dfArousal.groupby("name")["recordId"].count(), "Arousal/Rera")
         plot.save("arousal-rera")
-        plot.plotClassDistribution(df.query("name == 'arousal'").groupby("sleepStage")["recordIndex"].count(), "sleepStage Arousal")
-        plot.save("arousal-sleepStage")
-        plot.plotClassDistribution(df.query("name == 'arousal_rera'").groupby("sleepStage")["recordIndex"].count(), "sleepStage Rera")
-        plot.save("rara-sleepStage")
-        plot.plotClassDistribution(df.query("name == 'arousal_rera'").groupby("sleepStage")["recordIndex"].count(), "sleepStage")
-        plot.save("sleepStage")
+        # plot.plotClassDistribution(df.query("name == 'arousal'").groupby("sleepStage")["recordIndex"].count(), "sleepStage Arousal")
+        # plot.save("arousal-sleepStage")
+        # plot.plotClassDistribution(df.query("name == 'arousal_rera'").groupby("sleepStage")["recordIndex"].count(), "sleepStage Rera")
+        # plot.save("rara-sleepStage")
+        # plot.plotClassDistribution(df.query("name == 'arousal_rera'").groupby("sleepStage")["recordIndex"].count(), "sleepStage")
+        # plot.save("sleepStage")
         
-        df["type"] = df.apply(lambda row: ("L" if row["legmovements"] != "" else "") + ("R" if row["resp_event"] != "" else ""), axis=1)
-        df["first_resp"] = df.apply(lambda row: row["resp_event"].split(",")[0], axis=1)
+        # df["type"] = df.apply(lambda row: ("L" if row["legmovements"] != "" else "") + ("R" if row["resp_event"] != "" else ""), axis=1)
+        # df["first_resp"] = df.apply(lambda row: row["resp_event"].split(",")[0], axis=1)
         
-        plot.plotClassDistribution(df.groupby("type")["recordIndex"].count(), "type")
-        plot.save("type")
+        # plot.plotClassDistribution(df.groupby("type")["recordIndex"].count(), "type")
+        # plot.save("type")
         
-        plot.plotClassDistribution(df.query("first_resp != ''").groupby("first_resp")["recordIndex"].count())
-        plot.save("first_resp")
+        # plot.plotClassDistribution(df.query("first_resp != ''").groupby("first_resp")["recordIndex"].count())
+        # plot.save("first_resp")
         
         
-        plot.plotClassDistribution(df.groupby("resp_event")["recordIndex"].count(), "resp_events")
-        plot.save("resp_events")
+        # plot.plotClassDistribution(df.groupby("resp_event")["recordIndex"].count(), "resp_events")
+        # plot.save("resp_events")
         
         
         # df["duration"].plot(kind='density')
-        self.plotArousalHist(df, "duration", "Duration")
+        self.plotArousalHist(dfArousal, "duration", "Duration")
         plt.text(10 + 2.5, plt.ylim()[1]*0.9, "10", color='red', ha='center', va='bottom')
         plt.axvline(x=10, color='red')
         plot.save("duration")
         
-        self.plotArousalHist(df.query("name == 'arousal_rera'"), "duration", "Rera Duration")
+        self.plotArousalHist(dfArousal.query("name == 'arousal_rera'"), "duration", "Rera Duration")
         plt.text(10 + 2.5, plt.ylim()[1]*0.9, "10", color='red', ha='center', va='bottom')
         plt.axvline(x=10, color='red')
         plot.save("rera-duration")
         
-        self.plotArousalHist(df.query("name == 'arousal'"), "duration", "Arousal Duration")
+        self.plotArousalHist(dfArousal.query("name == 'arousal'"), "duration", "Arousal Duration")
         plt.text(10 + 2.5, plt.ylim()[1]*0.9, "10", color='red', ha='center', va='bottom')
         plt.axvline(x=10, color='red')
         plot.save("arousal-duration")
         
-        self.plotArousalHist(df.query("name == 'arousal'"), "start", "Arousal Start")
+        self.plotArousalHist(dfArousal.query("name == 'arousal'"), "start", "Arousal Start")
         plot.save("arousal-start")
         
-        self.plotArousalHist(df.query("name == 'arousal_rera'"), "start", "Rera Start")
+        self.plotArousalHist(dfArousal.query("name == 'arousal_rera'"), "start", "Rera Start")
         plot.save("rera-start")
         
-        self.plotArousalHist(df, "start", "Start")
+        self.plotArousalHist(dfArousal, "start", "Start")
         plt.gca().xaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: f"{x/3600:.1f}h"))
         plot.save("start")
         

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/SleePyPhases/phases/ExtractFeatures.py

@@ -166,7 +166,7 @@ class ExtractFeatures(Phase):
         featureConfigs = self.getConfig("featureExtraction.features", [])
         if featureNameDict != {}:
             featureNames = list(featureNameDict.keys())
-            featureConfigs = [f for f in featureConfigs if f["name"] in featureNames]
+            featureConfigs = [f for f in featureConfigs if f["name"] + "_checked" in featureNames]
 
         recordLoader = RecordLoader.get()
         recordSignal = None
@@ -181,9 +181,10 @@ class ExtractFeatures(Phase):
 
             
         for featureConfig in featureConfigs:
+            checkedCol = featureConfig["name"] + "_checked"
             if recordSignal is None:
                 self.features.loc[recordId, "recordId"] = recordId
-                self.features.loc[recordId, featureConfig["name"]] = True
+                self.features.loc[recordId, checkedCol] = True
                 self.registerData("features", self.features)
                 return {}
             
@@ -198,7 +199,7 @@ class ExtractFeatures(Phase):
 
                 self.features.loc[idx, "recordId"] = recordId
                 self.features.loc[idx, "channel"] = c
-                self.features.loc[idx, featureConfig["name"]] = True
+                self.features.loc[idx, checkedCol] = True
         
         self.registerData("features", self.features)
         idx = (recordId, channel) if channel is not None else recordId
@@ -211,7 +212,7 @@ class ExtractFeatures(Phase):
         recordIds = metadata["recordId"]
         forceCalculation = self.getConfig("featureExtraction.force", False)
 
-        reqFeatures = {f["name"]: True for f in self.getConfig("featureExtraction.features", [])}
+        reqFeatures = {f["name"] + "_checked": True for f in self.getConfig("featureExtraction.features", [])}
 
         recordId = self.getConfig("recordId", False)
         recordIds = [recordId] if recordId else recordIds.iloc

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/SleePyPhases/phases/Predict.py

@@ -11,9 +11,7 @@ from pyPhasesRecordloader.RecordLoader import ChannelsNotPresent
 from SleePyPhases.DataManipulation import DataManipulation
 from SleePyPhases.FeatureExtraction import FeatureExtraction
 from SleePyPhases.PreManipulation import PreManipulation
-from SleePyPhases.PSGEventManager import PSGEventManager
 from SleePyPhases.SignalPreprocessing import SignalPreprocessing
-from SleePyPhases.phases.Extract import RecordProcessor
 
 
 class Predict(Phase):
@@ -129,11 +127,12 @@ class Predict(Phase):
         
         return recordSignal
     
-    def preprocessSignal(self, recordSignal):
+    def preprocessSignal(self, recordSignal, targetSignals=None):
         """Preprocess the signal for model input."""
         preprocessingConfig = self.getConfig("preprocessing")
         targetFrequency = preprocessingConfig["targetFrequency"]
-        targetSignals = preprocessingConfig["targetChannels"]
+        targetSignals = preprocessingConfig["targetChannels"] if targetSignals is None else None
+        
         featureChannels = preprocessingConfig.get("featureChannels", [])
         
         recordSignal.targetFrequency = targetFrequency
@@ -165,31 +164,40 @@ class Predict(Phase):
 
         # Load and preprocess the signal
         recordSignal = self.getSignalFromFile(inputFile, channelMapping)
+
+        return self.predictRecordSignal(recordSignal)
+
+    def predictRecordSignal(self, recordSignal, dummyY=None):
         processedSignal = self.preprocessSignal(recordSignal)
 
-        # Prepare input for model
-        if len(processedSignal.shape) == 2:
-            processedSignal = processedSignal.reshape([1] + list(processedSignal.shape))
+        # # Prepare input for model
+        # if len(processedSignal.shape) == 2:
+        #     processedSignal = processedSignal.reshape([1] + list(processedSignal.shape))
 
         # Apply segment manipulation for evaluation
         manipulationSteps = self.getConfig("segmentManipulationEval", [])
         da = DataManipulation.getInstance(manipulationSteps, "test", self.project.config)
-        processedSignal, _ = da((processedSignal, np.zeros(1)))  # Dummy label
-
-        # Load model with optional custom weights
-        weightsPath = self.getConfig("predict.weights", None)
-        model = self.getModel(weightsPath)
-
-        # Run prediction
-        prediction = model.predict(processedSignal, returnNumpy=True)
-
-        # Apply post-prediction manipulation if configured
-        manipulationAfterPredict = self.getConfig("manipulationAfterPredict", False)
-        if manipulationAfterPredict:
-            threshold = self.getConfig("fixedThreshold", False)
-            threshold = threshold or self.getData("threshold", list, generate=False)
-            da = DataManipulation.getInstance(manipulationAfterPredict, "test", self.project.config, threshold=threshold)
-            prediction, _ = da((prediction, np.zeros(1)))
+        dummyY = np.array([0]).reshape(1, -1, 1) if  dummyY is None else dummyY
+        processedSignal, dummyY = da((processedSignal, dummyY))  # Dummy label
+
+        with self.project:
+            overwriteConfig = self.getConfig("predict", {})
+            self.project.updateConfig(overwriteConfig)
+
+            # Load model with optional custom weights
+            weightsPath = self.getConfig("predict.weights", False)
+            model = self.getModel(weightsPath)
+
+            # Run prediction
+            prediction = model.predict(processedSignal, returnNumpy=True)
+
+            # Apply post-prediction manipulation if configured
+            manipulationAfterPredict = self.getConfig("manipulationAfterPredict", False)
+            if manipulationAfterPredict:
+                threshold = self.getConfig("fixedThreshold", False)
+                threshold = threshold or self.getData("threshold", list, generate=False)
+                da = DataManipulation.getInstance(manipulationAfterPredict, "test", self.project.config, threshold=threshold)
+                prediction, _ = da((prediction, dummyY))
 
         return prediction
 

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/SleePyPhases/phases/Setup.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 from pyPhases import Phase
 from pyPhasesML import DataversionManager, Scorer
-from pyPhasesRecordloader import RecordLoader
+from pyPhasesRecordloader import RecordLoader, RecordLoaderNotFound
 
 
 
@@ -18,8 +18,11 @@ class Setup(Phase):
         self.setConfig("segmentManipulationEval", defaultValidationbatchManipulation)
 
         preprocessingConfig = self.getConfig("preprocessing", {})
-        if "combineChannels" in preprocessingConfig:
-            RecordLoader.get().addCombinedChannels(preprocessingConfig["combineChannels"])
+        if "combineChannels" in preprocessingConfig and self.getConfig("useLoader", False):
+            try:
+                RecordLoader.get().addCombinedChannels(preprocessingConfig["combineChannels"])
+            except RecordLoaderNotFound as e:
+                self.logError(e)
 
 
         # default fold is 0 if none is set
@@ -101,8 +104,6 @@ class Setup(Phase):
             dm.addSplitByRemaining("validation", valSplit) # , remainingSplit=trainingSlice
             dm.addSplitByRemaining("training", 1)
 
-            
-
         if "test" not in dm.splits:
             dm.addSplitByRemaining("test", testSplit)
 

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/SleePyPhases.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SleePyPhases
-Version: 0.6.0
+Version: 0.6.2
 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.6.0 → sleepyphases-0.6.2}/SleePyPhases.egg-info/SOURCES.txt

@@ -6,7 +6,6 @@ SleePyPhases/DataManipulation.py
 SleePyPhases/EventScorer.py
 SleePyPhases/FeatureExtraction.py
 SleePyPhases/MultiScorer.py
-SleePyPhases/PSGEventManager.py
 SleePyPhases/Plot.py
 SleePyPhases/Plugin.py
 SleePyPhases/PreManipulation.py

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/setup.py

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

{sleepyphases-0.6.0 → sleepyphases-0.6.2}/tests/unit/test_RecordFeatureExtraction.py

@@ -3,7 +3,7 @@
 # import numpy as np
 # from pyPhasesRecordloader import Event
 
-# from SleePyPhases.PSGEventManager import PSGEventManager
+# from SleepHarmonizer.PSGEventManager import PSGEventManager
 # from SleePyPhases.RecordFeatureExtraction import RecordFeatureExtraction
 
 

sleepyphases-0.6.0/SleePyPhases/PSGEventManager.py

@@ -1,137 +0,0 @@
-from pyPhasesRecordloader import EventManager
-
-
-class PSGEventManager(EventManager):
-    INDEX_WAKE = 2
-    INDEX_NREM1 = 4
-    INDEX_NREM2 = 8
-    INDEX_NREM3 = 16
-    INDEX_REM = 32
-
-    INDEX_APNEA_OBSTRUCTIVE = 2
-    INDEX_APNEA_HYPO = 4
-    INDEX_APNEA_CENTRAL = 8
-    INDEX_APNEA_MIXED = 16
-    INDEX_APNEA_PARTIALOBSTRUCTIVE = 32
-    INDEX_APNEA_HYPOVENTILATION = 64
-    INDEX_APNEA_CHEYNESTOKESBREATH = 128
-
-    INDEX_AROUSAL_RERA = 2
-    INDEX_AROUSAL_SPONTANEOUS = 4
-    INDEX_AROUSAL_PLM = 8
-    INDEX_AROUSAL_SNORE = 16
-    INDEX_AROUSAL_BRUXISM = 32
-    INDEX_AROUSAL_NOISE = 64
-    INDEX_AROUSAL = 128
-    INDEX_AROUSAL_ASDA = 256
-    INDEX_AROUSAL_CHIN = 512
-    INDEX_AROUSAL_LIMB = 8
-
-    INDEX_LEGMOVEMENT = 8
-    INDEX_LEGMOVEMENT_LEFT = 2
-    INDEX_LEGMOVEMENT_RIGHT = 4
-
-    def __init__(self):
-        eventGroups = {
-            "sleepStage": ["undefined", "W", "N1", "N2", "N3", "R"],
-            "bodyposition": [
-                "undefinedBodyPosition",
-                "Up",
-                "Supine",
-                "Left",
-                "Prone",
-                "Right",
-            ],
-            "apnea": [
-                "noneApnea",
-                "resp_obstructiveapnea",
-                "resp_hypopnea",
-                "resp_centralapnea",
-                "resp_mixedapnea",
-                "resp_partialobstructive",
-                "resp_hypoventilation",
-                "resp_cheynestokesbreath",
-                "resp_hypopnea_obstructive",
-                "resp_hypopnea_central",
-                "resp_rera" # flow limitation (>10 sec)
-            ],
-            "arousal": [
-                "noneArousal",
-                "arousal_rera", # the actual arousal
-                "arousal_spontaneous",
-                "arousal_plm",
-                "arousal_snore",
-                "arousal_bruxism",
-                "arousal_noise",
-                "arousal",
-                "arousal_asda",  # shhs/mros: American Sleep Disorders Association
-                "arousal_chin",  # shhs
-                "arousal_limb",
-                "arousal_respiratory",	
-            ],
-            "grapho": [
-                "no-grapho",
-                "AlphaActivity-eeg",
-                "RapidEyeMovement",
-                "SlowEyeMovement",
-                "Spindle-eeg",
-            ],
-            "fail": [  # maximal 31 for 32bit integer
-                "workingSignal",
-                "fail-channel0",
-                "fail-channel1",
-                "fail-channel2",
-                "fail-channel3",
-                "fail-channel4",
-                "fail-channel5",
-                "fail-channel6",
-                "fail-channel7",
-                "fail-channel8",
-                "fail-channel9",
-                "fail-channel10",
-                "fail-channel11",
-                "fail-channel12",
-                "fail-channel13",
-                "fail-channel14",
-                "fail-channel15",
-                "fail-channel16",
-                "fail-channel17",
-                "fail-channel18",
-                "fail-channel19",
-                "fail-channel20",
-                "fail-channel21",
-                "fail-channel22",
-                "fail-channel23",
-                "fail-channel24",
-                "fail-channel25",
-                "fail-channel26",
-                "fail-channel27",
-                "fail-channel28",
-                "fail-channel29",
-            ],
-            "limb": [
-                "noneLegmovement", 
-                "LegMovement-Left", 
-                "LegMovement-Right", 
-                "LegMovement", 
-                "PLM",
-                "PLM-Left",
-                "PLM-Right",
-            ],
-            "spo2": [
-                "spo2_desaturation",
-                "spo2_meanPerEpoch",
-                "spo2_minPerEpoch",
-                "spo2_Lower90",
-                "spo2_Lower80",
-            ],
-            "cardiac": [
-                "hr_rise",
-                "sinus_tachycardia",
-            ],
-            "light": [
-                "lightOff",
-                "lightOn",
-            ],
-        }
-        super().__init__(eventGroups)