Bump cherrypy from 18.8.0 to 18.9.0 (#2266)

* Bump cherrypy from 18.8.0 to 18.9.0

Bumps [cherrypy](https://github.com/cherrypy/cherrypy) from 18.8.0 to 18.9.0.
- [Changelog](https://github.com/cherrypy/cherrypy/blob/main/CHANGES.rst)
- [Commits](https://github.com/cherrypy/cherrypy/compare/v18.8.0...v18.9.0)

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

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

* Update cherrypy==18.9.0

---------

Signed-off-by: dependabot[bot] <support@github.com>
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/win32com/client/selecttlb.py

@@ -0,0 +1,183 @@
+"""Utilities for selecting and enumerating the Type Libraries installed on the system
+"""
+
+import pythoncom
+import win32api
+import win32con
+
+
+class TypelibSpec:
+    def __init__(self, clsid, lcid, major, minor, flags=0):
+        self.clsid = str(clsid)
+        self.lcid = int(lcid)
+        # We avoid assuming 'major' or 'minor' are integers - when
+        # read from the registry there is some confusion about if
+        # they are base 10 or base 16 (they *should* be base 16, but
+        # how they are written is beyond our control.)
+        self.major = major
+        self.minor = minor
+        self.dll = None
+        self.desc = None
+        self.ver_desc = None
+        self.flags = flags
+
+    # For the SelectList
+    def __getitem__(self, item):
+        if item == 0:
+            return self.ver_desc
+        raise IndexError("Cant index me!")
+
+    def __lt__(self, other):  # rich-cmp/py3k-friendly version
+        me = (
+            (self.ver_desc or "").lower(),
+            (self.desc or "").lower(),
+            self.major,
+            self.minor,
+        )
+        them = (
+            (other.ver_desc or "").lower(),
+            (other.desc or "").lower(),
+            other.major,
+            other.minor,
+        )
+        return me < them
+
+    def __eq__(self, other):  # rich-cmp/py3k-friendly version
+        return (
+            (self.ver_desc or "").lower() == (other.ver_desc or "").lower()
+            and (self.desc or "").lower() == (other.desc or "").lower()
+            and self.major == other.major
+            and self.minor == other.minor
+        )
+
+    def Resolve(self):
+        if self.dll is None:
+            return 0
+        tlb = pythoncom.LoadTypeLib(self.dll)
+        self.FromTypelib(tlb, None)
+        return 1
+
+    def FromTypelib(self, typelib, dllName=None):
+        la = typelib.GetLibAttr()
+        self.clsid = str(la[0])
+        self.lcid = la[1]
+        self.major = la[3]
+        self.minor = la[4]
+        if dllName:
+            self.dll = dllName
+
+
+def EnumKeys(root):
+    index = 0
+    ret = []
+    while 1:
+        try:
+            item = win32api.RegEnumKey(root, index)
+        except win32api.error:
+            break
+        try:
+            # Note this doesn't handle REG_EXPAND_SZ, but the implementation
+            # here doesn't need to - that is handled as the data is read.
+            val = win32api.RegQueryValue(root, item)
+        except win32api.error:
+            val = ""  # code using this assumes a string.
+
+        ret.append((item, val))
+        index = index + 1
+    return ret
+
+
+FLAG_RESTRICTED = 1
+FLAG_CONTROL = 2
+FLAG_HIDDEN = 4
+
+
+def EnumTlbs(excludeFlags=0):
+    """Return a list of TypelibSpec objects, one for each registered library."""
+    key = win32api.RegOpenKey(win32con.HKEY_CLASSES_ROOT, "Typelib")
+    iids = EnumKeys(key)
+    results = []
+    for iid, crap in iids:
+        try:
+            key2 = win32api.RegOpenKey(key, str(iid))
+        except win32api.error:
+            # A few good reasons for this, including "access denied".
+            continue
+        for version, tlbdesc in EnumKeys(key2):
+            major_minor = version.split(".", 1)
+            if len(major_minor) < 2:
+                major_minor.append("0")
+            # For some reason, this code used to assume the values were hex.
+            # This seems to not be true - particularly for CDO 1.21
+            # *sigh* - it appears there are no rules here at all, so when we need
+            # to know the info, we must load the tlb by filename and request it.
+            # The Resolve() method on the TypelibSpec does this.
+            # For this reason, keep the version numbers as strings - that
+            # way we can't be wrong!  Let code that really needs an int to work
+            # out what to do.  FWIW, http://support.microsoft.com/kb/816970 is
+            # pretty clear that they *should* be hex.
+            major = major_minor[0]
+            minor = major_minor[1]
+            key3 = win32api.RegOpenKey(key2, str(version))
+            try:
+                # The "FLAGS" are at this point
+                flags = int(win32api.RegQueryValue(key3, "FLAGS"))
+            except (win32api.error, ValueError):
+                flags = 0
+            if flags & excludeFlags == 0:
+                for lcid, crap in EnumKeys(key3):
+                    try:
+                        lcid = int(lcid)
+                    except ValueError:  # not an LCID entry
+                        continue
+                    # Check for both "{lcid}\win32" and "{lcid}\win64" keys.
+                    try:
+                        key4 = win32api.RegOpenKey(key3, "%s\\win32" % (lcid,))
+                    except win32api.error:
+                        try:
+                            key4 = win32api.RegOpenKey(key3, "%s\\win64" % (lcid,))
+                        except win32api.error:
+                            continue
+                    try:
+                        dll, typ = win32api.RegQueryValueEx(key4, None)
+                        if typ == win32con.REG_EXPAND_SZ:
+                            dll = win32api.ExpandEnvironmentStrings(dll)
+                    except win32api.error:
+                        dll = None
+                    spec = TypelibSpec(iid, lcid, major, minor, flags)
+                    spec.dll = dll
+                    spec.desc = tlbdesc
+                    spec.ver_desc = tlbdesc + " (" + version + ")"
+                    results.append(spec)
+    return results
+
+
+def FindTlbsWithDescription(desc):
+    """Find all installed type libraries with the specified description"""
+    ret = []
+    items = EnumTlbs()
+    for item in items:
+        if item.desc == desc:
+            ret.append(item)
+    return ret
+
+
+def SelectTlb(title="Select Library", excludeFlags=0):
+    """Display a list of all the type libraries, and select one.   Returns None if cancelled"""
+    import pywin.dialogs.list
+
+    items = EnumTlbs(excludeFlags)
+    # fixup versions - we assume hex (see __init__ above)
+    for i in items:
+        i.major = int(i.major, 16)
+        i.minor = int(i.minor, 16)
+    items.sort()
+    rc = pywin.dialogs.list.SelectFromLists(title, items, ["Type Library"])
+    if rc is None:
+        return None
+    return items[rc]
+
+
+# Test code.
+if __name__ == "__main__":
+    print(SelectTlb().__dict__)