Remove USE_TZ setting

Author: davegaeddert

plain-htmx/tests/settings.py

@@ -1,5 +1,3 @@
 INSTALLED_PACKAGES = [
     "plain.htmx",
 ]
-
-USE_TZ = True

plain-importmap/test_project/settings.py

@@ -57,5 +57,3 @@
 USE_I18N = True
 
 USE_L10N = True
-
-USE_TZ = True

plain-models/plain/models/backends/base/base.py

@@ -9,7 +9,6 @@
 from collections import deque
 from contextlib import contextmanager
 
-from plain.exceptions import ImproperlyConfigured
 from plain.models.backends import utils
 from plain.models.backends.base.validation import BaseDatabaseValidation
 from plain.models.backends.signals import connection_created
@@ -150,9 +149,7 @@ def timezone(self):
         Plain uses may be constrained by the requirements of other users of
         the database.
         """
-        if not settings.USE_TZ:
-            return None
-        elif self.settings_dict["TIME_ZONE"] is None:
+        if self.settings_dict["TIME_ZONE"] is None:
             return datetime.timezone.utc
         else:
             return zoneinfo.ZoneInfo(self.settings_dict["TIME_ZONE"])
@@ -162,9 +159,7 @@ def timezone_name(self):
         """
         Name of the time zone of the database connection.
         """
-        if not settings.USE_TZ:
-            return settings.TIME_ZONE
-        elif self.settings_dict["TIME_ZONE"] is None:
+        if self.settings_dict["TIME_ZONE"] is None:
             return "UTC"
         else:
             return self.settings_dict["TIME_ZONE"]
@@ -238,8 +233,6 @@ def create_cursor(self, name=None):
 
     def connect(self):
         """Connect to the database. Assume that the connection is closed."""
-        # Check for invalid configurations.
-        self.check_settings()
         # In case the previous connection was closed while in an atomic block
         self.in_atomic_block = False
         self.savepoint_ids = []
@@ -262,13 +255,6 @@ def connect(self):
 
         self.run_on_commit = []
 
-    def check_settings(self):
-        if self.settings_dict["TIME_ZONE"] is not None and not settings.USE_TZ:
-            raise ImproperlyConfigured(
-                "Connection '%s' cannot set TIME_ZONE because USE_TZ is False."
-                % self.alias
-            )
-
     def ensure_connection(self):
         """Guarantee that a connection to the database is established."""
         if self.connection is None:

plain-models/plain/models/backends/base/operations.py

@@ -7,7 +7,6 @@
 
 from plain.models.backends import utils
 from plain.models.db import NotSupportedError
-from plain.runtime import settings
 from plain.utils import timezone
 from plain.utils.encoding import force_str
 
@@ -591,10 +590,12 @@ def year_lookup_bounds_for_datetime_field(self, value, iso_year=False):
         else:
             first = datetime.datetime(value, 1, 1)
             second = datetime.datetime(value, 12, 31, 23, 59, 59, 999999)
-        if settings.USE_TZ:
-            tz = timezone.get_current_timezone()
-            first = timezone.make_aware(first, tz)
-            second = timezone.make_aware(second, tz)
+
+        # Make sure that datetimes are aware in the current timezone
+        tz = timezone.get_current_timezone()
+        first = timezone.make_aware(first, tz)
+        second = timezone.make_aware(second, tz)
+
         first = self.adapt_datetimefield_value(first)
         second = self.adapt_datetimefield_value(second)
         return [first, second]

plain-models/plain/models/backends/mysql/operations.py

@@ -5,7 +5,6 @@
 from plain.models.constants import OnConflict
 from plain.models.expressions import Exists, ExpressionWrapper
 from plain.models.lookups import Lookup
-from plain.runtime import settings
 from plain.utils import timezone
 from plain.utils.encoding import force_str
 from plain.utils.regex_helper import _lazy_re_compile
@@ -91,7 +90,7 @@ def _prepare_tzname_delta(self, tzname):
         return f"{sign}{offset}" if offset else tzname
 
     def _convert_sql_to_tz(self, sql, params, tzname):
-        if tzname and settings.USE_TZ and self.connection.timezone_name != tzname:
+        if tzname and self.connection.timezone_name != tzname:
             return f"CONVERT_TZ({sql}, %s, %s)", (
                 *params,
                 self.connection.timezone_name,
@@ -230,13 +229,7 @@ def adapt_datetimefield_value(self, value):
 
         # MySQL doesn't support tz-aware datetimes
         if timezone.is_aware(value):
-            if settings.USE_TZ:
-                value = timezone.make_naive(value, self.connection.timezone)
-            else:
-                raise ValueError(
-                    "MySQL backend does not support timezone-aware datetimes when "
-                    "USE_TZ is False."
-                )
+            value = timezone.make_naive(value, self.connection.timezone)
         return str(value)
 
     def adapt_timefield_value(self, value):
@@ -283,8 +276,7 @@ def get_db_converters(self, expression):
         if internal_type == "BooleanField":
             converters.append(self.convert_booleanfield_value)
         elif internal_type == "DateTimeField":
-            if settings.USE_TZ:
-                converters.append(self.convert_datetimefield_value)
+            converters.append(self.convert_datetimefield_value)
         elif internal_type == "UUIDField":
             converters.append(self.convert_uuidfield_value)
         return converters

plain-models/plain/models/backends/postgresql/base.py

@@ -13,7 +13,6 @@
 from plain.models.backends.utils import CursorDebugWrapper as BaseCursorDebugWrapper
 from plain.models.db import DatabaseError as WrappedDatabaseError
 from plain.models.db import connections
-from plain.runtime import settings
 from plain.utils.functional import cached_property
 from plain.utils.safestring import SafeString
 
@@ -213,9 +212,7 @@ def get_connection_params(self):
         if settings_dict["PORT"]:
             conn_params["port"] = settings_dict["PORT"]
         if is_psycopg3:
-            conn_params["context"] = get_adapters_template(
-                settings.USE_TZ, self.timezone
-            )
+            conn_params["context"] = get_adapters_template(self.timezone)
             # Disable prepared statements by default to keep connection poolers
             # working. Can be reenabled via OPTIONS in the settings dict.
             conn_params["prepare_threshold"] = conn_params.pop(
@@ -315,7 +312,7 @@ def create_cursor(self, name=None):
             if self.timezone != tzloader.timezone:
                 register_tzloader(self.timezone, cursor)
         else:
-            cursor.tzinfo_factory = self.tzinfo_factory if settings.USE_TZ else None
+            cursor.tzinfo_factory = self.tzinfo_factory
         return cursor
 
     def tzinfo_factory(self, offset):

plain-models/plain/models/backends/postgresql/operations.py

@@ -11,7 +11,6 @@
 )
 from plain.models.backends.utils import split_tzname_delta
 from plain.models.constants import OnConflict
-from plain.runtime import settings
 from plain.utils.regex_helper import _lazy_re_compile
 
 
@@ -106,7 +105,7 @@ def _prepare_tzname_delta(self, tzname):
         return tzname
 
     def _convert_sql_to_tz(self, sql, params, tzname):
-        if tzname and settings.USE_TZ:
+        if tzname:
             tzname_param = self._prepare_tzname_delta(tzname)
             return f"{sql} AT TIME ZONE %s", (*params, tzname_param)
         return sql, params

plain-models/plain/models/backends/postgresql/psycopg_any.py

@@ -51,7 +51,7 @@ def upgrade(self, obj, format):
             return dumper
 
     @lru_cache
-    def get_adapters_template(use_tz, timezone):
+    def get_adapters_template(timezone):
         # Create at adapters map extending the base one.
         ctx = adapt.AdaptersMap(adapters)
         # Register a no-op dumper to avoid a round trip from psycopg version 3

plain-models/plain/models/backends/sqlite3/operations.py

@@ -9,7 +9,6 @@
 from plain.models.constants import OnConflict
 from plain.models.db import DatabaseError, NotSupportedError
 from plain.models.expressions import Col
-from plain.runtime import settings
 from plain.utils import timezone
 from plain.utils.dateparse import parse_date, parse_datetime, parse_time
 from plain.utils.functional import cached_property
@@ -103,7 +102,7 @@ def time_trunc_sql(self, lookup_type, sql, params, tzname=None):
         )
 
     def _convert_tznames_to_sql(self, tzname):
-        if tzname and settings.USE_TZ:
+        if tzname:
             return tzname, self.connection.timezone_name
         return None, None
 
@@ -245,13 +244,7 @@ def adapt_datetimefield_value(self, value):
 
         # SQLite doesn't support tz-aware datetimes
         if timezone.is_aware(value):
-            if settings.USE_TZ:
-                value = timezone.make_naive(value, self.connection.timezone)
-            else:
-                raise ValueError(
-                    "SQLite backend does not support timezone-aware datetimes when "
-                    "USE_TZ is False."
-                )
+            value = timezone.make_naive(value, self.connection.timezone)
 
         return str(value)
 
@@ -290,7 +283,7 @@ def convert_datetimefield_value(self, value, expression, connection):
         if value is not None:
             if not isinstance(value, datetime.datetime):
                 value = parse_datetime(value)
-            if settings.USE_TZ and not timezone.is_aware(value):
+            if not timezone.is_aware(value):
                 value = timezone.make_aware(value, self.connection.timezone)
         return value
 

plain-models/plain/models/fields/__init__.py

@@ -1289,7 +1289,7 @@ def to_python(self, value):
         if value is None:
             return value
         if isinstance(value, datetime.datetime):
-            if settings.USE_TZ and timezone.is_aware(value):
+            if timezone.is_aware(value):
                 # Convert aware datetimes to the default time zone
                 # before casting them to dates (#17742).
                 default_timezone = timezone.get_default_timezone()
@@ -1391,20 +1391,21 @@ def to_python(self, value):
             return value
         if isinstance(value, datetime.date):
             value = datetime.datetime(value.year, value.month, value.day)
-            if settings.USE_TZ:
-                # For backwards compatibility, interpret naive datetimes in
-                # local time. This won't work during DST change, but we can't
-                # do much about it, so we let the exceptions percolate up the
-                # call stack.
-                warnings.warn(
-                    "DateTimeField {}.{} received a naive datetime "
-                    "({}) while time zone support is active.".format(
-                        self.model.__name__, self.name, value
-                    ),
-                    RuntimeWarning,
-                )
-                default_timezone = timezone.get_default_timezone()
-                value = timezone.make_aware(value, default_timezone)
+
+            # For backwards compatibility, interpret naive datetimes in
+            # local time. This won't work during DST change, but we can't
+            # do much about it, so we let the exceptions percolate up the
+            # call stack.
+            warnings.warn(
+                "DateTimeField {}.{} received a naive datetime "
+                "({}) while time zone support is active.".format(
+                    self.model.__name__, self.name, value
+                ),
+                RuntimeWarning,
+            )
+            default_timezone = timezone.get_default_timezone()
+            value = timezone.make_aware(value, default_timezone)
+
             return value
 
         try:
@@ -1449,7 +1450,7 @@ def pre_save(self, model_instance, add):
     def get_prep_value(self, value):
         value = super().get_prep_value(value)
         value = self.to_python(value)
-        if value is not None and settings.USE_TZ and timezone.is_naive(value):
+        if value is not None and timezone.is_naive(value):
             # For backwards compatibility, interpret naive datetimes in local
             # time. This won't work during DST change, but we can't do much
             # about it, so we let the exceptions percolate up the call stack.

plain-models/plain/models/functions/datetime.py

@@ -17,7 +17,6 @@
     YearLt,
     YearLte,
 )
-from plain.runtime import settings
 from plain.utils import timezone
 
 
@@ -29,13 +28,10 @@ def get_tzname(self):
         # applying a function. 2015-12-31 23:00:00 -02:00 is stored in the
         # database as 2016-01-01 01:00:00 +00:00. Any results should be
         # based on the input datetime not the stored datetime.
-        tzname = None
-        if settings.USE_TZ:
-            if self.tzinfo is None:
-                tzname = timezone.get_current_timezone_name()
-            else:
-                tzname = timezone._get_timezone_name(self.tzinfo)
-        return tzname
+        if self.tzinfo is None:
+            return timezone.get_current_timezone_name()
+        else:
+            return timezone._get_timezone_name(self.tzinfo)
 
 
 class Extract(TimezoneMixin, Transform):
@@ -335,9 +331,7 @@ def resolve_expression(
 
     def convert_value(self, value, expression, connection):
         if isinstance(self.output_field, DateTimeField):
-            if not settings.USE_TZ:
-                pass
-            elif value is not None:
+            if value is not None:
                 value = value.replace(tzinfo=None)
                 value = timezone.make_aware(value, self.tzinfo)
             elif not connection.features.has_zoneinfo_database:

plain-models/plain/models/query.py

@@ -37,7 +37,6 @@
     create_namedtuple_class,
     resolve_callables,
 )
-from plain.runtime import settings
 from plain.utils import timezone
 from plain.utils.functional import cached_property, partition
 
@@ -1259,11 +1258,10 @@ def datetimes(self, field_name, kind, order="ASC", tzinfo=None):
             )
         if order not in ("ASC", "DESC"):
             raise ValueError("'order' must be either 'ASC' or 'DESC'.")
-        if settings.USE_TZ:
-            if tzinfo is None:
-                tzinfo = timezone.get_current_timezone()
-        else:
-            tzinfo = None
+
+        if tzinfo is None:
+            tzinfo = timezone.get_current_timezone()
+
         return (
             self.annotate(
                 datetimefield=Trunc(

plain/plain/forms/fields.py

@@ -14,7 +14,6 @@
 
 from plain import validators
 from plain.exceptions import ValidationError
-from plain.runtime import settings
 from plain.utils import timezone
 from plain.utils.dateparse import parse_datetime, parse_duration
 from plain.utils.duration import duration_string
@@ -1001,7 +1000,7 @@ def from_current_timezone(value):
     When time zone support is enabled, convert naive datetimes
     entered in the current time zone to aware datetimes.
     """
-    if settings.USE_TZ and value is not None and timezone.is_naive(value):
+    if value is not None and timezone.is_naive(value):
         current_timezone = timezone.get_current_timezone()
         try:
             if timezone._datetime_ambiguous_or_imaginary(value, current_timezone):
@@ -1025,6 +1024,6 @@ def to_current_timezone(value):
     When time zone support is enabled, convert aware datetimes
     to naive datetimes in the current time zone for display.
     """
-    if settings.USE_TZ and value is not None and timezone.is_aware(value):
+    if value is not None and timezone.is_aware(value):
         return timezone.make_naive(value)
     return value

plain/plain/runtime/global_settings.py

@@ -20,13 +20,10 @@
 
 # Local time zone for this installation. All choices can be found here:
 # https://en.wikipedia.org/wiki/List_of_tz_zones_by_name (although not all
-# systems may support all possibilities). When USE_TZ is True, this is
-# interpreted as the default user time zone.
+# systems may support all possibilities). This is interpreted as the default
+# user time zone.
 TIME_ZONE: str = "UTC"
 
-# If you set this to True, Plain will use timezone-aware datetimes.
-USE_TZ = True
-
 # Default charset to use for all Response objects, if a MIME type isn't
 # manually specified. It's used to construct the Content-Type header.
 DEFAULT_CHARSET = "utf-8"