Oui, c'est possible, c'est l'une des choses les plus cool de python, en Python, toutes les classes sont créées par la classe type

Vous pouvez lire en détail ici , mais ce que vous devez faire est ceci

In [58]: My_Class = type("My_Class", (My_Class,), {"__my_hidden_field__": X})

In [59]: My_Class.__my_hidden_field__
Out[59]:
array([[0.73998002, 0.68213825, 0.41621582],
       [0.05936479, 0.14348496, 0.61119082]])

* Modifié car l'héritage était manquant, vous devez passer la classe d'origine comme deuxième argument (dans le tuple) pour qu'elle se mette à jour, sinon elle réécrit simplement la classe)

Vous voulez probablement lowref.WeakKeyDictionary . À partir du doc,

Cela peut être utilisé pour associer des données supplémentaires à un objet appartenant à d'autres parties d'une application sans ajouter d'attributs à ces objets.

Comme un attribut, et contrairement à un dict simple, cela permet aux objets d'être récupérés lorsqu'il n'y a pas d'autres références à celui-ci.

Vous recherchez le champ avec

X._my_hidden_field

au lieu de

my_hidden_field[X]

Deux mises en garde: Premièrement, comme une clé faible peut être supprimée à tout moment sans avertissement, vous ne devrait pas parcourir un WeakKeyDictionary . La recherche d'un objet auquel vous avez une référence est cependant très bien. Et deuxièmement, vous ne pouvez pas faire de faible référence à un type d'objet écrit en C qui n'a pas de slot pour lui (vrai pour de nombreux intégrés), ou à un type écrit en Python qui n'autorise pas un __weakref __ (généralement dû à __slots__).

Si cela pose un problème, vous pouvez simplement utiliser un dict normal pour ces types, mais vous devrez le nettoyer vous-même.

Réponse rapide

Est-il possible d'ajouter des attributs à des objets python intégrés de manière dynamique en Python?

Non, les raisons pour lesquelles vous lisez dans les liens que vous avez publiés, sont les mêmes de nos jours. Mais j'ai sorti une recette qui, je pense, pourrait être le point de départ de votre traceur.

Instrumentation utilisant le sous-classement combiné avec AST

Après avoir beaucoup lu à ce sujet, je suis sorti avec un recette qui n'est peut-être pas la solution complète, mais il semble que vous puissiez commencer à partir d'ici.

La bonne chose à propos de cette recette est qu'elle n'utilise pas de bibliothèques tierces, tout est réalisé avec le bibliothèques standard (Python 3.5, 3.6, 3.7).

Le code cible.

Cette recette fera un code comme celui-ci être instrumenté (une simple instrumentation est effectuée ici, c'est juste un pouf du concept) et exécuté.

>>> {1: 2, 3: 4} 
>>> (0, 0)

Sous-classification

Nous devons d'abord ajouter le hidden_field à tout ce que nous voulons (ceci recette ont été testés uniquement avec des dictionnaires).

Le code suivant reçoit une valeur, trouve son type / classe et le sous-classe afin d'ajouter le hidden_field mentionné. p >

# target/target.py

d = {1: 2}
d.update({3: 4})
print(d)                 # Will print "{1: 2, 3: 4}"
print(d.hidden_field)    # Will print "(0, 0)"

avec cela en place, vous pouvez:

import ast
import os
from ast_transformer import AnalyserNodeTransformer

# instrument_node need to be in the namespace here.
from ast_transformer import instrument_node

if __name__ == "__main__":

    target_path = os.path.join(os.path.dirname(__file__), 'target/target.py')

    with open(target_path, 'r') as program:
        # Read and parse the target script.
        tree = ast.parse(program.read())
        # Make transformations.
        tree = AnalyserNodeTransformer().visit(tree)
        # Fix locations.
        ast.fix_missing_locations(tree)
        # Compile and execute.
        compiled = compile(tree, filename='target.py', mode='exec')
        exec(compiled)

À ce stade, nous connaissons déjà un moyen d ' "ajouter une instrumentation à un dictionnaire intégré" mais il n'y a pas de transparence ici .

Modifiez l'AST.

L'étape suivante consiste à "masquer" l'appel instrument_node et nous le ferons en utilisant le ast Module Python.

Ce qui suit est un transformateur de nœud AST qui prendra n'importe quel dictionnaire qu'il trouve et l'enveloppera dans un instrument_node call:

class AnalyserNodeTransformer(ast.NodeTransformer):
    """Wraps all dicts in a call to instrument_node()"""
    def visit_Dict(self, node):
        return ast.Call(func=ast.Name(id='instrument_node', ctx=ast.Load()),
                        args=[node], keywords=[])
        return node

Mettre tout ensemble.

Avec ces outils, vous pouvez écrire un script qui:

1. Lisez le code cible.
2. Analyser le programme.
3. Appliquer les modifications AST.
4. Compilez-le.
5. Et exécutez-le.

d = {1: 2}
d = instrument_node(d) 
d.update({3: 4})
print(d)                 # Do print "{1: 2, 3: 4}"
print(d.hidden_field)    # Do print "(0, 0)"

Cela prendra notre code cible, et encapsulera chaque dictionnaire avec un instrument_node () et exécutera le résultat d'un tel changement.

Le résultat de l'exécution de ceci sur notre code cible,

def instrument_node(value):
    VarType = type(value)
    class AnalyserHelper(VarType):
        def __init__(self, *args, **kwargs):
            self.hidden_field = (0, 0)
            super(AnalyserHelper, self).__init__(*args, **kwargs)
    return AnalyserHelper(value)

est:

# target/target.py

d = {1: 2}
d.update({3: 4})
print(d)                 # Should print "{1: 2, 3: 4}"
print(d.hidden_field)    # Should print "(0, 0)"

Exemple de travail h2 >

Vous pouvez cloner un exemple fonctionnel ici . p>