Se que puedo hacer esto:
class A:
def p( self, msg ):
print( msg )
class B:
def __init__( self, a: A ):
self._p = a.p
def __call__( self, msg ):
self._p( msg )
a = A( )
b = B( a )
b( "Probando ..." )
Lo cual es una manera de hacer un alias del método A.p. ...
@Trauma Puedes definir una clase base que haga la llamada, y luego derivas B de esa clase base.
La única ventaja de esta solución es que puedes definir múltiples subclases, ninguna de las cuales implementa la llamada (que es delegada a la clase base). Si te sirve, puedo publicar una respuesta.
class A:
def p( self, msg ):
print( msg )
class Base:
def __init__(self, x):
self._p = x.p
def __call__(self, msg):
self._p(msg)
class B (Base):
def __init__( self, a: A ):
super().__init__(a)
__setattr__() se usa para manejar los casos en que asignas un valor a un atributo que no existe. Es decir, resuelve el caso cuando haces b.precio = 10 en un objeto que no tiene (en ese momento) definido el precio.
@CandidMoe Lo que quiero es que python no tenga que hacer la búsqueda del atributo 2 veces, 1 vez en Base y otra vez en A
Tengo Sender = Callable[[msg],None] en todas partes, así que necesito algo que cumpla con eso, que haga de proxy para el verdadero método, que está en la clase A
Si aplico los cambios, cuando llama a la instancia real que implementa el método, es como si estuviera llamando a una instancia distinta: le faltas variables internas
:-O
Chulo XD
Vamos a probar con el MethodType ese
Ah carajo, ya se lo que le pasa XDDDD
Hago Clase.__call__ = Base.method
Pero eso setea __call__para todas las instancias de la clase Clase
Tengo varias instancias, y todas intentan usar la misma instancia de Base, cuando cada instancia debería usar una instancia de Base concreta xDD
Se que puedo hacer esto:
class A:
def p( self, msg ):
print( msg )
class B:
def __init__( self, a: A ):
self._p = a.p
def __call__( self, msg ):
self._p( msg )
a = A( )
b = B( a )
b( "Probando ..." )
Lo cual es una manera de hacer un alias del método A.p. ...
@Trauma. Tu supones que Python hace una doble búsqueda. Me parece que no es cierto. Yo díria que cuando haces `self._p = a.p` Python resuelve de inmediato la referencia al método final y la asigna directamente. Te puedes dar cuenta pues si luego redefine A.p, la clase B sigue llamando al método original.
Si lo piensas, es mucho más simple escribir un intérprete que resuelve las referencias de inmediato. Lo único que tiene que almacenar es la referencia. Si en cambio deja la expresión, tiene que guardarla y evaluarla cada vez que aparezca durante la ejecución. Eso si que es complicarse la vida.
@Mateo Apostaría que hoy en día todos los interpretes generan byte-code para una máquina virtual. Eso hace fácil la portabilidad.
@Trauma Cobol tiene una instrucción ALTER que te permite cambiar el destino de un GOTO. Super nice: miras que la instrucción dice GOTO IMPRIMIR sin darte cuenta que en algun punto durante la ejecución se ejecutó un ALTER IMPRIMIR TO SALIR y ahora el GOTO salta a otra parte.
@Trauma IBM/360 tiene una instruccion "Branch and Link" que te permite parchar la instrucción justo antes de ejecutarla, sin modificarla en memoria. Nice, nice
@Trauma En el caso de IBM, dejas la dirección de retorno en un registro pre-acordado. Luego la rutina hace un salto via registro. Olvidate de recursividad o reentrancia.
Tengo un proyecto de microservicios en gcp. Kong es un apigateway utilizando docker.
Cuando inicio el docker y pongo a correr alguna maquina de los servicios. AL ingresar a http con la ipExterna del kong y el puerto 8000 con su respectiva ruta no carga.
Ademas, cuando realizo este comando sobre e...
Kubi, 2023, una película de samurais del tiempo justo antes de Shogun. Son personajes y situaciones históricas.
Es lo más brutal que he visto en años. Realmente hay que tener estómago, pues es un reguero de muertes a diestra y sinistra, condimentados con una alta dosis de sadismo y crueldad. Aquí la vida no vale nada, y se matan unos a otros como si de aplastar un mosquito se tratara.
No creo que haya una película con más muertos que esta.
También un montón de personajes (todos históricos) y se hace díficil seguirlos.
Se que puedo hacer esto:
class A:
def p( self, msg ):
print( msg )
class B:
def __init__( self, a: A ):
self._p = a.p
def __call__( self, msg ):
self._p( msg )
a = A( )
b = B( a )
b( "Probando ..." )
Lo cual es una manera de hacer un alias del método A.p. ...
