Para el ejercicio se propuso una solución de una sola línea con diferentes variaciones:
def solve(string):
    s = ''.join([ch for ch in string if ch in '()'])
    return len(max(s.split(')'), key=len))


¿Solución funcional? No.
Si le pasamos a esta función la cadena (()(())), la respuesta correcta (profundidad) es: 3, pero la función devuelve 2. La lógica de "cantidad de paréntesis de apertura consecutivos" falla en cualquier estructura anidada que no sea la primera rama.

☝🏻 Cómo resolver correctamente
Una solución aburrida pero funcional con complejidad O(n) implica un contador simple. Recorremos la cadena, incrementamos el contador con (, lo decrementamos con ) y en cada paso actualizamos el máximo global.

def max_depth(s: str) -> int:
    current_depth = 0
    max_depth = 0
    
    for char in s:
        if char == '(':
            current_depth += 1
            max_depth = max(max_depth, current_depth)
        elif char == ')':
            current_depth -= 1
            # Validación de corrección (opcional)
            if current_depth < 0:
                return -1 
                
    return max_depth if current_depth == 0 else -1


Variante para estetas (funcional):

Si realmente se quiere en una línea, se puede usar accumulate. Mapeamos los paréntesis a 1 y -1, calculamos las sumas prefijas (accumulate) y tomamos el máximo.

from itertools import accumulate

def solve_poly(s: str) -> int:
    # Convertimos '(' en 1, ')' en -1, el resto en 0
    depths = accumulate(1 if c == '(' else -1 if c == ')' else 0 for c in s)
    return max(depths, default=0)


#algosobes