chore: bump dependencies and fix linter issues (#186)

* chore: bump dependencies and fix linter issues

* chore: bump helm values

* chore: bump dockerfile image version

* fix: linebreak

Author: JTaeuber

.github/workflows/python-tests.yml

@@ -17,10 +17,10 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
-      - name: Set up Python 3.9
+      - name: Set up Python 3.10
         uses: actions/setup-python@v5
         with:
-          python-version: 3.9
+          python-version: "3.10"
       - name: Install dependencies
         run: |
           pip install poetry

.pre-commit-config.yaml

@@ -64,29 +64,29 @@ repos:
 
   # formatters
   - repo: https://github.com/asottile/reorder_python_imports
-    rev: v3.15.0
+    rev: v3.16.0
     hooks:
       - id: reorder-python-imports
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.10
+    rev: v0.14.11
     hooks:
       # Run the linter.
-      - id: ruff
+      - id: ruff-check
         args: [--fix]
       # Run the formatter.
       - id: ruff-format
 
   # linters
   - repo: https://github.com/PyCQA/bandit
-    rev: 1.8.6
+    rev: 1.9.2
     hooks:
       - id: bandit
         args: ["-x", "tests"]
         stages: [pre-push]
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.17.1
+    rev: v1.19.1
     hooks:
       - id: mypy
         additional_dependencies: [types-pytz, types-requests]
@@ -109,7 +109,7 @@ repos:
       - id: python-check-blanket-noqa
 
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.6.2
+    rev: v3.7.4
     hooks:
       - id: prettier
         files: \.md$

.travis.yml

@@ -2,7 +2,7 @@ dist: bionic
 sudo: yes
 language: python
 python:
-  - "3.9"
+  - "3.10"
 services:
   - docker
 install:

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.12.12-alpine3.22 AS builder
+FROM python:3.12.12-alpine3.23 AS builder
 
 WORKDIR /
 

README.md

@@ -296,15 +296,17 @@ You can also use simplified time specifications.
 If the weekday range or the timezone is not included in the specification, the downscaler can automatically complete the rule when corresponding environment variables are defined.
 
 The following environment variables can be used to provide default values:
+
 - `DEFAULT_TIMEZONE` defines the time zone to use when not specified in the specification (for example `Europe/Paris`).
 - `DEFAULT_WEEKFRAME` defines the weekday range to use to use when not specified in the specification (for example `Mon-Sun`).
 
 For example:
+
 - `Mon-Fri 08:00-20:00` interpreted as `Mon-Fri 08:00-20:00 Europe/Paris` when `DEFAULT_TIMEZONE` is set to `Europe/Paris`.
 - `08:00-20:00 Europe/Paris` interpreted as `Mon-Sun 08:00-20:00 Europe/Paris` when `DEFAULT_WEEKFRAME` is set to `Mon-Sun`.
 - `08:00-20:00` will only be valid if both `DEFAULT_TIMEZONE` and `DEFAULT_WEEKFRAME` are defined.
 
-If the timezone and/or the weekday range are not provided in the specification and the corresponding default environment variable  is not set, the downscaler will raise a clear `ValueError` to prevent ambiguous or unintended behavior.
+If the timezone and/or the weekday range are not provided in the specification and the corresponding default environment variable is not set, the downscaler will raise a clear `ValueError` to prevent ambiguous or unintended behavior.
 
 If you want to schedule downtime from 23:30 to 09:30 the following day,
 a configuration like this would be incorrect:
@@ -489,19 +491,18 @@ argument is strongly recommended when using the `--once` argument to process lar
 
 `--qps`
 
-: Optional: rate of API requests a KubeDownscaler is allowed to send per second 
+: Optional: rate of API requests a KubeDownscaler is allowed to send per second
 (default: 0, meaning qps control is disabled)
 
 `--burst`
 
-: Optional: maximum number of requests a KubeDownscaler can send at once above the QPS limit for 
+: Optional: maximum number of requests a KubeDownscaler can send at once above the QPS limit for
 (default: 0, meaning burst control is disabled) Burst must be greater-equal than qps
 
-
 `--max-retries-on-throttling`
 
-: Optional: How many retries to perform when KubeDownscaler hits API Server throttling limits (default: 0). The
-retries are performed using an exponential backoff strategy to reduce the chance of hitting the rate limit again.
+: Optional: How many retries to perform when KubeDownscaler hits API Server throttling limits (default: 0).
+The retries are performed using an exponential backoff strategy to reduce the chance of hitting the rate limit again.
 
 ### Constrained Mode (Limited Access Mode)
 

chart/Chart.yaml

@@ -3,5 +3,5 @@ name: py-kube-downscaler
 description: A Helm chart for deploying py-kube-downscaler
 
 type: application
-version: 0.3.8
-appVersion: "25.11.0"
+version: 0.3.9
+appVersion: "26.1.0"

kube_downscaler/helper.py

@@ -1,14 +1,19 @@
 import datetime
 import json
 import logging
-import re
 import os
+import re
 import sys
 import time
-from typing import Match, Callable, TypeVar, Optional
+from typing import Callable
+from typing import Match
+from typing import Optional
+from typing import TypeVar
+
 import pykube
 import pytz
 import requests
+
 from kube_downscaler.tokenbucket import TokenBucket
 
 logger = logging.getLogger(__name__)
@@ -21,8 +26,10 @@
 TIME_SPEC_PATTERN = re.compile(
     r"^([a-zA-Z]{3})-([a-zA-Z]{3}) (\d\d):(\d\d)-(\d\d):(\d\d) (?P<tz>[a-zA-Z/_]+)$"
 )
-TIME_SPEC_PATTERN_WO_TZ = re.compile(r'.*(\d\d)$')
-TIME_SPEC_PATTERN_WO_WF = re.compile(r'^(\d\d):(\d\d)-(\d\d):(\d\d) (?P<tz>[a-zA-Z/_]+)$')
+TIME_SPEC_PATTERN_WO_TZ = re.compile(r".*(\d\d)$")
+TIME_SPEC_PATTERN_WO_WF = re.compile(
+    r"^(\d\d):(\d\d)-(\d\d):(\d\d) (?P<tz>[a-zA-Z/_]+)$"
+)
 _ISO_8601_TIME_SPEC_PATTERN = r"(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[-+]\d{2}:\d{2})"
 ABSOLUTE_TIME_SPEC_PATTERN = re.compile(
     r"^{0}-{0}$".format(_ISO_8601_TIME_SPEC_PATTERN)
@@ -41,14 +48,18 @@ def matches_time_spec(time: datetime.datetime, spec: str):
         match = TIME_SPEC_PATTERN_WO_TZ.match(spec_)
         if match and not ABSOLUTE_TIME_SPEC_PATTERN.match(spec_):
             if DEFAULT_TIMEZONE:
-                spec_ = spec_ + ' ' + DEFAULT_TIMEZONE
+                spec_ = spec_ + " " + DEFAULT_TIMEZONE
             else:
-                raise ValueError("No default timezone defined in environment variable 'DEFAULT_TIMEZONE'")
+                raise ValueError(
+                    "No default timezone defined in environment variable 'DEFAULT_TIMEZONE'"
+                )
         if TIME_SPEC_PATTERN_WO_WF.match(spec_):
             if DEFAULT_WEEKFRAME:
-                spec_ = DEFAULT_WEEKFRAME + ' ' + spec_
+                spec_ = DEFAULT_WEEKFRAME + " " + spec_
             else:
-                raise ValueError("No default week frame defined in environment variable 'DEFAULT_WEEKFRAME'")
+                raise ValueError(
+                    "No default week frame defined in environment variable 'DEFAULT_WEEKFRAME'"
+                )
         recurring_match = TIME_SPEC_PATTERN.match(spec_)
         if recurring_match is not None and _matches_recurring_time_spec(
             time, recurring_match
@@ -153,7 +164,7 @@ def add_event(resource, message: str, reason: str, event_type: str, dry_run: boo
         try:
             call_with_exponential_backoff(
                 lambda: event.update(),
-                context_msg = f"updating event for id {uid}",
+                context_msg=f"updating event for id {uid}",
             )
             return event
         except requests.HTTPError as e:
@@ -212,47 +223,59 @@ def create_event(resource, message: str, reason: str, event_type: str, dry_run:
             else:
                 raise e
 
+
+class JsonFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        return json.dumps(
+            {
+                "time": self.formatTime(record),
+                "severity": record.levelname,
+                "message": record.getMessage().replace('"', "'"),
+            }
+        )
+
+
 def setup_logging(debug: bool, json_logs: bool):
-    logging.getLogger().handlers.clear()
     root_logger = logging.getLogger()
+    root_logger.handlers.clear()
     root_logger.setLevel(logging.DEBUG if debug else logging.INFO)
 
     stderr_handler = logging.StreamHandler(sys.stderr)
 
+    formatter: logging.Formatter
     if json_logs:
-        formatter = logging.Formatter()
-        formatter.format = lambda record: json.dumps({
-            "time": logging.Formatter.formatTime(logging.Formatter(), record),
-            "severity": record.levelname,
-            "message": record.getMessage().replace('"', "'")
-        })
+        formatter = JsonFormatter()
     else:
         formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s")
 
     stderr_handler.setFormatter(formatter)
     root_logger.addHandler(stderr_handler)
 
+
 def initialize_token_bucket(qps, burst):
     global TOKEN_BUCKET
     if qps == 0 and burst == 0:
         TOKEN_BUCKET = None
     TOKEN_BUCKET = TokenBucket(qps=qps, burst=burst)
 
+
 def initialize_max_retries(max_retries):
     global MAX_RETRIES
     MAX_RETRIES = max_retries
 
-T = TypeVar('T')
+
+T = TypeVar("T")
+
 
 def call_with_exponential_backoff(
-        func: Callable[..., T],
-        base_delay: float = 1.0,
-        max_delay: float = 60.0,
-        backoff_factor: int = 2,
-        jitter: bool = True,
-        retry_on_status_codes: tuple = (429,),
-        context_msg: Optional[str] = None,
-        use_token_bucket: bool = True
+    func: Callable[..., T],
+    base_delay: float = 1.0,
+    max_delay: float = 60.0,
+    backoff_factor: int = 2,
+    jitter: bool = True,
+    retry_on_status_codes: tuple = (429,),
+    context_msg: Optional[str] = None,
+    use_token_bucket: bool = True,
 ) -> T:
     """
     Generic function to call any function with exponential backoff on HTTP errors.
@@ -296,34 +319,45 @@ def call_with_exponential_backoff(
                         logger.error(error_msg)
                         raise e
 
-                    #check for "Retry-After" header
-                    retry_after = e.response.headers.get('Retry-After')
+                    # check for "Retry-After" header
+                    retry_after = e.response.headers.get("Retry-After")
 
                     if retry_after:
                         try:
-                            #retry-After can be in seconds (integer) or HTTP date format
+                            # retry-After can be in seconds (integer) or HTTP date format
                             if retry_after.isdigit():
                                 delay = float(retry_after)
                             else:
-                                #try parsing as HTTP date
+                                # try parsing as HTTP date
                                 from email.utils import parsedate_to_datetime
+
                                 retry_date = parsedate_to_datetime(retry_after)
-                                delay = (retry_date - datetime.datetime.now(retry_date.tzinfo)).total_seconds()
+                                delay = (
+                                    retry_date
+                                    - datetime.datetime.now(retry_date.tzinfo)
+                                ).total_seconds()
 
-                            #cap the delay at max_delay
+                            # cap the delay at max_delay
                             delay = min(delay, max_delay)
 
-                            logger.info(f"using Retry-After header value: {delay:.2f} seconds")
+                            logger.info(
+                                f"using Retry-After header value: {delay:.2f} seconds"
+                            )
                         except (ValueError, TypeError) as parse_error:
                             logger.warning(
-                                f"failed to parse Retry-After header '{retry_after}': {parse_error}. Using exponential backoff.")
-                            #fall back to exponential backoff
-                            delay = min(base_delay * (backoff_factor ** retry_count), max_delay)
+                                f"failed to parse Retry-After header '{retry_after}': {parse_error}. Using exponential backoff."
+                            )
+                            # fall back to exponential backoff
+                            delay = min(
+                                base_delay * (backoff_factor**retry_count), max_delay
+                            )
                     else:
-                        #calculate exponential backoff
-                        delay = min(base_delay * (backoff_factor ** retry_count), max_delay)
+                        # calculate exponential backoff
+                        delay = min(
+                            base_delay * (backoff_factor**retry_count), max_delay
+                        )
 
-                    #add jitter if not using "Retry-After" header
+                    # add jitter if not using "Retry-After" header
                     if jitter and not retry_after:
                         jitter_amount = delay * 0.1 * (time.time() % 1)
                         delay += jitter_amount
@@ -337,7 +371,7 @@ def call_with_exponential_backoff(
                     time.sleep(delay)
                     retry_count += 1
                 else:
-                    #re-raise non-retryable errors immediately
+                    # re-raise non-retryable errors immediately
                     raise e
 
         if last_exception:
@@ -348,4 +382,4 @@ def call_with_exponential_backoff(
         if use_token_bucket and TOKEN_BUCKET:
             TOKEN_BUCKET.acquire()
 
-        return func()
+        return func()

kube_downscaler/main.py

@@ -24,15 +24,15 @@ def main(args=None):
     args = parser.parse_args(args)
 
     if args.burst < args.qps:
-        logger.error("Failed to start, burst value must be greater than or equal to qps value")
+        logger.error(
+            "Failed to start, burst value must be greater than or equal to qps value"
+        )
         return None
 
-
     helper.setup_logging(args.debug, args.json_logs)
     helper.initialize_token_bucket(args.qps, args.burst)
     helper.initialize_max_retries(args.max_retries_on_throttling)
 
-
     config_str = ", ".join(f"{k}={v}" for k, v in sorted(vars(args).items()))
     logger.info(f"Downscaler v{__version__} started with {config_str}")