Suggerimenti sul tipo Python senza importazioni cicliche

Sto cercando di dividere la mia enorme classe in due; beh, fondamentalmente nella classe "principale" e un mixin con funzioni aggiuntive, in questo modo:

main.py file:

import mymixin.py

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

mymixin.py file:

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

Ora, mentre funziona bene, il suggerimento sul tipo MyMixin.func2ovviamente non può funzionare. Non posso importare main.py, perché otterrei un'importazione ciclica e senza il suggerimento, il mio editor (PyCharm) non può dire cosa selfsia.

Sto usando Python 3.4, disposto a passare a 3.5 se una soluzione è disponibile lì.

C'è un modo per dividere la mia classe in due file e mantenere tutte le "connessioni" in modo che il mio IDE mi offra ancora il completamento automatico e tutte le altre chicche che ne derivano conoscendo i tipi?

Non esiste un modo estremamente elegante per gestire i cicli di importazione in generale, temo. Le tue scelte sono di riprogettare il tuo codice per rimuovere la dipendenza ciclica o, se non è fattibile, fare qualcosa del genere:

# 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_CHECKINGcostante è sempre Falsein fase di esecuzione, quindi l'importazione non verrà valutata, ma mypy (e altri strumenti di controllo del tipo) valuteranno il contenuto di quel blocco.

Abbiamo anche bisogno di trasformare l' Mainannotazione del tipo in una stringa, dichiarandola effettivamente in avanti poiché il Mainsimbolo non è disponibile in fase di esecuzione.

Se stai usando Python 3.7+, possiamo almeno evitare di dover fornire un'annotazione di stringa esplicita sfruttando 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):
        ...

Il from __future__ import annotations importazione renderà tutti i suggerimenti di tipo stringhe e ignorerà la loro valutazione. Questo può aiutare a rendere il nostro codice qui leggermente più ergonomico.

Detto questo, l'uso di mixin con mypy richiederà probabilmente un po 'più di struttura rispetto a quella che hai attualmente. Mypy consiglia un approccio che è fondamentalmente ciò che decezesta descrivendo: creare un ABC che ereditano sia le tue Mainche le MyMixinclassi. Non sarei sorpreso se finissi per dover fare qualcosa di simile per rendere felice il controllore di Pycharm.

Per le persone che lottano con le importazioni cicliche durante l'importazione della classe solo per il controllo del tipo: probabilmente vorrai usare un riferimento diretto (PEP 484 - Suggerimenti sul tipo):

Quando un suggerimento di tipo contiene nomi che non sono stati ancora definiti, quella definizione può essere espressa come una stringa letterale, per essere risolta in seguito.

Quindi invece di:

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

tu fai:

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

Il problema più grande è che i tuoi tipi non sono sani di mente all'inizio. MyMixinfa un'ipotesi hardcoded che verrà mescolata inMain , mentre potrebbe essere mescolata in un numero qualsiasi di altre classi, nel qual caso probabilmente si spezzerebbe. Se il tuo mixin è codificato per essere mescolato in una classe specifica, puoi anche scrivere i metodi direttamente in quella classe invece di separarli.

Per farlo correttamente con una digitazione sana, MyMixindovrebbe essere codificato su un'interfaccia o una classe astratta nel linguaggio 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')

È venuto fuori che anche il mio tentativo originale era abbastanza vicino alla soluzione. Questo è quello che sto usando attualmente:

# 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
        ...

Nota l' if Falseistruzione import all'interno che non viene mai importata (ma IDE lo sa comunque) e utilizza la Mainclasse come stringa perché non è nota in fase di esecuzione.

Penso che il modo perfetto dovrebbe essere quello di importare tutte le classi e le dipendenze in un file (come __init__.py) e poi from __init__ import *in tutti gli altri file.

In questo caso lo sei

1. evitando più riferimenti a quei file e classi e
2. anche solo aggiungere una riga in ciascuno degli altri file e
3. il terzo sarebbe il pycharm che conosce tutte le classi che potresti usare.