text: r'''
      This module provides utilities to get the absolute filenames so that we can be sure that:
          - The case of a file will match the actual file in the filesystem (otherwise breakpoints won't be hit).
          - Providing means for the user to make path conversions when doing a remote debugging session in
            one machine and debugging in another.
  
      To do that, the PATHS_FROM_ECLIPSE_TO_PYTHON constant must be filled with the appropriate paths.
  
      @note:
          in this context, the server is where your python process is running
          and the client is where eclipse is running.
  
      E.g.:
          If the server (your python process) has the structure
              /user/projects/my_project/src/package/module1.py
  
          and the client has:
              c:\my_project\src\package\module1.py
  
          the PATHS_FROM_ECLIPSE_TO_PYTHON would have to be:
              PATHS_FROM_ECLIPSE_TO_PYTHON = [(r'c:\my_project\src', r'/user/projects/my_project/src')]
  
          alternatively, this can be set with an environment variable from the command line:
             set PATHS_FROM_ECLIPSE_TO_PYTHON=[['c:\my_project\src','/user/projects/my_project/src']]
  
      @note: DEBUG_CLIENT_SERVER_TRANSLATION can be set to True to debug the result of those translations
  
      @note: the case of the paths is important! Note that this can be tricky to get right when one machine
      uses a case-independent filesystem and the other uses a case-dependent filesystem (if the system being
      debugged is case-independent, 'normcase()' should be used on the paths defined in PATHS_FROM_ECLIPSE_TO_PYTHON).
  
      @note: all the paths with breakpoints must be translated (otherwise they won't be found in the server)
  
      @note: to enable remote debugging in the target machine (pydev extensions in the eclipse installation)
          import pydevd;pydevd.settrace(host, stdoutToServer, stderrToServer, port, suspend)
  
          see parameter docs on pydevd.py
  
      @note: for doing a remote debugging session, all the pydevd_ files must be on the server accessible
          through the PYTHONPATH (and the PATHS_FROM_ECLIPSE_TO_PYTHON only needs to be set on the target
          machine for the paths that'll actually have breakpoints).
  '''
  
  from _pydev_bundle import pydev_log
  from _pydevd_bundle.pydevd_constants import IS_PY2, IS_PY3K, DebugInfoHolder, IS_WINDOWS, IS_JYTHON
  from _pydev_bundle._pydev_filesystem_encoding import getfilesystemencoding
  from _pydevd_bundle.pydevd_comm_constants import file_system_encoding, filesystem_encoding_is_utf8
  from _pydev_bundle.pydev_log import error_once
  
  import json
  import os.path
  import sys
  import itertools
  import ntpath
  from functools import partial
  
  _nt_os_normcase = ntpath.normcase
  os_path_basename = os.path.basename
  os_path_exists = os.path.exists
  join = os.path.join
  
  try:
      FileNotFoundError
  except NameError:
      FileNotFoundError = IOError  # noqa
  
  try:
      os_path_real_path = os.path.realpath  # @UndefinedVariable
  except:
      # jython does not support os.path.realpath
      # realpath is a no-op on systems without islink support
      os_path_real_path = os.path.abspath
  
  
  def _get_library_dir():
      library_dir = None
      try:
          import sysconfig
          library_dir = sysconfig.get_path('purelib')
      except ImportError:
          pass  # i.e.: Only 2.7 onwards
  
      if library_dir is None or not os_path_exists(library_dir):
          for path in sys.path:
              if os_path_exists(path) and os.path.basename(path) == 'site-packages':
                  library_dir = path
                  break
  
      if library_dir is None or not os_path_exists(library_dir):
          library_dir = os.path.dirname(os.__file__)
  
      return library_dir
  
  
  # Note: we can't call sysconfig.get_path from _apply_func_and_normalize_case (it deadlocks on Python 2.7) so, we
  # need to get the library dir during module loading.
  _library_dir = _get_library_dir()
  
  # defined as a list of tuples where the 1st element of the tuple is the path in the client machine
  # and the 2nd element is the path in the server machine.
  # see module docstring for more details.
  try:
      PATHS_FROM_ECLIPSE_TO_PYTHON = json.loads(os.environ.get('PATHS_FROM_ECLIPSE_TO_PYTHON', '[]'))
  except Exception:
      pydev_log.critical('Error loading PATHS_FROM_ECLIPSE_TO_PYTHON from environment variable.')
      pydev_log.exception()
      PATHS_FROM_ECLIPSE_TO_PYTHON = []
  else:
      if not isinstance(PATHS_FROM_ECLIPSE_TO_PYTHON, list):
          pydev_log.critical('Expected PATHS_FROM_ECLIPSE_TO_PYTHON loaded from environment variable to be a list.')
          PATHS_FROM_ECLIPSE_TO_PYTHON = []
      else:
          # Converting json lists to tuple
          PATHS_FROM_ECLIPSE_TO_PYTHON = [tuple(x) for x in PATHS_FROM_ECLIPSE_TO_PYTHON]
  
  # example:
  # PATHS_FROM_ECLIPSE_TO_PYTHON = [
  #  (r'd:\temp\temp_workspace_2\test_python\src\yyy\yyy',
  #   r'd:\temp\temp_workspace_2\test_python\src\hhh\xxx')
  # ]
  
  convert_to_long_pathname = lambda filename:filename
  convert_to_short_pathname = lambda filename:filename
  get_path_with_real_case = lambda filename:filename
  
  if sys.platform == 'win32':
      try:
          import ctypes
          from ctypes.wintypes import MAX_PATH, LPCWSTR, LPWSTR, DWORD
  
          GetLongPathName = ctypes.windll.kernel32.GetLongPathNameW  # noqa
          GetLongPathName.argtypes = [LPCWSTR, LPWSTR, DWORD]
          GetLongPathName.restype = DWORD
  
          GetShortPathName = ctypes.windll.kernel32.GetShortPathNameW  # noqa
          GetShortPathName.argtypes = [LPCWSTR, LPWSTR, DWORD]
          GetShortPathName.restype = DWORD
  
          def _convert_to_long_pathname(filename):
              buf = ctypes.create_unicode_buffer(MAX_PATH)
  
              if IS_PY2 and isinstance(filename, str):
                  filename = filename.decode(getfilesystemencoding())
              rv = GetLongPathName(filename, buf, MAX_PATH)
              if rv != 0 and rv <= MAX_PATH:
                  filename = buf.value
  
              if IS_PY2:
                  filename = filename.encode(getfilesystemencoding())
              return filename
  
          def _convert_to_short_pathname(filename):
              buf = ctypes.create_unicode_buffer(MAX_PATH)
  
              if IS_PY2 and isinstance(filename, str):
                  filename = filename.decode(getfilesystemencoding())
              rv = GetShortPathName(filename, buf, MAX_PATH)
              if rv != 0 and rv <= MAX_PATH:
                  filename = buf.value
  
              if IS_PY2:
                  filename = filename.encode(getfilesystemencoding())
              return filename
  
          # Note that we have a cache for previous list dirs... the only case where this may be an
          # issue is if the user actually changes the case of an existing file on windows while
          # the debugger is executing (as this seems very unlikely and the cache can save a
          # reasonable time -- especially on mapped drives -- it seems nice to have it).
          _listdir_cache = {}
  
          def _resolve_listing(resolved, iter_parts, cache=_listdir_cache):
              while True:  # Note: while True to make iterative and not recursive
                  try:
                      resolve_lowercase = next(iter_parts)  # must be lowercase already
                  except StopIteration:
                      return resolved
  
                  resolved_lower = resolved.lower()
  
                  resolved_joined = cache.get((resolved_lower, resolve_lowercase))
                  if resolved_joined is None:
                      dir_contents = cache.get(resolved_lower)
                      if dir_contents is None:
                          dir_contents = cache[resolved_lower] = os.listdir(resolved)
  
                      for filename in dir_contents:
                          if filename.lower() == resolve_lowercase:
                              resolved_joined = os.path.join(resolved, filename)
                              cache[(resolved_lower, resolve_lowercase)] = resolved_joined
                              break
                      else:
                          raise FileNotFoundError('Unable to find: %s in %s' % (
                              resolve_lowercase, resolved))
  
                  resolved = resolved_joined
  
          def _get_path_with_real_case(filename):
              # Note: this previously made:
              # convert_to_long_pathname(convert_to_short_pathname(filename))
              # but this is no longer done because we can't rely on getting the shortname
              # consistently (there are settings to disable it on Windows).
              # So, using approach which resolves by listing the dir.
  
              if IS_PY2 and isinstance(filename, unicode):  # noqa
                  filename = filename.encode(getfilesystemencoding())
  
              if '~' in filename:
                  filename = convert_to_long_pathname(filename)
  
              if filename.startswith('<') or not os_path_exists(filename):
                  return filename  # Not much we can do.
  
              drive, parts = os.path.splitdrive(os.path.normpath(filename))
              drive = drive.upper()
              while parts.startswith(os.path.sep):
                  parts = parts[1:]
                  drive += os.path.sep
              parts = parts.lower().split(os.path.sep)
  
              try:
                  return _resolve_listing(drive, iter(parts))
              except FileNotFoundError:
                  _listdir_cache.clear()
                  # Retry once after clearing the cache we have.
                  try:
                      return _resolve_listing(drive, iter(parts))
                  except FileNotFoundError:
                      if os_path_exists(filename):
                          # This is really strange, ask the user to report as error.
                          pydev_log.critical(
                              'pydev debugger: critical: unable to get real case for file. Details:\n'
                              'filename: %s\ndrive: %s\nparts: %s\n'
                              '(please create a ticket in the tracker to address this).',
                              filename, drive, parts
                          )
                          pydev_log.exception()
                      # Don't fail, just return the original file passed.
                      return filename
  
          # Check that it actually works
          _get_path_with_real_case(__file__)
      except:
          # Something didn't quite work out, leave no-op conversions in place.
          if DebugInfoHolder.DEBUG_TRACE_LEVEL > 2:
              pydev_log.exception()
      else:
          convert_to_long_pathname = _convert_to_long_pathname
          convert_to_short_pathname = _convert_to_short_pathname
          get_path_with_real_case = _get_path_with_real_case
  
  elif IS_JYTHON and IS_WINDOWS:
  
      def get_path_with_real_case(filename):
          from java.io import File  # noqa
          f = File(filename)
          ret = f.getCanonicalPath()
          if IS_PY2 and not isinstance(ret, str):
              return ret.encode(getfilesystemencoding())
          return ret
  
  if IS_JYTHON:
  
      def _normcase_windows(filename):
          return filename.lower()
  
  else:
  
      def _normcase_windows(filename):
          # `normcase` doesn't lower case on Python 2 for non-English locale, so we should do it manually.
          if '~' in filename:
              filename = convert_to_long_pathname(filename)
  
          filename = _nt_os_normcase(filename)
          return filename.lower()
  
  
  def _normcase_linux(filename):
      return filename  # no-op
  
  
  _filename_normalization = os.environ.get('PYDEVD_FILENAME_NORMALIZATION', '').lower()
  if _filename_normalization == 'lower':
      # Note: this is mostly for testing (forcing to always lower-case all contents
      # internally -- used to mimick Windows normalization on Linux).
  
      def _normcase_lower(filename):
          return filename.lower()
  
      _default_normcase = _normcase_lower
  
  elif _filename_normalization == 'none':
      # Disable any filename normalization may be an option on Windows if the
      # user is having issues under some circumstances.
      _default_normcase = _normcase_linux
  
  elif IS_WINDOWS:
      _default_normcase = _normcase_windows
  
  else:
      _default_normcase = _normcase_linux
  
  
  def normcase(s, NORMCASE_CACHE={}):
      try:
          return NORMCASE_CACHE[s]
      except:
          normalized = NORMCASE_CACHE[s] = _default_normcase(s)
          return normalized
  
  
  _ide_os = 'WINDOWS' if IS_WINDOWS else 'UNIX'
  
  _normcase_from_client = normcase
  
  DEBUG_CLIENT_SERVER_TRANSLATION = os.environ.get('DEBUG_PYDEVD_PATHS_TRANSLATION', 'False').lower() in ('1', 'true')
  
  
  def set_ide_os(os):
      '''
      We need to set the IDE os because the host where the code is running may be
      actually different from the client (and the point is that we want the proper
      paths to translate from the client to the server).
  
      :param os:
          'UNIX' or 'WINDOWS'
      '''
      global _ide_os
      global _normcase_from_client
      prev = _ide_os
      if os == 'WIN':  # Apparently PyCharm uses 'WIN' (https://github.com/fabioz/PyDev.Debugger/issues/116)
          os = 'WINDOWS'
  
      assert os in ('WINDOWS', 'UNIX')
  
      if DEBUG_CLIENT_SERVER_TRANSLATION:
          print('pydev debugger: client OS: %s' % (os,))
  
      _normcase_from_client = normcase
      if os == 'WINDOWS':
  
          # Client in Windows and server in Unix, we need to normalize the case.
          if not IS_WINDOWS:
              _normcase_from_client = _normcase_windows
  
      else:
          # Client in Unix and server in Windows, we can't normalize the case.
          if IS_WINDOWS:
              _normcase_from_client = _normcase_linux
  
      if prev != os:
          _ide_os = os
          # We need to (re)setup how the client <-> server translation works to provide proper separators.
          setup_client_server_paths(_last_client_server_paths_set)
  
  
  # Caches filled as requested during the debug session.
  NORM_PATHS_CONTAINER = {}
  NORM_PATHS_AND_BASE_CONTAINER = {}
  
  
  def canonical_normalized_path(filename):
      '''
      This returns a filename that is canonical and it's meant to be used internally
      to store information on breakpoints and see if there's any hit on it.
  
      Note that this version is only internal as it may not match the case and
      may have symlinks resolved (and thus may not match what the user expects
      in the editor).
      '''
      return get_abs_path_real_path_and_base_from_file(filename)[1]
  
  
  def absolute_path(filename):
      '''
      Provides a version of the filename that's absolute (and NOT normalized).
      '''
      return get_abs_path_real_path_and_base_from_file(filename)[0]
  
  
  def basename(filename):
      '''
      Provides the basename for a file.
      '''
      return get_abs_path_real_path_and_base_from_file(filename)[2]
  
  
  # Returns tuple of absolute path and real path for given filename
  def _abs_and_canonical_path(filename, NORM_PATHS_CONTAINER=NORM_PATHS_CONTAINER):
      try:
          return NORM_PATHS_CONTAINER[filename]
      except:
          if filename.__class__ != str:
              raise AssertionError('Paths passed to _abs_and_canonical_path must be str. Found: %s (%s)' % (filename, type(filename)))
          if os is None:  # Interpreter shutdown
              return filename, filename
  
          os_path = os.path
          if os_path is None:  # Interpreter shutdown
              return filename, filename
  
          os_path_abspath = os_path.abspath
          os_path_isabs = os_path.isabs
  
          if os_path_abspath is None or os_path_isabs is None or os_path_real_path is None:  # Interpreter shutdown
              return filename, filename
  
          isabs = os_path_isabs(filename)
  
          normalize = False
          abs_path = _apply_func_and_normalize_case(filename, os_path_abspath, isabs, normalize)
  
          normalize = True
          real_path = _apply_func_and_normalize_case(filename, os_path_real_path, isabs, normalize)
  
          # cache it for fast db later
          NORM_PATHS_CONTAINER[filename] = abs_path, real_path
          return abs_path, real_path
  
  
  def _get_relative_filename_abs_path(filename, func, os_path_exists=os_path_exists):
      # If we have a relative path and the file does not exist when made absolute, try to
      # resolve it based on the sys.path entries.
      for p in sys.path:
          r = func(os.path.join(p, filename))
          if os_path_exists(r):
              return r
  
      # We couldn't find the real file for the relative path. Resolve it as if it was in
      # a library (so that it's considered a library file and not a project file).
      r = func(os.path.join(_library_dir, filename))
      return r
  
  
  def _apply_func_and_normalize_case(filename, func, isabs, normalize_case, os_path_exists=os_path_exists, join=join):
      if filename.startswith('<'):
          # Not really a file, rather a synthetic name like <string> or <ipython-...>;
          # shouldn't be normalized.
          return filename
  
      r = func(filename)
  
      if not isabs:
          if not os_path_exists(r):
              r = _get_relative_filename_abs_path(filename, func)
  
      ind = r.find('.zip')
      if ind == -1:
          ind = r.find('.egg')
      if ind != -1:
          ind += 4
          zip_path = r[:ind]
          inner_path = r[ind:]
          if inner_path.startswith('!'):
              # Note (fabioz): although I can replicate this by creating a file ending as
              # .zip! or .egg!, I don't really know what's the real-world case for this
              # (still kept as it was added by @jetbrains, but it should probably be reviewed
              # later on).
              # Note 2: it goes hand-in-hand with 'exists'.
              inner_path = inner_path[1:]
              zip_path = zip_path + '!'
  
          if inner_path.startswith('/') or inner_path.startswith('\\'):
              inner_path = inner_path[1:]
          if inner_path:
              if normalize_case:
                  r = join(normcase(zip_path), inner_path)
              else:
                  r = join(zip_path, inner_path)
              return r
  
      if normalize_case:
          r = normcase(r)
      return r
  
  
  _ZIP_SEARCH_CACHE = {}
  _NOT_FOUND_SENTINEL = object()
  
  
  def exists(filename):
      if os_path_exists(filename):
          return True
  
      if not os.path.isabs(filename):
          filename = _get_relative_filename_abs_path(filename, os.path.abspath)
          if os_path_exists(filename):
              return True
  
      ind = filename.find('.zip')
      if ind == -1:
          ind = filename.find('.egg')
  
      if ind != -1:
          ind += 4
          zip_path = filename[:ind]
          inner_path = filename[ind:]
          if inner_path.startswith("!"):
              # Note (fabioz): although I can replicate this by creating a file ending as
              # .zip! or .egg!, I don't really know what's the real-world case for this
              # (still kept as it was added by @jetbrains, but it should probably be reviewed
              # later on).
              # Note 2: it goes hand-in-hand with '_apply_func_and_normalize_case'.
              inner_path = inner_path[1:]
              zip_path = zip_path + '!'
  
          zip_file_obj = _ZIP_SEARCH_CACHE.get(zip_path, _NOT_FOUND_SENTINEL)
          if zip_file_obj is None:
              return False
          elif zip_file_obj is _NOT_FOUND_SENTINEL:
              try:
                  import zipfile
                  zip_file_obj = zipfile.ZipFile(zip_path, 'r')
                  _ZIP_SEARCH_CACHE[zip_path] = zip_file_obj
              except:
                  _ZIP_SEARCH_CACHE[zip_path] = _NOT_FOUND_SENTINEL
                  return False
  
          try:
              if inner_path.startswith('/') or inner_path.startswith('\\'):
                  inner_path = inner_path[1:]
  
              _info = zip_file_obj.getinfo(inner_path.replace('\\', '/'))
  
              return join(zip_path, inner_path)
          except KeyError:
              return False
  
      else:
          pydev_log.debug('os.path.exists(%r) returned False.', filename)
  
      return False
  
  
  try:
      try:
          code = os_path_real_path.func_code
      except AttributeError:
          code = os_path_real_path.__code__
      if not os.path.isabs(code.co_filename):
          pydev_log.critical('This version of python seems to be incorrectly compiled')
          pydev_log.critical('(internal generated filenames are not absolute).')
          pydev_log.critical('This may make the debugger miss breakpoints.')
          pydev_log.critical('Related bug: http://bugs.python.org/issue1666807')
      elif not exists(code.co_filename):  # Note: checks for files inside .zip containers.
          pydev_log.critical('It seems the debugger cannot resolve %s', code.co_filename)
          pydev_log.critical('This may make the debugger miss breakpoints in the standard library.')
          pydev_log.critical('Related bug: https://bugs.python.org/issue1180193')
  except:
      # Don't fail if there's something not correct here -- but at least print it to the user so that we can correct that
      pydev_log.exception()
  
  # Note: as these functions may be rebound, users should always import
  # pydevd_file_utils and then use:
  #
  # pydevd_file_utils.map_file_to_client
  # pydevd_file_utils.map_file_to_server
  #
  # instead of importing any of those names to a given scope.
  
  
  def _path_to_expected_str(filename):
      if IS_PY2:
          if not filesystem_encoding_is_utf8 and hasattr(filename, "decode"):
              # filename_in_utf8 is a byte string encoded using the file system encoding
              # convert it to utf8
              filename = filename.decode(file_system_encoding)
  
          if not isinstance(filename, bytes):
              filename = filename.encode('utf-8')
  
      else:  # py3
          if isinstance(filename, bytes):
              filename = filename.decode(file_system_encoding)
  
      return filename
  
  
  def _original_file_to_client(filename, cache={}):
      try:
          return cache[filename]
      except KeyError:
          translated = _path_to_expected_str(get_path_with_real_case(absolute_path(filename)))
          cache[filename] = (translated, False)
      return cache[filename]
  
  
  def _original_map_file_to_server(filename):
      # By default just mapping to the server does nothing if there are no mappings (usually
      # afterwards the debugger must do canonical_normalized_path to get a normalized version).
      return filename
  
  
  map_file_to_client = _original_file_to_client
  map_file_to_server = _original_map_file_to_server
  
  
  def _fix_path(path, sep, add_end_sep=False):
      if add_end_sep:
          if not path.endswith('/') and not path.endswith('\\'):
              path += '/'
      else:
          if path.endswith('/') or path.endswith('\\'):
              path = path[:-1]
  
      if sep != '/':
          path = path.replace('/', sep)
      return path
  
  
  _last_client_server_paths_set = []
  
  _source_reference_to_frame_id = {}
  _source_reference_to_server_filename = {}
  _line_cache_source_reference_to_server_filename = {}
  _client_filename_in_utf8_to_source_reference = {}
  _next_source_reference = partial(next, itertools.count(1))
  
  
  def get_client_filename_source_reference(client_filename):
      return _client_filename_in_utf8_to_source_reference.get(client_filename, 0)
  
  
  def get_server_filename_from_source_reference(source_reference):
      return _source_reference_to_server_filename.get(source_reference, '')
  
  
  def create_source_reference_for_linecache(server_filename):
      source_reference = _next_source_reference()
      pydev_log.debug('Created linecache id source reference: %s for server filename: %s', source_reference, server_filename)
      _line_cache_source_reference_to_server_filename[source_reference] = server_filename
      return source_reference
  
  
  def get_source_reference_filename_from_linecache(source_reference):
      return _line_cache_source_reference_to_server_filename.get(source_reference)
  
  
  def create_source_reference_for_frame_id(frame_id, original_filename):
      source_reference = _next_source_reference()
      pydev_log.debug('Created frame id source reference: %s for frame id: %s (%s)', source_reference, frame_id, original_filename)
      _source_reference_to_frame_id[source_reference] = frame_id
      return source_reference
  
  
  def get_frame_id_from_source_reference(source_reference):
      return _source_reference_to_frame_id.get(source_reference)
  
  
  def setup_client_server_paths(paths):
      '''paths is the same format as PATHS_FROM_ECLIPSE_TO_PYTHON'''
  
      global map_file_to_client
      global map_file_to_server
      global _last_client_server_paths_set
      global _next_source_reference
  
      _last_client_server_paths_set = paths[:]
  
      _source_reference_to_server_filename.clear()
      _client_filename_in_utf8_to_source_reference.clear()
      _next_source_reference = partial(next, itertools.count(1))
  
      # Work on the client and server slashes.
      python_sep = '\\' if IS_WINDOWS else '/'
      eclipse_sep = '\\' if _ide_os == 'WINDOWS' else '/'
  
      norm_filename_to_server_container = {}
      norm_filename_to_client_container = {}
  
      initial_paths = []
      initial_paths_with_end_sep = []
  
      paths_from_eclipse_to_python = []
      paths_from_eclipse_to_python_with_end_sep = []
  
      # Apply normcase to the existing paths to follow the os preferences.
  
      for i, (path0, path1) in enumerate(paths):
          if IS_PY2:
              if isinstance(path0, unicode):  # noqa
                  path0 = path0.encode(sys.getfilesystemencoding())
              if isinstance(path1, unicode):  # noqa
                  path1 = path1.encode(sys.getfilesystemencoding())
  
          force_only_slash = path0.endswith(('/', '\\')) and path1.endswith(('/', '\\'))
  
          if not force_only_slash:
              path0 = _fix_path(path0, eclipse_sep, False)
              path1 = _fix_path(path1, python_sep, False)
              initial_paths.append((path0, path1))
              paths_from_eclipse_to_python.append((_normcase_from_client(path0), normcase(path1)))
  
          # Now, make a version with a slash in the end.
          path0 = _fix_path(path0, eclipse_sep, True)
          path1 = _fix_path(path1, python_sep, True)
          initial_paths_with_end_sep.append((path0, path1))
          paths_from_eclipse_to_python_with_end_sep.append((_normcase_from_client(path0), normcase(path1)))
  
      # Fix things so that we always match the versions with a slash in the end first.
      initial_paths = initial_paths_with_end_sep + initial_paths
      paths_from_eclipse_to_python = paths_from_eclipse_to_python_with_end_sep + paths_from_eclipse_to_python
  
      if not paths_from_eclipse_to_python:
          # no translation step needed (just inline the calls)
          map_file_to_client = _original_file_to_client
          map_file_to_server = _original_map_file_to_server
          return
  
      # only setup translation functions if absolutely needed!
      def _map_file_to_server(filename, cache=norm_filename_to_server_container):
          # Eclipse will send the passed filename to be translated to the python process
          # So, this would be 'NormFileFromEclipseToPython'
          try:
              return cache[filename]
          except KeyError:
              if eclipse_sep != python_sep:
                  # Make sure that the separators are what we expect from the IDE.
                  filename = filename.replace(python_sep, eclipse_sep)
  
              # used to translate a path from the client to the debug server
              translated = filename
              translated_normalized = _normcase_from_client(filename)
              for eclipse_prefix, server_prefix in paths_from_eclipse_to_python:
                  if translated_normalized.startswith(eclipse_prefix):
                      found_translation = True
                      if DEBUG_CLIENT_SERVER_TRANSLATION:
                          pydev_log.critical('pydev debugger: replacing to server: %s', filename)
                      translated = server_prefix + filename[len(eclipse_prefix):]
                      if DEBUG_CLIENT_SERVER_TRANSLATION:
                          pydev_log.critical('pydev debugger: sent to server: %s - matched prefix: %s', translated, eclipse_prefix)
                      break
              else:
                  found_translation = False
  
              # Note that when going to the server, we do the replace first and only later do the norm file.
              if eclipse_sep != python_sep:
                  translated = translated.replace(eclipse_sep, python_sep)
  
              if found_translation:
                  # Note: we don't normalize it here, this must be done as a separate
                  # step by the caller.
                  translated = absolute_path(translated)
              else:
                  if not os_path_exists(translated):
                      if not translated.startswith('<'):
                          # This is a configuration error, so, write it always so
                          # that the user can fix it.
                          error_once('pydev debugger: unable to find translation for: "%s" in [%s] (please revise your path mappings).\n',
                              filename, ', '.join(['"%s"' % (x[0],) for x in paths_from_eclipse_to_python]))
                  else:
                      # It's possible that we had some round trip (say, we sent /usr/lib and received
                      # it back, so, having no translation is ok too).
  
                      # Note: we don't normalize it here, this must be done as a separate
                      # step by the caller.
                      translated = absolute_path(translated)
  
              cache[filename] = translated
              return translated
  
      def _map_file_to_client(filename, cache=norm_filename_to_client_container):
          # The result of this method will be passed to eclipse
          # So, this would be 'NormFileFromPythonToEclipse'
          try:
              return cache[filename]
          except KeyError:
              abs_path = absolute_path(filename)
              translated_proper_case = get_path_with_real_case(abs_path)
              translated_normalized = normcase(abs_path)
  
              path_mapping_applied = False
  
              if translated_normalized.lower() != translated_proper_case.lower():
                  if DEBUG_CLIENT_SERVER_TRANSLATION:
                      pydev_log.critical(
                          'pydev debugger: translated_normalized changed path (from: %s to %s)',
                              translated_proper_case, translated_normalized)
  
              for i, (eclipse_prefix, python_prefix) in enumerate(paths_from_eclipse_to_python):
                  if translated_normalized.startswith(python_prefix):
                      if DEBUG_CLIENT_SERVER_TRANSLATION:
                          pydev_log.critical('pydev debugger: replacing to client: %s', translated_normalized)
  
                      # Note: use the non-normalized version.
                      eclipse_prefix = initial_paths[i][0]
                      translated = eclipse_prefix + translated_proper_case[len(python_prefix):]
                      if DEBUG_CLIENT_SERVER_TRANSLATION:
                          pydev_log.critical('pydev debugger: sent to client: %s - matched prefix: %s', translated, python_prefix)
                      path_mapping_applied = True
                      break
              else:
                  if DEBUG_CLIENT_SERVER_TRANSLATION:
                      pydev_log.critical('pydev debugger: to client: unable to find matching prefix for: %s in %s',
                          translated_normalized, [x[1] for x in paths_from_eclipse_to_python])
                  translated = translated_proper_case
  
              if eclipse_sep != python_sep:
                  translated = translated.replace(python_sep, eclipse_sep)
  
              translated = _path_to_expected_str(translated)
  
              # The resulting path is not in the python process, so, we cannot do a normalize the path here,
              # only at the beginning of this method.
              cache[filename] = (translated, path_mapping_applied)
  
              if translated not in _client_filename_in_utf8_to_source_reference:
                  if path_mapping_applied:
                      source_reference = 0
                  else:
                      source_reference = _next_source_reference()
                      pydev_log.debug('Created source reference: %s for untranslated path: %s', source_reference, filename)
  
                  _client_filename_in_utf8_to_source_reference[translated] = source_reference
                  _source_reference_to_server_filename[source_reference] = filename
  
              return (translated, path_mapping_applied)
  
      map_file_to_server = _map_file_to_server
      map_file_to_client = _map_file_to_client
  
  
  setup_client_server_paths(PATHS_FROM_ECLIPSE_TO_PYTHON)
  
  
  # For given file f returns tuple of its absolute path, real path and base name
  def get_abs_path_real_path_and_base_from_file(
          filename, NORM_PATHS_AND_BASE_CONTAINER=NORM_PATHS_AND_BASE_CONTAINER):
      try:
          return NORM_PATHS_AND_BASE_CONTAINER[filename]
      except:
          f = filename
          if not f:
              # i.e.: it's possible that the user compiled code with an empty string (consider
              # it as <string> in this case).
              f = '<string>'
  
          if f.startswith('<'):
              return f, normcase(f), f
  
          if _abs_and_canonical_path is None:  # Interpreter shutdown
              i = max(f.rfind('/'), f.rfind('\\'))
              return (f, f, f[i + 1:])
  
          if f is not None:
              if f.endswith('.pyc'):
                  f = f[:-1]
              elif f.endswith('$py.class'):
                  f = f[:-len('$py.class')] + '.py'
  
          abs_path, canonical_normalized_filename = _abs_and_canonical_path(f)
  
          try:
              base = os_path_basename(canonical_normalized_filename)
          except AttributeError:
              # Error during shutdown.
              i = max(f.rfind('/'), f.rfind('\\'))
              base = f[i + 1:]
          ret = abs_path, canonical_normalized_filename, base
          NORM_PATHS_AND_BASE_CONTAINER[filename] = ret
          return ret
  
  
  def get_abs_path_real_path_and_base_from_frame(frame, NORM_PATHS_AND_BASE_CONTAINER=NORM_PATHS_AND_BASE_CONTAINER):
      try:
          return NORM_PATHS_AND_BASE_CONTAINER[frame.f_code.co_filename]
      except:
          # This one is just internal (so, does not need any kind of client-server translation)
          f = frame.f_code.co_filename
  
          if f is not None and f.startswith (('build/bdist.', 'build\\bdist.')):
              # files from eggs in Python 2.7 have paths like build/bdist.linux-x86_64/egg/<path-inside-egg>
              f = frame.f_globals['__file__']
  
          if get_abs_path_real_path_and_base_from_file is None:
              # Interpreter shutdown
              if not f:
                  # i.e.: it's possible that the user compiled code with an empty string (consider
                  # it as <string> in this case).
                  f = '<string>'
              i = max(f.rfind('/'), f.rfind('\\'))
              return f, f, f[i + 1:]
  
          ret = get_abs_path_real_path_and_base_from_file(f)
          # Also cache based on the frame.f_code.co_filename (if we had it inside build/bdist it can make a difference).
          NORM_PATHS_AND_BASE_CONTAINER[frame.f_code.co_filename] = ret
          return ret
  
  
  def get_fullname(mod_name):
      if IS_PY3K:
          import pkgutil
      else:
          from _pydev_imps import _pydev_pkgutil_old as pkgutil
      try:
          loader = pkgutil.get_loader(mod_name)
      except:
          return None
      if loader is not None:
          for attr in ("get_filename", "_get_filename"):
              meth = getattr(loader, attr, None)
              if meth is not None:
                  return meth(mod_name)
      return None
  
  
  def get_package_dir(mod_name):
      for path in sys.path:
          mod_path = join(path, mod_name.replace('.', '/'))
          if os.path.isdir(mod_path):
              return mod_path
      return None
  
  