Indication de type Python sans importations cycliques

J'essaye de diviser ma classe énorme en deux; enfin, essentiellement dans la classe "main" et un mixin avec des fonctions supplémentaires, comme ceci:

main.py fichier:

import mymixin.py

class Main(object, MyMixin):
    def func1(self, xxx):
        ...

mymixin.py fichier:

class MyMixin(object):
    def func2(self: Main, xxx):  # <--- note the type hint
        ...

Maintenant, bien que cela fonctionne très bien, l'indication de type MyMixin.func2ne peut bien sûr pas fonctionner. Je ne peux pas importer main.py, car j'obtiendrais une importation cyclique et sans l'indice, mon éditeur (PyCharm) ne peut pas dire ce que selfc'est.

J'utilise Python 3.4, prêt à passer à 3.5 si une solution y est disponible.

Est-il possible que je puisse diviser ma classe en deux fichiers et conserver toutes les "connexions" afin que mon IDE me propose toujours la complétion automatique et tous les autres avantages qui en découlent en connaissant les types?

Il n'y a pas de moyen extrêmement élégant de gérer les cycles d'importation en général, j'en ai peur. Vos choix sont soit de reconcevoir votre code pour supprimer la dépendance cyclique, soit si ce n'est pas faisable, faites quelque chose comme ceci:

# some_file.py

from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from main import Main

class MyObject(object):
    def func2(self, some_param: 'Main'):
        ...

La TYPE_CHECKINGconstante est toujours Falseà l'exécution, donc l'importation ne sera pas évaluée, mais mypy (et d'autres outils de vérification de type) évaluera le contenu de ce bloc.

Nous devons également transformer l' Mainannotation de type en une chaîne, en la déclarant effectivement car le Mainsymbole n'est pas disponible au moment de l'exécution.

Si vous utilisez Python 3.7+, nous pouvons au moins éviter d'avoir à fournir une annotation de chaîne explicite en tirant parti de PEP 563 :

# some_file.py

from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from main import Main

class MyObject(object):
    # Hooray, cleaner annotations!
    def func2(self, some_param: Main):
        ...

L' from __future__ import annotationsimportation fera de toutes les indications de type des chaînes et ignorera leur évaluation. Cela peut aider à rendre notre code ici légèrement plus ergonomique.

Cela dit, l'utilisation de mixins avec mypy nécessitera probablement un peu plus de structure que celle que vous avez actuellement. Mypy recommande une approche qui est essentiellement ce que decezedécrit - pour créer un ABC dont votre Mainet vos MyMixinclasses héritent. Je ne serais pas surpris si vous deviez faire quelque chose de similaire pour rendre le vérificateur de Pycharm heureux.

Pour les personnes aux prises avec des importations cycliques lors de l'importation d'une classe uniquement pour la vérification de type: vous souhaiterez probablement utiliser une référence directe (PEP 484 - Indices de type):

Lorsqu'un indice de type contient des noms qui n'ont pas encore été définis, cette définition peut être exprimée sous forme de chaîne littérale, à résoudre ultérieurement.

Donc au lieu de:

class Tree:
    def __init__(self, left: Tree, right: Tree):
        self.left = left
        self.right = right

tu fais:

class Tree:
    def __init__(self, left: 'Tree', right: 'Tree'):
        self.left = left
        self.right = right

Le plus gros problème est que vos types ne sont pas sains d'esprit au départ. MyMixinfait une hypothèse codée en dur dans laquelle il sera mélangé Main, alors qu'il pourrait être mélangé dans n'importe quel nombre d'autres classes, auquel cas il se briserait probablement. Si votre mixin est codé en dur pour être mélangé dans une classe spécifique, vous pouvez aussi bien écrire les méthodes directement dans cette classe au lieu de les séparer.

Pour faire cela correctement avec un typage sain, MyMixindoit être codé par rapport à une interface ou à une classe abstraite dans le langage Python:

import abc


class MixinDependencyInterface(abc.ABC):
    @abc.abstractmethod
    def foo(self):
        pass


class MyMixin:
    def func2(self: MixinDependencyInterface, xxx):
        self.foo()  # ← mixin only depends on the interface


class Main(MixinDependencyInterface, MyMixin):
    def foo(self):
        print('bar')

Il s'avère que ma tentative initiale était également assez proche de la solution. Voici ce que j'utilise actuellement:

# main.py
import mymixin.py

class Main(object, MyMixin):
    def func1(self, xxx):
        ...


# mymixin.py
if False:
    from main import Main

class MyMixin(object):
    def func2(self: 'Main', xxx):  # <--- note the type hint
        ...

Notez l' if Falseinstruction import within qui n'est jamais importée (mais IDE le sait de toute façon) et utilisez la Mainclasse comme chaîne car elle n'est pas connue au moment de l'exécution.

Je pense que le moyen idéal devrait être d'importer toutes les classes et dépendances dans un fichier (comme __init__.py), puis from __init__ import *dans tous les autres fichiers.

Dans ce cas, vous êtes

1. éviter de multiples références à ces fichiers et classes et
2. il suffit également d'ajouter une ligne dans chacun des autres fichiers et
3. le troisième serait le pycharm connaissant toutes les classes que vous pourriez utiliser.