pyPhasesRecordloaderProfusion 0.1.0__tar.gz

pyphasesrecordloaderprofusion-0.1.0/.gitlab-ci.yml

@@ -0,0 +1,50 @@
+image: python:3.13-alpine
+
+variables:
+  PROJECTNAME: $CI_PROJECT_NAME
+
+stages:
+    - test
+    - release
+
+test:
+    stage: test
+    cache: {}
+    before_script:
+        - apk update
+        - apk add build-base
+    script:
+        - pip install -U -r requirements.txt
+        - pip install -U coverage
+        - python -m coverage run -m unittest discover -s tests -p "test_*.py"
+        - python -m coverage report --data-file=.coverage
+        - python -m coverage xml --data-file=.coverage -o cov/coverage.xml
+        - python -m coverage html --data-file=.coverage -d cov/htmlcov
+    only:
+        - pushes
+    coverage: '/TOTAL.*\s+(\d+\%)/'
+    artifacts:
+        paths:
+        - :./cov/
+        reports:
+            coverage_report:
+                coverage_format: cobertura
+                path: cov/coverage.xml
+pypi:
+    stage: release
+    before_script:
+        - apk update
+        - apk add build-base
+    cache: {}
+    variables:
+        APP_VERSION: $CI_COMMIT_TAG
+        TWINE_NON_INTERACTIVE: "1"
+        TWINE_REPOSITORY_URL: "https://upload.pypi.org/legacy/"
+    script:
+        - sed -i "s/v0.0.0/${APP_VERSION}/g" setup.py
+        - pip install -U -r requirements.txt
+        - pip install -U 'twine<5.0' pip setuptools
+        - python setup.py sdist
+        - twine upload dist/*
+    rules:
+        - if: '$CI_COMMIT_TAG =~ /^v\d+\.\d+(\.\d+)?(-\S*)?$/'

pyphasesrecordloaderprofusion-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 pyPhases
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyphasesrecordloaderprofusion-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-exclude tests *
+recursive-include . *.yaml
+recursive-include . *.yml

pyphasesrecordloaderprofusion-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: pyPhasesRecordloaderProfusion
+Version: 0.1.0
+Summary: Adds a record loaders to the pyPhases package
+Home-page: https://gitlab.com/tud.ibmt.public/pyphases/pyPhasesRecordloaderProfusion/
+Author: Franz Ehrlich
+Author-email: fehrlichd@gmail.com
+License: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.5
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyPhases
+Requires-Dist: pyPhasesRecordloader
+Requires-Dist: pyedflib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Extension for pyPhasesRecordloader
+
+
+
+## Usage
+
+In a phase you can access the data through the `RecordLoader`:
+
+Add the plugins and config values to your project.yaml::
+
+```yaml
+name: ProfusionProject
+plugins:
+  - pyPhasesML
+  - pyPhasesRecordloaderProfusion
+  - pyPhasesRecordloader
+
+phases:
+  - name: MyPhase
+
+config:
+  profusion-path: C:/datasets/recordings
+
+```
+
+In a phase (`phases/MyPhase.py`) you can access the records using the `RecordLoader`:
+
+```python
+from pyPhasesRecordloader import RecordLoader
+from pyPhases import Phase
+
+class MyPhase(Phase):
+    def run(self):
+      recordIds = recordLoader.getRecordList()
+      for recordId in recordIds:
+        record = recordLoader.getRecord(recordId)
+```
+
+Run your project with `python -m phases run MyPhase`.

pyphasesrecordloaderprofusion-0.1.0/README.md

@@ -0,0 +1,39 @@
+# Extension for pyPhasesRecordloader
+
+
+
+## Usage
+
+In a phase you can access the data through the `RecordLoader`:
+
+Add the plugins and config values to your project.yaml::
+
+```yaml
+name: ProfusionProject
+plugins:
+  - pyPhasesML
+  - pyPhasesRecordloaderProfusion
+  - pyPhasesRecordloader
+
+phases:
+  - name: MyPhase
+
+config:
+  profusion-path: C:/datasets/recordings
+
+```
+
+In a phase (`phases/MyPhase.py`) you can access the records using the `RecordLoader`:
+
+```python
+from pyPhasesRecordloader import RecordLoader
+from pyPhases import Phase
+
+class MyPhase(Phase):
+    def run(self):
+      recordIds = recordLoader.getRecordList()
+      for recordId in recordIds:
+        record = recordLoader.getRecord(recordId)
+```
+
+Run your project with `python -m phases run MyPhase`.

pyphasesrecordloaderprofusion-0.1.0/pyPhasesRecordloaderProfusion/Plugin.py

@@ -0,0 +1,13 @@
+from pyPhases import PluginAdapter
+from pyPhasesRecordloader import RecordLoader
+
+
+class Plugin(PluginAdapter):
+    def initPlugin(self):
+        # self.project.loadConfig(self.project.loadConfig(pathlib.Path(__file__).parent.absolute().joinpath("config.yaml")))
+        module = "pyPhasesRecordloaderProfusion"
+        rlPath = f"{module}.recordLoaders"
+        RecordLoader.registerRecordLoader("RecordLoaderProfusion", rlPath)
+        RecordLoader.registerRecordLoader("ProfusionAnnotationLoader", rlPath)
+        profusionPath = self.getConfig("profusion-path")
+        self.project.setConfig("loader.profusion.filePath", profusionPath)

pyphasesrecordloaderprofusion-0.1.0/pyPhasesRecordloaderProfusion/__init__.py

@@ -0,0 +1,2 @@
+from .recordLoaders.ProfusionAnnotationLoader import ProfusionAnnotationLoader
+from .recordLoaders.RecordLoaderProfusion import RecordLoaderProfusion

pyphasesrecordloaderprofusion-0.1.0/pyPhasesRecordloaderProfusion/config.yaml

@@ -0,0 +1,93 @@
+loader:
+  profusion:
+    dataBase: Profusion
+    dataBaseVersion: 1.0.0 # needs to be raised every time new data is added
+
+    filePath: ./datasets/recordings
+    copyRawDataToLocal: True
+    dataIsFinal: False
+
+    dataset:
+      loaderName: RecordLoaderProfusion
+      fromFiles: True # if the records are read from files or sql-database
+      dataHandler:
+        type: folders
+        listFilter: null
+        canReadRemote: True
+        basePath: .
+        extensions: [.edf, -nsrr.xml]
+        basePathExtensionwise:
+          [
+            Profusion\polysomnography\edfs\Profusion,
+            Profusion\polysomnography\annotations-events-nsrr\Profusion,
+          ]
+        force: False
+        idPattern: .*/(.*).edf
+        signal-path: "{recordId}/{recordId}.edf"
+        annotation-path: "{recordId}/{recordId}.xml"
+        metadata-path: "{recordId}/{recordId}.txt"
+      filePattern: "*.edf"
+
+    # the channels that should be extracted from the edf files
+    sourceChannels:
+      - name: EEG F3-M2 # harmonized label name should be based on EDF+
+        type: eeg
+        aliases: [F3-M2] # actual names in the different edfs
+      - name: EEG C3-M2
+        type: eeg
+        aliases: [C3-M2]
+      - name: EEG O1-M2
+        type: eeg
+        aliases: [O1-M2]
+      - name: EEG F4-M1
+        type: eeg
+        aliases: [F4-M1]
+      - name: EEG C4-M1
+        type: eeg
+        aliases: [C4-M1]
+      - name: EEG O2-M1
+        type: eeg
+        aliases: [O2-M1]
+      - name: EOG ROC-M2
+        type: eog
+        aliases: [ROC-M2]
+      - name: EOG LOC-M2
+        type: eog
+        aliases: [LOC-M2]
+      - name: EMG EMG1-EMG2
+        type: emg
+        aliases: [EMG1-EMG2]
+      - name: ECG
+        type: ecg
+      - name: EMG Leg/l
+        type: emg
+        aliases: [Leg/l]
+      - name: EMG Leg/r
+        type: emg
+        aliases: [Leg/r]
+      - name: MIC
+        type: mic
+      - name: Airflow
+        type: flow
+      - name: Thor
+        type: effort
+      - name: Abdo
+        type: effort
+      - name: SpO2
+        type: sao2
+      - name: Pressure
+        type: pressure
+        optional: true
+      # - name: Pulse
+      #   type: pulse
+      - name: Position
+        type: position
+      # - name: Light
+      #   type: light
+
+
+    combineChannels: []
+
+useLoader: profusion
+profusion-path: datasets/Profusion
+

pyphasesrecordloaderprofusion-0.1.0/pyPhasesRecordloaderProfusion/recordLoaders/ProfusionAnnotationLoader.py

@@ -0,0 +1,149 @@
+from typing import List
+
+from pyPhases.util.Logger import classLogger
+from pyPhasesRecordloader import AnnotationInvalid, AnnotationNotFound, Event
+from pyPhasesRecordloader.recordLoaders.XMLAnnotationLoader import XMLAnnotationLoader
+
+
+@classLogger
+class ProfusionAnnotationLoader(XMLAnnotationLoader):
+
+    mapSleep = {
+        '9': 'undefined',
+        '0': 'W',
+        '1': 'N1',
+        '2': 'N2',
+        '3': 'N3',
+        '5': 'R',
+    }
+
+    mapEvents = {
+        'Central Apnea': 'resp_centralapnea', 
+        'Obstructive Apnea': 'resp_obstructiveapnea', 
+        'Mixed Apnea': 'resp_mixedapnea',
+        'Hypopnea': 'resp_hypopnea',
+
+        'Obstructive Hypopnea': 'resp_hypopnea_obstructive',
+        'Central Hypopnea': 'resp_hypopnea_central',
+        'Mixed Hypopnea': 'hypopnea',
+
+        'Arousal ()': 'arousal',
+        'Arousal (ARO RES)': 'arousal_respiratory',
+        'Arousal (ARO Limb)': 'arousal_limb',
+        'Arousal (ARO SPONT)': 'arousal_spontaneous',
+
+        'RERA': 'arousal_rera',
+
+        'Limb Movement (Left)': 'LegMovement-Left',
+        'Limb Movement (Right)': 'egMovement-Right',
+        'PLM (Left)': 'PLM-Left',
+        'PLM (Right)': 'PLM-Right',
+
+        'Cheyne Stokes Breathing': 'resp_cheynestokesbreath',
+
+        'SpO2 desaturation': 'spo2_desaturation',
+
+        # 'Unsure': '',
+        # 'Bradycardia': '',
+        # 'Tachycardia': '',
+        # 'TcCO2 artifact': '',
+        # 'EtCO2 artifact': '',
+        # 'Distal pH artifact': '',
+        # 'Distal pH': '',
+        # 'Proximal pH artifact': '',
+        # 'Blood pressure artifact': '',
+        # 'Body temperature artifact': '',
+        # 'Respiratory Paradox': '',
+        # 'Periodic Breathing': '',
+        # 'Respiratory artifact': '',
+        # 'SpO2 artifact': '',
+    }
+    
+
+    def getPath(self, xml, path):
+        path = "./" + path
+        return xml.findall(path)
+
+    def loadEvents(
+        self,
+        path,
+        eventMap,
+        durationChild="Duration",
+        startChild="Start",
+        typeChild="EventType",
+        conceptChild="EventConcept",
+        defaultState="ignore",
+        minDuration=0,
+        replaceName=None,
+    ):
+        tags = self.getPath(self.metaXML, path)
+        if tags is None:
+            raise AnnotationNotFound(path)
+
+        events = []
+
+        lastDefaultEvent = None
+        for tag in tags:
+            name = tag.find(conceptChild).text
+            startValue = float(tag.find(startChild).text)
+            if startValue is None:
+                raise AnnotationInvalid(path + [startChild])
+
+            startInSeconds = float(startValue)
+            # if the name is in the eventMap it will be added to the annotations
+            if name in eventMap:
+                event = Event()
+                event.start = startInSeconds
+                event.manual = True
+                eventName = replaceName(tag) if replaceName else eventMap[name]
+
+                event.name = eventName
+
+                if durationChild is not None:
+                    # if there is a duration the event will be saved as as 2 events:
+                    # startTime, "(eventName"
+                    # endTime, "eventName)"
+                    durationValue = float(tag.find(durationChild).text)
+                    if durationValue is None:
+                        raise AnnotationInvalid(path + [durationChild])
+
+                    durationInSeconds = float(durationValue)
+                    if durationInSeconds > minDuration:
+                        event.duration = durationInSeconds
+                        events.append(event)
+                else:
+                    # if its without a duration, it is considered a permanent state change
+                    # that will persist until it is changed again
+                    if lastDefaultEvent is not None:
+                        lastDefaultEvent.duration = event.start - lastDefaultEvent.start
+                    events.append(event)
+                    lastDefaultEvent = event
+            # else:
+            #     self.logWarning("Event " + name + " not in EventMap.")
+
+        if lastDefaultEvent is not None and self.lightOn is not None:
+            lastDefaultEvent.duration = self.lightOn - lastDefaultEvent.start
+
+        return events
+
+    def loadAnnotation(self, xmlFile) -> List[Event]:
+        self.loadXmlFile(xmlFile)
+
+        allEvents = []
+        allEvents += self.loadEvents(
+            "SleepStages/SleepStage",
+            self.mapSleep,
+        )
+        allEvents += self.loadEvents(
+            "ScoredEvents/ScoredEvent",
+            self.mapEvents,
+        )
+
+        # no light annotations ?
+        self.lightOff = 0
+        self.lightOn = None
+
+        return allEvents
+
+    def fillRecord(self, record, xmlFile):
+        pass

pyphasesrecordloaderprofusion-0.1.0/pyPhasesRecordloaderProfusion/recordLoaders/RecordLoaderProfusion.py

@@ -0,0 +1,92 @@
+from pathlib import Path
+
+from .ProfusionAnnotationLoader import ProfusionAnnotationLoader
+from pyPhasesRecordloader.recordLoaders.EDFRecordLoader import EDFRecordLoader
+from pyPhasesRecordloader.recordLoaders.CSVMetaLoader import CSVMetaLoader
+
+
+class RecordLoaderProfusion(EDFRecordLoader):
+
+    def loadAnnotation(self, recordId, fileName, valueMap=None):
+        filePath = self.getFilePathAnnotation(recordId)
+        annotationLoader = ProfusionAnnotationLoader.load(filePath, valueMap, self.annotationFrequency)
+
+        return annotationLoader.events
+
+    def getEventList(self, recordName, targetFrequency=1):
+        metaXML = self.getFilePathAnnotation(recordName)
+        xmlLoader = ProfusionAnnotationLoader()
+
+        eventArray = xmlLoader.loadAnnotation(metaXML)
+        self.lightOff = xmlLoader.lightOff
+        self.lightOn = xmlLoader.lightOn
+
+        if targetFrequency != 1:
+            eventArray = self.updateFrequencyForEventList(eventArray, targetFrequency)
+
+        return eventArray
+    
+    def getRelevantCols(self):
+        return {
+            "gender": lambda row: "male" if row["gender"] == 1 else "female",
+            "age": "age_s1",
+            "bmi": "bmi_s1",
+            "tst": "slpprdp", # slptime in v.15
+            "sLatency": "slplatp",
+            "rLatency": "remlaiip",
+            "waso": "waso",
+            "sEfficiency": "slpeffp",
+            "indexArousal": "ai_all",
+            # countArousal
+            "ArREMBP": "arrembp",
+            "ArREMOP": "arremop",
+            "ArNREMBP": "arnrembp",
+            "ArNREMOP": "arnremop",
+            "ahi": "ahi_a0h4a",
+            "bp_diastolic": "diasbp",
+            "bp_systolic": "systbp",
+            "race": "race", 
+            # % N1, N2, N3, R
+            # therapy / diagnostics
+            # Diagnosis
+            # PLMSI
+            # PLMSIArI
+        }
+
+    def getMetaData2(self, recordName, loadMetadataFromCSV=True):
+        pass
+    
+    def getMetaData(self, recordName, loadMetadataFromCSV=True):
+        metaData = super().getMetaData(recordName)
+        metaData["recordId"] = recordName
+
+        return metaData
+    
+    def getAllMetaData(self, visit=1):
+        relevantCols = self.getRelevantCols()
+        csvLoader = CSVMetaLoader(
+            f"{self.filePath}/datasets/Profusion{visit}-dataset-0.20.0.csv", idColumn="nsrrid", relevantRows=relevantCols
+        )
+        csvMetaData = csvLoader.getAllMetaData()
+        csvMetaData["countArousal"] = csvMetaData["ArREMBP"] + csvMetaData["ArREMOP"] + csvMetaData["ArNREMBP"] + csvMetaData["ArNREMOP"]
+
+        # append Profusion1 to recordId
+        csvMetaData["recordId"] = f"Profusion{visit}-" + csvMetaData["recordId"].astype(str)
+
+        return csvMetaData
+
+    def getSubjectId(self, recordId):
+        return recordId
+    
+    def getSessionId(self, recordId):
+        return "1"
+    
+    
+    # Compumedics P-series Sleep Monitoring system, version 3
+    def getDICOMMetadata(self, recordId):
+        return {
+            "Manufacturer": "Compumedics",
+            "ManufacturerModelName": "Profusion 5",
+            "DeviceSerialNumber": "TBD",
+            "SoftwareVersions": "Profusion 5",
+        }

pyphasesrecordloaderprofusion-0.1.0/pyPhasesRecordloaderProfusion.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: pyPhasesRecordloaderProfusion
+Version: 0.1.0
+Summary: Adds a record loaders to the pyPhases package
+Home-page: https://gitlab.com/tud.ibmt.public/pyphases/pyPhasesRecordloaderProfusion/
+Author: Franz Ehrlich
+Author-email: fehrlichd@gmail.com
+License: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.5
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyPhases
+Requires-Dist: pyPhasesRecordloader
+Requires-Dist: pyedflib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Extension for pyPhasesRecordloader
+
+
+
+## Usage
+
+In a phase you can access the data through the `RecordLoader`:
+
+Add the plugins and config values to your project.yaml::
+
+```yaml
+name: ProfusionProject
+plugins:
+  - pyPhasesML
+  - pyPhasesRecordloaderProfusion
+  - pyPhasesRecordloader
+
+phases:
+  - name: MyPhase
+
+config:
+  profusion-path: C:/datasets/recordings
+
+```
+
+In a phase (`phases/MyPhase.py`) you can access the records using the `RecordLoader`:
+
+```python
+from pyPhasesRecordloader import RecordLoader
+from pyPhases import Phase
+
+class MyPhase(Phase):
+    def run(self):
+      recordIds = recordLoader.getRecordList()
+      for recordId in recordIds:
+        record = recordLoader.getRecord(recordId)
+```
+
+Run your project with `python -m phases run MyPhase`.

pyphasesrecordloaderprofusion-0.1.0/pyPhasesRecordloaderProfusion.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+./.gitlab-ci.yml
+./pyPhasesRecordloaderProfusion/config.yaml
+pyPhasesRecordloaderProfusion/Plugin.py
+pyPhasesRecordloaderProfusion/__init__.py
+pyPhasesRecordloaderProfusion/config.yaml
+pyPhasesRecordloaderProfusion.egg-info/PKG-INFO
+pyPhasesRecordloaderProfusion.egg-info/SOURCES.txt
+pyPhasesRecordloaderProfusion.egg-info/dependency_links.txt
+pyPhasesRecordloaderProfusion.egg-info/requires.txt
+pyPhasesRecordloaderProfusion.egg-info/top_level.txt
+pyPhasesRecordloaderProfusion/recordLoaders/ProfusionAnnotationLoader.py
+pyPhasesRecordloaderProfusion/recordLoaders/RecordLoaderProfusion.py
+pyPhasesRecordloaderProfusion/recordLoaders/__init__.py

pyphasesrecordloaderprofusion-0.1.0/pyPhasesRecordloaderProfusion.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyphasesrecordloaderprofusion-0.1.0/pyPhasesRecordloaderProfusion.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pyPhases
+pyPhasesRecordloader
+pyedflib

pyphasesrecordloaderprofusion-0.1.0/pyPhasesRecordloaderProfusion.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+pyPhasesRecordloaderProfusion
+tests

pyphasesrecordloaderprofusion-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyphasesrecordloaderprofusion-0.1.0/setup.py

@@ -0,0 +1,25 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="pyPhasesRecordloaderProfusion",
+    version="v0.1.0"[1:],
+    author="Franz Ehrlich",
+    author_email="fehrlichd@gmail.com",
+    description="Adds a record loaders to the pyPhases package",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://gitlab.com/tud.ibmt.public/pyphases/pyPhasesRecordloaderProfusion/",
+    packages=setuptools.find_packages(),
+    include_package_data=True,
+    package_data={"pyPhasesRecordloaderProfusion": ["**/*.yaml"]},
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+    install_requires=["pyPhases", "pyPhasesRecordloader", "pyedflib"],
+    python_requires=">=3.5",
+    license="License :: OSI Approved :: MIT License"
+)