py2docfx 0.1.16rc2051518__py3-none-any.whl → 0.1.17__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/opencensus/ext/azure/trace_exporter/__init__.py

@@ -1,236 +1,236 @@
-# Copyright 2019, OpenCensus Authors
-#
-# 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 atexit
-import json
-import logging
-
-from opencensus.common.schedule import QueueExitEvent
-from opencensus.ext.azure.common import Options, utils
-from opencensus.ext.azure.common.exporter import BaseExporter
-from opencensus.ext.azure.common.processor import ProcessorMixin
-from opencensus.ext.azure.common.protocol import (
-    Data,
-    Envelope,
-    ExceptionData,
-    RemoteDependency,
-    Request,
-)
-from opencensus.ext.azure.common.storage import LocalFileStorage
-from opencensus.ext.azure.common.transport import (
-    TransportMixin,
-    TransportStatusCode,
-)
-from opencensus.ext.azure.statsbeat import statsbeat
-from opencensus.trace import attributes_helper
-from opencensus.trace.span import SpanKind
-
-try:
-    from urllib.parse import urlparse
-except ImportError:
-    from urlparse import urlparse
-
-logger = logging.getLogger(__name__)
-
-__all__ = ['AzureExporter']
-
-HTTP_METHOD = attributes_helper.COMMON_ATTRIBUTES['HTTP_METHOD']
-HTTP_PATH = attributes_helper.COMMON_ATTRIBUTES['HTTP_PATH']
-HTTP_ROUTE = attributes_helper.COMMON_ATTRIBUTES['HTTP_ROUTE']
-HTTP_URL = attributes_helper.COMMON_ATTRIBUTES['HTTP_URL']
-HTTP_STATUS_CODE = attributes_helper.COMMON_ATTRIBUTES['HTTP_STATUS_CODE']
-ERROR_MESSAGE = attributes_helper.COMMON_ATTRIBUTES['ERROR_MESSAGE']
-ERROR_NAME = attributes_helper.COMMON_ATTRIBUTES['ERROR_NAME']
-STACKTRACE = attributes_helper.COMMON_ATTRIBUTES['STACKTRACE']
-
-
-class AzureExporter(BaseExporter, TransportMixin, ProcessorMixin):
-    """An exporter that sends traces to Microsoft Azure Monitor.
-
-    :param options: Options for the exporter.
-    """
-
-    def __init__(self, **options):
-        super(AzureExporter, self).__init__(**options)
-        self.options = Options(**options)
-        utils.validate_instrumentation_key(self.options.instrumentation_key)
-        self.storage = None
-        if self.options.enable_local_storage:
-            self.storage = LocalFileStorage(
-                path=self.options.storage_path,
-                max_size=self.options.storage_max_size,
-                maintenance_period=self.options.storage_maintenance_period,
-                retention_period=self.options.storage_retention_period,
-                source=self.__class__.__name__,
-            )
-        self._telemetry_processors = []
-        atexit.register(self._stop, self.options.grace_period)
-        # start statsbeat on exporter instantiation
-        if self._check_stats_collection():
-            statsbeat.collect_statsbeat_metrics(self.options)
-        # For redirects
-        self._consecutive_redirects = 0  # To prevent circular redirects
-
-    def span_data_to_envelope(self, sd):
-        envelope = Envelope(
-            iKey=self.options.instrumentation_key,
-            tags=dict(utils.azure_monitor_context),
-            time=sd.start_time,
-        )
-
-        envelope.tags['ai.operation.id'] = sd.context.trace_id
-        if sd.parent_span_id:
-            envelope.tags['ai.operation.parentId'] = '{}'.format(
-                sd.parent_span_id,
-            )
-        if sd.span_kind == SpanKind.SERVER:
-            if ERROR_MESSAGE in sd.attributes:
-                message = sd.attributes.get(ERROR_MESSAGE)
-                if not message:
-                    message = "Exception"
-                stack_trace = sd.attributes.get(STACKTRACE, [])
-                if not hasattr(stack_trace, '__iter__'):
-                    stack_trace = []
-                type_name = sd.attributes.get(ERROR_NAME, 'Exception')
-                exc_env = Envelope(**envelope)
-                exc_env.name = 'Microsoft.ApplicationInsights.Exception'
-                data = ExceptionData(
-                    exceptions=[{
-                        'id': 1,
-                        'outerId': 0,
-                        'typeName': type_name,
-                        'message': message,
-                        'hasFullStack': STACKTRACE in sd.attributes,
-                        'parsedStack': stack_trace
-                    }],
-                )
-                exc_env.data = Data(baseData=data, baseType='ExceptionData')
-                yield exc_env
-
-            envelope.name = 'Microsoft.ApplicationInsights.Request'
-            data = Request(
-                id='{}'.format(sd.span_id),
-                duration=utils.timestamp_to_duration(
-                    sd.start_time,
-                    sd.end_time,
-                ),
-                responseCode=str(sd.status.code),
-                success=False,  # Modify based off attributes or status
-                properties={},
-            )
-            envelope.data = Data(baseData=data, baseType='RequestData')
-            data.name = ''
-            if HTTP_METHOD in sd.attributes:
-                data.name = sd.attributes[HTTP_METHOD]
-            if HTTP_ROUTE in sd.attributes:
-                data.name = data.name + ' ' + sd.attributes[HTTP_ROUTE]
-                envelope.tags['ai.operation.name'] = data.name
-                data.properties['request.name'] = data.name
-            elif HTTP_PATH in sd.attributes:
-                data.properties['request.name'] = data.name + \
-                    ' ' + sd.attributes[HTTP_PATH]
-            if HTTP_URL in sd.attributes:
-                data.url = sd.attributes[HTTP_URL]
-                data.properties['request.url'] = sd.attributes[HTTP_URL]
-            if HTTP_STATUS_CODE in sd.attributes:
-                status_code = sd.attributes[HTTP_STATUS_CODE]
-                data.responseCode = str(status_code)
-                data.success = (
-                    status_code >= 200 and status_code <= 399
-                )
-            elif sd.status.code == 0:
-                data.success = True
-        else:
-            envelope.name = \
-                'Microsoft.ApplicationInsights.RemoteDependency'
-            data = RemoteDependency(
-                name=sd.name,  # TODO
-                id='{}'.format(sd.span_id),
-                resultCode=str(sd.status.code),
-                duration=utils.timestamp_to_duration(
-                    sd.start_time,
-                    sd.end_time,
-                ),
-                success=False,  # Modify based off attributes or status
-                properties={},
-            )
-            envelope.data = Data(
-                baseData=data,
-                baseType='RemoteDependencyData',
-            )
-            if sd.span_kind == SpanKind.CLIENT:
-                data.type = sd.attributes.get('component')
-                if HTTP_URL in sd.attributes:
-                    url = sd.attributes[HTTP_URL]
-                    # TODO: error handling, probably put scheme as well
-                    data.data = url
-                    parse_url = urlparse(url)
-                    # target matches authority (host:port)
-                    data.target = parse_url.netloc
-                    if HTTP_METHOD in sd.attributes:
-                        # name is METHOD/path
-                        data.name = sd.attributes[HTTP_METHOD] \
-                            + ' ' + parse_url.path
-                if HTTP_STATUS_CODE in sd.attributes:
-                    status_code = sd.attributes[HTTP_STATUS_CODE]
-                    data.resultCode = str(status_code)
-                    data.success = 200 <= status_code < 400
-                elif sd.status.code == 0:
-                    data.success = True
-            else:
-                data.type = 'INPROC'
-                data.success = True
-        if sd.links:
-            links = []
-            for link in sd.links:
-                links.append(
-                    {"operation_Id": link.trace_id, "id": link.span_id})
-            data.properties["_MS.links"] = json.dumps(links)
-        # TODO: tracestate, tags
-        for key in sd.attributes:
-            # This removes redundant data from ApplicationInsights
-            if key.startswith('http.'):
-                continue
-            data.properties[key] = sd.attributes[key]
-        yield envelope
-
-    def emit(self, batch, event=None):
-        try:
-            if batch:
-                envelopes = [envelope
-                             for sd in batch
-                             for envelope in self.span_data_to_envelope(sd)]
-                envelopes = self.apply_telemetry_processors(envelopes)
-                result = self._transmit(envelopes)
-                # Only store files if local storage enabled
-                if self.storage and result is TransportStatusCode.RETRY:
-                    self.storage.put(
-                        envelopes,
-                        self.options.minimum_retry_interval
-                    )
-            if event:
-                if self.storage and isinstance(event, QueueExitEvent):
-                    self._transmit_from_storage()  # send files before exit
-                event.set()
-                return
-            if self.storage and len(batch) < self.options.max_batch_size:
-                self._transmit_from_storage()
-        except Exception:
-            logger.exception('Exception occurred while exporting the data.')
-
-    def _stop(self, timeout=None):
-        if self.storage:
-            self.storage.close()
-        if self._worker:
-            self._worker.stop(timeout)
+# Copyright 2019, OpenCensus Authors
+#
+# 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 atexit
+import json
+import logging
+
+from opencensus.common.schedule import QueueExitEvent
+from opencensus.ext.azure.common import Options, utils
+from opencensus.ext.azure.common.exporter import BaseExporter
+from opencensus.ext.azure.common.processor import ProcessorMixin
+from opencensus.ext.azure.common.protocol import (
+    Data,
+    Envelope,
+    ExceptionData,
+    RemoteDependency,
+    Request,
+)
+from opencensus.ext.azure.common.storage import LocalFileStorage
+from opencensus.ext.azure.common.transport import (
+    TransportMixin,
+    TransportStatusCode,
+)
+from opencensus.ext.azure.statsbeat import statsbeat
+from opencensus.trace import attributes_helper
+from opencensus.trace.span import SpanKind
+
+try:
+    from urllib.parse import urlparse
+except ImportError:
+    from urlparse import urlparse
+
+logger = logging.getLogger(__name__)
+
+__all__ = ['AzureExporter']
+
+HTTP_METHOD = attributes_helper.COMMON_ATTRIBUTES['HTTP_METHOD']
+HTTP_PATH = attributes_helper.COMMON_ATTRIBUTES['HTTP_PATH']
+HTTP_ROUTE = attributes_helper.COMMON_ATTRIBUTES['HTTP_ROUTE']
+HTTP_URL = attributes_helper.COMMON_ATTRIBUTES['HTTP_URL']
+HTTP_STATUS_CODE = attributes_helper.COMMON_ATTRIBUTES['HTTP_STATUS_CODE']
+ERROR_MESSAGE = attributes_helper.COMMON_ATTRIBUTES['ERROR_MESSAGE']
+ERROR_NAME = attributes_helper.COMMON_ATTRIBUTES['ERROR_NAME']
+STACKTRACE = attributes_helper.COMMON_ATTRIBUTES['STACKTRACE']
+
+
+class AzureExporter(BaseExporter, TransportMixin, ProcessorMixin):
+    """An exporter that sends traces to Microsoft Azure Monitor.
+
+    :param options: Options for the exporter.
+    """
+
+    def __init__(self, **options):
+        super(AzureExporter, self).__init__(**options)
+        self.options = Options(**options)
+        utils.validate_instrumentation_key(self.options.instrumentation_key)
+        self.storage = None
+        if self.options.enable_local_storage:
+            self.storage = LocalFileStorage(
+                path=self.options.storage_path,
+                max_size=self.options.storage_max_size,
+                maintenance_period=self.options.storage_maintenance_period,
+                retention_period=self.options.storage_retention_period,
+                source=self.__class__.__name__,
+            )
+        self._telemetry_processors = []
+        atexit.register(self._stop, self.options.grace_period)
+        # start statsbeat on exporter instantiation
+        if self._check_stats_collection():
+            statsbeat.collect_statsbeat_metrics(self.options)
+        # For redirects
+        self._consecutive_redirects = 0  # To prevent circular redirects
+
+    def span_data_to_envelope(self, sd):
+        envelope = Envelope(
+            iKey=self.options.instrumentation_key,
+            tags=dict(utils.azure_monitor_context),
+            time=sd.start_time,
+        )
+
+        envelope.tags['ai.operation.id'] = sd.context.trace_id
+        if sd.parent_span_id:
+            envelope.tags['ai.operation.parentId'] = '{}'.format(
+                sd.parent_span_id,
+            )
+        if sd.span_kind == SpanKind.SERVER:
+            if ERROR_MESSAGE in sd.attributes:
+                message = sd.attributes.get(ERROR_MESSAGE)
+                if not message:
+                    message = "Exception"
+                stack_trace = sd.attributes.get(STACKTRACE, [])
+                if not hasattr(stack_trace, '__iter__'):
+                    stack_trace = []
+                type_name = sd.attributes.get(ERROR_NAME, 'Exception')
+                exc_env = Envelope(**envelope)
+                exc_env.name = 'Microsoft.ApplicationInsights.Exception'
+                data = ExceptionData(
+                    exceptions=[{
+                        'id': 1,
+                        'outerId': 0,
+                        'typeName': type_name,
+                        'message': message,
+                        'hasFullStack': STACKTRACE in sd.attributes,
+                        'parsedStack': stack_trace
+                    }],
+                )
+                exc_env.data = Data(baseData=data, baseType='ExceptionData')
+                yield exc_env
+
+            envelope.name = 'Microsoft.ApplicationInsights.Request'
+            data = Request(
+                id='{}'.format(sd.span_id),
+                duration=utils.timestamp_to_duration(
+                    sd.start_time,
+                    sd.end_time,
+                ),
+                responseCode=str(sd.status.code),
+                success=False,  # Modify based off attributes or status
+                properties={},
+            )
+            envelope.data = Data(baseData=data, baseType='RequestData')
+            data.name = ''
+            if HTTP_METHOD in sd.attributes:
+                data.name = sd.attributes[HTTP_METHOD]
+            if HTTP_ROUTE in sd.attributes:
+                data.name = data.name + ' ' + sd.attributes[HTTP_ROUTE]
+                envelope.tags['ai.operation.name'] = data.name
+                data.properties['request.name'] = data.name
+            elif HTTP_PATH in sd.attributes:
+                data.properties['request.name'] = data.name + \
+                    ' ' + sd.attributes[HTTP_PATH]
+            if HTTP_URL in sd.attributes:
+                data.url = sd.attributes[HTTP_URL]
+                data.properties['request.url'] = sd.attributes[HTTP_URL]
+            if HTTP_STATUS_CODE in sd.attributes:
+                status_code = sd.attributes[HTTP_STATUS_CODE]
+                data.responseCode = str(status_code)
+                data.success = (
+                    status_code >= 200 and status_code <= 399
+                )
+            elif sd.status.code == 0:
+                data.success = True
+        else:
+            envelope.name = \
+                'Microsoft.ApplicationInsights.RemoteDependency'
+            data = RemoteDependency(
+                name=sd.name,  # TODO
+                id='{}'.format(sd.span_id),
+                resultCode=str(sd.status.code),
+                duration=utils.timestamp_to_duration(
+                    sd.start_time,
+                    sd.end_time,
+                ),
+                success=False,  # Modify based off attributes or status
+                properties={},
+            )
+            envelope.data = Data(
+                baseData=data,
+                baseType='RemoteDependencyData',
+            )
+            if sd.span_kind == SpanKind.CLIENT:
+                data.type = sd.attributes.get('component')
+                if HTTP_URL in sd.attributes:
+                    url = sd.attributes[HTTP_URL]
+                    # TODO: error handling, probably put scheme as well
+                    data.data = url
+                    parse_url = urlparse(url)
+                    # target matches authority (host:port)
+                    data.target = parse_url.netloc
+                    if HTTP_METHOD in sd.attributes:
+                        # name is METHOD/path
+                        data.name = sd.attributes[HTTP_METHOD] \
+                            + ' ' + parse_url.path
+                if HTTP_STATUS_CODE in sd.attributes:
+                    status_code = sd.attributes[HTTP_STATUS_CODE]
+                    data.resultCode = str(status_code)
+                    data.success = 200 <= status_code < 400
+                elif sd.status.code == 0:
+                    data.success = True
+            else:
+                data.type = 'INPROC'
+                data.success = True
+        if sd.links:
+            links = []
+            for link in sd.links:
+                links.append(
+                    {"operation_Id": link.trace_id, "id": link.span_id})
+            data.properties["_MS.links"] = json.dumps(links)
+        # TODO: tracestate, tags
+        for key in sd.attributes:
+            # This removes redundant data from ApplicationInsights
+            if key.startswith('http.'):
+                continue
+            data.properties[key] = sd.attributes[key]
+        yield envelope
+
+    def emit(self, batch, event=None):
+        try:
+            if batch:
+                envelopes = [envelope
+                             for sd in batch
+                             for envelope in self.span_data_to_envelope(sd)]
+                envelopes = self.apply_telemetry_processors(envelopes)
+                result = self._transmit(envelopes)
+                # Only store files if local storage enabled
+                if self.storage and result is TransportStatusCode.RETRY:
+                    self.storage.put(
+                        envelopes,
+                        self.options.minimum_retry_interval
+                    )
+            if event:
+                if self.storage and isinstance(event, QueueExitEvent):
+                    self._transmit_from_storage()  # send files before exit
+                event.set()
+                return
+            if self.storage and len(batch) < self.options.max_batch_size:
+                self._transmit_from_storage()
+        except Exception:
+            logger.exception('Exception occurred while exporting the data.')
+
+    def _stop(self, timeout=None):
+        if self.storage:
+            self.storage.close()
+        if self._worker:
+            self._worker.stop(timeout)

py2docfx/venv/venv1/Lib/site-packages/packaging/__init__.py

@@ -0,0 +1,15 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+__title__ = "packaging"
+__summary__ = "Core utilities for Python packages"
+__uri__ = "https://github.com/pypa/packaging"
+
+__version__ = "25.0"
+
+__author__ = "Donald Stufft and individual contributors"
+__email__ = "donald@stufft.io"
+
+__license__ = "BSD-2-Clause or Apache-2.0"
+__copyright__ = f"2014 {__author__}"

py2docfx/venv/{basevenv/Lib/site-packages/wheel/vendored → venv1/Lib/site-packages}/packaging/_elffile.py

@@ -8,10 +8,12 @@ Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca
 ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html
 """
 
+from __future__ import annotations
+
 import enum
 import os
 import struct
-from typing import IO, Optional, Tuple
+from typing import IO
 
 
 class ELFInvalid(ValueError):
@@ -46,8 +48,8 @@ class ELFFile:
 
         try:
             ident = self._read("16B")
-        except struct.error:
-            raise ELFInvalid("unable to parse identification")
+        except struct.error as e:
+            raise ELFInvalid("unable to parse identification") from e
         magic = bytes(ident[:4])
         if magic != b"\x7fELF":
             raise ELFInvalid(f"invalid magic: {magic!r}")
@@ -65,11 +67,10 @@ class ELFFile:
                 (2, 1): ("<HHIQQQIHHH", "<IIQQQQQQ", (0, 2, 5)),  # 64-bit LSB.
                 (2, 2): (">HHIQQQIHHH", ">IIQQQQQQ", (0, 2, 5)),  # 64-bit MSB.
             }[(self.capacity, self.encoding)]
-        except KeyError:
+        except KeyError as e:
             raise ELFInvalid(
-                f"unrecognized capacity ({self.capacity}) or "
-                f"encoding ({self.encoding})"
-            )
+                f"unrecognized capacity ({self.capacity}) or encoding ({self.encoding})"
+            ) from e
 
         try:
             (
@@ -87,11 +88,11 @@ class ELFFile:
         except struct.error as e:
             raise ELFInvalid("unable to parse machine and section information") from e
 
-    def _read(self, fmt: str) -> Tuple[int, ...]:
+    def _read(self, fmt: str) -> tuple[int, ...]:
         return struct.unpack(fmt, self._f.read(struct.calcsize(fmt)))
 
     @property
-    def interpreter(self) -> Optional[str]:
+    def interpreter(self) -> str | None:
         """
         The path recorded in the ``PT_INTERP`` section header.
         """

py2docfx/venv/venv1/Lib/site-packages/{wheel/vendored/packaging → packaging}/_manylinux.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import collections
 import contextlib
 import functools
@@ -5,7 +7,7 @@ import os
 import re
 import sys
 import warnings
-from typing import Dict, Generator, Iterator, NamedTuple, Optional, Sequence, Tuple
+from typing import Generator, Iterator, NamedTuple, Sequence
 
 from ._elffile import EIClass, EIData, ELFFile, EMachine
 
@@ -17,7 +19,7 @@ EF_ARM_ABI_FLOAT_HARD = 0x00000400
 # `os.PathLike` not a generic type until Python 3.9, so sticking with `str`
 # as the type for `path` until then.
 @contextlib.contextmanager
-def _parse_elf(path: str) -> Generator[Optional[ELFFile], None, None]:
+def _parse_elf(path: str) -> Generator[ELFFile | None, None, None]:
     try:
         with open(path, "rb") as f:
             yield ELFFile(f)
@@ -72,7 +74,7 @@ def _have_compatible_abi(executable: str, archs: Sequence[str]) -> bool:
 # For now, guess what the highest minor version might be, assume it will
 # be 50 for testing. Once this actually happens, update the dictionary
 # with the actual value.
-_LAST_GLIBC_MINOR: Dict[int, int] = collections.defaultdict(lambda: 50)
+_LAST_GLIBC_MINOR: dict[int, int] = collections.defaultdict(lambda: 50)
 
 
 class _GLibCVersion(NamedTuple):
@@ -80,7 +82,7 @@ class _GLibCVersion(NamedTuple):
     minor: int
 
 
-def _glibc_version_string_confstr() -> Optional[str]:
+def _glibc_version_string_confstr() -> str | None:
     """
     Primary implementation of glibc_version_string using os.confstr.
     """
@@ -90,7 +92,7 @@ def _glibc_version_string_confstr() -> Optional[str]:
     # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183
     try:
         # Should be a string like "glibc 2.17".
-        version_string: Optional[str] = os.confstr("CS_GNU_LIBC_VERSION")
+        version_string: str | None = os.confstr("CS_GNU_LIBC_VERSION")
         assert version_string is not None
         _, version = version_string.rsplit()
     except (AssertionError, AttributeError, OSError, ValueError):
@@ -99,7 +101,7 @@ def _glibc_version_string_confstr() -> Optional[str]:
     return version
 
 
-def _glibc_version_string_ctypes() -> Optional[str]:
+def _glibc_version_string_ctypes() -> str | None:
     """
     Fallback implementation of glibc_version_string using ctypes.
     """
@@ -143,12 +145,12 @@ def _glibc_version_string_ctypes() -> Optional[str]:
     return version_str
 
 
-def _glibc_version_string() -> Optional[str]:
+def _glibc_version_string() -> str | None:
     """Returns glibc version string, or None if not using glibc."""
     return _glibc_version_string_confstr() or _glibc_version_string_ctypes()
 
 
-def _parse_glibc_version(version_str: str) -> Tuple[int, int]:
+def _parse_glibc_version(version_str: str) -> tuple[int, int]:
     """Parse glibc version.
 
     We use a regexp instead of str.split because we want to discard any
@@ -159,16 +161,16 @@ def _parse_glibc_version(version_str: str) -> Tuple[int, int]:
     m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str)
     if not m:
         warnings.warn(
-            f"Expected glibc version with 2 components major.minor,"
-            f" got: {version_str}",
+            f"Expected glibc version with 2 components major.minor, got: {version_str}",
             RuntimeWarning,
+            stacklevel=2,
         )
         return -1, -1
     return int(m.group("major")), int(m.group("minor"))
 
 
 @functools.lru_cache
-def _get_glibc_version() -> Tuple[int, int]:
+def _get_glibc_version() -> tuple[int, int]:
     version_str = _glibc_version_string()
     if version_str is None:
         return (-1, -1)