datadog-checks-base 37.23.2__py2.py3-none-any.whl → 37.24.0__py2.py3-none-any.whl

datadog_checks/base/__about__.py

@@ -1,4 +1,4 @@
 # (C) Datadog, Inc. 2018-present
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
-__version__ = "37.23.2"
+__version__ = "37.24.0"

datadog_checks/base/checks/base.py

@@ -1487,14 +1487,20 @@ class AgentCheck(object):
         import subprocess
         import sys
 
+        # Force UTF-8 encoding for subprocess
+        env = os.environ.copy()
+        env['PYTHONIOENCODING'] = 'utf-8'
+
         process = subprocess.Popen(
             [sys.executable, '-c', 'import sys, yaml; print(yaml.safe_load(sys.stdin.read()))'],
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            env=env,
         )
-        stdout, stderr = process.communicate(yaml_str.encode())
+        # Explicitly encode as UTF-8 to match PYTHONIOENCODING
+        stdout, stderr = process.communicate(yaml_str.encode('utf-8'))
         if process.returncode != 0:
-            raise ValueError(f'Failed to load config: {stderr.decode()}')
+            raise ValueError(f'Failed to load config: {stderr.decode("utf-8", errors="replace")}')
 
-        return _parse_ast_config(stdout.strip().decode())
+        return _parse_ast_config(stdout.strip().decode('utf-8'))

datadog_checks/base/checks/db.py

@@ -2,6 +2,8 @@
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
 
+from abc import abstractmethod
+
 from . import AgentCheck
 
 
@@ -20,3 +22,32 @@ class DatabaseCheck(AgentCheck):
 
     def database_monitoring_health(self, raw_event: str):
         self.event_platform_event(raw_event, "dbm-health")
+
+    @property
+    @abstractmethod
+    def reported_hostname(self) -> str | None:
+        pass
+
+    @property
+    @abstractmethod
+    def database_identifier(self) -> str:
+        pass
+
+    @property
+    def dbms(self) -> str:
+        return self.__class__.__name__.lower()
+
+    @property
+    @abstractmethod
+    def dbms_version(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def tags(self) -> list[str]:
+        pass
+
+    @property
+    @abstractmethod
+    def cloud_metadata(self) -> dict:
+        pass

datadog_checks/base/checks/win/wmi/base.py

@@ -110,8 +110,8 @@ class WinWMICheck(AgentCheck):
             )
             raise TypeError
 
-    def _get_tag_query_tag(self, sampler, wmi_obj, tag_query):
-        # type: (WMISampler, WMIObject, TagQuery) -> str
+    def _get_tag_query_tag(self, sampler, wmi_obj, tag_query, alias):
+        # type: (WMISampler, WMIObject, TagQuery, str) -> str
         """
         Design a query based on the given WMIObject to extract a tag.
 
@@ -133,13 +133,14 @@ class WinWMICheck(AgentCheck):
 
             link_value = str(tag_query_sampler[0][target_property]).lower()
 
-        tag = "{tag_name}:{tag_value}".format(tag_name=target_property.lower(), tag_value="_".join(link_value.split()))
+        tag_name = alias.lower()
+        tag = "{tag_name}:{tag_value}".format(tag_name=tag_name, tag_value="_".join(link_value.split()))
 
         self.log.debug("Extracted `tag_queries` tag: '%s'", tag)
         return tag
 
-    def _extract_metrics(self, wmi_sampler, tag_by, tag_queries, constant_tags):
-        # type: (WMISampler, str, List[List[str]], List[str]) -> List[WMIMetric]
+    def _extract_metrics(self, wmi_sampler, tag_by, tag_queries, constant_tags, tag_by_aliases, tag_queries_aliases):
+        # type: (WMISampler, str, List[List[str]], List[str], Dict[str, str], List[str]) -> List[WMIMetric]
         """
         Extract and tag metrics from the WMISampler.
 
@@ -170,9 +171,9 @@ class WinWMICheck(AgentCheck):
             tags = list(constant_tags) if constant_tags else []
 
             # Tag with `tag_queries` parameter
-            for query in tag_queries:
+            for index, query in enumerate(tag_queries):
                 try:
-                    tags.append(self._get_tag_query_tag(wmi_sampler, wmi_obj, query))
+                    tags.append(self._get_tag_query_tag(wmi_sampler, wmi_obj, query, tag_queries_aliases[index]))
                 except TagQueryUniquenessFailure:
                     continue
 
@@ -193,17 +194,17 @@ class WinWMICheck(AgentCheck):
                     continue
                 # Tag with `tag_by` parameter
                 for t in tag_by.split(','):
-                    t = t.strip()
-                    if wmi_property == t:
+                    if normalized_wmi_property == t:
                         tag_value = str(wmi_value).lower()
                         if tag_queries and tag_value.find("#") > 0:
                             tag_value = tag_value[: tag_value.find("#")]
 
-                        tags.append("{name}:{value}".format(name=t, value=tag_value))
+                        alias = tag_by_aliases.get(t)
+                        tags.append("{name}:{value}".format(name=alias, value=tag_value))
                         continue
 
                 # No metric extraction on 'Name' and properties in tag_by
-                if wmi_property == 'name' or normalized_wmi_property in tag_by.lower():
+                if normalized_wmi_property == 'name' or normalized_wmi_property in tag_by.lower():
                     continue
 
                 try:
@@ -260,6 +261,7 @@ class WinWMICheck(AgentCheck):
     def get_running_wmi_sampler(self, properties, filters, **kwargs):
         # type: (List[str], List[Dict[str, WMIFilter]], **Any) -> WMISampler
         tag_by = kwargs.pop('tag_by', "")
+
         return self._get_running_wmi_sampler(
             instance_key=None,
             wmi_class=self.wmi_class,
@@ -303,6 +305,49 @@ class WinWMICheck(AgentCheck):
 
         return self._wmi_props
 
+    def parse_tag_queries_aliases(self, tag_queries):
+        # type: (List[TagQuery]) -> None
+        """
+        Validate tag_queries configuration to ensure aliases are provided when 'AS' is used.
+        return parsed_tag_queries and aliases
+        """
+        aliases = []  # type: list[str]
+        parsed_tag_queries = []  # type: list[TagQuery]
+        for tag_query in tag_queries:
+            if len(tag_query) < 4:
+                continue
+            target_property_str = tag_query[3]
+            property, alias = self.parse_alias(target_property_str)
+            aliases.append(alias)
+            tag_query[3] = property
+            parsed_tag_queries.append(tag_query)
+        return parsed_tag_queries, aliases
+
+    def parse_alias(self, property):
+        # type: (str) -> Tuple[str, Optional[str]]
+        """
+        Parse an alias from a string.
+        """
+        property = property.strip().lower()
+        if ' as ' in property:
+            # Valid format: property AS alias (with spaces around AS)
+            property_split = property.split(' as ')
+            property = property_split[0].strip()
+            alias = property_split[1].strip()
+            self.log.debug("Parsed alias: {%s} for property: {%s}", alias, property)
+            if alias == "":
+                self.log.warning("No alias provided after 'AS' for property: %s. Using property for tag", property)
+                alias = property
+        elif ' as' in property:
+            # Invalid format: AS found but without proper spacing
+            raise InvalidWMIQuery(
+                "Invalid alias syntax in property '{}'. "
+                "Expected format: 'property AS alias' with spaces around 'AS'".format(property)
+            )
+        else:
+            alias = property
+        return property, alias
+
 
 def from_time(
     year=None, month=None, day=None, hours=None, minutes=None, seconds=None, microseconds=None, timezone=None

datadog_checks/base/utils/db/schemas.py

@@ -0,0 +1,189 @@
+# (C) Datadog, Inc. 2025-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, TypedDict
+
+from datadog_checks.base.utils.serialization import json
+
+from .utils import now_ms
+
+if TYPE_CHECKING:
+    from datadog_checks.base.checks.db import DatabaseCheck
+
+try:
+    import datadog_agent  # type: ignore
+except ImportError:
+    from datadog_checks.base.stubs import datadog_agent
+
+
+class DatabaseInfo(TypedDict):
+    name: str
+
+
+# The schema collector sends lists of DatabaseObjects to the agent
+# DBMS subclasses may add additional fields to the dictionary
+class DatabaseObject(TypedDict):
+    name: str
+
+
+# Common configuration for schema collector
+# Individual DBMS implementations should map their specific
+# configuration to this type
+class SchemaCollectorConfig:
+    def __init__(self):
+        self.collection_interval = 3600
+        self.payload_chunk_size = 10_000
+
+
+class SchemaCollector(ABC):
+    """
+    Abstract base class for DBM schema collectors.
+    """
+
+    def __init__(self, check: DatabaseCheck, config: SchemaCollectorConfig):
+        self._check = check
+        self._log = check.log
+        self._config = config
+        self._reset()
+
+    def _reset(self):
+        # Timestamp in whole milliseconds when the current collection started.
+        self._collection_started_at = None
+        self._collection_payloads_count = 0
+        self._queued_rows = []
+        self._total_rows_count = 0
+
+    def collect_schemas(self) -> bool:
+        """
+        Collects and submits all applicable schema metadata to the agent.
+        This class relies on the owning check to handle scheduling this method.
+        """
+        status = "success"
+        try:
+            self._collection_started_at = now_ms()
+            databases = self._get_databases()
+            self._log.debug("Collecting schemas for %d databases", len(databases))
+            for database in databases:
+                self._log.debug("Starting collection of schemas for database %s", database['name'])
+                database_name = database['name']
+                if not database_name:
+                    self._log.warning("database has no name %v", database)
+                    continue
+                with self._get_cursor(database_name) as cursor:
+                    # Get the next row from the cursor
+                    # We need to know when we've reached the last row so we can efficiently flush the last payload
+                    # without an empty final payload
+                    next_row = self._get_next(cursor)
+                    while next_row:
+                        self._queued_rows.append(self._map_row(database, next_row))
+                        self._total_rows_count += 1
+                        # Because we're iterating over a cursor we need to try to get
+                        # the next row to see if we've reached the last row
+                        next_row = self._get_next(cursor)
+                        is_last_payload = database == databases[-1] and next_row is None
+                        self.maybe_flush(is_last_payload)
+                self._log.debug("Completed collection of schemas for database %s", database_name)
+        except Exception as e:
+            status = "error"
+            self._log.error("Error collecting schema: %s", e)
+            raise e
+        finally:
+            self._check.histogram(
+                f"dd.{self._check.dbms}.schema.time",
+                now_ms() - self._collection_started_at,
+                tags=self._check.tags + ["status:" + status],
+                hostname=self._check.reported_hostname,
+                raw=True,
+            )
+            self._check.gauge(
+                f"dd.{self._check.dbms}.schema.tables_count",
+                self._total_rows_count,
+                tags=self._check.tags + ["status:" + status],
+                hostname=self._check.reported_hostname,
+                raw=True,
+            )
+            self._check.gauge(
+                f"dd.{self._check.dbms}.schema.payloads_count",
+                self._collection_payloads_count,
+                tags=self._check.tags + ["status:" + status],
+                hostname=self._check.reported_hostname,
+                raw=True,
+            )
+
+            self._reset()
+        return True
+
+    @property
+    def base_event(self):
+        return {
+            "host": self._check.reported_hostname,
+            "database_instance": self._check.database_identifier,
+            "kind": self.kind,
+            "agent_version": datadog_agent.get_version(),
+            "collection_interval": self._config.collection_interval,
+            "dbms": self._check.dbms,
+            "dbms_version": str(self._check.dbms_version),
+            "tags": self._check.tags,
+            "cloud_metadata": self._check.cloud_metadata,
+            "collection_started_at": self._collection_started_at,
+        }
+
+    def maybe_flush(self, is_last_payload):
+        if is_last_payload or len(self._queued_rows) >= self._config.payload_chunk_size:
+            event = self.base_event
+            event["timestamp"] = now_ms()
+            # DBM backend expects metadata to be an array of database objects
+            event["metadata"] = self._queued_rows
+            self._collection_payloads_count += 1
+            if is_last_payload:
+                # For the last payload, we need to include the total number of payloads collected
+                # This is used for snapshotting to ensure that all payloads have been received
+                event["collection_payloads_count"] = self._collection_payloads_count
+            self._check.database_monitoring_metadata(json.dumps(event))
+
+            self._queued_rows = []
+
+    @property
+    @abstractmethod
+    def kind(self) -> str:
+        """
+        Returns the kind property of the schema metadata event.
+        Subclasses should override this property to return the kind of schema being collected.
+        """
+        raise NotImplementedError("Subclasses must implement kind")
+
+    @abstractmethod
+    def _get_databases(self) -> list[DatabaseInfo]:
+        """
+        Returns a list of database dictionaries.
+        Subclasses should override this method to return the list of databases to collect schema metadata for.
+        """
+        raise NotImplementedError("Subclasses must implement _get_databases")
+
+    @abstractmethod
+    def _get_cursor(self, database):
+        """
+        Returns a cursor for the given database.
+        Subclasses should override this method to return the cursor for the given database.
+        """
+        raise NotImplementedError("Subclasses must implement _get_cursor")
+
+    @abstractmethod
+    def _get_next(self, cursor):
+        """
+        Returns the next row from the cursor.
+        Subclasses should override this method to return the next row from the cursor.
+        """
+        raise NotImplementedError("Subclasses must implement _get_next")
+
+    def _map_row(self, database: DatabaseInfo, _cursor_row) -> DatabaseObject:
+        """
+        Maps a cursor row to a dict that matches the schema expected by DBM.
+        The base implementation of this method returns just the database dictionary.
+        Subclasses should override this method to add schema and table data based on the cursor row.
+        """
+        return {**database}

datadog_checks/base/utils/db/utils.py

@@ -647,3 +647,10 @@ class TagManager:
         # Generate and cache regular tags
         self._cached_tag_list = self._generate_tag_strings(self._tags)
         return list(self._cached_tag_list)
+
+
+def now_ms() -> int:
+    """
+    Get the current time in whole milliseconds.
+    """
+    return int(time.time() * 1000)

{datadog_checks_base-37.23.2.dist-info → datadog_checks_base-37.24.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datadog-checks-base
-Version: 37.23.2
+Version: 37.24.0
 Summary: The Datadog Check Toolkit
 Project-URL: Source, https://github.com/DataDog/integrations-core
 Author-email: Datadog <packages@datadoghq.com>
@@ -31,7 +31,7 @@ Requires-Dist: requests-toolbelt==1.0.0; extra == 'deps'
 Requires-Dist: requests-unixsocket2==1.0.0; extra == 'deps'
 Requires-Dist: requests==2.32.5; extra == 'deps'
 Requires-Dist: simplejson==3.20.1; extra == 'deps'
-Requires-Dist: urllib3==2.6.2; extra == 'deps'
+Requires-Dist: urllib3==2.5.0; extra == 'deps'
 Requires-Dist: wrapt==1.17.3; extra == 'deps'
 Provides-Extra: http
 Requires-Dist: aws-requests-auth==0.4.3; extra == 'http'

{datadog_checks_base-37.23.2.dist-info → datadog_checks_base-37.24.0.dist-info}/RECORD

@@ -3,7 +3,7 @@ datadog_checks/config.py,sha256=PrAXGdlLnoV2VMQff_noSaSJJ0wg4BAiGnw7jCQLSik,196
 datadog_checks/errors.py,sha256=eFwmnrX-batIgbu-iJyseqAPNO_4rk1UuaKK89evLhg,155
 datadog_checks/log.py,sha256=orvOgMKGNEsqSTLalCAQpWP-ouorpG1A7Gn-j2mRD80,301
 datadog_checks/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-datadog_checks/base/__about__.py,sha256=mxfnF5UtdjcBXByAkU2G2evIXh0grpahewFqPQLc1RA,139
+datadog_checks/base/__about__.py,sha256=wSZGCjyvIvIxmZigNmkP1nHZ-mq9lRhQoAtnr48RZq8,139
 datadog_checks/base/__init__.py,sha256=yWegSLE-TZWIGSvAiJj9PSrUxzlOo_UVJLt2zORZ8Ek,363
 datadog_checks/base/__init__.pyi,sha256=a4Y1JIcPJ8pz9tRkBAvjWdtvSQwZxbMZBuRmIiSs_4E,1031
 datadog_checks/base/agent.py,sha256=nX9x_BYYizRKGNYfXq5z7S0FZ9xcX_wd2tuxpGe3_8k,350
@@ -15,8 +15,8 @@ datadog_checks/base/types.py,sha256=anajZS0W0TsxUHJQw-JHOP2NSeuC9BisXSy9mAStlxQ,
 datadog_checks/base/checks/__init__.py,sha256=q7V6v-FwQWkQC1QWaVzKaPjZMaxPJHJcLd71C0uM7bA,211
 datadog_checks/base/checks/__init__.pyi,sha256=ydetl6kEFCSChppYQhs8mvIP5l6vnZD5AbLABGhbFcM,309
 datadog_checks/base/checks/_config_ast.py,sha256=v1rAhwORF80b3kfZKhf6zXZ7S5D3A2QPUK4tSo8eo-Y,3268
-datadog_checks/base/checks/base.py,sha256=mnh61HRvHFisSP4IvUtoDPswxB3_ybX-nWkfXMyzWJE,60721
-datadog_checks/base/checks/db.py,sha256=HzEOH4uZaMDAaUTJYy0K5wV9FryNQDXsSMAOHXPVaf4,794
+datadog_checks/base/checks/base.py,sha256=UgQmWpClcMQ9hawWNcOFGMPrfSKu8YP22ovTEB1dAUg,60965
+datadog_checks/base/checks/db.py,sha256=9BeEwuDJ5TDXlq6yJXYVs9T_UlbCa3bWrSOq5ZshDKc,1350
 datadog_checks/base/checks/network.py,sha256=UkgqkVHaoX7Hqi0WKEx-TvaFiF6-37VyF9A3m2aSaJM,1966
 datadog_checks/base/checks/kube_leader/__init__.py,sha256=q7V6v-FwQWkQC1QWaVzKaPjZMaxPJHJcLd71C0uM7bA,211
 datadog_checks/base/checks/kube_leader/__init__.pyi,sha256=UGDywoRwmCIz3Zii1uHsp7jiFGWRdn5fFMZZxgGGlQs,398
@@ -75,7 +75,7 @@ datadog_checks/base/checks/win/winpdh_base.py,sha256=z3pPHG0H5ixwjeGi08cLe00VbZ3
 datadog_checks/base/checks/win/winpdh_stub.py,sha256=M5fyBkzAuEKvoZrG9ktQapwkH_7K-KOIYF5VpS83LMk,391
 datadog_checks/base/checks/win/wmi/__init__.py,sha256=q7V6v-FwQWkQC1QWaVzKaPjZMaxPJHJcLd71C0uM7bA,211
 datadog_checks/base/checks/win/wmi/__init__.pyi,sha256=2lgW_cDX36mGgwjBQ4jcUUkD4pIN73QfXvlPO7oK-X8,594
-datadog_checks/base/checks/win/wmi/base.py,sha256=QzwCEgzu9DF8hZwcwTNpomq0ApUWwZSNRS-oqbeJXG8,15155
+datadog_checks/base/checks/win/wmi/base.py,sha256=xbY8S4mvquI5m7o1b6baeauj6PxEr9eCKlugO_xsi1I,17152
 datadog_checks/base/checks/win/wmi/counter_type.py,sha256=7772XGtWyPJXewyvaYyowVmDy9DxZ42ki9WD5XabuVE,5773
 datadog_checks/base/checks/win/wmi/sampler.py,sha256=NJlkALF8y1khAWRocpbH2LpwxtQb2F8fzBhCavvRX4w,23490
 datadog_checks/base/checks/win/wmi/types.py,sha256=4E8e1ypp2P-eOxgLsRrftlauqvapWCuVaAPocqCrwVg,412
@@ -143,13 +143,14 @@ datadog_checks/base/utils/db/__init__.pyi,sha256=ewmGxxyJ52wAaYxNZahi2koEUnddfvH
 datadog_checks/base/utils/db/core.py,sha256=bYanwXIqBzsSxK7b-Ofb0W1WiHbFBtKyYdUBonBLe_Q,11165
 datadog_checks/base/utils/db/health.py,sha256=riJaJInOuYFK3y0wNH19HojIkXPwQaMtvxuyPCRxnZY,4182
 datadog_checks/base/utils/db/query.py,sha256=-PyxdqpbShkQ78h7sWnghQZVtjdLGVrm71n8OpHuPW4,14432
+datadog_checks/base/utils/db/schemas.py,sha256=RqEhbX-bZr335Ah6XdvPoB4XUQ-hE72tI0jNFCusXF4,7435
 datadog_checks/base/utils/db/sql.py,sha256=oiEzQa_vC_w3U65VFrFCoQHWj5GQLLRlSO0CfiSlp4A,2490
 datadog_checks/base/utils/db/sql_commenter.py,sha256=r_efK6TGRQxM_-Qj-ndEJdECk47J4nCFjkVyxu1XmvU,1522
 datadog_checks/base/utils/db/statement_metrics.py,sha256=U7EtERkmFzfCtfyd3094fBaKQ-CuJxoRt-3AcDBCkIA,7087
 datadog_checks/base/utils/db/timed_cache.py,sha256=a9Ks5KKUvExB6GOATXTSCLamVtLD919Dn6HpweGKtFw,2114
 datadog_checks/base/utils/db/transform.py,sha256=H3JN8_MF0Pk0HaXvIZeX1A8iQrP8KBgS741MPeBiWDo,23969
 datadog_checks/base/utils/db/types.py,sha256=OLX2Oq58JQPFBD4oqUpCLkAP7ovRGN_i1vFk1E0N8Lg,267
-datadog_checks/base/utils/db/utils.py,sha256=fJZrf2YcAbWmX4IRqLf4r0Rt8tGLDwgdIVmSMSft1co,26464
+datadog_checks/base/utils/db/utils.py,sha256=7h8kk7BdGcxC7EcySAS-fbZXp2vcTSGepO7u04U42SE,26586
 datadog_checks/base/utils/discovery/__init__.py,sha256=vPCOdsThBcBjFJRPhDm6IsZGOwk8HlvciwCe_l8dKLk,211
 datadog_checks/base/utils/discovery/__init__.pyi,sha256=ScVLU1Njj9ekZmewltb0cULI6BylssVHfn4CcPNeyr8,173
 datadog_checks/base/utils/discovery/cache.py,sha256=f9L3A7YZpZ-mpZpFIwjsa5ab9cZMGkqdetdr9EpalbI,887
@@ -223,6 +224,6 @@ datadog_checks/utils/tracing.py,sha256=HQbQakKM-Lw75MDkItaYJYipS6YO24Z_ymDVxDsx5
 datadog_checks/utils/prometheus/__init__.py,sha256=8WwXnM9g1sfS5267QYCJX_hd8MZl5kRgBgQ_SzdNdXs,161
 datadog_checks/utils/prometheus/functions.py,sha256=4vWsTGLgujHwdYZo0tlAQkqDPHofqUJM3k9eItJqERQ,197
 datadog_checks/utils/prometheus/metrics_pb2.py,sha256=xg3UdUHe4TjeR4s13LUKZ2U1WVSt6U6zjsVRG6lX6dc,173
-datadog_checks_base-37.23.2.dist-info/METADATA,sha256=zlabqwys0YOujr_DtntwAehdAzCahH89eqs7yxVzzms,4245
-datadog_checks_base-37.23.2.dist-info/WHEEL,sha256=aha0VrrYvgDJ3Xxl3db_g_MDIW-ZexDdrc_m-Hk8YY4,105
-datadog_checks_base-37.23.2.dist-info/RECORD,,
+datadog_checks_base-37.24.0.dist-info/METADATA,sha256=NONVEvQ8UyQLnGpL067F7u_Tp74pZRJME9rCn1f6THg,4245
+datadog_checks_base-37.24.0.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+datadog_checks_base-37.24.0.dist-info/RECORD,,

{datadog_checks_base-37.23.2.dist-info → datadog_checks_base-37.24.0.dist-info}/WHEEL

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