Bump apscheduler from 3.8.0 to 3.9.1 (#1675)

* Bump apscheduler from 3.8.0 to 3.9.1

Bumps [apscheduler](https://github.com/agronholm/apscheduler) from 3.8.0 to 3.9.1.
- [Release notes](https://github.com/agronholm/apscheduler/releases)
- [Changelog](https://github.com/agronholm/apscheduler/blob/3.9.1/docs/versionhistory.rst)
- [Commits](https://github.com/agronholm/apscheduler/compare/3.8.0...3.9.1)

---
updated-dependencies:
- dependency-name: apscheduler
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

* Update apscheduler==3.9.1

* Update pytz==2022.1

* Add pytz-deprecation-shim==0.1.0.post0

* Update tzdata==2022.1

* Update tzlocal==4.2

* Update requirements.txt

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: JonnyWong16 <9099342+JonnyWong16@users.noreply.github.com>

[skip ci]

lib/tzlocal/win32.py

@@ -1,32 +1,53 @@
+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."""
-    dict = {}
+    result = {}
     size = winreg.QueryInfoKey(key)[1]
     for i in range(size):
         data = winreg.EnumValue(key, i)
-        dict[data[0]] = data[1]
-    return dict
+        result[data[0]] = data[1]
+    return result
 
 
-def get_localzone_name():
+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():
     # 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"
@@ -34,44 +55,16 @@ def get_localzone_name():
     keyvalues = valuestodict(localtz)
     localtz.Close()
 
-    if 'TimeZoneKeyName' in keyvalues:
-        # Windows 7 (and Vista?)
+    if "TimeZoneKeyName" in keyvalues:
+        # Windows 7 and later
 
         # 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:
-        # 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')
+        # Don't support XP any longer
+        raise LookupError("Can not find Windows timezone configuration")
 
     timezone = win_tz.get(tzkeyname)
     if timezone is None:
@@ -81,24 +74,64 @@ def get_localzone_name():
 
     # Return what we have.
     if timezone is None:
-        raise pytz.UnknownTimeZoneError('Can not find timezone ' + tzkeyname)
+        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}"
 
     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 = pytz.timezone(get_localzone_name())
+        _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)
 
-    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
-    _cache_tz = pytz.timezone(get_localzone_name())
+    global _cache_tz_name
+    _cache_tz_name = _get_localzone_name()
+    _cache_tz = pds.timezone(_cache_tz_name)
     utils.assert_tz_offset(_cache_tz)
     return _cache_tz