retuve.keyphrases.config

  1# Copyright 2024 Adam McArthur
  2#
  3# Licensed under the Apache License, Version 2.0 (the "License");
  4# you may not use this file except in compliance with the License.
  5# You may obtain a copy of the License at
  6#
  7#     http://www.apache.org/licenses/LICENSE-2.0
  8#
  9# Unless required by applicable law or agreed to in writing, software
 10# distributed under the License is distributed on an "AS IS" BASIS,
 11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12# See the License for the specific language governing permissions and
 13# limitations under the License.
 14
 15"""
 16The parent class for for Retuve configs
 17"""
 18
 19import copy
 20from typing import List, Tuple
 21
 22from PIL import ImageFont
 23from radstract.data.dicom import DicomTypes
 24from torch.types import Device
 25
 26from retuve.keyphrases.enums import OperationType
 27from retuve.keyphrases.subconfig import (
 28    APIConfig,
 29    BatchConfig,
 30    HipConfig,
 31    TrakConfig,
 32    VisualsConfig,
 33)
 34from retuve.logs import ulogger
 35from retuve.utils import RETUVE_DIR, register_config_dirs
 36
 37
 38class GlobalConfig:
 39    def __init__(self, username: str, password: str):
 40        self.username = username
 41        self.password = password
 42
 43
 44class Config:
 45    """Configuration class."""
 46
 47    configs = {}
 48    live_config = None
 49
 50    def __init__(
 51        self,
 52        dicom_type: DicomTypes,
 53        crop_coordinates: Tuple[float],
 54        template: bool,
 55        min_seg_confidence: float,
 56        device: Device,
 57        operation_type: OperationType,
 58        dev: bool,
 59        replace_old: bool,
 60        seg_export: bool,
 61        test_data_passthrough: bool,
 62        subconfig_hip: HipConfig,
 63        subconfig_trak: TrakConfig,
 64        subconfig_visuals: VisualsConfig,
 65        subconfig_api: APIConfig,
 66        subconfig_batch: BatchConfig,
 67        name=None,
 68    ):
 69        """
 70        Initialize Config.
 71
 72        :param dicom_type (DicomTypes): The type of dicom to use.
 73        :param crop_coordinates (Tuple[float]): The crop coordinates.
 74        :param template (bool): Whether this is a template config.
 75        :param min_seg_confidence (float): The minimum segmentation confidence.
 76        :param device (Device): The device to use.
 77        :param operation_type (OperationType): The operation type.
 78        :param dev (bool): Whether to use dev mode.
 79        :param replace_old (bool): Whether to replace old files.
 80        :param seg_export (bool): Whether to export segmentation.
 81        :param test_data_passthrough (bool): Whether to pass through test data.
 82        :param subconfig_hip (HipConfig): The hip subconfig.
 83        :param subconfig_trak (TrakConfig): The trak subconfig.
 84        :param subconfig_visuals (VisualsConfig): The visuals subconfig.
 85        :param subconfig_api (APIConfig): The api subconfig.
 86        :param subconfig_batch (BatchConfig): The batch subconfig.
 87        :param name (str): The name (keyphrase) of the config.
 88        """
 89        self.name = name
 90
 91        if not (template or name):
 92            raise ValueError("Template configs must have a name specified.")
 93
 94        if not template and (name):
 95            self.register(name)
 96
 97        self.dicom_type = dicom_type
 98        self.crop_coordinates = crop_coordinates
 99        self.min_seg_confidence = min_seg_confidence
100
101        self.device = device
102        self.replace_old = replace_old
103        self.operation_type = operation_type
104        self.dev = dev
105
106        self.seg_export = seg_export
107
108        self.hip: HipConfig = subconfig_hip
109        self.trak: TrakConfig = subconfig_trak
110        self.visuals: VisualsConfig = subconfig_visuals
111        self.api: APIConfig = subconfig_api
112        self.batch: BatchConfig = subconfig_batch
113
114        self.test_data_passthrough = test_data_passthrough
115
116        if operation_type not in [
117            OperationType.SEG,
118            OperationType.LANDMARK,
119        ]:
120            raise ValueError(f"Invalid operation type: {operation_type}")
121
122    def register(
123        self,
124        name: str,
125        store: bool = True,
126        silent: bool = False,
127        live: bool = False,
128    ):
129        """
130        Register the config.
131
132        :param name (str): The name of the config.
133        :param store (bool): Whether to store the config
134                             for later retrieval.
135
136        """
137        self.name = name
138
139        # check if config already exists
140        if self.configs.get(name):
141            raise ValueError(f"Config {name} already exists.")
142
143        if not self.configs.get(name) and store:
144            self.configs[name] = {}
145
146        if store:
147            self.configs[name] = self
148
149        if live:
150            Config.live_config = self
151
152        # defaults need registering
153        if self.visuals.default_font_size:
154            self.visuals.font_h1 = ImageFont.truetype(
155                f"{RETUVE_DIR}/files/RobotoMono-Regular.ttf",
156                self.visuals.default_font_size,
157            )
158
159            self.visuals.font_h2 = ImageFont.truetype(
160                f"{RETUVE_DIR}/files/RobotoMono-Regular.ttf",
161                self.visuals.default_font_size,
162            )
163
164        self.batch.register()
165
166        register_config_dirs(self)
167
168        if not self.api.api_token:
169            ValueError("API token must be set.")
170
171        if not silent:
172            ulogger.info(f"Registered config for {name}")
173
174    def unregister(self, silent: bool = False):
175        """
176        Unregister the config.
177        """
178        if self.name in self.configs:
179            del self.configs[self.name]
180
181        if not silent:
182            ulogger.info(f"Unregistered config for {self.name}")
183
184    def get_copy(self) -> "Config":
185        """
186        Get a copy of the config.
187
188        :return: A copy of the config.
189        """
190        return copy.deepcopy(self)
191
192    def inject_global_config(self, username, password):
193        """
194        Inject the global config into the config.
195
196        :param username (str): The username.
197        :param password (str): The password.
198        """
199        Config.global_config = GlobalConfig(username, password)
200
201    @classmethod
202    def get_configs(self) -> List[Tuple[str, "Config"]]:
203        """
204        Get all registered/stored configs.
205
206        :return: A list of tuples of name and config.
207        """
208        return [(name, config) for name, config, in self.configs.items()]
209
210    @classmethod
211    def get_config(cls, name: str) -> "Config":
212        """
213        Get a config by name.
214
215        :param name (str): The name of the config.
216
217        :return: The config.
218        """
219        # check if name is of type Config
220        if isinstance(name, Config):
221            return name
222
223        if not cls.configs.get(name):
224            raise ValueError(f"Config {name} does not exist.")
225
226        return cls.configs[name]
227
228    @classmethod
229    def keyphrase_exists(cls, name: str) -> bool:
230        """
231        Check if a keyphrase exists in the configs.
232
233        :param name (str): The name of the keyphrase.
234
235        :return: Whether the keyphrase exists.
236        """
237        lower_keys = [key.lower() for key in cls.configs.keys()]
238        return name.lower() in lower_keys