Sugestão de tipo Python sem importações cíclicas

Estou tentando dividir minha enorme classe em duas; bem, basicamente na classe "principal" e um mixin com funções adicionais, como:

main.py Arquivo:

import mymixin.py

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

mymixin.py Arquivo:

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

Agora, embora isso funcione bem, a dica de tipo MyMixin.func2obviamente não pode funcionar. Eu não posso importar main.py, porque eu obteria uma importação cíclica e sem a dica, meu editor (PyCharm) não poderia dizer o que selfé.

Estou usando Python 3.4, disposto a mudar para 3.5 se houver uma solução disponível lá.

Existe alguma maneira de dividir minha classe em dois arquivos e manter todas as "conexões" para que meu IDE ainda me ofereça preenchimento automático e todas as outras vantagens que vêm dele, sabendo os tipos?

Receio que não haja uma maneira extremamente elegante de lidar com os ciclos de importação em geral. Suas opções são reprojetar seu código para remover a dependência cíclica ou, se não for viável, fazer algo assim:

# some_file.py

from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from main import Main

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

A TYPE_CHECKINGconstante está sempre Falseem tempo de execução, portanto, a importação não será avaliada, mas mypy (e outras ferramentas de verificação de tipo) avaliará o conteúdo desse bloco.

Também precisamos fazer a Mainanotação de tipo em uma string, efetivamente declarando-o, uma vez que o Mainsímbolo não está disponível em tempo de execução.

Se você estiver usando o Python 3.7+, podemos pelo menos pular a necessidade de fornecer uma anotação de string explícita, aproveitando o 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):
        ...

A from __future__ import annotationsimportação fará com que todas as dicas de tipo sejam strings e pulará sua avaliação. Isso pode ajudar a tornar nosso código um pouco mais ergonômico.

Dito isso, usar mixins com mypy provavelmente exigirá um pouco mais de estrutura do que você tem atualmente. Mypy recomenda uma abordagem que é basicamente o que decezeestá descrevendo - criar um ABC que tanto sua Mainquanto as MyMixinclasses herdam. Eu não ficaria surpreso se você acabasse precisando fazer algo semelhante para deixar o verificador de Pycharm feliz.

Para pessoas que lutam com importações cíclicas ao importar classe apenas para verificação de tipo: você provavelmente desejará usar uma referência direta (PEP 484 - dicas de tipo):

Quando uma dica de tipo contém nomes que ainda não foram definidos, essa definição pode ser expressa como uma string literal, para ser resolvida posteriormente.

Então, em vez de:

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

Você faz:

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

O maior problema é que, para começar, seus tipos não são sãos. MyMixinfaz uma suposição codificada de que ele será misturado em Main, ao passo que poderia ser misturado a qualquer número de outras classes, caso em que provavelmente seria quebrado. Se seu mixin for codificado para ser mixado em uma classe específica, você também pode escrever os métodos diretamente naquela classe em vez de separá-los.

Para fazer isso corretamente com uma digitação sã, MyMixindeve ser codificado em uma interface ou classe abstrata na linguagem 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')

Acontece que minha tentativa original também estava bem próxima da solução. Isso é o que estou usando atualmente:

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

Observe a if Falseinstrução import within que nunca é importada (mas o IDE sabe disso de qualquer maneira) e usando a Mainclasse como string porque não é conhecida em tempo de execução.

Acho que a maneira perfeita deveria ser importar todas as classes e dependências em um arquivo (como __init__.py) e depois from __init__ import *em todos os outros arquivos.

Neste caso você é

1. evitando referências múltiplas a esses arquivos e classes e
2. também só precisa adicionar uma linha em cada um dos outros arquivos e
3. a terceira seria o pycharm sabendo sobre todas as classes que você pode usar.