stac-fastapi-core 6.7.4__tar.gz → 6.7.6__tar.gz

{stac_fastapi_core-6.7.4 → stac_fastapi_core-6.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stac_fastapi_core
-Version: 6.7.4
+Version: 6.7.6
 Summary: Core library for the Elasticsearch and Opensearch stac-fastapi backends.
 Project-URL: Homepage, https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
 License: MIT
@@ -9,13 +9,11 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 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-Python: >=3.9
+Requires-Python: >=3.11
 Requires-Dist: attrs>=23.2.0
 Requires-Dist: fastapi~=0.109.0
 Requires-Dist: geojson-pydantic~=1.0.0
@@ -24,12 +22,14 @@ Requires-Dist: orjson~=3.11.0
 Requires-Dist: overrides~=7.4.0
 Requires-Dist: pydantic<3.0.0,>=2.4.1
 Requires-Dist: pygeofilter~=0.3.1
-Requires-Dist: redis==6.4.0
 Requires-Dist: slowapi~=0.1.9
-Requires-Dist: stac-fastapi-api==6.0.0
-Requires-Dist: stac-fastapi-extensions==6.0.0
-Requires-Dist: stac-fastapi-types==6.0.0
+Requires-Dist: stac-fastapi-api==6.1.1
+Requires-Dist: stac-fastapi-extensions==6.1.1
+Requires-Dist: stac-fastapi-types==6.1.1
 Requires-Dist: stac-pydantic~=3.3.0
+Provides-Extra: redis
+Requires-Dist: redis~=6.4.0; extra == 'redis'
+Requires-Dist: retry~=0.9.2; extra == 'redis'
 Description-Content-Type: text/markdown
 
 # stac-fastapi-core

{stac_fastapi_core-6.7.4 → stac_fastapi_core-6.7.6}/pyproject.toml

@@ -6,15 +6,13 @@ build-backend = "hatchling.build"
 name = "stac_fastapi_core"
 description = "Core library for the Elasticsearch and Opensearch stac-fastapi backends."
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.11"
 license = {text = "MIT"}
 authors = []
 classifiers = [
     "Intended Audience :: Developers",
     "Intended Audience :: Information Technology",
     "Intended Audience :: Science/Research",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -35,16 +33,21 @@ dependencies = [
     "attrs>=23.2.0",
     "pydantic>=2.4.1,<3.0.0",
     "stac_pydantic~=3.3.0",
-    "stac-fastapi.types==6.0.0",
-    "stac-fastapi.api==6.0.0",
-    "stac-fastapi.extensions==6.0.0",
+    "stac-fastapi.types==6.1.1",
+    "stac-fastapi.api==6.1.1",
+    "stac-fastapi.extensions==6.1.1",
     "orjson~=3.11.0",
     "overrides~=7.4.0",
     "geojson-pydantic~=1.0.0",
     "pygeofilter~=0.3.1",
     "jsonschema~=4.0.0",
     "slowapi~=0.1.9",
-    "redis==6.4.0",
+]
+
+[project.optional-dependencies]
+redis = [
+    "redis~=6.4.0",
+    "retry~=0.9.2",
 ]
 
 [project.urls]

{stac_fastapi_core-6.7.4 → stac_fastapi_core-6.7.6}/stac_fastapi/core/core.py

@@ -24,7 +24,6 @@ from stac_fastapi.core.base_database_logic import BaseDatabaseLogic
 from stac_fastapi.core.base_settings import ApiBaseSettings
 from stac_fastapi.core.datetime_utils import format_datetime_range
 from stac_fastapi.core.models.links import PagingLinks
-from stac_fastapi.core.redis_utils import redis_pagination_links
 from stac_fastapi.core.serializers import CollectionSerializer, ItemSerializer
 from stac_fastapi.core.session import Session
 from stac_fastapi.core.utilities import filter_fields, get_bool_env
@@ -426,6 +425,8 @@ class CoreClient(AsyncBaseCoreClient):
         ]
 
         if redis_enable:
+            from stac_fastapi.core.redis_utils import redis_pagination_links
+
             await redis_pagination_links(
                 current_url=str(request.url),
                 token=token,
@@ -790,9 +791,10 @@ class CoreClient(AsyncBaseCoreClient):
                 search=search, collection_ids=search_request.collections
             )
 
+        datetime_parsed = format_datetime_range(date_str=search_request.datetime)
         try:
             search, datetime_search = self.database.apply_datetime_filter(
-                search=search, datetime=search_request.datetime
+                search=search, datetime=datetime_parsed
             )
         except (ValueError, TypeError) as e:
             # Handle invalid interval formats if return_date fails
@@ -903,6 +905,8 @@ class CoreClient(AsyncBaseCoreClient):
         links.extend(collection_links)
 
         if redis_enable:
+            from stac_fastapi.core.redis_utils import redis_pagination_links
+
             await redis_pagination_links(
                 current_url=str(request.url),
                 token=token_param,

stac_fastapi_core-6.7.6/stac_fastapi/core/datetime_utils.py

@@ -0,0 +1,123 @@
+"""Utility functions to handle datetime parsing."""
+
+from datetime import datetime, timezone
+
+from stac_fastapi.core.utilities import get_bool_env
+from stac_fastapi.types.rfc3339 import rfc3339_str_to_datetime
+
+
+def format_datetime_range(date_str: str) -> str:
+    """
+    Convert a datetime range string into a normalized UTC string for API requests using rfc3339_str_to_datetime.
+
+    Args:
+        date_str (str): A string containing two datetime values separated by a '/'.
+
+    Returns:
+        str: A string formatted as 'YYYY-MM-DDTHH:MM:SSZ/YYYY-MM-DDTHH:MM:SSZ', with '..' used if any element is None.
+    """
+    use_datetime_nanos = get_bool_env("USE_DATETIME_NANOS", default=True)
+
+    if use_datetime_nanos:
+        MIN_DATE_NANOS = datetime(1970, 1, 1, tzinfo=timezone.utc)
+        MAX_DATE_NANOS = datetime(2262, 4, 11, 23, 47, 16, 854775, tzinfo=timezone.utc)
+
+        def normalize(dt):
+            """Normalize datetime string and preserve nano second precision."""
+            dt = dt.strip()
+            if not dt or dt == "..":
+                return ".."
+            dt_utc = rfc3339_str_to_datetime(dt).astimezone(timezone.utc)
+            if dt_utc < MIN_DATE_NANOS:
+                dt_utc = MIN_DATE_NANOS
+            if dt_utc > MAX_DATE_NANOS:
+                dt_utc = MAX_DATE_NANOS
+            dt_normalized = dt_utc.isoformat(timespec="auto").replace("+00:00", "Z")
+            if "." not in dt_normalized:
+                dt_normalized = dt_normalized.replace("Z", ".0Z")
+            return dt_normalized
+
+        if not isinstance(date_str, str):
+            return f"{MIN_DATE_NANOS.isoformat(timespec='auto').replace('+00:00','Z')}/{MAX_DATE_NANOS.isoformat(timespec='auto').replace('+00:00','Z')}"
+
+        if "/" not in date_str:
+            return f"{normalize(date_str)}/{normalize(date_str)}"
+
+        try:
+            start, end = date_str.split("/", 1)
+        except Exception:
+            return f"{MIN_DATE_NANOS.isoformat(timespec='auto').replace('+00:00','Z')}/{MAX_DATE_NANOS.isoformat(timespec='auto').replace('+00:00','Z')}"
+
+        normalized_start = normalize(start)
+        normalized_end = normalize(end)
+
+        if normalized_start == "..":
+            normalized_start = MIN_DATE_NANOS.isoformat(timespec="auto").replace(
+                "+00:00", "Z"
+            )
+        if normalized_end == "..":
+            normalized_end = MAX_DATE_NANOS.isoformat(timespec="auto").replace(
+                "+00:00", "Z"
+            )
+
+        return f"{normalized_start}/{normalized_end}"
+
+    else:
+
+        def normalize(dt):
+            """Normalize datetime string and preserve millisecond precision."""
+            dt = dt.strip()
+            if not dt or dt == "..":
+                return ".."
+            dt_obj = rfc3339_str_to_datetime(dt)
+            dt_utc = dt_obj.astimezone(timezone.utc)
+            return dt_utc.isoformat(timespec="milliseconds").replace("+00:00", "Z")
+
+        if not isinstance(date_str, str):
+            return "../.."
+
+        if "/" not in date_str:
+            return f"{normalize(date_str)}/{normalize(date_str)}"
+
+        try:
+            start, end = date_str.split("/", 1)
+        except Exception:
+            return "../.."
+        return f"{normalize(start)}/{normalize(end)}"
+
+
+# Borrowed from pystac - https://github.com/stac-utils/pystac/blob/f5e4cf4a29b62e9ef675d4a4dac7977b09f53c8f/pystac/utils.py#L370-L394
+def datetime_to_str(dt: datetime, timespec: str = "auto") -> str:
+    """Convert a :class:`datetime.datetime` instance to an ISO8601 string in the `RFC 3339, section 5.6.
+
+    <https://datatracker.ietf.org/doc/html/rfc3339#section-5.6>`__ format required by
+    the :stac-spec:`STAC Spec <master/item-spec/common-metadata.md#date-and-time>`.
+
+    Args:
+        dt : The datetime to convert.
+        timespec: An optional argument that specifies the number of additional
+            terms of the time to include. Valid options are 'auto', 'hours',
+            'minutes', 'seconds', 'milliseconds' and 'microseconds'. The default value
+            is 'auto'.
+    Returns:
+        str: The ISO8601 (RFC 3339) formatted string representing the datetime.
+    """
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+
+    timestamp = dt.isoformat(timespec=timespec)
+    zulu = "+00:00"
+    if timestamp.endswith(zulu):
+        timestamp = f"{timestamp[: -len(zulu)]}Z"
+
+    return timestamp
+
+
+def now_in_utc() -> datetime:
+    """Return a datetime value of now with the UTC timezone applied."""
+    return datetime.now(timezone.utc)
+
+
+def now_to_rfc3339_str() -> str:
+    """Return an RFC 3339 string representing now."""
+    return datetime_to_str(now_in_utc())

{stac_fastapi_core-6.7.4 → stac_fastapi_core-6.7.6}/stac_fastapi/core/redis_utils.py

@@ -2,25 +2,25 @@
 
 import json
 import logging
-from typing import List, Optional, Tuple
+from functools import wraps
+from typing import Callable, List, Optional, Tuple, cast
 from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
 
 from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings
 from redis import asyncio as aioredis
 from redis.asyncio.sentinel import Sentinel
+from redis.exceptions import ConnectionError as RedisConnectionError
+from redis.exceptions import TimeoutError as RedisTimeoutError
+from retry import retry  # type: ignore
 
 logger = logging.getLogger(__name__)
 
 
-class RedisSentinelSettings(BaseSettings):
-    """Configuration for connecting to Redis Sentinel."""
+class RedisCommonSettings(BaseSettings):
+    """Common configuration for Redis Sentinel and Redis Standalone."""
 
-    REDIS_SENTINEL_HOSTS: str = ""
-    REDIS_SENTINEL_PORTS: str = "26379"
-    REDIS_SENTINEL_MASTER_NAME: str = "master"
     REDIS_DB: int = 15
-
     REDIS_MAX_CONNECTIONS: Optional[int] = None
     REDIS_RETRY_TIMEOUT: bool = True
     REDIS_DECODE_RESPONSES: bool = True
@@ -28,9 +28,13 @@ class RedisSentinelSettings(BaseSettings):
     REDIS_HEALTH_CHECK_INTERVAL: int = Field(default=30, gt=0)
     REDIS_SELF_LINK_TTL: int = 1800
 
+    REDIS_QUERY_RETRIES_NUM: int = Field(default=3, gt=0)
+    REDIS_QUERY_INITIAL_DELAY: float = Field(default=1.0, gt=0)
+    REDIS_QUERY_BACKOFF: float = Field(default=2.0, gt=1)
+
     @field_validator("REDIS_DB")
     @classmethod
-    def validate_db_sentinel(cls, v: int) -> int:
+    def validate_db(cls, v: int) -> int:
         """Validate REDIS_DB is not negative integer."""
         if v < 0:
             raise ValueError("REDIS_DB must be a positive integer")
@@ -46,12 +50,20 @@ class RedisSentinelSettings(BaseSettings):
 
     @field_validator("REDIS_SELF_LINK_TTL")
     @classmethod
-    def validate_self_link_ttl_sentinel(cls, v: int) -> int:
-        """Validate REDIS_SELF_LINK_TTL is not a negative integer."""
+    def validate_self_link_ttl(cls, v: int) -> int:
+        """Validate REDIS_SELF_LINK_TTL is negative."""
         if v < 0:
             raise ValueError("REDIS_SELF_LINK_TTL must be a positive integer")
         return v
 
+
+class RedisSentinelSettings(RedisCommonSettings):
+    """Configuration for connecting to Redis Sentinel."""
+
+    REDIS_SENTINEL_HOSTS: str = ""
+    REDIS_SENTINEL_PORTS: str = "26379"
+    REDIS_SENTINEL_MASTER_NAME: str = "master"
+
     def get_sentinel_hosts(self) -> List[str]:
         """Parse Redis Sentinel hosts from string to list."""
         if not self.REDIS_SENTINEL_HOSTS:
@@ -96,19 +108,11 @@ class RedisSentinelSettings(BaseSettings):
         return [(str(host), int(port)) for host, port in zip(hosts, ports)]
 
 
-class RedisSettings(BaseSettings):
+class RedisSettings(RedisCommonSettings):
     """Configuration for connecting Redis."""
 
     REDIS_HOST: str = ""
     REDIS_PORT: int = 6379
-    REDIS_DB: int = 15
-
-    REDIS_MAX_CONNECTIONS: Optional[int] = None
-    REDIS_RETRY_TIMEOUT: bool = True
-    REDIS_DECODE_RESPONSES: bool = True
-    REDIS_CLIENT_NAME: str = "stac-fastapi-app"
-    REDIS_HEALTH_CHECK_INTERVAL: int = Field(default=30, gt=0)
-    REDIS_SELF_LINK_TTL: int = 1800
 
     @field_validator("REDIS_PORT")
     @classmethod
@@ -118,89 +122,93 @@ class RedisSettings(BaseSettings):
             raise ValueError("REDIS_PORT must be a positive integer")
         return v
 
-    @field_validator("REDIS_DB")
-    @classmethod
-    def validate_db_standalone(cls, v: int) -> int:
-        """Validate REDIS_DB is not a negative integer."""
-        if v < 0:
-            raise ValueError("REDIS_DB must be a positive integer")
-        return v
-
-    @field_validator("REDIS_MAX_CONNECTIONS", mode="before")
-    @classmethod
-    def validate_max_connections(cls, v):
-        """Handle empty/None values for REDIS_MAX_CONNECTIONS."""
-        if v in ["", "null", "Null", "NULL", "none", "None", "NONE", None]:
-            return None
-        return v
-
-    @field_validator("REDIS_SELF_LINK_TTL")
-    @classmethod
-    def validate_self_link_ttl_standalone(cls, v: int) -> int:
-        """Validate REDIS_SELF_LINK_TTL is negative."""
-        if v < 0:
-            raise ValueError("REDIS_SELF_LINK_TTL must be a positive integer")
-        return v
-
 
 # Configure only one Redis configuration
 sentinel_settings = RedisSentinelSettings()
-standalone_settings = RedisSettings()
+settings: RedisCommonSettings = cast(
+    RedisCommonSettings,
+    sentinel_settings if sentinel_settings.REDIS_SENTINEL_HOSTS else RedisSettings(),
+)
+
+
+def redis_retry(func: Callable) -> Callable:
+    """Retry with back-off decorator for Redis connections."""
+
+    @wraps(func)
+    @retry(
+        exceptions=(RedisConnectionError, RedisTimeoutError),
+        tries=settings.REDIS_QUERY_RETRIES_NUM,
+        delay=settings.REDIS_QUERY_INITIAL_DELAY,
+        backoff=settings.REDIS_QUERY_BACKOFF,
+        logger=logger,
+    )
+    async def wrapper(*args, **kwargs):
+        return await func(*args, **kwargs)
 
+    return wrapper
 
-async def connect_redis() -> Optional[aioredis.Redis]:
+
+@redis_retry
+async def _connect_redis_internal() -> Optional[aioredis.Redis]:
     """Return a Redis connection Redis or Redis Sentinel."""
-    try:
-        if sentinel_settings.REDIS_SENTINEL_HOSTS:
-            sentinel_nodes = sentinel_settings.get_sentinel_nodes()
-            sentinel = Sentinel(
-                sentinel_nodes,
-                decode_responses=sentinel_settings.REDIS_DECODE_RESPONSES,
-            )
+    if sentinel_settings.REDIS_SENTINEL_HOSTS:
+        sentinel_nodes = settings.get_sentinel_nodes()
+        sentinel = Sentinel(
+            sentinel_nodes,
+            decode_responses=settings.REDIS_DECODE_RESPONSES,
+        )
 
-            redis = sentinel.master_for(
-                service_name=sentinel_settings.REDIS_SENTINEL_MASTER_NAME,
-                db=sentinel_settings.REDIS_DB,
-                decode_responses=sentinel_settings.REDIS_DECODE_RESPONSES,
-                retry_on_timeout=sentinel_settings.REDIS_RETRY_TIMEOUT,
-                client_name=sentinel_settings.REDIS_CLIENT_NAME,
-                max_connections=sentinel_settings.REDIS_MAX_CONNECTIONS,
-                health_check_interval=sentinel_settings.REDIS_HEALTH_CHECK_INTERVAL,
-            )
-            logger.info("Connected to Redis Sentinel")
-
-        elif standalone_settings.REDIS_HOST:
-            pool = aioredis.ConnectionPool(
-                host=standalone_settings.REDIS_HOST,
-                port=standalone_settings.REDIS_PORT,
-                db=standalone_settings.REDIS_DB,
-                max_connections=standalone_settings.REDIS_MAX_CONNECTIONS,
-                decode_responses=standalone_settings.REDIS_DECODE_RESPONSES,
-                retry_on_timeout=standalone_settings.REDIS_RETRY_TIMEOUT,
-                health_check_interval=standalone_settings.REDIS_HEALTH_CHECK_INTERVAL,
-            )
-            redis = aioredis.Redis(
-                connection_pool=pool, client_name=standalone_settings.REDIS_CLIENT_NAME
-            )
-            logger.info("Connected to Redis")
-        else:
-            logger.warning("No Redis configuration found")
-            return None
+        redis = sentinel.master_for(
+            service_name=settings.REDIS_SENTINEL_MASTER_NAME,
+            db=settings.REDIS_DB,
+            decode_responses=settings.REDIS_DECODE_RESPONSES,
+            retry_on_timeout=settings.REDIS_RETRY_TIMEOUT,
+            client_name=settings.REDIS_CLIENT_NAME,
+            max_connections=settings.REDIS_MAX_CONNECTIONS,
+            health_check_interval=settings.REDIS_HEALTH_CHECK_INTERVAL,
+        )
+        logger.info("Connected to Redis Sentinel")
+
+    elif settings.REDIS_HOST:
+        pool = aioredis.ConnectionPool(
+            host=settings.REDIS_HOST,
+            port=settings.REDIS_PORT,
+            db=settings.REDIS_DB,
+            max_connections=settings.REDIS_MAX_CONNECTIONS,
+            decode_responses=settings.REDIS_DECODE_RESPONSES,
+            retry_on_timeout=settings.REDIS_RETRY_TIMEOUT,
+            health_check_interval=settings.REDIS_HEALTH_CHECK_INTERVAL,
+        )
+        redis = aioredis.Redis(
+            connection_pool=pool, client_name=settings.REDIS_CLIENT_NAME
+        )
+        logger.info("Connected to Redis")
+    else:
+        logger.warning("No Redis configuration found")
+        return None
+
+    return redis
 
-        return redis
 
+async def connect_redis() -> Optional[aioredis.Redis]:
+    """Handle Redis connection."""
+    try:
+        return await _connect_redis_internal()
+    except (
+        aioredis.ConnectionError,
+        aioredis.TimeoutError,
+    ) as e:
+        logger.error(f"Redis connection failed after retries: {e}")
     except aioredis.ConnectionError as e:
         logger.error(f"Redis connection error: {e}")
         return None
     except aioredis.AuthenticationError as e:
         logger.error(f"Redis authentication error: {e}")
         return None
-    except aioredis.TimeoutError as e:
-        logger.error(f"Redis timeout error: {e}")
-        return None
     except Exception as e:
         logger.error(f"Failed to connect to Redis: {e}")
         return None
+    return None
 
 
 def get_redis_key(url: str, token: str) -> str:
@@ -230,19 +238,21 @@ def build_url_with_token(base_url: str, token: str) -> str:
     )
 
 
+@redis_retry
 async def save_prev_link(
     redis: aioredis.Redis, next_url: str, current_url: str, next_token: str
 ) -> None:
     """Save the current page as the previous link for the next URL."""
     if next_url and next_token:
         if sentinel_settings.REDIS_SENTINEL_HOSTS:
-            ttl_seconds = sentinel_settings.REDIS_SELF_LINK_TTL
-        elif standalone_settings.REDIS_HOST:
-            ttl_seconds = standalone_settings.REDIS_SELF_LINK_TTL
+            ttl_seconds = settings.REDIS_SELF_LINK_TTL
+        elif settings.REDIS_HOST:
+            ttl_seconds = settings.REDIS_SELF_LINK_TTL
         key = get_redis_key(next_url, next_token)
         await redis.setex(key, ttl_seconds, current_url)
 
 
+@redis_retry
 async def get_prev_link(
     redis: aioredis.Redis, current_url: str, current_token: str
 ) -> Optional[str]:

{stac_fastapi_core-6.7.4 → stac_fastapi_core-6.7.6}/stac_fastapi/core/version.py

@@ -1,2 +1,2 @@
 """library version."""
-__version__ = "6.7.4"
+__version__ = "6.7.6"

stac_fastapi_core-6.7.4/stac_fastapi/core/datetime_utils.py

@@ -1,75 +0,0 @@
-"""Utility functions to handle datetime parsing."""
-
-from datetime import datetime, timezone
-
-from stac_fastapi.types.rfc3339 import rfc3339_str_to_datetime
-
-
-def format_datetime_range(date_str: str) -> str:
-    """
-    Convert a datetime range string into a normalized UTC string for API requests using rfc3339_str_to_datetime.
-
-    Args:
-        date_str (str): A string containing two datetime values separated by a '/'.
-
-    Returns:
-        str: A string formatted as 'YYYY-MM-DDTHH:MM:SSZ/YYYY-MM-DDTHH:MM:SSZ', with '..' used if any element is None.
-    """
-
-    def normalize(dt):
-        """Normalize datetime string and preserve millisecond precision."""
-        dt = dt.strip()
-        if not dt or dt == "..":
-            return ".."
-        dt_obj = rfc3339_str_to_datetime(dt)
-        dt_utc = dt_obj.astimezone(timezone.utc)
-        return dt_utc.isoformat(timespec="milliseconds").replace("+00:00", "Z")
-
-    if not isinstance(date_str, str):
-        return "../.."
-
-    if "/" not in date_str:
-        return f"{normalize(date_str)}/{normalize(date_str)}"
-
-    try:
-        start, end = date_str.split("/", 1)
-    except Exception:
-        return "../.."
-    return f"{normalize(start)}/{normalize(end)}"
-
-
-# Borrowed from pystac - https://github.com/stac-utils/pystac/blob/f5e4cf4a29b62e9ef675d4a4dac7977b09f53c8f/pystac/utils.py#L370-L394
-def datetime_to_str(dt: datetime, timespec: str = "auto") -> str:
-    """Convert a :class:`datetime.datetime` instance to an ISO8601 string in the `RFC 3339, section 5.6.
-
-    <https://datatracker.ietf.org/doc/html/rfc3339#section-5.6>`__ format required by
-    the :stac-spec:`STAC Spec <master/item-spec/common-metadata.md#date-and-time>`.
-
-    Args:
-        dt : The datetime to convert.
-        timespec: An optional argument that specifies the number of additional
-            terms of the time to include. Valid options are 'auto', 'hours',
-            'minutes', 'seconds', 'milliseconds' and 'microseconds'. The default value
-            is 'auto'.
-    Returns:
-        str: The ISO8601 (RFC 3339) formatted string representing the datetime.
-    """
-    if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=timezone.utc)
-
-    timestamp = dt.isoformat(timespec=timespec)
-    zulu = "+00:00"
-    if timestamp.endswith(zulu):
-        timestamp = f"{timestamp[: -len(zulu)]}Z"
-
-    return timestamp
-
-
-def now_in_utc() -> datetime:
-    """Return a datetime value of now with the UTC timezone applied."""
-    return datetime.now(timezone.utc)
-
-
-def now_to_rfc3339_str() -> str:
-    """Return an RFC 3339 string representing now."""
-    return datetime_to_str(now_in_utc())