Debugger only shows Python bytecode when debugging SOMPY library functions


I am trying to set up a self-organizing map (SOM) with the python library SOMPY right now. I made some changes to the original code since I would like to implement an alternative method for the computation of the best-matching unit (BMU). However I found that these changes had no effect and when trying to step into the library with the debugger I ended up in a file with unfamiliar formatting.

To investigate this issue, I tried to step into the method to see why my changes were not executed. Below is a minimal example:

import sompy 
import numpy as np 

test =, 3)))

I anticipated to end up in the definition of the SOMFactory class

class SOMFactory(object):

    def build(data,
        :param data: data to be clustered, represented as a matrix of n rows,
            as inputs and m cols as input features
        :param neighborhood: neighborhood object calculator.  Options are:
            - gaussian
            - bubble
            - manhattan (not implemented yet)
            - cut_gaussian (not implemented yet)
            - epanechicov (not implemented yet)

        :param normalization: normalizer object calculator. Options are:
            - var

        :param mapsize: tuple/list defining the dimensions of the som.
            If single number is provided is considered as the number of nodes.
        :param mask: mask
        :param mapshape: shape of the som. Options are:
            - planar
            - toroid (not implemented yet)
            - cylinder (not implemented yet)

        :param lattice: type of lattice. Options are:
            - rect
            - hexa

        :param initialization: method to be used for initialization of the som.
            Options are:
            - pca
            - random

        :param name: name used to identify the som
        :param training: Training mode (seq, batch)
        print("I am in the function! ")
        if normalization:
            normalizer =
            normalizer = None
        neighborhood_calculator =
        return SOM(data, neighborhood_calculator, normalizer, mapsize, mask,
                   mapshape, lattice, initialization, training, name, component_names)

but instead I ended up in a file called showing only this:

LOAD_FAST(normalization), POP_JUMP_IF_FALSE{16}
LOAD_GLOBAL(NormalizerFactory), LOAD_METHOD(build), LOAD_FAST(normalization), CALL_METHOD{1}, STORE_FAST(normalizer), JUMP_FORWARD(to 20)

normalizer = |16|None
LOAD_GLOBAL(NeighborhoodFactory), LOAD_METHOD(build), LOAD_FAST(neighborhood), CALL_METHOD{1}, STORE_FAST(neighborhood_calculator)
return SOM(data, neighborhood_calculator, normalizer, mapsize, mask, 
mapshape, lattice, initialization, training, name, component_names)

It is a Python file, but the formatting looks unfamiliar to me. I was wondering what this code is and what I need to change such that changes in the file were the SOMFactory class is defined actually take affect.

Asked By: Yeggers



I have found a solution to the problem: the file the debugger steps into is python bytecode and it does this since the source files are not available. To make sure that the source code is available, I went into the directory of the library, uninstalled it and then reinstalled it with a flag telling pip to install the package in editable mode:

pip uninstall sompy 
pip install -e .
Answered By: Yeggers
Categories: questions Tags: , ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.