django-health-check 4.0rc2__tar.gz → 4.0rc4__tar.gz

{django_health_check-4.0rc2 → django_health_check-4.0rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-health-check
-Version: 4.0rc2
+Version: 4.0rc4
 Summary: Monitor the health of your Django app and its connected services.
 Keywords: django,postgresql
 Author-email: Kristian Ollegaard <kristian@oellegaard.com>, Johannes Maron <johannes@maron.family>
@@ -29,17 +29,20 @@ License-File: LICENSE
 Requires-Dist: Django>=5.2
 Requires-Dist: dnspython>=2.0.0
 Requires-Dist: psutil
+Requires-Dist: httpx>=0.27.0 ; extra == "atlassian"
 Requires-Dist: celery>=5.0.0 ; extra == "celery"
 Requires-Dist: confluent-kafka>=2.0.0 ; extra == "kafka"
 Requires-Dist: aio-pika>=9.0.0 ; extra == "rabbitmq"
 Requires-Dist: redis>=4.2.0 ; extra == "redis"
 Requires-Dist: httpx>=0.27.0 ; extra == "rss"
+Requires-Dist: feedparser>=6.0.0 ; extra == "rss"
 Project-URL: Changelog, https://github.com/codingjoe/django-health-check/releases
 Project-URL: Documentation, https://codingjoe.dev/django-health-check/
 Project-URL: Homepage, https://codingjoe.dev/django-health-check/
 Project-URL: Issues, https://github.com/codingjoe/django-health-check/issues
 Project-URL: Releasenotes, https://github.com/codingjoe/django-health-check/releases/latest
 Project-URL: Source, https://github.com/codingjoe/django-health-check
+Provides-Extra: atlassian
 Provides-Extra: celery
 Provides-Extra: kafka
 Provides-Extra: rabbitmq

{django_health_check-4.0rc2 → django_health_check-4.0rc4}/health_check/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '4.0rc2'
-__version_tuple__ = version_tuple = (4, 0, 'rc2')
+__version__ = version = '4.0rc4'
+__version_tuple__ = version_tuple = (4, 0, 'rc4')
 
-__commit_id__ = commit_id = 'gb01cffaff'
+__commit_id__ = commit_id = 'g4b2293052'

{django_health_check-4.0rc2 → django_health_check-4.0rc4}/health_check/checks.py

@@ -54,20 +54,30 @@ class Cache(HealthCheck):
 
     Args:
         alias: The cache alias to test against.
-        cache_key: The cache key to use for the test.
+        key_prefix: Prefix for the node specific cache key.
+        timeout: Time until probe keys expire in the cache backend.
 
     """
 
     alias: str = "default"
-    cache_key: str = dataclasses.field(default="djangohealthcheck_test", repr=False)
+    key_prefix: str = dataclasses.field(default="djangohealthcheck_test", repr=False)
+    timeout: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(seconds=5), repr=False
+    )
 
     async def run(self):
         cache = caches[self.alias]
-        ts = datetime.datetime.now().timestamp()
+        # Use an isolated key per probe run to avoid cross-process write races.
+        cache_key = f"{self.key_prefix}:{uuid.uuid4().hex}"
+        cache_value = f"itworks-{datetime.datetime.now().timestamp()}"
         try:
-            await cache.aset(self.cache_key, f"itworks-{ts}")
-            if not await cache.aget(self.cache_key) == f"itworks-{ts}":
-                raise ServiceUnavailable(f"Cache key {self.cache_key} does not match")
+            await cache.aset(
+                cache_key,
+                cache_value,
+                timeout=self.timeout.total_seconds(),
+            )
+            if not await cache.aget(cache_key) == cache_value:
+                raise ServiceUnavailable(f"Cache key {cache_key} does not match")
         except CacheKeyWarning as e:
             raise ServiceReturnedUnexpectedResult("Cache key warning") from e
         except ValueError as e:

django_health_check-4.0rc4/health_check/contrib/atlassian.py

@@ -0,0 +1,167 @@
+"""Atlassian Status Page API health checks for cloud provider status pages."""
+
+import dataclasses
+import datetime
+import logging
+import typing
+
+import httpx
+
+from health_check import HealthCheck, __version__
+from health_check.exceptions import ServiceUnavailable, ServiceWarning
+
+logger = logging.getLogger(__name__)
+
+
+class AtlassianStatusPage(HealthCheck):
+    """
+    Base class for Atlassian status page health checks.
+
+    Monitor cloud provider service health via Atlassian Status Page API v2.
+
+    Each subclass should define the `base_url` for the specific status page
+    and appropriate `timeout` value. The `max_age` parameter is not used
+    since the API endpoint only returns currently unresolved incidents.
+
+    Examples:
+        >>> class FlyIo(AtlassianStatusPage):
+        ...     timeout = datetime.timedelta(seconds=10)
+        ...     base_url = "https://status.flyio.net"
+
+    """
+
+    base_url: typing.ClassVar[str] = NotImplemented
+    timeout: datetime.timedelta = NotImplemented
+
+    async def run(self):
+        if msg := "\n".join([i async for i in self._fetch_incidents()]):
+            raise ServiceWarning(msg)
+        logger.debug("No recent incidents found")
+
+    async def _fetch_incidents(self):
+        api_url = f"{self.base_url}/api/v2/incidents/unresolved.json"
+        logger.debug("Fetching incidents from %r", api_url)
+
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(
+                    api_url,
+                    headers={"User-Agent": f"django-health-check@{__version__}"},
+                    timeout=self.timeout.total_seconds(),
+                    follow_redirects=True,
+                )
+            except httpx.TimeoutException as e:
+                raise ServiceUnavailable("API request timed out") from e
+            except httpx.RequestError as e:
+                raise ServiceUnavailable(f"Failed to fetch API: {e}") from e
+
+            try:
+                response.raise_for_status()
+            except httpx.HTTPStatusError as e:
+                raise ServiceUnavailable(
+                    f"HTTP error {e.response.status_code} fetching API from {api_url!r}"
+                ) from e
+
+            try:
+                data = response.json()
+            except ValueError as e:
+                raise ServiceUnavailable("Failed to parse JSON response") from e
+
+        for incident in data["incidents"]:
+            yield f"{incident['name']}: {incident['shortlink']}"
+
+
+@dataclasses.dataclass
+class Cloudflare(AtlassianStatusPage):
+    """
+    Check Cloudflare platform status via Atlassian Status Page API v2.
+
+    Args:
+        timeout: Request timeout duration.
+
+    """
+
+    timeout: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(seconds=10), repr=False
+    )
+    base_url: typing.ClassVar[str] = "https://www.cloudflarestatus.com"
+
+
+@dataclasses.dataclass
+class FlyIo(AtlassianStatusPage):
+    """
+    Check Fly.io platform status via Atlassian Status Page API v2.
+
+    Args:
+        timeout: Request timeout duration.
+
+    """
+
+    timeout: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(seconds=10), repr=False
+    )
+    base_url: typing.ClassVar[str] = "https://status.flyio.net"
+
+
+@dataclasses.dataclass
+class PlatformSh(AtlassianStatusPage):
+    """
+    Check Platform.sh platform status via Atlassian Status Page API v2.
+
+    Args:
+        timeout: Request timeout duration.
+
+    """
+
+    timeout: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(seconds=10), repr=False
+    )
+    base_url: typing.ClassVar[str] = "https://status.platform.sh"
+
+
+@dataclasses.dataclass
+class DigitalOcean(AtlassianStatusPage):
+    """
+    Check DigitalOcean platform status via Atlassian Status Page API v2.
+
+    Args:
+        timeout: Request timeout duration.
+
+    """
+
+    timeout: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(seconds=10), repr=False
+    )
+    base_url: typing.ClassVar[str] = "https://status.digitalocean.com"
+
+
+@dataclasses.dataclass
+class Render(AtlassianStatusPage):
+    """
+    Check Render platform status via Atlassian Status Page API v2.
+
+    Args:
+        timeout: Request timeout duration.
+
+    """
+
+    timeout: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(seconds=10), repr=False
+    )
+    base_url: typing.ClassVar[str] = "https://status.render.com"
+
+
+@dataclasses.dataclass
+class Vercel(AtlassianStatusPage):
+    """
+    Check Vercel platform status via Atlassian Status Page API v2.
+
+    Args:
+        timeout: Request timeout duration.
+
+    """
+
+    timeout: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(seconds=10), repr=False
+    )
+    base_url: typing.ClassVar[str] = "https://www.vercel-status.com"

django_health_check-4.0rc4/health_check/contrib/rss.py

@@ -0,0 +1,226 @@
+"""RSS feed health checks for cloud provider status pages."""
+
+import dataclasses
+import datetime
+import logging
+import typing
+
+import feedparser
+import httpx
+
+from health_check import HealthCheck, __version__
+from health_check.exceptions import ServiceUnavailable, ServiceWarning
+
+logger = logging.getLogger(__name__)
+
+
+class Feed(HealthCheck):
+    """
+    Base class for cloud provider status feed health checks.
+
+    Monitor cloud provider service health via their public RSS or Atom status feeds.
+
+    Subclasses must provide:
+
+    Attributes:
+        feed_url: The full URL of the RSS or Atom feed to monitor.
+        timeout: Maximum duration to wait for the HTTP request before failing.
+        max_age: Maximum age for an incident entry to be considered active.
+
+    The `timeout` and `max_age` values are used to control how long the
+    health check waits for the feed and how far back in time incidents are
+    considered relevant. The `feed_url` is used to fetch the status feed.
+
+    Examples:
+        >>> import dataclasses
+        >>> import datetime
+        >>> import typing
+        >>> from health_check.contrib.rss import Feed
+        >>> @dataclasses.dataclass
+        ... class MyProviderStatus(Feed):
+        ...     \"\"\"Check MyProvider status via its public RSS feed.\"\"\"
+        ...     timeout: datetime.timedelta = dataclasses.field(
+        ...         default=datetime.timedelta(seconds=10),
+        ...         repr=False,
+        ...     )
+        ...     max_age: datetime.timedelta = dataclasses.field(
+        ...         default=datetime.timedelta(hours=4),
+        ...         repr=False,
+        ...     )
+        ...     feed_url: typing.ClassVar[str] = "https://status.myprovider.com/feed"
+
+    """
+
+    feed_url: typing.ClassVar[str] = NotImplemented
+    timeout: datetime.timedelta = NotImplemented
+    max_age: datetime.timedelta = NotImplemented
+
+    async def run(self):
+        logger.debug("Fetching feed from %s", self.feed_url)
+
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(
+                    self.feed_url,
+                    headers={"User-Agent": f"django-health-check@{__version__}"},
+                    timeout=self.timeout.total_seconds(),
+                    follow_redirects=True,
+                )
+            except httpx.TimeoutException as e:
+                raise ServiceUnavailable("Feed request timed out") from e
+            except httpx.RequestError as e:
+                raise ServiceUnavailable(f"Failed to fetch feed: {e}") from e
+
+            try:
+                response.raise_for_status()
+            except httpx.HTTPStatusError as e:
+                raise ServiceUnavailable(
+                    f"HTTP error {e.response.status_code} fetching feed from {self.feed_url!r}"
+                ) from e
+
+            content = response.text
+
+        feed = feedparser.parse(content)
+
+        if feed.bozo:
+            # feedparser sets bozo=1 for malformed feeds
+            logger.warning("Feed parsing encountered errors: %s", feed.bozo_exception)
+
+        if not feed.entries:
+            logger.debug("No entries found in feed")
+            return
+
+        incidents = [entry for entry in feed.entries if self._is_recent_incident(entry)]
+
+        if incidents:
+            raise ServiceWarning(
+                f"Found {len(incidents)} recent incident(s): {
+                    ', '.join(
+                        getattr(entry, 'title', 'Untitled incident')
+                        or 'Untitled incident'
+                        for entry in incidents
+                    )
+                }"
+            )
+
+        logger.debug("No recent incidents found in feed")
+
+    def _is_recent_incident(self, entry):
+        """Check if entry is a recent incident."""
+        published_at = self._extract_date(entry)
+        if not published_at:
+            return True
+
+        now = datetime.datetime.now(tz=datetime.timezone.utc)
+        cutoff = now - self.max_age
+        return now >= published_at > cutoff
+
+    def _extract_date(self, entry):
+        # feedparser normalizes both RSS and Atom dates to struct_time
+        # Try published first, then updated
+        for date_field in ["published_parsed", "updated_parsed"]:
+            if date_tuple := getattr(entry, date_field, None):
+                try:
+                    # Convert struct_time to datetime
+                    return datetime.datetime(
+                        *date_tuple[:6], tzinfo=datetime.timezone.utc
+                    )
+                except (ValueError, TypeError):
+                    logger.warning(
+                        "Failed to parse date from entry %r for %r",
+                        date_tuple,
+                        self.feed_url,
+                        exc_info=True,
+                    )
+        return None
+
+
+@dataclasses.dataclass
+class AWS(Feed):
+    """
+    Check AWS service status via their public RSS status feeds.
+
+    Args:
+        region: AWS region code (e.g., 'us-east-1', 'eu-west-1').
+        service: AWS service name (e.g., 'ec2', 's3', 'rds').
+        timeout: Request timeout duration.
+        max_age: Maximum age for an incident to be considered active.
+
+    """
+
+    region: str
+    service: str
+    timeout: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(seconds=10), repr=False
+    )
+    max_age: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(hours=8), repr=False
+    )
+
+    def __post_init__(self):
+        self.feed_url: str = (
+            f"https://status.aws.amazon.com/rss/{self.service}-{self.region}.rss"
+        )
+
+
+@dataclasses.dataclass
+class Heroku(Feed):
+    """
+    Check Heroku platform status via their public RSS status feed.
+
+    Args:
+        timeout: Request timeout duration.
+        max_age: Maximum age for an incident to be considered active.
+
+    """
+
+    timeout: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(seconds=10), repr=False
+    )
+    max_age: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(hours=8), repr=False
+    )
+    feed_url: typing.ClassVar[str] = "https://status.heroku.com/feed"
+
+
+@dataclasses.dataclass
+class Azure(Feed):
+    """
+    Check Azure platform status via their public RSS status feed.
+
+    Args:
+        timeout: Request timeout duration.
+        max_age: Maximum age for an incident to be considered active.
+
+    """
+
+    timeout: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(seconds=10), repr=False
+    )
+    max_age: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(hours=8), repr=False
+    )
+    feed_url: typing.ClassVar[str] = (
+        "https://rssfeed.azure.status.microsoft/en-us/status/feed/"
+    )
+
+
+@dataclasses.dataclass
+class GoogleCloud(Feed):
+    """
+    Check Google Cloud platform status via their public Atom status feed.
+
+    Args:
+        timeout: Request timeout duration.
+        max_age: Maximum age for an incident to be considered active.
+
+    """
+
+    timeout: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(seconds=10), repr=False
+    )
+    max_age: datetime.timedelta = dataclasses.field(
+        default=datetime.timedelta(hours=8), repr=False
+    )
+
+    feed_url: typing.ClassVar[str] = "https://status.cloud.google.com/en/feed.atom"

django_health_check-4.0rc4/health_check/management/commands/health_check.py

@@ -0,0 +1,124 @@
+import os
+import sys
+import urllib.error
+import urllib.request
+
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from django.urls import NoReverseMatch, reverse
+
+
+class Command(BaseCommand):
+    help = "Run health checks and exit 0 if everything went well."
+
+    @property
+    def default_forwarded_host(self):
+        return (
+            settings.ALLOWED_HOSTS[0].strip(".")
+            if settings.ALLOWED_HOSTS and settings.ALLOWED_HOSTS[0] != "*"
+            else None
+        )
+
+    @property
+    def default_addrport(self):
+        return ":".join([os.getenv("HOST", "127.0.0.1"), os.getenv("PORT", "8000")])
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "endpoint",
+            type=str,
+            help="URL-pattern name of health check endpoint to test",
+        )
+        parser.add_argument(
+            "addrport",
+            nargs="?",
+            type=str,
+            default=self.default_addrport,
+            help=f"Optional port number, or ipaddr:port (default: {self.default_addrport})",
+        )
+        parser.add_argument(
+            "--forwarded-host",
+            type=str,
+            default=self.default_forwarded_host,
+            help=f"Value for X-Forwarded-Host header (default: {self.default_forwarded_host})",
+        )
+        parser.add_argument(
+            "--forwarded-proto",
+            type=str,
+            choices=["http", "https"],
+            default="https",
+            help="Value for X-Forwarded-Proto header (default: https)",
+        )
+        parser.add_argument(
+            "--timeout",
+            type=int,
+            default=5,
+            help="Timeout in seconds for the health check request (default: 5 seconds)",
+        )
+
+    def handle(self, *args, **options):
+        endpoint = options.get("endpoint")
+        try:
+            path = reverse(endpoint)
+        except NoReverseMatch as e:
+            self.stderr.write(
+                f"Could not resolve endpoint {endpoint!r}: {e}\n"
+                "Please provide a valid URL pattern name for the health check endpoint."
+            )
+            sys.exit(2)
+        addrport = options.get("addrport")
+        # Use HTTPS only when SSL redirect is enabled without forwarded headers (direct HTTPS required).
+        # Otherwise use HTTP (typical for containers with X-Forwarded-Proto header support).
+        proto = (
+            "https"
+            if settings.SECURE_SSL_REDIRECT and not settings.USE_X_FORWARDED_HOST
+            else "http"
+        )
+        url = f"{proto}://{addrport}{path}"
+
+        headers = {"Accept": "text/plain"}
+
+        # Add X-Forwarded-Host header
+        if forwarded_host := options.get("forwarded_host"):
+            headers["X-Forwarded-Host"] = forwarded_host
+
+        # Add X-Forwarded-Proto header
+        if forwarded_proto := options.get("forwarded_proto"):
+            headers["X-Forwarded-Proto"] = forwarded_proto
+
+        if options.get("verbosity", 1) >= 2:
+            self.stdout.write(
+                f"Checking health endpoint at {url!r} with headers: {headers}"
+            )
+
+        request = urllib.request.Request(url, headers=headers)  # noqa: S310
+        try:
+            response = urllib.request.urlopen(request, timeout=options["timeout"])  # noqa: S310
+        except urllib.error.HTTPError as e:
+            match e.code:
+                case 500:  # Health check failed
+                    self.stdout.write(e.read().decode("utf-8"))
+                    sys.exit(1)
+                case 400:
+                    self.stderr.write(
+                        f"{url!r} is not reachable: {e.reason}\nPlease check your ALLOWED_HOSTS setting or use the --forwarded-host option."
+                    )
+                    sys.exit(2)
+                case _:
+                    self.stderr.write(
+                        "Unexpected HTTP error "
+                        f"when trying to reach {url!r}: {e}\n"
+                        f"You may have selected an invalid endpoint {endpoint!r}"
+                        f" or another application is running on {addrport!r}."
+                    )
+                    sys.exit(2)
+        except urllib.error.URLError as e:
+            self.stderr.write(
+                f"{url!r} is not reachable: {e.reason}\nPlease check your server is running and reachable."
+            )
+            sys.exit(2)
+        except TimeoutError as e:
+            self.stderr.write(f"Timeout when trying to reach {url!r}: {e}")
+            sys.exit(2)
+        else:
+            self.stdout.write(response.read().decode("utf-8"))

{django_health_check-4.0rc2 → django_health_check-4.0rc4}/health_check/templates/health_check/index.html

@@ -68,7 +68,7 @@
     }
 
     tr.error {
-      background: light-dark(lightcoral, #440000);
+      background: light-dark(lightcoral, #440000) !important;
     }
 
     table thead tr {

{django_health_check-4.0rc2 → django_health_check-4.0rc4}/pyproject.toml

@@ -48,7 +48,8 @@ celery = ["celery>=5.0.0"]
 kafka = ["confluent-kafka>=2.0.0"]
 rabbitmq = ["aio-pika>=9.0.0"]
 redis = ["redis>=4.2.0"]
-rss = ["httpx>=0.27.0"]
+rss = ["httpx>=0.27.0", "feedparser>=6.0.0"]
+atlassian = ["httpx>=0.27.0"]
 
 [project.urls]
 # https://packaging.python.org/en/latest/specifications/well-known-project-urls/#well-known-labels

django_health_check-4.0rc2/health_check/contrib/rss.py

@@ -1,113 +0,0 @@
-"""RSS feed health checks for cloud provider status pages."""
-
-import dataclasses
-import datetime
-import email.utils
-import logging
-from xml.etree import ElementTree
-
-import httpx
-
-from health_check.base import HealthCheck
-from health_check.exceptions import ServiceUnavailable, ServiceWarning
-
-logger = logging.getLogger(__name__)
-
-
-@dataclasses.dataclass
-class AWS(HealthCheck):
-    """
-    Check AWS service status via their public RSS status feeds.
-
-    Args:
-        region: AWS region code (e.g., 'us-east-1', 'eu-west-1').
-        service: AWS service name (e.g., 'ec2', 's3', 'rds').
-        timeout: Request timeout duration.
-        max_age: Maximum age for an incident to be considered active.
-
-    """
-
-    region: str
-    service: str
-    timeout: datetime.timedelta = dataclasses.field(
-        default=datetime.timedelta(seconds=10), repr=False
-    )
-    max_age: datetime.timedelta = dataclasses.field(
-        default=datetime.timedelta(days=1), repr=False
-    )
-
-    def __post_init__(self):
-        self.feed_url: str = (
-            f"https://status.aws.amazon.com/rss/{self.service}-{self.region}.rss"
-        )
-
-    async def run(self):
-        """Check the RSS feed for incidents."""
-        logger.debug("Fetching feed from %s", self.feed_url)
-
-        async with httpx.AsyncClient() as client:
-            try:
-                response = await client.get(
-                    self.feed_url,
-                    headers={"User-Agent": "django-health-check"},
-                    timeout=self.timeout.total_seconds(),
-                    follow_redirects=True,
-                )
-            except httpx.TimeoutException as e:
-                raise ServiceUnavailable("RSS feed request timed out") from e
-            except httpx.RequestError as e:
-                raise ServiceUnavailable(f"Failed to fetch RSS feed: {e}") from e
-
-            try:
-                response.raise_for_status()
-            except httpx.HTTPStatusError as e:
-                raise ServiceUnavailable(
-                    f"HTTP error {e.response.status_code} fetching RSS feed"
-                ) from e
-
-            content = response.text
-
-        try:
-            root = ElementTree.fromstring(content)  # noqa: S314
-        except ElementTree.ParseError as e:
-            raise ServiceUnavailable("Failed to parse RSS feed") from e
-
-        entries = self._extract_entries(root)
-        incidents = [entry for entry in entries if self._is_recent_incident(entry)]
-
-        if incidents:
-            incident_titles = [self._extract_title(entry) for entry in incidents]
-            raise ServiceWarning(
-                f"Found {len(incidents)} recent incident(s): {', '.join(incident_titles)}"
-            )
-
-        logger.debug("No recent incidents found in RSS feed")
-
-    def _extract_entries(self, root):
-        """Extract entries from RSS 2.0 feed."""
-        return root.findall(".//item")
-
-    def _is_recent_incident(self, entry):
-        """Check if entry is a recent incident."""
-        published_at = self._extract_date(entry)
-        if not published_at:
-            return True
-
-        cutoff = datetime.datetime.now(tz=datetime.timezone.utc) - self.max_age
-        return published_at > cutoff
-
-    def _extract_date(self, entry):
-        """Extract publication date from RSS entry."""
-        pub_date = entry.find("pubDate")
-        if pub_date is not None and (date_text := pub_date.text):
-            try:
-                return email.utils.parsedate_to_datetime(date_text)
-            except (ValueError, TypeError):
-                pass
-
-    def _extract_title(self, entry):
-        """Extract title from RSS entry."""
-        if (title := entry.find("title")) is not None:
-            return title.text or "Untitled incident"
-
-        return "Untitled incident"

django_health_check-4.0rc2/health_check/management/commands/health_check.py

@@ -1,46 +0,0 @@
-import sys
-import urllib.error
-import urllib.request
-
-from django.core.management.base import BaseCommand
-from django.urls import reverse
-
-
-class Command(BaseCommand):
-    help = "Run health checks and exit 0 if everything went well."
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            "endpoint",
-            type=str,
-            help="URL-pattern name of health check endpoint to test",
-        )
-        parser.add_argument(
-            "addrport",
-            nargs="?",
-            type=str,
-            help="Optional port number, or ipaddr:port (default: localhost:8000)",
-            default="localhost:8000",
-        )
-
-    def handle(self, *args, **options):
-        endpoint = options.get("endpoint")
-        path = reverse(endpoint)
-        host, sep, port = options.get("addrport").partition(":")
-        url = f"http://{host}:{port}{path}" if sep else f"http://{host}{path}"
-        request = urllib.request.Request(  # noqa: S310
-            url, headers={"Accept": "text/plain"}
-        )
-        try:
-            response = urllib.request.urlopen(request)  # noqa: S310
-        except urllib.error.HTTPError as e:
-            # 500 status codes will raise HTTPError
-            self.stdout.write(e.read().decode("utf-8"))
-            sys.exit(1)
-        except urllib.error.URLError as e:
-            self.stderr.write(
-                f'"{url}" is not reachable: {e.reason}\nPlease check your ALLOWED_HOSTS setting.'
-            )
-            sys.exit(2)
-        else:
-            self.stdout.write(response.read().decode("utf-8"))