detquantlib 3.11.0__tar.gz → 3.13.0__tar.gz

{detquantlib-3.11.0 → detquantlib-3.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: detquantlib
-Version: 3.11.0
+Version: 3.13.0
 Summary: An internal library containing functions and classes that can be used across Quant models.
 License-File: LICENSE.txt
 Author: DET
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: colorlog (>=6.10.1,<7.0.0)
 Requires-Dist: numpy (>=2.2.6,<3.0.0)
 Requires-Dist: pandas (>=2.3.3,<3.0.0)
 Requires-Dist: paramiko (>=4.0.0,<5.0.0)
@@ -98,6 +99,15 @@ Classes:
   - `from detquantlib.data import Sftp`
   - `from detquantlib.data.sftp.sftp import Sftp`
 
+Functions:
+
+- `list_to_sql_columns`:
+  - `from detquantlib.data import list_to_sql_columns`
+  - `from detquantlib.data.databases.helpers import list_to_sql_columns`
+- `list_to_sql_set`:
+  - `from detquantlib.data import list_to_sql_set`
+  - `from detquantlib.data.databases.helpers import list_to_sql_set`
+
 <!-- END EXPOSED SYMBOLS AUTO-GENERATED -->
 
 ## Configuration

{detquantlib-3.11.0 → detquantlib-3.13.0}/README.md

@@ -73,6 +73,15 @@ Classes:
   - `from detquantlib.data import Sftp`
   - `from detquantlib.data.sftp.sftp import Sftp`
 
+Functions:
+
+- `list_to_sql_columns`:
+  - `from detquantlib.data import list_to_sql_columns`
+  - `from detquantlib.data.databases.helpers import list_to_sql_columns`
+- `list_to_sql_set`:
+  - `from detquantlib.data import list_to_sql_set`
+  - `from detquantlib.data.databases.helpers import list_to_sql_set`
+
 <!-- END EXPOSED SYMBOLS AUTO-GENERATED -->
 
 ## Configuration

detquantlib-3.13.0/detquantlib/converters/__init__.py

@@ -0,0 +1,2 @@
+from .energy import *
+from .price import *

detquantlib-3.13.0/detquantlib/converters/definitions.py

@@ -0,0 +1,24 @@
+class PowerUnits:
+    """A class that contains hard-coded information about power units."""
+
+    CONVERSIONS = [
+        {"unit": "W", "value_in_base_unit": 1},
+        {"unit": "kW", "value_in_base_unit": 1e3},
+        {"unit": "MW", "value_in_base_unit": 1e6},
+        {"unit": "GW", "value_in_base_unit": 1e9},
+        {"unit": "TW", "value_in_base_unit": 1e12},
+        {"unit": "MJ/s", "value_in_base_unit": 1e6},
+    ]
+
+
+class EnergyUnits:
+    """A class that contains hard-coded information about energy units."""
+
+    CONVERSIONS = [
+        {"unit": "Wh", "value_in_base_unit": 1},
+        {"unit": "kWh", "value_in_base_unit": 1e3},
+        {"unit": "MWh", "value_in_base_unit": 1e6},
+        {"unit": "GWh", "value_in_base_unit": 1e9},
+        {"unit": "TWh", "value_in_base_unit": 1e12},
+        {"unit": "MJ", "value_in_base_unit": 1e6 / 3600},
+    ]

detquantlib-3.13.0/detquantlib/converters/energy.py

@@ -0,0 +1,140 @@
+# Python built-in packages
+from datetime import datetime
+
+# Third-party packages
+import numpy as np
+
+# Internal modules
+from detquantlib.converters.definitions import EnergyUnits, PowerUnits
+from detquantlib.converters.helpers import convert_unit_same_cat
+from detquantlib.dates import count_nr_hours
+from detquantlib.tradable_products import tenor_to_nr_hours
+
+# Specify functions to expose
+__all__ = ["convert_power", "convert_energy", "power_to_energy", "energy_to_power"]
+
+
+def convert_power(value_in: float | np.ndarray, unit_in: str, unit_out: str) -> float | np.ndarray:
+    """
+    Converts power from one unit to another.
+
+    Args:
+        value_in: Power quantity
+        unit_in: Unit of input power quantity
+        unit_out: Unit of output power quantity
+
+    Returns:
+        Converted power quantity
+    """
+    return convert_unit_same_cat(
+        conversions=PowerUnits.CONVERSIONS, value_in=value_in, unit_in=unit_in, unit_out=unit_out
+    )
+
+
+def convert_energy(
+    value_in: float | np.ndarray, unit_in: str, unit_out: str
+) -> float | np.ndarray:
+    """
+    Converts energy from one unit to another.
+
+    Args:
+        value_in: Energy quantity
+        unit_in: Unit of input energy quantity
+        unit_out: Unit of output energy quantity
+
+    Returns:
+        Converted energy quantity
+    """
+    return convert_unit_same_cat(
+        conversions=EnergyUnits.CONVERSIONS, value_in=value_in, unit_in=unit_in, unit_out=unit_out
+    )
+
+
+def power_to_energy(
+    power: float | np.ndarray,
+    power_unit: str,
+    energy_unit: str,
+    tenor: str = None,
+    delivery_start: datetime = None,
+    delivery_end: datetime = None,
+):
+    """
+    Converts a power quantity into its corresponding energy quantity.
+
+    Args:
+        power: Power quantity
+        power_unit: Unit of input power quantity
+        energy_unit: Unit of output energy quantity
+        tenor: (Optional) Product tenor. If not provided, delivery_start and delivery_end must be
+            provided.
+        delivery_start: (Optional) Delivery start date. Only needed if tenor is not provided,
+            or if tenor > 1 hour to account for DST switches.
+        delivery_end: (Optional) Delivery end date. Only needed if tenor is not provided, or
+            if tenor > 1 hour to account for DST switches.
+
+    Returns:
+        Energy quantity
+    """
+    # Count number of hours in delivery period
+    if tenor is None:
+        nr_hours = count_nr_hours(start_date=delivery_start, end_date=delivery_end)
+    else:
+        nr_hours = tenor_to_nr_hours(
+            tenor=tenor, delivery_start=delivery_start, delivery_end=delivery_end
+        )
+
+    # Convert power from input unit to W
+    power_w = convert_power(value_in=power, unit_in=power_unit, unit_out="w")
+
+    # Convert power (W) to energy (Wh)
+    energy_wh = power_w * nr_hours
+
+    # Convert energy from Wh to output unit
+    energy = convert_energy(value_in=energy_wh, unit_in="wh", unit_out=energy_unit)
+
+    return energy
+
+
+def energy_to_power(
+    energy: float | np.ndarray,
+    energy_unit: str,
+    power_unit: str,
+    tenor: str = None,
+    delivery_start: datetime = None,
+    delivery_end: datetime = None,
+):
+    """
+    Converts an energy quantity into its corresponding power quantity.
+
+    Args:
+        energy: Energy quantity
+        energy_unit: Unit of input energy quantity
+        power_unit: Unit of output power quantity
+        tenor: (Optional) Product tenor. If not provided, delivery_start and delivery_end must be
+            provided.
+        delivery_start: (Optional) Delivery start date. Only needed if tenor is not provided,
+            or if tenor > 1 hour to account for DST switches.
+        delivery_end: (Optional) Delivery end date. Only needed if tenor is not provided, or
+            if tenor > 1 hour to account for DST switches.
+
+    Returns:
+        Power quantity
+    """
+    # Count number of hours in delivery period
+    if tenor is None:
+        nr_hours = count_nr_hours(start_date=delivery_start, end_date=delivery_end)
+    else:
+        nr_hours = tenor_to_nr_hours(
+            tenor=tenor, delivery_start=delivery_start, delivery_end=delivery_end
+        )
+
+    # Convert energy from input unit to Wh
+    energy_wh = convert_energy(value_in=energy, unit_in=energy_unit, unit_out="wh")
+
+    # Convert energy (Wh) to power (W)
+    power_w = energy_wh / nr_hours
+
+    # Convert power from W to output unit
+    power = convert_power(value_in=power_w, unit_in="w", unit_out=power_unit)
+
+    return power

detquantlib-3.13.0/detquantlib/converters/helpers.py

@@ -0,0 +1,67 @@
+# Third-party packages
+import numpy as np
+
+# Internal modules
+from detquantlib.utils import list_to_str
+
+
+def get_base_unit(conversions: list[dict]) -> str:
+    """
+    Gets the base unit of a given unit group.
+
+    Args:
+        conversions: List of conversion dicts of a given unit group
+
+    Returns:
+        Base unit
+    """
+    return next((d for d in conversions if d["value_in_base_unit"] == 1))["unit"]
+
+
+def get_unit_dict(unit: str, conversions: list[dict]) -> dict:
+    """
+    Gets the unit conversion dict of a given unit.
+
+    Args:
+        unit: Unit
+        conversions: List of conversion dicts of a given unit group
+
+    Returns:
+        Conversion dict of the input unit
+
+    Raises:
+        ValueError: Raises an error if the input unit is not supported.
+    """
+    unit_dict = next((d for d in conversions if d["unit"].lower() == unit.lower()), None)
+    if unit_dict is None:
+        units_str = list_to_str([d["unit"] for d in conversions])
+        raise ValueError(f"Unsupported unit '{unit}'. Accepted values: {units_str}.")
+    return unit_dict
+
+
+def convert_unit_same_cat(
+    conversions: list[dict], value_in: float | np.ndarray, unit_in: str, unit_out: str
+) -> float | np.ndarray:
+    """
+    Converts a quantity from a given unit to another unit of the same unit group.
+
+    Args:
+        conversions: List of conversion dicts of a given unit group
+        value_in: Quantity to convert
+        unit_in: Unit of the input quantity
+        unit_out: Unit of the output quantity
+
+    Returns:
+        Converted quantity
+    """
+    # Get unit dicts
+    unit_dict_in = get_unit_dict(unit_in, conversions)
+    unit_dict_out = get_unit_dict(unit_out, conversions)
+
+    # Convert input value to base unit
+    value_base = value_in * unit_dict_in["value_in_base_unit"]
+
+    # Convert base value to output unit
+    value_out = value_base / unit_dict_out["value_in_base_unit"]
+
+    return value_out

detquantlib-3.13.0/detquantlib/converters/price.py

@@ -0,0 +1,107 @@
+# Third-party packages
+import numpy as np
+
+# Internal modules
+from detquantlib.converters.definitions import EnergyUnits
+from detquantlib.converters.helpers import convert_unit_same_cat
+
+# Specify functions to expose
+__all__ = ["convert_price", "flag_cents"]
+
+
+def convert_price(
+    price_in: float | np.ndarray,
+    currency_in: str,
+    unit_in: str,
+    currency_out: str,
+    unit_out: str,
+    commodity_category: str,
+) -> float | np.ndarray:
+    """
+    Converts a price from a given currency and volume unit to another.
+
+    Args:
+        price_in: Price
+        currency_in: Currency of input price
+        unit_in: Volume unit of current price
+        currency_out: Currency of output price
+        unit_out: Volume unit of output price
+        commodity_category: Commodity category
+
+    Returns:
+        Converted price
+
+    Raises:
+        ValueError: Raises an error if the commodity category is not supported.
+        ValueError: Raises an error if the currency conversion is not supported.
+    """
+    # Split currency and cents indicator
+    currency_pre_in, is_cent_in = flag_cents(currency_in)
+    currency_pre_out, is_cent_out = flag_cents(currency_out)
+
+    # Get unit converters
+    match commodity_category.lower():
+        case "energy":
+            conversions = EnergyUnits.CONVERSIONS
+        case _:
+            raise ValueError(f"Commodity category '{commodity_category}' is not supported.")
+
+    # 1. Convert price based on currency
+    if currency_pre_in.lower() != currency_pre_out.lower():
+        raise ValueError(
+            f"Price conversion from currency prefix '{currency_pre_in}' to currency prefix "
+            f"'{currency_pre_out}' is not supported."
+        )
+
+    # 2. Convert price based on units
+    unit_factor = convert_unit_same_cat(
+        conversions=conversions, value_in=1, unit_in=unit_in, unit_out=unit_out
+    )
+    price_out = price_in / unit_factor
+
+    # 3. Convert price based on cents indicators
+    if is_cent_in and not is_cent_out:
+        price_out /= 100
+    elif not is_cent_in and is_cent_out:
+        price_out *= 100
+
+    return price_out
+
+
+def flag_cents(currency_str: str) -> (str, bool):
+    """
+    Checks if the input currency is expressed in cents or not.
+
+    Args:
+        currency_str: Currency string (e.g. "EUR", "EUR_CENTS")
+
+    Returns:
+        tuple:
+            - Currency, excluding cents flag (e.g. "EUR")
+            - Cents flag, given as Boolean
+
+    Raises:
+        ValueError: Raises an error if the suffix of the currency string is not recognized.
+        ValueError: Raises an error if the currency string could not be parsed.
+    """
+    # Split currency and cents flag
+    currency_list = currency_str.split("_")
+
+    currency = currency_list[0]
+    if len(currency_list) == 1:
+        is_cent = False
+    elif len(currency_list) == 2:
+        if currency_list[1].lower() == "cents":
+            is_cent = True
+        else:
+            raise ValueError(
+                f"Suffix '{currency_list[1]}' of currency string '{currency_str}' not recognized "
+                f"as valid cents indicator."
+            )
+    else:
+        raise ValueError(
+            f"Currency string '{currency_str}' could not be parsed into currency and cents "
+            f"indicator."
+        )
+
+    return currency, is_cent

detquantlib-3.13.0/detquantlib/data/__init__.py

@@ -0,0 +1,6 @@
+from .databases.detdatabase import DetDatabase
+from .databases.helpers import *
+from .entsoe.entsoe import Entsoe
+from .sftp.sftp import Sftp
+
+__all__ = ["DetDatabase", "Entsoe", "Sftp", "list_to_sql_set", "list_to_sql_columns"]

detquantlib-3.13.0/detquantlib/data/databases/helpers.py

@@ -0,0 +1,40 @@
+# Internal modules
+from detquantlib.utils import list_to_str
+
+# Specify functions to expose
+__all__ = ["list_to_sql_set", "list_to_sql_columns"]
+
+
+def list_to_sql_set(list_in: list[str]) -> str:
+    """
+    Converts a list of the form ["a", "b", "c"] into a string of the form "('a', 'b', 'c')".
+    This string can be used in SQL queries applying the IN operator to filter data. Example:
+    >> "SELECT * FROM my_table WHERE my_column IN ('a', 'b', 'c')").
+
+    Args:
+        list_in: Input list of values
+
+    Returns:
+        Set of values reformatted in SQL string format
+    """
+    return "(" + list_to_str(list_in) + ")"
+
+
+def list_to_sql_columns(list_in: list[str]) -> str:
+    """
+    Converts a list of the form ["a", "b", "c"] into a string of the form "[a], [b], [c]".
+    This string can be used in SQL queries to select specific columns. Example:
+    >> "SELECT [a], [b], [c] FROM my_table
+
+    Args:
+        list_in: Input list of values
+
+    Returns:
+        String containing reformatted values
+    """
+    # Convert columns to string
+    if len(list_in) == 1:
+        columns = str(list_in[0])
+    else:
+        columns = f"[{'], ['.join(list_in)}]"
+    return columns

{detquantlib-3.11.0 → detquantlib-3.13.0}/detquantlib/dates/dates.py

@@ -1,11 +1,50 @@
 # Python built-in packages
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Literal
 
 # Third-party packages
 import pandas as pd
 from dateutil.relativedelta import *
 
+# Specify functions to expose
+__all__ = [
+    "count_nr_hours",
+    "count_delivery_periods",
+    "calc_months_diff",
+    "datetime_to_month_code",
+]
+
+
+def count_nr_hours(start_date: datetime, end_date: datetime) -> float:
+    """
+    Counts the number of hours in a given time interval.
+
+    Note:
+        - datetime.timedelta does not take into account timezone-awareness. As such, it does
+            not take into account DST switches in the hours count.
+        - To correct for this, we first convert the dates to UTC, and then count the number of
+            hours.
+
+    Args:
+        start_date: Start date
+        end_date: End date
+
+    Returns:
+        Number of hours in the given time interval
+    """
+
+    def _convert_to_utc(dt: datetime) -> datetime:
+        utc = timezone.utc
+        return dt.replace(tzinfo=timezone.utc) if dt.tzinfo is None else dt.astimezone(tz=utc)
+
+    # Convert dates to UTC
+    start_date = _convert_to_utc(start_date)
+    end_date = _convert_to_utc(end_date)
+
+    # Calculate nr hours
+    td = end_date - start_date
+    return td.days * 24 + td.seconds / 3600
+
 
 def count_delivery_periods(
     start_date: datetime,

{detquantlib-3.11.0 → detquantlib-3.13.0}/detquantlib/forecasting/forecasting.py

@@ -5,6 +5,9 @@ from datetime import datetime
 import numpy as np
 import pandas as pd
 
+# Specify functions to expose
+__all__ = ["forecast_knife_strategy"]
+
 
 def forecast_knife_strategy(
     dates: list[datetime] | list[pd.Timestamp] | pd.DatetimeIndex, values: list | np.ndarray

{detquantlib-3.11.0 → detquantlib-3.13.0}/detquantlib/tradable_products/tradable_products.py

@@ -8,7 +8,66 @@ import pandas as pd
 from dateutil.relativedelta import *
 
 # Internal modules
-from detquantlib.dates.dates import calc_months_diff
+from detquantlib.dates import calc_months_diff, count_nr_hours
+from detquantlib.utils import list_to_str
+
+# Specify functions to expose
+__all__ = [
+    "convert_delivery_start_date_to_maturity",
+    "convert_maturity_to_delivery_start_date",
+    "tenor_to_pd_offset_alias",
+    "tenor_to_nr_hours",
+]
+
+
+def tenor_to_pd_offset_alias(tenor: str) -> str:
+    """A short helper function mapping a product tenor to the corresponding pandas offset alias."""
+    tenor = tenor.upper()
+    mapper = dict(QUARTERHOUR="15min", HALFHOUR="30min", HOUR="h", DAY="D", WEEK="W")
+    if tenor not in mapper.keys():
+        tenors_str = list_to_str(list(mapper.keys()))
+        raise ValueError(f"Input tenor '{tenor}' is not supported. Accepted values: {tenors_str}.")
+    return mapper[tenor]
+
+
+def tenor_to_nr_hours(
+    tenor: str, delivery_start: datetime = None, delivery_end: datetime = None
+) -> float:
+    """
+    Counts the number of hours in a given tenor.
+
+    Args:
+        tenor: Tenor
+        delivery_start: Delivery start date (only used if tenor > 1 hour, to account for DST
+            switches)
+        delivery_end: Delivery end date (only used if tenor > 1 hour, to account for DST switches)
+
+    Returns:
+        Number of hours in tenor
+
+    Raises:
+        ValueError: Raises an error if the tenor delivery period is flexible and delivery dates
+            are not provided.
+        ValueError: Raises an error if he input tenor is not supported.
+    """
+    tenor = tenor.upper()
+    if tenor == "QUARTERHOUR":
+        nr_hours = 0.25
+    elif tenor == "HALFHOUR":
+        nr_hours = 0.5
+    elif tenor == "HOUR":
+        nr_hours = 1.0
+    elif tenor in ["DAY", "WEEK", "WEEKEND", "MONTH", "QUARTER", "YEAR"]:
+        if delivery_start and delivery_end:
+            nr_hours = count_nr_hours(delivery_start, delivery_end)
+        else:
+            raise ValueError(
+                f"Missing input(s) 'delivery_start' and/or 'delivery_end'. They must be provided "
+                f"for tenor '{tenor}', to account for DST switches and leap years."
+            )
+    else:
+        raise ValueError(f"Input tenor '{tenor}' is not supported.")
+    return nr_hours
 
 
 def convert_delivery_start_date_to_maturity(

detquantlib-3.13.0/detquantlib/utils/__init__.py

@@ -0,0 +1,2 @@
+from .logging import *
+from .utils import *

detquantlib-3.13.0/detquantlib/utils/logging.py

@@ -0,0 +1,126 @@
+# Python built-in packages
+import logging
+import sys
+import threading
+from pathlib import Path
+from types import TracebackType
+
+# Third-party packages
+from colorlog import ColoredFormatter
+
+# Specify functions to expose
+__all__ = ["setup_logger"]
+
+
+def setup_logger(log_dir: Path):
+    """
+    Initializes logging with both console and file handlers.
+
+    Args:
+        log_dir: Full path to the log file
+    """
+    # Clear existing handlers to avoid duplicate logs
+    for handler in logging.root.handlers[:]:
+        handler.close()
+        logging.root.removeHandler(handler)
+
+    # Console handler with colors
+    console_formatter = CustomFormatter(
+        fmt=(
+            "%(log_color)s%(asctime)-8s%(reset)s "
+            "%(log_color)s[%(levelname)s]%(reset)s "
+            "%(log_color)s%(message)s"
+        ),
+        datefmt="%Y-%m-%d %H:%M:%S",
+        reset=True,
+    )
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    console_handler.setFormatter(console_formatter)
+
+    # File handler (plain, no colors)
+    file_formatter = logging.Formatter(
+        fmt="%(asctime)s [%(levelname)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    file_handler = logging.FileHandler(log_dir, mode="a", encoding="utf-8")
+    file_handler.setLevel(logging.INFO)
+    file_handler.setFormatter(file_formatter)
+
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.INFO)
+    root_logger.addHandler(console_handler)
+    root_logger.addHandler(file_handler)
+
+    # Capture uncaught exceptions
+    sys.excepthook = exception_handler
+    threading.excepthook = thread_exception_handler
+
+
+def exception_handler(
+    exc_type: type[BaseException], exc_value: BaseException, exc_traceback: TracebackType
+):
+    """
+    Handles uncaught exceptions in the main thread and logs them.
+
+    Args:
+        exc_type: Exception type
+        exc_value: Exception instance
+        exc_traceback: Traceback object
+    """
+    if issubclass(exc_type, KeyboardInterrupt):
+        sys.__excepthook__(exc_type, exc_value, exc_traceback)
+        return
+
+    logging.critical(
+        "Uncaught exception",
+        exc_info=(exc_type, exc_value, exc_traceback),
+    )
+
+
+def thread_exception_handler(args: threading.ExceptHookArgs):
+    """
+    Handles uncaught exceptions in threads and logs them.
+
+    Args:
+        args: Thread exception arguments
+    """
+    logging.critical(
+        f"Uncaught thread exception in {args.thread.name}",
+        exc_info=(args.exc_type, args.exc_value, args.exc_traceback),
+    )
+
+
+class CustomFormatter(ColoredFormatter):
+    """Custom formatter to override default colorlog colors."""
+
+    # ANSI color codes
+    COLORS = dict(
+        BRIGHT_WHITE="\033[97m",
+        LIGHT_WHITE="\033[38;5;250m",
+        BRIGHT_YELLOW="\033[93m",
+        RED="\033[91m",
+        RESET="\033[0m",
+    )
+
+    def _get_escape_code(self, log_colors: dict, level_name: str) -> str:
+        """
+        Returns ANSI escape codes for log levels.
+
+        Overrides DEBUG/INFO to light-white, CRITICAL to non-bold red. WARNING/ERROR remain
+        default.
+
+        Args:
+            log_colors: Mapping of log levels to colors
+            level_name: Log level name
+
+        Returns:
+            ANSI escape code string
+        """
+        if level_name in ("DEBUG", "INFO"):
+            return CustomFormatter.COLORS["LIGHT_WHITE"]
+        if level_name == "CRITICAL":
+            return super()._get_escape_code(log_colors, "ERROR")
+        else:
+            return super()._get_escape_code(log_colors, level_name)

{detquantlib-3.11.0 → detquantlib-3.13.0}/detquantlib/utils/utils.py

@@ -4,6 +4,9 @@ from datetime import datetime
 # Third-party packages
 import numpy as np
 
+# Specify functions to expose
+__all__ = ["add_log", "list_to_str", "divide_with_nan"]
+
 
 def add_log(message: str):
     """
@@ -15,6 +18,11 @@ def add_log(message: str):
     print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] {message}")
 
 
+def list_to_str(lt: list[str | int | float | bool]) -> str:
+    """Converts a list of the form [a, b, c] into a string of the form "'a', 'b', 'c'"."""
+    return ", ".join(f"'{x}'" for x in lt)
+
+
 def divide_with_nan(
     numerator: np.array, denominator: np.array, nan=np.nan, posinf=np.nan, neginf=np.nan
 ) -> np.array:

{detquantlib-3.11.0 → detquantlib-3.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "detquantlib"
-version = "3.11.0"
+version = "3.13.0"
 description = "An internal library containing functions and classes that can be used across Quant models."
 authors = ["DET"]
 readme = "README.md"
@@ -20,6 +20,7 @@ numpy = "^2.2.6"
 pandas = "^2.3.3"
 pyarrow = "^21.0.0"
 scipy = "^1.15.2"
+colorlog = "^6.10.1"
 
 [tool.poetry.group.dev.dependencies]
 toml = "^0.10.2"

detquantlib-3.11.0/detquantlib/data/__init__.py

@@ -1,5 +0,0 @@
-from .databases.detdatabase import DetDatabase
-from .entsoe.entsoe import Entsoe
-from .sftp.sftp import Sftp
-
-__all__ = ["DetDatabase", "Entsoe", "Sftp"]

detquantlib-3.11.0/detquantlib/utils/__init__.py

@@ -1 +0,0 @@
-from .utils import *