Determine the height of a Tetris game's board after a sequence of moves
The first thing I did was use Black to reformat the code - yours is pretty good, but there are some minor style complaints I had (generally around the lack of whitespace in a few places). Additionally, PEP8 defines the naming conventions in python - generally, prefer_this notThis.
Lastly, all of your methods should have docstrings. I haven't added this b/c it isn't as pertinent to the code review, but it is good practice in general.
From there, I thought about your actual approach. At a high level you:

Create a new instance of the object
Pass it a string, parse the string, and process each token
Attempt to fit pieces
Clear full rows

None of that is inherently bad, but I think it can be tightened up a bit.
User Input
Right now you don't have any validation of the user inputs - we're being very trusting that the values that are provided will be usable. We probably want to do this validation
Additionally, I don't think that the Tetris class should be responsible for handling the comma-delimited string - it should just take a piece and a position, and something else should be responsible for taking the input and translating it into arguments. If you're feeling friendly, a @classmethod might be appropriate. Lastly, I think this class method should return the board, not the height, so I added a new height property to the class. I ended up with something like this:
pieces = {
    &quot;I&quot;: ((True, True, True, True)),
    &quot;Q&quot;: ((True, True), (True, True)),
    &quot;T&quot;: ((True, True, True), (False, True, False)),
    &quot;Z&quot;: ((True, True, False), (False, True, True)),
    &quot;S&quot;: ((False, True, True), (True, True, False)),
    &quot;L&quot;: ((True, False), (True, False), (True, True)),
    &quot;J&quot;: ((False, True), (False, True), (True, True)),
}

@classmethod
def add_pieces(cls, user_input):
    board = Tetris()
    for piece in user_input.split(&quot;,&quot;):
        if len(piece) &gt; 2:
            raise ValueError(f&quot;Piece {piece} is malformed&quot;)
        piece_id = piece[0]
        drop_position = piece[1]
        if not Tetris.is_valid_piece(piece_id):
            raise ValueError(f&quot;Piece {piece_id} is not a valid Tetris piece&quot;)
        if not Tetris.is_valid_drop_location(drop_position):
            raise IndexError(
                f&quot;Drop location {drop_position} is not a valid board location&quot;
            )
        board.add_piece(piece_id, drop_position)
    return board

@classmethod
def is_valid_piece(cls, piece_id):
    return piece_id in cls.pieces

@classmethod
def is_valid_drop_location(drop_position):
    try:
        int(drop_position)
    except ValueError:
        return False

    return drop_position &gt;= 0 and drop_position &lt; 10

@property
def height(self):
    return self.board.length


You'll also notice that I moved Tetris.pieces into a class attribute instead of an instance attribute - this is because it should be the same everywhere. I also changed 0/1 to True/False because it is a binary value (I think an enum is probably best to be explicit, e.g. boardState.FULL and boardState.EMPTY). Lastly, I changed from nested lists to nested tuples - this is because tuples are immutable, and you never need to change the shape definition.
OOP
I wonder if it is worthwhile making a separate class to represent the pieces, and then you can do something like TetrisPiece.fitsAtLocation(board, location). I haven't fully thought about what this would look like or if it is actually better, but it might be a nice way to encapsulate that functionality.
This would also be a convenient way to extend this to handle rotations as well, as you would just do TetrisPiece.rotate(Direction.LEFT) and handle it all under the hood.
If you want to extend this to a full game, then instead of just having a &quot;drop position&quot; you also need a relative location on the board, handling T-spins, etc. The more complicated this gets, the more I think a separate class is going to improve readability.
General nitpicks

doesThePieceFit seems really weird - I get how it works, but you should definitely introduce some constants to replace the magic method, and maybe consider if there is a better way to model the data.

In particular, perhaps we should store the block state for a different shape in reverse order (e.g. bottom-to-top instead of top-to-bottom)?


removeFullRows creates a list, then sorts it - I think you can probably come up with a different approach for this
addPieceAt has the same magic as doesThePieceFit - is there a way that we can either combine their functionality, or use a common helper method?
addPiece I think you can use for-else to handle this a bit more elegantly than using the ternary, but my mood on the for-else swings every time I use it