debugpy 1.8.5__zip → 1.8.7__zip

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_filtering.py

@@ -9,17 +9,17 @@ import json
 from collections import namedtuple
 from _pydev_bundle._pydev_saved_modules import threading
 from pydevd_file_utils import normcase
-from _pydevd_bundle.pydevd_constants import USER_CODE_BASENAMES_STARTING_WITH, \
-    LIBRARY_CODE_BASENAMES_STARTING_WITH, IS_PYPY, IS_WINDOWS
+from _pydevd_bundle.pydevd_constants import USER_CODE_BASENAMES_STARTING_WITH, LIBRARY_CODE_BASENAMES_STARTING_WITH, IS_PYPY, IS_WINDOWS
 from _pydevd_bundle import pydevd_constants
+from _pydevd_bundle.pydevd_constants import is_true_in_env
 
-ExcludeFilter = namedtuple('ExcludeFilter', 'name, exclude, is_path')
+ExcludeFilter = namedtuple("ExcludeFilter", "name, exclude, is_path")
 
 
 def _convert_to_str_and_clear_empty(roots):
     new_roots = []
     for root in roots:
-        assert isinstance(root, str), '%s not str (found: %s)' % (root, type(root))
+        assert isinstance(root, str), "%s not str (found: %s)" % (root, type(root))
         if root:
             new_roots.append(root)
     return new_roots
@@ -37,11 +37,10 @@ def _check_matches(patterns, paths):
     path = normcase(paths[0])
 
     if not glob.has_magic(pattern):
-
         if pattern != path:
             return False
 
-    elif pattern == '**':
+    elif pattern == "**":
         if len(patterns) == 1:
             return True  # if ** is the last one it matches anything to the right.
 
@@ -63,12 +62,12 @@ def glob_matches_path(path, pattern, sep=os.sep, altsep=os.altsep):
         pattern = pattern.replace(altsep, sep)
         path = path.replace(altsep, sep)
 
-    drive = ''
-    if len(path) > 1 and path[1] == ':':
+    drive = ""
+    if len(path) > 1 and path[1] == ":":
         drive, path = path[0], path[2:]
 
     if drive and len(pattern) > 1:
-        if pattern[1] == ':':
+        if pattern[1] == ":":
             if drive.lower() != pattern[0].lower():
                 return False
             pattern = pattern[2:]
@@ -76,21 +75,21 @@ def glob_matches_path(path, pattern, sep=os.sep, altsep=os.altsep):
     patterns = pattern.split(sep)
     paths = path.split(sep)
     if paths:
-        if paths[0] == '':
+        if paths[0] == "":
             paths = paths[1:]
     if patterns:
-        if patterns[0] == '':
+        if patterns[0] == "":
             patterns = patterns[1:]
 
     return _check_matches(patterns, paths)
 
 
 class FilesFiltering(object):
-    '''
+    """
     Note: calls at FilesFiltering are uncached.
 
     The actual API used should be through PyDB.
-    '''
+    """
 
     def __init__(self):
         self._exclude_filters = []
@@ -101,16 +100,16 @@ class FilesFiltering(object):
         self._use_libraries_filter = False
         self.require_module = False  # True if some exclude filter filters by the module.
 
-        self.set_use_libraries_filter(os.getenv('PYDEVD_FILTER_LIBRARIES') is not None)
+        self.set_use_libraries_filter(is_true_in_env("PYDEVD_FILTER_LIBRARIES"))
 
-        project_roots = os.getenv('IDE_PROJECT_ROOTS', None)
+        project_roots = os.getenv("IDE_PROJECT_ROOTS", None)
         if project_roots is not None:
             project_roots = project_roots.split(os.pathsep)
         else:
             project_roots = []
         self.set_project_roots(project_roots)
 
-        library_roots = os.getenv('LIBRARY_ROOTS', None)
+        library_roots = os.getenv("LIBRARY_ROOTS", None)
         if library_roots is not None:
             library_roots = library_roots.split(os.pathsep)
         else:
@@ -118,11 +117,11 @@ class FilesFiltering(object):
         self.set_library_roots(library_roots)
 
         # Stepping filters.
-        pydevd_filters = os.getenv('PYDEVD_FILTERS', '')
+        pydevd_filters = os.getenv("PYDEVD_FILTERS", "")
         # To filter out it's something as: {'**/not_my_code/**': True}
         if pydevd_filters:
             pydev_log.debug("PYDEVD_FILTERS %s", (pydevd_filters,))
-            if pydevd_filters.startswith('{'):
+            if pydevd_filters.startswith("{"):
                 # dict(glob_pattern (str) -> exclude(True or False))
                 exclude_filters = []
                 for key, val in json.loads(pydevd_filters).items():
@@ -131,7 +130,7 @@ class FilesFiltering(object):
             else:
                 # A ';' separated list of strings with globs for the
                 # list of excludes.
-                filters = pydevd_filters.split(';')
+                filters = pydevd_filters.split(";")
                 new_filters = []
                 for new_filter in filters:
                     if new_filter.strip():
@@ -151,7 +150,7 @@ class FilesFiltering(object):
         except ImportError:
             pass
         else:
-            for path_name in set(('stdlib', 'platstdlib', 'purelib', 'platlib')) & set(sysconfig.get_path_names()):
+            for path_name in set(("stdlib", "platstdlib", "purelib", "platlib")) & set(sysconfig.get_path_names()):
                 roots.append(sysconfig.get_path(path_name))
 
         # Make sure we always get at least the standard library location (based on the `os` and
@@ -170,7 +169,7 @@ class FilesFiltering(object):
                 pydev_log.debug("Adding %s to default library roots.", pypy_lib_dir)
                 roots.append(pypy_lib_dir)
 
-        if hasattr(site, 'getusersitepackages'):
+        if hasattr(site, "getusersitepackages"):
             site_paths = site.getusersitepackages()
             if isinstance(site_paths, (list, tuple)):
                 for site_path in site_paths:
@@ -178,7 +177,7 @@ class FilesFiltering(object):
             else:
                 roots.append(site_paths)
 
-        if hasattr(site, 'getsitepackages'):
+        if hasattr(site, "getsitepackages"):
             site_paths = site.getsitepackages()
             if isinstance(site_paths, (list, tuple)):
                 for site_path in site_paths:
@@ -187,7 +186,7 @@ class FilesFiltering(object):
                 roots.append(site_paths)
 
         for path in sys.path:
-            if os.path.exists(path) and os.path.basename(path) in ('site-packages', 'pip-global'):
+            if os.path.exists(path) and os.path.basename(path) in ("site-packages", "pip-global"):
                 roots.append(path)
 
         # On WASM some of the roots may not exist, filter those out.
@@ -202,15 +201,15 @@ class FilesFiltering(object):
         for root in roots:
             path = self._absolute_normalized_path(root)
             if pydevd_constants.IS_WINDOWS:
-                new_roots.append(path + '\\')
+                new_roots.append(path + "\\")
             else:
-                new_roots.append(path + '/')
+                new_roots.append(path + "/")
         return new_roots
 
     def _absolute_normalized_path(self, filename):
-        '''
+        """
         Provides a version of the filename that's absolute and normalized.
-        '''
+        """
         return normcase(pydevd_file_utils.absolute_path(filename))
 
     def set_project_roots(self, project_roots):
@@ -228,33 +227,39 @@ class FilesFiltering(object):
         return self._library_roots
 
     def in_project_roots(self, received_filename):
-        '''
+        """
         Note: don't call directly. Use PyDb.in_project_scope (there's no caching here and it doesn't
         handle all possibilities for knowing whether a project is actually in the scope, it
         just handles the heuristics based on the absolute_normalized_filename without the actual frame).
-        '''
+        """
         DEBUG = False
 
         if received_filename.startswith(USER_CODE_BASENAMES_STARTING_WITH):
             if DEBUG:
-                pydev_log.debug('In in_project_roots - user basenames - starts with %s (%s)', received_filename, USER_CODE_BASENAMES_STARTING_WITH)
+                pydev_log.debug(
+                    "In in_project_roots - user basenames - starts with %s (%s)", received_filename, USER_CODE_BASENAMES_STARTING_WITH
+                )
             return True
 
         if received_filename.startswith(LIBRARY_CODE_BASENAMES_STARTING_WITH):
             if DEBUG:
-                pydev_log.debug('Not in in_project_roots - library basenames - starts with %s (%s)', received_filename, LIBRARY_CODE_BASENAMES_STARTING_WITH)
+                pydev_log.debug(
+                    "Not in in_project_roots - library basenames - starts with %s (%s)",
+                    received_filename,
+                    LIBRARY_CODE_BASENAMES_STARTING_WITH,
+                )
             return False
 
         project_roots = self._get_project_roots()  # roots are absolute/normalized.
 
         absolute_normalized_filename = self._absolute_normalized_path(received_filename)
-        absolute_normalized_filename_as_dir = absolute_normalized_filename + ('\\' if IS_WINDOWS else '/')
+        absolute_normalized_filename_as_dir = absolute_normalized_filename + ("\\" if IS_WINDOWS else "/")
 
         found_in_project = []
         for root in project_roots:
             if root and (absolute_normalized_filename.startswith(root) or root == absolute_normalized_filename_as_dir):
                 if DEBUG:
-                    pydev_log.debug('In project: %s (%s)', absolute_normalized_filename, root)
+                    pydev_log.debug("In project: %s (%s)", absolute_normalized_filename, root)
                 found_in_project.append(root)
 
         found_in_library = []
@@ -263,10 +268,10 @@ class FilesFiltering(object):
             if root and (absolute_normalized_filename.startswith(root) or root == absolute_normalized_filename_as_dir):
                 found_in_library.append(root)
                 if DEBUG:
-                    pydev_log.debug('In library: %s (%s)', absolute_normalized_filename, root)
+                    pydev_log.debug("In library: %s (%s)", absolute_normalized_filename, root)
             else:
                 if DEBUG:
-                    pydev_log.debug('Not in library: %s (%s)', absolute_normalized_filename, root)
+                    pydev_log.debug("Not in library: %s (%s)", absolute_normalized_filename, root)
 
         if not project_roots:
             # If we have no project roots configured, consider it being in the project
@@ -274,28 +279,28 @@ class FilesFiltering(object):
             # and not the other way around).
             in_project = not found_in_library
             if DEBUG:
-                pydev_log.debug('Final in project (no project roots): %s (%s)', absolute_normalized_filename, in_project)
+                pydev_log.debug("Final in project (no project roots): %s (%s)", absolute_normalized_filename, in_project)
 
         else:
             in_project = False
             if found_in_project:
                 if not found_in_library:
                     if DEBUG:
-                        pydev_log.debug('Final in project (in_project and not found_in_library): %s (True)', absolute_normalized_filename)
+                        pydev_log.debug("Final in project (in_project and not found_in_library): %s (True)", absolute_normalized_filename)
                     in_project = True
                 else:
                     # Found in both, let's see which one has the bigger path matched.
                     if max(len(x) for x in found_in_project) > max(len(x) for x in found_in_library):
                         in_project = True
                     if DEBUG:
-                        pydev_log.debug('Final in project (found in both): %s (%s)', absolute_normalized_filename, in_project)
+                        pydev_log.debug("Final in project (found in both): %s (%s)", absolute_normalized_filename, in_project)
 
         return in_project
 
     def use_libraries_filter(self):
-        '''
+        """
         Should we debug only what's inside project folders?
-        '''
+        """
         return self._use_libraries_filter
 
     def set_use_libraries_filter(self, use):
@@ -307,24 +312,24 @@ class FilesFiltering(object):
         return len(self._exclude_filters) > 0
 
     def exclude_by_filter(self, absolute_filename, module_name):
-        '''
+        """
         :return: True if it should be excluded, False if it should be included and None
             if no rule matched the given file.
-        '''
+        """
         for exclude_filter in self._exclude_filters:  # : :type exclude_filter: ExcludeFilter
             if exclude_filter.is_path:
                 if glob_matches_path(absolute_filename, exclude_filter.name):
                     return exclude_filter.exclude
             else:
                 # Module filter.
-                if exclude_filter.name == module_name or module_name.startswith(exclude_filter.name + '.'):
+                if exclude_filter.name == module_name or module_name.startswith(exclude_filter.name + "."):
                     return exclude_filter.exclude
         return None
 
     def set_exclude_filters(self, exclude_filters):
-        '''
+        """
         :param list(ExcludeFilter) exclude_filters:
-        '''
+        """
         self._exclude_filters = exclude_filters
         self.require_module = False
         for exclude_filter in exclude_filters: