If I understand your question correctly, you should be able to reference class A within class A by putting the type annotation in quotes. This is called forward reference.

class A:
  # do something
  def some_func(self, a: 'A')
  # ...

See ref below

1. https://github.com/python/mypy/issues/3661
2. https://www.youtube.com/watch?v=AJsrxBkV3kc

You need @classmethod rather than @staticmethod - a class method will get passed a reference to the class (where a method will get self), so you can look up attributes on it.

class FooBarBaz:
    BAR = 123

    @classmethod
    def getBar(cls):
        return cls.BAR

You need the second form.

class temp(class1.class1):
   ...

With how you've import class1, in your class2 module, class1 is a reference to the class1 module which holds the class1 class.

The alternative is to only import the class1 class from the class1 module:

from class1 import class1

class temp(class1):
    ...

In general, to avoid these problems, you're best bet is to follow PEP 8 naming conventions -- Classes should be written as UppCaseWords, modules should use names_with_underscores.

You forgot quotes:

run = test_imports.alive['import_1']

Note that inside class there's no need to use global, secondly inside methods you can use self to refer to the class as well as instance attributes:

run = self.alive['import_1']

You need to store a reference to the object which has the instance of a Y object:

class X(object):
    def __init__(self):
        self.count = 5
        self.y = Y(self) #create a y passing in the current instance of x
    def add2(self):
        self.count += 2

class Y(object):
    def __init__(self,parent):
        self.parent = parent #set the parent attribute to a reference to the X which has it
    def modify(self):
        self.parent.add2()

Example usage:

>>> x = X()
>>> x.y.modify()
>>> x.count
7

You could also make it work by adding a wrapper class that is smarter about what calling whatever it's dealing with.

Since you mentioned in a comment that you're going to need to make the call to one of thewritersmultiple places, I've updated my answer to address this by adding a nested wrapper class to encapsulate the logic of calling the various callable types in one spot. This is a classic example of using OOP to apply the DRY principle.

def save_c(v):
    print("c :" + v)

class Writer(object):
    @classmethod
    def save(cls, t, v):
        cls.writerst

    @classmethod
    def save_a(cls, v):
        print("a :" + v)

    @staticmethod
    def save_b(v):
        print("b :" + v)

    def _wrapper(writer):
        if isinstance(writer, classmethod):
            return type('ClassmethodWrapper', (object,), {'__call__':
                        lambda self, cls, v: writer.__func__(cls, str(v))})()
        elif isinstance(writer, staticmethod):
            return type('StaticmethodWrapper', (object,), {'__call__':
                        lambda self, cls, v: writer.__func__(str(v))})()
        else:
            return type('VanillaWrapper', (object,), {'__call__':
                        lambda self, cls, v: writer(str(v))})()

    writers = list(map(_wrapper, (save_a, save_b, save_c)))

if __name__ == "__main__":
    Writer.save(0, [1, 2, 3])  # -> a :[1, 2, 3]
    Writer.save(1, [4, 5, 6])  # -> b :[4, 5, 6]
    Writer.save(2, [7, 8, 9])  # -> c :[7, 8, 9]