python-ldap · Alphix · Jan 26, 2024 · Jan 26, 2024 · Jan 26, 2024 · Jan 26, 2024
diff --git a/Doc/fake_ldap_module_for_documentation.py b/Doc/fake_ldap_module_for_documentation.py
@@ -1,21 +1,21 @@
 """
-A module that mocks `_ldap` for the purposes of generating documentation
+A module that mocks `ldap._ldap` for the purposes of generating documentation

-This module provides placeholders for the contents of `_ldap`, making it
-possible to generate documentation even _ldap is not compiled.
+This module provides placeholders for the contents of `ldap._ldap`, making it
+possible to generate documentation even if ldap._ldap is not compiled.
 It should also make the documentation independent of which features are
 available in the system OpenLDAP library.

 The overly long module name will show up in AttributeError messages,
-hinting that this is not the actual _ldap.
+hinting that this is not the actual ldap._ldap.

 See https://www.python-ldap.org/ for details.
 """

 import sys

-# Cause `import _ldap` to import this module instead of the actual `_ldap`.
-sys.modules['_ldap'] = sys.modules[__name__]
+# Cause `import ldap._ldap` to import this module instead of the actual module.
+sys.modules['ldap._ldap'] = sys.modules[__name__]

 from constants import CONSTANTS
 from pkginfo import __version__

diff --git a/Lib/ldap/__init__.py b/Lib/ldap/__init__.py
@@ -6,21 +6,27 @@

 # This is also the overall release version number

+from __future__ import annotations
 from ldap.pkginfo import __version__, __author__, __license__

 import os
 import sys

+import threading
+
+from typing import Any, Type
+
+
 if __debug__:
  # Tracing is only supported in debugging mode
  import atexit
  import traceback
  _trace_level = int(os.environ.get("PYTHON_LDAP_TRACE_LEVEL", 0))
-  _trace_file = os.environ.get("PYTHON_LDAP_TRACE_FILE")
-  if _trace_file is None:
+  _trace_file_path = os.environ.get("PYTHON_LDAP_TRACE_FILE")
+  if _trace_file_path is None:
    _trace_file = sys.stderr
  else:
-    _trace_file = open(_trace_file, 'a')
+    _trace_file = open(_trace_file_path, 'a')
    atexit.register(_trace_file.close)
  _trace_stack_limit = None
 else:
@@ -31,10 +37,10 @@
  _trace_file = sys.stderr
  _trace_stack_limit = None

-import _ldap
+import ldap._ldap as _ldap
 assert _ldap.__version__==__version__, \
       ImportError(f'ldap {__version__} and _ldap {_ldap.__version__} version mismatch!')
-from _ldap import *
+from ldap._ldap import *
 # call into libldap to initialize it right now
 LIBLDAP_API_INFO = _ldap.get_option(_ldap.OPT_API_INFO)

@@ -43,22 +49,7 @@
  if k.startswith('OPT_'):
    OPT_NAMES_DICT[v]=k

-class DummyLock:
-  """Define dummy class with methods compatible to threading.Lock"""
-  def __init__(self):
-    pass
-  def acquire(self):
-    pass
-  def release(self):
-    pass
-
-try:
-  # Check if Python installation was build with thread support
-  import threading
-except ImportError:
-  LDAPLockBaseClass = DummyLock
-else:
-  LDAPLockBaseClass = threading.Lock
+LDAPLockBaseClass = threading.Lock


 class LDAPLock:
@@ -69,7 +60,11 @@ class LDAPLock:
  """
  _min_trace_level = 3

-  def __init__(self,lock_class=None,desc=''):
+  def __init__(
+    self,
+    lock_class: Type[Any] | None = None,
+    desc: str = ''
+  ) -> None:
    """
    lock_class
        Class compatible to threading.Lock
@@ -79,19 +74,19 @@ def __init__(self,lock_class=None,desc=''):
    self._desc = desc
    self._lock = (lock_class or LDAPLockBaseClass)()

-  def acquire(self):
+  def acquire(self) -> bool:
    if __debug__:
      global _trace_level
      if _trace_level>=self._min_trace_level:
        _trace_file.write('***{}.acquire() {} {}\n'.format(self.__class__.__name__,repr(self),self._desc))
    return self._lock.acquire()

-  def release(self):
+  def release(self) -> None:
    if __debug__:
      global _trace_level
      if _trace_level>=self._min_trace_level:
        _trace_file.write('***{}.release() {} {}\n'.format(self.__class__.__name__,repr(self),self._desc))
-    return self._lock.release()
+    self._lock.release()


 # Create module-wide lock for serializing all calls into underlying LDAP lib