ctp-client 1.0.1__py3-none-any.whl

ctp_client-1.0.1.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: ctp-client
+Version: 1.0.1
+Summary: ctp-client is a Python client for [Clinical Trials Processor](https://mircwiki.rsna.org/index.php?title=MIRC_CTP).
+Project-URL: CI/CD, https://gitlab.com/radiology/infrastructure/data-curation-tools/ctp-client/-/pipelines
+Project-URL: Changelog, https://ctp-client.readthedocs.io/en/latest/changelog.html
+Project-URL: Documentation, https://ctp-client.readthedocs.io
+Project-URL: Download, https://gitlab.com/radiology/infrastructure/data-curation-tools/ctp-client/-/archive/master/ctp-client-master.zip
+Project-URL: Homepage, https://gitlab.com/radiology/infrastructure/data-curation-tools/ctp-client.git
+Project-URL: Issues, https://gitlab.com/radiology/infrastructure/data-curation-tools/ctp-client/-/issues
+Author-email: BIGR Imaging Infrastructure Group <imaging.infrastructure@erasmusmc.nl>
+License: Apache 2.0
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: System :: Logging
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Requires-Dist: beautifulsoup4==4.12.3
+Requires-Dist: click-log==0.4.0
+Requires-Dist: click-loglevel==0.5.1
+Requires-Dist: click==8.1.3
+Requires-Dist: pydantic==2.10.3
+Requires-Dist: pyyaml==6.0.2
+Requires-Dist: requests>=2.22.0
+Requires-Dist: tabulate==0.9.0
+Description-Content-Type: text/markdown
+
+# CTPy
+
+CTPy is a Python client for [Clinical Trials Processor](https://mircwiki.rsna.org/index.php?title=MIRC_CTP).

ctp_client-1.0.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+ctpy/__init__.py,sha256=EP3GZi8JGn1trSB9AoYk0mEaeKPepvt6y41TOKl3mCs,1446
+ctpy/client.py,sha256=TystTq56n5U-i405s7aKg0saT4EauNDpiveM1mnyIVs,9964
+ctpy/exceptions.py,sha256=MfOIIsysalSGq0Q5zjoFygEQT1Fxhl9_clad-k_TDAw,1144
+ctpy/helpers.py,sha256=eU6Bapl7PZJSPmwE6bU3Bw1bGBbFsMWtEreb0d62R_Y,7390
+ctpy/version.py,sha256=Zk7F83QsYfUU3p4V3lMkE5OwMPMEZAUNWBZQoj7REW0,455
+ctpy/cli/__init__.py,sha256=F5erEag1v1NfNPQl2UFpuL49vmT2W4hXaTqkTCi-WsA,710
+ctpy/cli/cli.py,sha256=RyCcXVZMwgMv2dxVgO5GCAwzfXHuZIYD-FlIWsHfGPU,7307
+ctpy/core/__init__.py,sha256=ENrDRrf2Ur_jU1nEHhx_3P9Od4Sk6qRMjxUyxrmpyyk,782
+ctpy/core/pipeline.py,sha256=CVWYMa6Wz6ps6Huj6d8ffxfD1qd8DbIZuoJ26YpykNg,1279
+ctpy/core/server.py,sha256=GEpjcn25A2wGveJVQ7KsjvSysMeNbUFfu4LeVFKzFMk,1949
+ctpy/core/stages.py,sha256=oDd3NOMBuuyrBiabJPN70m_Vp4mnz-lrPDz0xY5Quss,5865
+ctpy/tests/mock.py,sha256=jFU2d9mM9IEtgjqtIpWouAypo3UsCM9c7hEdhKAb3DY,1189
+ctpy/tests/test_init.py,sha256=iAc-l17rVRyhVlUxByHENGVRnZbkc_EXVDaVG5WE_I4,649
+ctp_client-1.0.1.dist-info/METADATA,sha256=FQtuc_mv023nefnuDN1Qdc5I67YkAsCJo1tA4Q-JUxY,2228
+ctp_client-1.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ctp_client-1.0.1.dist-info/entry_points.txt,sha256=wKTrCeAZoSgYSpds8OJnxIjHki5cGIupxs6TJmmlt9s,38
+ctp_client-1.0.1.dist-info/licenses/LICENSE,sha256=ohsbe-1180tqV0K-E81i4S5MMEHucR1lLirw3LvIpXw,665
+ctp_client-1.0.1.dist-info/RECORD,,

ctp_client-1.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ctp_client-1.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ctpy = ctpy.cli:cli

ctp_client-1.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,14 @@
+Copyright 2017 Biomedical Imaging Group Rotterdam, Departments of
+Medical Informatics and Radiology, Erasmus MC, Rotterdam, The Netherlands
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

ctpy/__init__.py

@@ -0,0 +1,43 @@
+# Copyright 2017 Biomedical Imaging Group Rotterdam, Departments of
+# Medical Informatics and Radiology, Erasmus MC, Rotterdam, The Netherlands
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from typing import Optional
+
+from .import version
+from .client import CTPYclient
+
+__version__ = version.version
+
+
+def connect(host: str,
+            port: int,
+            username: str,
+            password: str,
+            rate_limit: Optional[int] = None) -> CTPYclient:
+    """
+    Createa a connection to a CTP server
+
+    :param host: host to connect to
+    :param port: port to connect to
+    :param username: username to login as
+    :param password: password for user
+    :param rate_limit: optionally limit the time between requests, this is specified
+                       as the maximum requests per second
+
+    :return: CTP client object
+    """
+    ctpy_client = CTPYclient(host, port, username, password, rate_limit)
+    return ctpy_client

ctpy/cli/__init__.py

@@ -0,0 +1,17 @@
+# Copyright 2017 Biomedical Imaging Group Rotterdam, Departments of
+# Medical Informatics and Radiology, Erasmus MC, Rotterdam, The Netherlands
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from .cli import cli

ctpy/cli/cli.py

@@ -0,0 +1,157 @@
+# Copyright 2017 Biomedical Imaging Group Rotterdam, Departments of
+# Medical Informatics and Radiology, Erasmus MC, Rotterdam, The Netherlands
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import socket
+import logging
+from pathlib import Path
+
+import click
+import tabulate
+from click_loglevel import LogLevel
+import yaml
+from yaml.loader import SafeLoader
+
+from ctpy import CTPYclient
+from ctpy import exceptions
+from ctpy.helpers import poll_object_tracker_for_studyuid, summarize_object_tracker_content
+
+@click.group()
+@click.version_option()
+@click.pass_context
+def cli(ctx):
+    ctx.ensure_object(dict)
+
+@cli.command()
+@click.option('--lookup-table-filename', type=Path, required=True)
+@click.option('--ctp-host', required=True)
+@click.option('--ctp-port', type=int, default=1180, required=True)
+@click.option('--dicom-anonymizer-id', required=True)
+@click.option('--username', required=True)
+@click.option('--password', required=True, prompt=True, hide_input=True)
+@click.option('--log-level', type=LogLevel(), default=logging.INFO)
+@click.pass_context
+def post_lookup_table(_, lookup_table_filename, ctp_host, ctp_port,
+                        dicom_anonymizer_id, username, password, log_level):
+    logging.basicConfig(
+        format=f"%(asctime)s - {socket.gethostname()} - [%(levelname)-8s] %(message)s",
+        level=log_level,
+    )
+    ctpy_client = CTPYclient(ctp_host, ctp_port, username, password, rate_limit=0.2)
+    with open(lookup_table_filename, encoding='utf-8') as lookup_table_file:
+        lut = yaml.load(lookup_table_file, Loader=SafeLoader)
+        for key, value in lut.items():
+            try:
+                ctpy_client.add_to_lookup(dicom_anonymizer_id, key, value)
+            except exceptions.CTPYFailedAddingLUT:
+                pass
+            break
+
+@cli.command()
+@click.option('--ctp-host', required=True)
+@click.option('--ctp-port', type=int, default=1180, required=True)
+@click.option('--pipeline-id', type=int, default=0, required=True)
+@click.option('--object-tracker-id', type=int, default=1, required=True)
+@click.option('--username', required=True, default="king")
+@click.option('--password', required=True, default="password", prompt=True, hide_input=True)
+@click.option('--patient-id', required=True)
+@click.option('--study-uid', 'study_uid_filter')
+@click.option('--delay', type=int, default=5)
+@click.option('--timeout', type=int, default=900)
+@click.option('--log-level', type=LogLevel(), default=logging.INFO)
+@click.pass_context
+def check_object_tracker(_, ctp_host, ctp_port, pipeline_id, object_tracker_id,
+                         username, password, patient_id, study_uid_filter, delay,
+                         timeout, log_level):
+    logging.basicConfig(
+        format=f"%(asctime)s - {socket.gethostname()} - [%(levelname)-8s] %(message)s",
+        level=log_level,
+    )
+    ctpy_client = CTPYclient(ctp_host, ctp_port, username, password, rate_limit=0.2)
+    object_tracker_data = poll_object_tracker_for_studyuid(ctpy_client,
+                                                           pipeline_id,
+                                                           object_tracker_id,
+                                                           patient_id,
+                                                           study_uid_filter,
+                                                           delay,
+                                                           timeout)
+    logging.debug('patient_data: %s', object_tracker_data)
+    if object_tracker_data and patient_id in object_tracker_data:
+        for study_uid, series_info in object_tracker_data[patient_id].items():
+            for series_uid, instances in series_info.items():
+                logging.info('%s|%s|%s', study_uid, series_uid, instances)
+
+@cli.command()
+@click.option('--ctp-host', required=True)
+@click.option('--ctp-port', type=int, default=1180, required=True)
+@click.option('--pipeline-id', type=int, default=0, required=True)
+@click.option('--idmap-id', type=int, default=1, required=True)
+@click.option('--username', required=True, default="king")
+@click.option('--password', required=True, default="password", prompt=True, hide_input=True)
+@click.option('--keytype', required=True)
+@click.option('--key', required=True)
+@click.option('--log-level', type=LogLevel(), default=logging.INFO)
+@click.pass_context
+def query_idmap(_, ctp_host, ctp_port, pipeline_id, idmap_id, keytype, key,
+                username, password, log_level):
+    logging.basicConfig(
+        format=f"%(asctime)s - {socket.gethostname()} - [%(levelname)-8s] %(message)s",
+        level=log_level,
+    )
+    ctpy_client = CTPYclient(ctp_host, ctp_port, username, password, rate_limit=0.2)
+    study_uid = ctpy_client.idmap_search(pipeline_id, idmap_id, key, keytype)
+    if study_uid:
+        logging.info(study_uid)
+
+
+@cli.command()
+@click.option('--ctp-host', required=True)
+@click.option('--ctp-port', type=int, default=1180, required=True)
+@click.option('--username', required=False)
+@click.option('--password', required=False)
+def get_summary(ctp_host, ctp_port, username, password):
+    logging.basicConfig(
+        format=f"%(asctime)s - {socket.gethostname()} - [%(levelname)-8s] %(message)s",
+        level='INFO',
+    )
+    ctpy_client = CTPYclient(ctp_host, ctp_port, username, password, rate_limit=0.2)
+    summary = ctpy_client.get_ctp_summary()
+    logging.info(f"\n{tabulate.tabulate([s.to_table_row() for s in summary], headers=['pipeline', 'import', 'export', 'quarantines'])}")
+
+
+@cli.command()
+@click.option('--ctp-host', required=True)
+@click.option('--ctp-port', type=int, default=1180, required=True)
+@click.option('--username', required=True)
+@click.option('--password', required=True)
+@click.option('--pipeline-name', required=True)
+def get_tracker_summary(ctp_host, ctp_port, username, password, pipeline_name):
+    logging.basicConfig(
+        format=f"%(asctime)s - {socket.gethostname()} - [%(levelname)-8s] %(message)s",
+        level='INFO',
+    )
+    
+    ctpy_client = CTPYclient(ctp_host, ctp_port, username, password, rate_limit=0.2)
+    pipeline = ctpy_client.server.pipelines.get(pipeline_name)
+    if pipeline is None:
+        raise exceptions.CTPYPipelineNotFound(f"Pipeline {pipeline_name} not found!")
+    
+    trackers_summary = list()
+    object_trackers = ctpy_client.find_object_tracker_stages(pipeline)
+    for tracker_id, object_tracker in object_trackers:
+        object_tracker_contents = ctpy_client.get_object_tracker_patient_info(pipeline_id=pipeline.pipeline_id, stage_id=tracker_id)
+                
+        trackers_summary.append([object_tracker.name, *summarize_object_tracker_content(object_tracker_contents)])
+    logging.info(f"\n{tabulate.tabulate(trackers_summary, headers=['name', 'subjects', 'experiments', 'scans', 'instances'])}")

ctpy/client.py

@@ -0,0 +1,265 @@
+# Copyright 2022 Biomedical Imaging Group Rotterdam, Department of
+# Radiology, Erasmus MC, Rotterdam, The Netherlands
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import logging
+import re
+from time import time, sleep
+from typing import Dict, List, Optional
+
+import requests
+from requests.exceptions import ConnectionError as RequestsConnectionError
+
+from ctpy import exceptions
+from ctpy.core import CTPServer
+from ctpy.core.stages import ObjectTracker
+from ctpy.helpers import parse_idmap_results, parse_object_tracker_results, parse_summary, parse_step, CtpSummary
+
+
+class CTPYclient():
+
+    def __init__(self, host: str, port: int, username: str, password: str, rate_limit: Optional[int] = None):
+        self.host: str = host
+        self.port: int = port
+        self.headers: Dict[str, str] = {}
+
+        if username is None:
+            logging.debug(f'No username information')
+            self.session: requests.Session = requests.Session()
+        else:
+            logging.debug(f'Log in as user: {username}')
+            self.session: requests.Session = self._login(username, password)
+
+        self.rate_limit: int = rate_limit
+        self.server: CTPServer = CTPServer(self)
+
+    def _login(self, username: str, password: str) -> requests.Session:
+        cookies = {
+            'CTP': 'session',
+        }
+
+        headers = {
+            'Connection': 'keep-alive',
+            'Referer': f'{self.host}:{self.port}/',
+        }
+
+        timestamp = int(time())
+        query = f'username={username}&password={password}&url=/&timestamp={timestamp}'
+        login_uri = f'{self.host}:{self.port}/login?{query}'
+        logging.debug(f'Logging in using url: {login_uri}')
+        try:
+            response = requests.get(login_uri, cookies=cookies,
+                                    headers=headers, allow_redirects=False)
+            logging.debug(f'got response: {response}')
+        except RequestsConnectionError as esc:
+            raise exceptions.CTPYLoginException(esc)
+
+        if response.status_code == 302 and 'RSNASESSION' in response.cookies:
+            logging.debug('Succesfully connected to CTP')
+            session = requests.Session()
+            session.cookies.update({
+                'RSNASESSION': response.cookies['RSNASESSION']
+            })
+        else:
+            raise exceptions.CTPYLoginException
+        return session
+
+    def _rate_limit(self):
+        if self.rate_limit:
+            sleep(1 / self.rate_limit)
+
+    def format_uri(self, path: str, query: Optional[str] = None) -> str:
+        if path and path[0] != '/':
+            path = '/' + path
+        if query and query[0] != '?':
+            query = '?' + query
+
+        if not query:
+            query = ''
+        if not path:
+            path = ''
+
+        return f'{self.host}:{self.port}{path}{query}'
+
+    def get(self,
+            path: str,
+            query: Optional[str] = None,
+            timeout: Optional[float] = None,
+            headers: Dict[str, str] = None) -> requests.Response:
+        """
+        Process a REST GET to the server
+
+        :param path: path for the request
+        :param query: query string to use for the request
+        :param timeout: timeout
+        :param headers: request headers
+        :return: requests response
+        """
+        uri = self.format_uri(path, query)
+        logging.debug('GET: %s', uri)
+        self._rate_limit()
+        try:
+            response = self.session.get(uri, timeout=timeout, headers=headers)
+        except RequestsConnectionError as esc:
+            raise exceptions.CTPYConnectionAborted(esc)
+        return response
+
+    def put(self,
+            path: str,
+            query: Optional[str] = None,
+            timeout: Optional[float] = None,
+            headers: Dict[str, str] = None) -> requests.Response:
+        uri = self.format_uri(path, query)
+        logging.debug('PUT: %s', uri)
+        self._rate_limit()
+        try:
+            response = self.session.put(uri, timeout=timeout, headers=headers)
+        except RequestsConnectionError as esc:
+            raise exceptions.CTPYConnectionAborted(esc)
+        return response
+
+    def post(self,
+             path: str,
+             data,
+             query: Optional[str] = None,
+             timeout: Optional[float] = None,
+             headers: Dict[str, str] = None) -> requests.Response:
+        uri = self.format_uri(path, query)
+        logging.debug('POST: %s', uri)
+        self._rate_limit()
+        try:
+            response = self.session.post(uri, data=data, timeout=timeout, headers=headers)
+        except RequestsConnectionError as esc:
+            raise exceptions.CTPYConnectionAborted(esc)
+        return response
+
+    def get_ctp_summary(self) -> List[CtpSummary]:
+        response = self.get('/summary?suppress')
+        if response.status_code == 200:
+            logging.debug('Succesfully got html')
+        elif response.status_code == 403:
+            logging.error('Forbidden')
+            raise exceptions.CTPYAccessException
+        else:
+            raise exceptions.CTPYGeneralError
+
+        results = parse_summary(response.content)
+        return results
+
+    def get_ctp_step(self, pipeline: int, step: int) -> Dict[str, Dict[str, str]]:
+        response = self.get(f'/summary?p={pipeline}&s={step}&suppress')
+        print(f"{response.status_code}=")
+
+        if response.status_code == 200:
+            logging.debug('Succesfully got html')
+        elif response.status_code == 403:
+            logging.error('Forbidden')
+            raise exceptions.CTPYAccessException
+        else:
+            raise exceptions.CTPYGeneralError
+
+        if "<title>ERROR</title>" in response.text:
+            match = re.search("java.lang.IndexOutOfBoundsException: Index (\d+) out of bounds for length (\d+)", response.text)
+
+            if match:
+                index = match.group(1)
+                length = match.group(2)
+
+                raise IndexError(f"Index out of range {index=} {length=}")
+            else:
+                raise exceptions.CTPYGeneralError
+
+        results = parse_step(response.content)
+        return results
+
+    def add_to_lookup(self, stage_id, key, value):
+        query = f'id={stage_id}&key={key}&value={value}'
+        response = self.put('/lookup', query)
+        if response.status_code == 200:
+            logging.info('Succesfully added Key/Value')
+        elif response.status_code == 304:
+            logging.warning('Did not modified key/value')
+            raise exceptions.CTPYFailedAddingLUT
+        elif response.status_code == 403:
+            logging.error('Forbidden')
+            raise exceptions.CTPYAccessException
+        else:
+            raise exceptions.CTPYGeneralError
+        # logging.debug(response.content)
+
+    def get_object_tracker_patient_info(self, pipeline_id, stage_id, key='', patient_id=None, study_uid_filter=None):
+        # headers = self.headers.copy()
+        headers = {}
+        headers['Referer'] = f'{self.host}:{self.port}/objecttracker'
+        data = {
+            'p': str(pipeline_id),
+            's': str(stage_id),
+            'suppress': '',
+            'keytype': 'patient',
+            'keys': key,
+            'format': 'csv'
+        }
+        response = self.post('objecttracker',
+                             headers=headers,
+                             data=data)
+        if response.status_code != 200:
+            logging.debug(response.text)
+            return None
+        logging.debug(f'Results: {response.text}')
+
+        object_tracker_dict = parse_object_tracker_results(response.text, patient_id, study_uid_filter)
+        return object_tracker_dict
+
+    def idmap_search(self, pipeline_id, stage_id, key, keytype):
+        headers = self.headers.copy()
+        headers['Referer'] = f'{self.host}:{self.port}/idmap'
+        data ={
+            "p": str(pipeline_id),
+            "s": str(stage_id),
+            "suppress": "",
+            "keytype": keytype,
+            "keys": str(key),
+            "format": "csv"
+        }
+        logging.debug(f'Querying ID-map at {pipeline_id};{stage_id}')
+        response = self.session.post(f'{self.host}:{self.port}/idmap',
+                                 headers=headers,
+                                 data=data)
+        if response.status_code != 200:
+            logging.debug(f'Got {response.status_code}')
+            logging.debug(response.text)
+            return None
+
+        new_id = parse_idmap_results(response.text)
+        return new_id
+
+    def idmap_search_uid(self, pipeline_id, stage_id, key):
+        return self.idmap_search(pipeline_id, stage_id, key, keytype="originalUID")
+
+    def idmap_reverse_search_uid(self, pipeline_id, stage_id, key):
+        return self.idmap_search(pipeline_id, stage_id, key, keytype="trialUID")
+
+    def idmap_search_patientid(self, pipeline_id, stage_id, key):
+        return self.idmap_search(pipeline_id, stage_id, key, keytype="originalPtID")
+
+    def idmap_reverse_search_patientid(self, pipeline_id, stage_id, key):
+        return self.idmap_search(pipeline_id, stage_id, key, keytype="trialPtID")
+
+    def find_object_tracker_stages(self, pipeline):
+        object_trackers = [stage for stage in pipeline.stages.items() if isinstance(stage[1], ObjectTracker)]
+        if object_trackers:
+            return object_trackers
+        else:
+            raise exceptions.CTPYNoObjectTrackerFound(f"No ObjectTracker stages found in pipeline {pipeline.pipeline_id}!")

ctpy/core/__init__.py

@@ -0,0 +1,18 @@
+# Copyright 2017 Biomedical Imaging Group Rotterdam, Departments of
+# Medical Informatics and Radiology, Erasmus MC, Rotterdam, The Netherlands
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .pipeline import Pipeline
+from .server import CTPServer
+from .stages import StageFactory

ctpy/core/pipeline.py

@@ -0,0 +1,33 @@
+# Copyright 2017 Biomedical Imaging Group Rotterdam, Departments of
+# Medical Informatics and Radiology, Erasmus MC, Rotterdam, The Netherlands
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import logging
+
+from ctpy.core.stages import StageFactory
+
+
+class Pipeline():
+    def __init__(self, server, pipeline_id, pipeline):
+        self.server = server
+        self.pipeline_id = pipeline_id
+        self.stages = {}
+        for stage_id, stage in enumerate(pipeline):
+            logging.debug('Create stage:<%s> <%s>', stage_id, stage)
+            ctp_stage = StageFactory.create_stage(self, stage_id, stage.attrib)
+            if id in stage.attrib:
+                self.stages[stage.attrib['id']] = ctp_stage
+            else:
+                self.stages[stage_id] = ctp_stage

ctpy/core/server.py

@@ -0,0 +1,50 @@
+# Copyright 2017 Biomedical Imaging Group Rotterdam, Departments of
+# Medical Informatics and Radiology, Erasmus MC, Rotterdam, The Netherlands
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import xml.etree.ElementTree as ET
+from xml.etree.ElementTree import ParseError
+
+from ctpy import exceptions
+from ctpy.core import Pipeline
+
+
+class CTPServer():
+    def __init__(self, ctpy_session):
+        self.ctpy_session = ctpy_session
+        response = self.ctpy_session.get('server')
+        if response.status_code != 200:
+            raise exceptions.CTPYServerXMLParseError()
+        xml_string = response.text
+        try:
+            server = ET.fromstring(xml_string)
+        except ParseError as exc:
+            raise exceptions.CTPYServerXMLParseError(exc)
+
+        # {'build': '2021.04.01 at 11:04:40 CDT', 'ip': '10.42.0.83', 'java': '1.7', 'port': '1080'}
+        self.build = server.attrib['build']
+        self.ip = server.attrib['ip']
+        self.java = server.attrib['java']
+        self.port = server.attrib['port']
+        self.pipelines = {}
+
+        for configuration in server:
+            if configuration.tag != 'Configuration':
+                raise exceptions.CTPYServerXMLParseError
+            pipeline_id = 0
+            for child in configuration:
+                if child.tag == 'Pipeline':
+                    self.pipelines[child.attrib['name']] = Pipeline(self, pipeline_id, child)
+                    pipeline_id += 1

ctpy/core/stages.py

@@ -0,0 +1,153 @@
+# Copyright 2017 Biomedical Imaging Group Rotterdam, Departments of
+# Medical Informatics and Radiology, Erasmus MC, Rotterdam, The Netherlands
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import logging
+
+from ctpy import exceptions
+from ctpy.helpers import parse_idmap_results, parse_object_tracker_results
+
+
+class StageFactory:
+    @classmethod
+    def create_stage(cls, pipeline, stage_id, stage_config):
+        stage_class = stage_config['class'].split('.')[-1]
+
+        sanitized_config = cls._sanitize_config(stage_config)
+        logging.debug('Creating stage: %s', stage_class)
+        logging.debug('Creating stage: %s', sanitized_config)
+
+        if stage_class == 'IDMap':
+            return IDMap(pipeline, stage_id, **sanitized_config)
+        if stage_class == 'DicomAnonymizer':
+            return DicomAnonymizer(pipeline, stage_id, **sanitized_config)
+        if stage_class == 'DicomFilter':
+            return DicomFilter(pipeline, stage_id, **sanitized_config)
+        if stage_class == 'DicomPixelAnonymizer':
+            return DicomPixelAnonymizer(pipeline, stage_id, **sanitized_config)
+        if stage_class == 'ObjectTracker':
+            return ObjectTracker(pipeline, stage_id, **sanitized_config)
+
+        return BaseStage(pipeline, stage_id, **sanitized_config)
+
+    @classmethod
+    def _sanitize_config(cls, stage_config):
+        sanitized_config = {}
+        if 'class' not in stage_config or 'root' not in stage_config:
+            raise exceptions.CTPYStageParseError
+        sanitized_config['stage_class'] = stage_config['class']
+        sanitized_config['root'] = stage_config['root']
+
+        accepted_keys = ['id', 'root', 'quarantine', 'lookup_table', 'script', 'name', 'script']
+
+        for key in accepted_keys:
+            if key in stage_config:
+                sanitized_config[key] = stage_config[key]
+        return sanitized_config
+
+
+class BaseStage():
+    def __init__(self, pipeline, stage_id, stage_class, root, id=None, quarantine=None, name=None):
+        self.id = id
+        self.stage_id = stage_id
+        self.pipeline = pipeline
+        self.stage_class = stage_class
+        self.root = root
+        self.quarantine = quarantine
+        self.name = name
+
+    def __str__(self):
+        return f'This Stage is of type: {type(self).__name__}'
+
+
+class ObjectTracker(BaseStage):
+    def query_patientids(self, key, study_uid_filter=None):
+        headers = {}
+        headers['Referer'] = self.pipeline.server.ctpy_session.format_uri('/objecttracker')
+        data = {
+            'p': str(self.pipeline.pipeline_id),
+            's': str(self.id),
+            'suppress': '',
+            'keytype': 'patient',
+            'keys': key,
+            'format': 'csv'
+        }
+        response = self.pipeline.server.ctpy_session.post('objecttracker',
+                             headers=headers,
+                             data=data)
+        if response.status_code != 200:
+            logging.debug(response.text)
+            return None
+        object_tracker_dict = parse_object_tracker_results(response.text, study_uid_filter)
+        return object_tracker_dict
+
+
+class IDMap(BaseStage):
+    def search(self, key, keytype):
+        headers = {}
+        headers['Referer'] = self.pipeline.server.ctpy_session.format_uri('/idmap')
+        data ={
+            'p': str(self.pipeline.pipeline_id),
+            's': str(self.id),
+            "suppress": "",
+            "keytype": keytype,
+            "keys": str(key),
+            "format": "csv"
+        }
+
+        response = self.pipeline.server.ctpy_session.post('idmap',
+                                 headers=headers,
+                                 data=data)
+        if response.status_code != 200:
+            logging.debug(response.text)
+            return None
+
+        new_id = parse_idmap_results(response.text)
+        return new_id
+
+
+class DicomFilter(BaseStage):
+    def __init__(self, pipeline, stage_id, stage_class, root,
+                 id=None, name=None, quarantine=None, script=None):
+        super().__init__(pipeline, stage_class, root, name, quarantine=quarantine, name=name, id=id)
+        self.script = script
+
+
+class DicomAnonymizer(BaseStage):
+    def __init__(self, pipeline, stage_id, stage_class, root, id,
+                 name=None, quarantine=None, script=None, lookup_table=None):
+        super().__init__(pipeline, stage_id, stage_class, root, quarantine=quarantine, name=name, id=id)
+        self.lookup_table = lookup_table
+        self.script = script
+
+    def add_key(self, key, value):
+        query = f'id={self.id}&key={key}&value={value}'
+        response = self.pipeline.server.ctpy_session.put('/lookup', query)
+        if response.status_code == 200:
+            logging.info('Succesfully added Key/Value')
+        elif response.status_code == 304:
+            logging.warning('Did not modified key/value')
+            raise exceptions.CTPYFailedAddingLUT
+        elif response.status_code == 403:
+            logging.error('Forbidden')
+            raise exceptions.CTPYAccessException
+        else:
+            raise exceptions.CTPYGeneralError
+
+class DicomPixelAnonymizer(BaseStage):
+    def __init__(self, pipeline, stage_id, stage_class,
+                 name=None, root=None, quarantine=None, script=None):
+        super().__init__(pipeline, stage_class, root, name)
+        self.script = script

ctpy/exceptions.py

@@ -0,0 +1,45 @@
+# Copyright 2022 Biomedical Imaging Group Rotterdam, Department of
+# Radiology, Erasmus MC, Rotterdam, The Netherlands
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class CTPYFailedAddingLUT(Exception):
+    pass
+
+class CTPYNoObjectTrackerFound(Exception):
+    pass
+
+class CTPYPipelineNotFound(Exception):
+    pass
+
+class CTPYLoginException(Exception):
+    pass
+
+class CTPYSSLError(Exception):
+    pass
+
+class CTPYAccessException(Exception):
+    pass
+
+class CTPYServerXMLParseError(Exception):
+    pass
+
+class CTPYConnectionAborted(Exception):
+    pass
+
+class CTPYStageParseError(Exception):
+    pass
+
+class CTPYGeneralError(Exception):
+    pass

ctpy/helpers.py

@@ -0,0 +1,188 @@
+# Copyright 2017 Biomedical Imaging Group Rotterdam, Departments of
+# Medical Informatics and Radiology, Erasmus MC, Rotterdam, The Netherlands
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from time import sleep, time
+import logging
+import datetime
+from typing import Dict, List, Optional, Union
+
+import bs4
+from pydantic import BaseModel, Field, AliasChoices, field_validator
+
+
+def parse_object_tracker_results(object_tracker_string: str,
+                                 patient_id_filter: Optional[str] = None,
+                                 study_uid_filter: Optional[str] = None) -> Union[None, Dict[str, Dict[str, Dict[str, str]]]]:
+    try:
+        data = object_tracker_string.split()[1:]
+    except IndexError:
+        return None
+    object_tracker_dict = {}
+    for row in data:
+        row = row.split(',')
+        patient_id = row[0]
+        study_uid = row[1]
+        series_uid = row[2]
+        instances = int(row[3])
+        if patient_id_filter and not patient_id == patient_id_filter:
+            logging.debug('Filtering Patient: %s not equal: %s', patient_id, patient_id_filter)
+            continue
+        if study_uid_filter and not study_uid == study_uid_filter:
+            logging.debug('Filtering StudyUID: %s', study_uid, study_uid_filter)
+            continue
+        if patient_id in object_tracker_dict:
+            if study_uid in object_tracker_dict[patient_id]:
+                if series_uid in object_tracker_dict[patient_id][study_uid]:
+                    object_tracker_dict[patient_id][study_uid][series_uid] = instances
+                    logging.debug('Update %s to object_tracker_dict', instances)
+                else:
+                    object_tracker_dict[patient_id][study_uid][series_uid] = instances
+                    logging.debug('Add %s to object_tracker_dict', instances)
+            else:
+                object_tracker_dict[patient_id][study_uid] = {series_uid: instances}
+                logging.debug('Add %s|%s;%s to object_tracker_dict',
+                                study_uid, series_uid, instances)
+        else:
+            logging.debug('Add %s|%s|%s;%s to object_tracker_dict',
+                            patient_id, study_uid, series_uid, instances)
+            object_tracker_dict[patient_id] = {study_uid: {series_uid: instances}}
+    return object_tracker_dict
+
+
+def parse_idmap_results(idmap_string: str) -> Union[None, str]:
+    logging.debug(f'idmap: {idmap_string}')
+    lines = idmap_string.split('\n')
+    _, new = lines[1].split(',')
+
+    if new.startswith('=("'):
+        trial_uid = new[3:-2]
+        return trial_uid
+    return None
+
+
+def poll_object_tracker_for_studyuid(ctpy_session, pipeline_id,
+                                     object_tracker_id, patient_id,
+                                     study_uid, delay, timeout):
+    old_data = object_tracker_data = {}
+    last_update = int(time())
+    logging.debug(f'Querying for patient:{patient_id}, study_uid: {study_uid}')
+    while old_data == object_tracker_data:
+        object_tracker_data = ctpy_session.get_object_tracker_patient_info(pipeline_id,
+                                                                           object_tracker_id,
+                                                                           '',
+                                                                           patient_id,
+                                                                           study_uid)
+        logging.debug('Checking for new data...')
+        if old_data == object_tracker_data:
+            logging.debug('No incoming data check timeout')
+            if int(time() - last_update) > timeout:
+                logging.debug('Timeout reached')
+                break
+        else:
+            last_update = int(time())
+            logging.debug('Incoming data...')
+            logging.debug(f'Found: {object_tracker_data}')
+
+        old_data = object_tracker_data
+        sleep(delay)
+
+    return object_tracker_data
+
+
+class CtpSummary(BaseModel):
+    pipeline: str = Field('', validation_alias=AliasChoices('Pipeline'))
+    import_queues: int = Field(0, validation_alias=AliasChoices('ImportQueues'))
+    export_queues: int = Field(0, validation_alias=AliasChoices('ExportQueues'))
+    quarantines: int = Field(0, validation_alias=AliasChoices('Quarantines'))
+    time_stamp: datetime.datetime = Field(
+        default_factory=lambda: datetime.datetime.now())  # pylint:disable=unnecessary-lambda
+
+    def __init__(self, row):
+        super().__init__()
+        values = row.find_all('td')
+        self.pipeline = values[0].text
+        self.import_queues = int(values[1].text)
+        self.export_queues = int(values[2].text)
+        self.quarantines = int(values[3].text)
+
+    @field_validator('import_queues', 'export_queues', 'quarantines', mode='before')
+    @classmethod
+    def remove_separators(cls, v: str) -> int:
+        if isinstance(v, int):
+            return v
+        return int(v.replace(',', ''))
+    
+    def to_table_row(self) -> List:
+        return [self.pipeline, self.import_queues, self.export_queues, self.quarantines]
+
+
+def parse_summary(html: Union[str, bytes]) -> Union[None, List[CtpSummary]]:
+    soup = bs4.BeautifulSoup(html, 'html.parser')
+    tables = soup.find_all('table', attrs={'class': 'summary'})
+    if len(tables) != 1:
+        return None
+
+    rows = tables[0].find_all('tr')
+    results = [CtpSummary(row) for row in rows[1:]]
+
+    return results
+
+
+def parse_step(html: Union[str, bytes]) -> Dict[str, Dict[str, str]]:
+    soup = bs4.BeautifulSoup(html, 'html.parser')
+
+    status_table = soup.find('h2', string='Status').find_next_sibling('table')
+    config_table = soup.find('h2', string='Configuration').find_next_sibling('table')
+
+    return {
+        'status': parse_vertical_table(status_table),
+        'config': parse_vertical_table(config_table),
+    }
+
+
+def parse_vertical_table(table_element: bs4.Tag) -> Dict[str, str]:
+    """
+    Parse the vertical tables that just have 2 columns with a key-value structure
+
+    :param table_element: table DOM element
+    :return: table parsed into a dict
+    """
+    rows = table_element.find_all('tr')
+
+    result = {}
+    for row in rows:
+        elements = row.find_all('td')
+        if len(elements) != 2:
+            raise ValueError('Expected table to have 2 columns only!')
+
+        result[elements[0].text] = elements[1].text
+
+    return result
+
+
+def summarize_object_tracker_content(object_tracker_content):
+    subjects = 0
+    experiments = 0
+    scans = 0
+    instances = 0
+    for _, subject_info in object_tracker_content.items():
+        subjects += 1
+        for _, experiment_info in subject_info.items():
+            experiments += 1
+            for _, scan_instances in experiment_info.items():
+                scans += 1
+                instances += scan_instances
+
+    return subjects, experiments, scans, instances

ctpy/tests/mock.py

@@ -0,0 +1,32 @@
+# Copyright 2024 Biomedical Imaging Group Rotterdam, Departments of
+# Medical Informatics and Radiology, Erasmus MC, Rotterdam, The Netherlands
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Pattern, Union
+
+from requests import Response
+from requests_mock import Mocker
+
+
+class CTPRequestsMocker(Mocker):
+    uri: str = "http://ctp.example.com"
+    port: int = 1080
+
+    def request(self,
+                method: str,
+                url: Union[str, Pattern[str]],
+                **kwargs: Any) -> Response:
+        url = f"{self.uri}:{self.port}/{url.lstrip('/')}"
+        print(f'Mocking request for {url}')
+        return super().request(method, url, **kwargs)

ctpy/tests/test_init.py

@@ -0,0 +1,18 @@
+import ctpy
+from ctpy import CTPYclient
+
+
+def test_connect(ctpy_mock):
+    ctpy_mock.get('/login', cookies={'RSNASESSION': '123'}, status_code=302)
+
+    build = "2021.04.01 at 11:04:40 CDT"
+    ip = "10.42.0.83"
+    java = "1.7"
+    ctpy_mock.get('/server', text=f"""<?xml version="1.0" encoding="UTF-8" ?>\n<server build="{build}" ip="{ip}" java="{java}" port="1080" />""")
+
+    connection = ctpy.connect(ctpy_mock.uri, port=ctpy_mock.port, username="test", password="secret")
+
+    assert isinstance(connection, CTPYclient)
+    assert connection.server.build == build
+    assert connection.server.ip == ip
+    assert connection.server.java == java

ctpy/version.py

@@ -0,0 +1,12 @@
+# This file is automatically generated by versioningit during build stage. Do not edit it manually.
+# Configuration is stored in the pyproject.toml file.
+
+version = '1.0.1'
+version_tuple = (1, 0, 1)
+base_version = '1.0.1'  # Latest released version known at build time
+git_revision = '89d6adf'
+git_revision_full = '89d6adf5e2ce060ebd334f67655bb8d278cfff22'
+git_branch = 'None'
+git_revision_date = '2025-01-16T12:32:55'
+build_date = '2025-01-16T12:36:14'
+