Class SourceMapping

_pydevd_bundle/pydevd_source_mapping.py:35–152

class SourceMapping(object):
    def __init__(self, on_source_mapping_changed=NULL):
        self._mappings_to_server = {}  # dict(normalized(file.py) to [SourceMappingEntry])
        self._mappings_to_client = {}  # dict(<cell> to File.py)
        self._cache = {}
        self._on_source_mapping_changed = on_source_mapping_changed

    def set_source_mapping(self, absolute_filename, mapping):
        """
        :param str absolute_filename:
            The filename for the source mapping (bytes on py2 and str on py3).

        :param list(SourceMappingEntry) mapping:
            A list with the source mapping entries to be applied to the given filename.

        :return str:
            An error message if it was not possible to set the mapping or an empty string if
            everything is ok.
        """
        # Let's first validate if it's ok to apply that mapping.
        # File mappings must be 1:N, not M:N (i.e.: if there's a mapping from file1.py to <cell1>,
        # there can be no other mapping from any other file to <cell1>).
        # This is a limitation to make it easier to remove existing breakpoints when new breakpoints are
        # set to a file (so, any file matching that breakpoint can be removed instead of needing to check
        # which lines are corresponding to that file).
        for map_entry in mapping:
            existing_source_filename = self._mappings_to_client.get(map_entry.runtime_source)
            if existing_source_filename and existing_source_filename != absolute_filename:
                return "Cannot apply mapping from %s to %s (it conflicts with mapping: %s to %s)" % (
                    absolute_filename,
                    map_entry.runtime_source,
                    existing_source_filename,
                    map_entry.runtime_source,
                )

        try:
            absolute_normalized_filename = pydevd_file_utils.normcase(absolute_filename)
            current_mapping = self._mappings_to_server.get(absolute_normalized_filename, [])
            for map_entry in current_mapping:
                del self._mappings_to_client[map_entry.runtime_source]

            self._mappings_to_server[absolute_normalized_filename] = sorted(mapping, key=lambda entry: entry.line)

            for map_entry in mapping:
                self._mappings_to_client[map_entry.runtime_source] = absolute_filename
        finally:
            self._cache.clear()
            self._on_source_mapping_changed()
        return ""

    def map_to_client(self, runtime_source_filename, lineno):
        key = (lineno, "client", runtime_source_filename)
        try:
            return self._cache[key]
        except KeyError:
            for _, mapping in list(self._mappings_to_server.items()):
                for map_entry in mapping:
                    if map_entry.runtime_source == runtime_source_filename:  # <cell1>