Revert "Update apscheduler==3.8.1"

This reverts commit 973cad264f.

lib/tzlocal/win32.py

@@ -1,53 +1,32 @@
-from datetime import datetime
-import pytz_deprecation_shim as pds
-
 try:
     import _winreg as winreg
 except ImportError:
     import winreg
 
+import pytz
+
 from tzlocal.windows_tz import win_tz
 from tzlocal import utils
 
 _cache_tz = None
-_cache_tz_name = None
 
 
 def valuestodict(key):
     """Convert a registry key's values to a dictionary."""
-    result = {}
+    dict = {}
     size = winreg.QueryInfoKey(key)[1]
     for i in range(size):
         data = winreg.EnumValue(key, i)
-        result[data[0]] = data[1]
-    return result
+        dict[data[0]] = data[1]
+    return dict
 
 
-def _get_dst_info(tz):
-    # Find the offset for when it doesn't have DST:
-    dst_offset = std_offset = None
-    has_dst = False
-    year = datetime.now().year
-    for dt in (datetime(year, 1, 1), datetime(year, 6, 1)):
-        if tz.dst(dt).total_seconds() == 0.0:
-            # OK, no DST during winter, get this offset
-            std_offset = tz.utcoffset(dt).total_seconds()
-        else:
-            has_dst = True
-
-    return has_dst, std_offset, dst_offset
-
-
-def _get_localzone_name():
+def get_localzone_name():
     # Windows is special. It has unique time zone names (in several
     # meanings of the word) available, but unfortunately, they can be
     # translated to the language of the operating system, so we need to
     # do a backwards lookup, by going through all time zones and see which
     # one matches.
-    tzenv = utils._tz_name_from_env()
-    if tzenv:
-        return tzenv
-
     handle = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
 
     TZLOCALKEYNAME = r"SYSTEM\CurrentControlSet\Control\TimeZoneInformation"
@@ -55,16 +34,44 @@ def _get_localzone_name():
     keyvalues = valuestodict(localtz)
     localtz.Close()
 
-    if "TimeZoneKeyName" in keyvalues:
-        # Windows 7 and later
+    if 'TimeZoneKeyName' in keyvalues:
+        # Windows 7 (and Vista?)
 
         # For some reason this returns a string with loads of NUL bytes at
         # least on some systems. I don't know if this is a bug somewhere, I
         # just work around it.
-        tzkeyname = keyvalues["TimeZoneKeyName"].split("\x00", 1)[0]
+        tzkeyname = keyvalues['TimeZoneKeyName'].split('\x00', 1)[0]
     else:
-        # Don't support XP any longer
-        raise LookupError("Can not find Windows timezone configuration")
+        # Windows 2000 or XP
+
+        # This is the localized name:
+        tzwin = keyvalues['StandardName']
+
+        # Open the list of timezones to look up the real name:
+        TZKEYNAME = r"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones"
+        tzkey = winreg.OpenKey(handle, TZKEYNAME)
+
+        # Now, match this value to Time Zone information
+        tzkeyname = None
+        for i in range(winreg.QueryInfoKey(tzkey)[0]):
+            subkey = winreg.EnumKey(tzkey, i)
+            sub = winreg.OpenKey(tzkey, subkey)
+            data = valuestodict(sub)
+            sub.Close()
+            try:
+                if data['Std'] == tzwin:
+                    tzkeyname = subkey
+                    break
+            except KeyError:
+                # This timezone didn't have proper configuration.
+                # Ignore it.
+                pass
+
+        tzkey.Close()
+        handle.Close()
+
+    if tzkeyname is None:
+        raise LookupError('Can not find Windows timezone configuration')
 
     timezone = win_tz.get(tzkeyname)
     if timezone is None:
@@ -74,64 +81,24 @@ def _get_localzone_name():
 
     # Return what we have.
     if timezone is None:
-        raise utils.ZoneInfoNotFoundError(tzkeyname)
-
-    if keyvalues.get("DynamicDaylightTimeDisabled", 0) == 1:
-        # DST is disabled, so don't return the timezone name,
-        # instead return Etc/GMT+offset
-
-        tz = pds.timezone(timezone)
-        has_dst, std_offset, dst_offset = _get_dst_info(tz)
-        if not has_dst:
-            # The DST is turned off in the windows configuration,
-            # but this timezone doesn't have DST so it doesn't matter
-            return timezone
-
-        if std_offset is None:
-            raise utils.ZoneInfoNotFoundError(
-                f"{tzkeyname} claims to not have a non-DST time!?")
-
-        if std_offset % 3600:
-            # I can't convert this to an hourly offset
-            raise utils.ZoneInfoNotFoundError(
-                f"tzlocal can't support disabling DST in the {timezone} zone.")
-
-        # This has whole hours as offset, return it as Etc/GMT
-        return f"Etc/GMT{-std_offset//3600:+.0f}"
+        raise pytz.UnknownTimeZoneError('Can not find timezone ' + tzkeyname)
 
     return timezone
 
 
-def get_localzone_name():
-    """Get the zoneinfo timezone name that matches the Windows-configured timezone."""
-    global _cache_tz_name
-    if _cache_tz_name is None:
-        _cache_tz_name = _get_localzone_name()
-
-    return _cache_tz_name
-
-
 def get_localzone():
     """Returns the zoneinfo-based tzinfo object that matches the Windows-configured timezone."""
-
     global _cache_tz
     if _cache_tz is None:
-        _cache_tz = pds.timezone(get_localzone_name())
-
-    if not utils._tz_name_from_env():
-        # If the timezone does NOT come from a TZ environment variable,
-        # verify that it's correct. If it's from the environment,
-        # we accept it, this is so you can run tests with different timezones.
-        utils.assert_tz_offset(_cache_tz)
+        _cache_tz = pytz.timezone(get_localzone_name())
 
+    utils.assert_tz_offset(_cache_tz)
     return _cache_tz
 
 
 def reload_localzone():
     """Reload the cached localzone. You need to call this if the timezone has changed."""
     global _cache_tz
-    global _cache_tz_name
-    _cache_tz_name = _get_localzone_name()
-    _cache_tz = pds.timezone(_cache_tz_name)
+    _cache_tz = pytz.timezone(get_localzone_name())
     utils.assert_tz_offset(_cache_tz)
     return _cache_tz