Forward declaration of classes?

Edit: Because of the added requirement of order I completely reworked my answer. I also make use of a class decorator, which was used here first by @Ignacio Vazquez-Abrams.

Edit2: code now tested and some stupidity slightly corrected

class Base(object):
    subs = []

    @classmethod
    def addsub(cls, before=None): 
        def inner(subclass):
            if before and before in cls.subs:
                cls.subs.insert(cls.subs.index(before), subclass)
            else:
                cls.subs.append(subclass)
            return subclass
        return inner

@Base.addsub()
class Sub1(Base):
    pass

class Sub2(Base):
    pass

@Base.addsub(before=Sub1)
class Sub3(Base):
    pass

Write a decorator that adds it to the registry in Base.

class Base(object):
  subs = []

  @classmethod
  def addsub(cls, scls):
    cls.subs.append(scls)

 ...

@Base.addsub
class Sub1(Base):
  pass

class Sub2(Base):
  pass

@Base.addsub
class Sub3(Base):
  pass

class Foo:
  pass

class Bar:
  pass

Foo.m = Bar()
Bar.m = Foo()

I would just define the subclasses as strings and have the inevitable decorator replace the strings with the classes that they name. I would also define the decorator on a metaclass because I think that that’s more in line with the objective: we’re modifying class behavior and just like you modify object behavior by modifying its class, you modify class behavior by modifying its metaclass.

class BaseMeta(type):

    def register(cls, subcls):
        try:
            i = cls.subs.index(subcls.__name__)
        except ValueError:
            pass
        else:
            cls.subs[i] = subcls
        finally:
            return cls


class Base(object):
    __metaclass__ = BaseMeta
    subs = ['Sub3', 'Sub1']

@Base.register
class Sub1(Base): pass

@Base.register
class Sub2(Base): pass

@Base.register
class Sub3(Base): pass

print Base.subs

This outputs:

[<class '__main__.Sub3'>, <class '__main__.Sub1'>]

I’m pretty sure this should work for you. Just assign the depended class attribute afterwards.
This is also a lot less complicated.

class Base:pass

class Sub1(Base): pass
class Sub2(Base): pass
class Sub3(Base): pass

Base.subs = [Sub3,Sub1]
print(Sub1.subs)
#[<class __main__.Sub3 at 0x0282B2D0>, <class __main__.Sub1 at 0x01C79810>]

There is no way to directly declare forward-references in Python, but there are several workarounds, a few of which are reasonable:

1) Add the subclasses manually after they are defined.

    - Pros: easy to do; Base.subs is updated in one place
    - Cons: easy to forget (plus you don't want to do it this way)

Example:

class Base(object):
    pass

class Sub1(Base):
    pass

class Sub2(Base):
    pass

class Sub3(Base):
    pass

Base.subs = [sub3, sub1]

2) Create Base.subs with str values, and use a class decorator to substitute the actual subclasses (this can be a class method on Base or a function — I’m showing the function version, although I would probably use the method version).

- Pros: easy to do
- Cons: somewhat easy to forget; 

Example:

def register_with_Base(cls):
    name = cls.__name__
    index = Base.subs.index(name)
    Base.subs[index] = cls
    return cls

class Base(object):
    subs = ['Sub3', 'Sub1']

@register_with_Base
class Sub1(Base):
    pass

class Sub2(Base):
    pass

@register_with_Base
class Sub3(Base):
    pass

3) Create Base.subs with str values, and have the method that uses Base.subs do the substitution.

- Pros: no extra work in decorators, no forgetting to update `subs` later
- Cons: small amount of extra work when accessing `subs`

Example:

class Base(object):
    subs = ['Sub3', 'Sub1']
    def select_sub(self, criteria):
        for sub in self.subs:
            sub = globals()[sub]
            if #sub matches criteria#:
                break
        else:
            # use a default, raise an exception, whatever
        # use sub, which is the class defined below

class Sub1(Base):
    pass

class Sub2(Base):
    pass

class Sub3(Base):
    pass

I would use option 3 myself, as it keeps the functionality and the data all in one place. The only thing you have to do is keep subs up to date (and write the appropriate subclasses, of course).

There is a workaround: put referenced dummy Sub1, Sub3 classes at the top, this works as “forward declaration”. They will be replaced by the actual implementations with the same names when executed.

forward-declaration.py:

class Sub1(): 
    print("Sub1 dummy class called")
    pass
class Sub3():
    print("Sub3 dummy class called")
    pass

class Base:
  subs = [Sub3, Sub1]
  print("Base class called")

class Sub1(Base): 
    print("Sub1 class called")
    def __init__(self):
        print("Sub1:__init__ called")
    pass
class Sub2(Base):
    def __init__(self):
        print("Sub2:__init__ called")
    pass
class Sub3(Base):
    def __init__(self):
        print("Sub3:__init__ called")
    pass

sub_1 = Sub1()
sub_2 = Sub2()
sub_3 = Sub3()

print(Base.subs)

python forward-declaration.py

Sub1 dummy class called
Sub3 dummy class called
Base class called
Sub1 class called
Sub1:__init__ called
Sub2:__init__ called
Sub3:__init__ called
[<class '__main__.Sub3'>, <class '__main__.Sub1'>]

Note: The above method fails on mypy or pylint static check but works properly

Not a direct answer to your question about forward declarations, but a direct solution for your problem of knowing all sub-classes in the base class itself: just use the (probably not very well known) __subclasses__ function, which should be defined on all classes in Python3. It directly gives you exactly what you want:

In [1]: class Base: pass

In [2]: class Sub1(Base): pass

In [3]: class Sub2(Base): pass

In [4]: class Sub3(Base): pass
    
In [5]: Base.__subclasses__()
Out[5]: [__main__.Sub1, __main__.Sub2, __main__.Sub3]

The documentation doesn’t specify if the order in which the sub-classes are defined is maintained, but it does appear to do so.

See also this answer to a question that asks about your problem.

If local inner classes inside an outer class can fullfill the given demands, a simple solution can help (so the inner classes are declared "in forward"; at least before they are instantiated inside the outer class):

class Base:
    class Sub1:
        # ...
    class Sub2:
        # ...
    class Sub3:
        # ...

    __Object1 = Sub1()
    __Object2 = Sub2()
    __Object3 = Sub3()
    # ...