Can modules have properties?

Question

Is it possible to add properties and special methods to modules? I want to define a module such that importing it acts like a class instance, and the body acts as a class definition. Essentially, it's to avoid ugly syntax like this:

import game
if game.Game().paused:
    print("The game is paused")

E.g. the game module would look like this:

_Speed = 1

@property
def paused():
    return _Speed == 0

And the file using it:

import game
if game.paused:
    print("The game is paused")

Also, is it possible to define special methods (such as __call__)?

To be clear, I do not differentiate between class/instance methods, since I'm using game.Game as a singleton/borg class.

I have tested using @property and defining __bool__, but neither acts as I hoped.

Edit (information on why I want to use a property):

I have a property game.speed, a function game.paused() and a function game.pause(bool). Essentially, I have a temporary variable used to store the game speed when the game is paused. There is a private speed variable that is set to zero when the game is paused. I never want the user to see the speed as being zero, and be able to modify the speed while the game is paused, so that when the game is resumed, it uses the new speed.

Answer 1

Python doesn't care that what's in sys.modules is actually a module. So you can just:

# game.py
class Game(object):
    pass

import sys
sys.modules["game"] = Game()

Now other modules that import game will get the Game instance, not the original module.

I'm not sure I recommend it, but it'll do what you want.

Answer 2

It seems you want to avoid accessing items via the module. That's fairly easy to do.

These two are equivalent:

import game
if game.Game().paused:
    print("The game is paused")

from game import Game
if Game().paused:
    print("The game is paused")

Ok then, how about this:

# game.py

class Game(object):
    @property
    def paused():
        return True

game = Game()

# from your module
from game import game
game.paused

Answer 3

If all you are looking for is the syntax as you mentioned, then you can define a class and use class level attributes

a1.py

class Game(object):
    paused = True


>>> from a1 import Game
>>> Game.paused
True
>>> Game.paused = False
>>> Game.paused
False

Well, as you asked about the Properties on Class, then you can do something with property decorator and classmethod. Soemthing like this

class ClassProperty(property):
    def __get__(self, cls, owner):
        return self.fget.__get__(None, owner)()

class Game(object):
    stage = True
    @ClassProperty
    @classmethod
    def paused(cls):
        return Game.stage == True

>>> from a1 import Game
>>> Game.paused
True

Answer 4

good answer here:

http://jtushman.github.io/blog/2014/05/02/module-properties/

Use of proxy pattern to implement module wide property. Elegant.

class Proxy(object):
    def __init__(self, local):
        self.local = local
    def __getattr__(self, name):
        return getattr(self.local(), name)

# aliasing for better syntax        
module_property = Proxy

class User(object):
    """Contrived User Object"""
    def __init__(self, **kwargs):
        self.name = kwargs.get('name', 'billy')
    def speak(self):
        print("Well hello there!")
    def say_hi(self, to_whom):
        print("Hi there {}".format(to_whom))

@module_property
def current_user():
  return User()

Then it can be used as property:

from login_manager import current_user, User

if __name__ == '__main__':
    print current_user.name
    current_user.speak()
    current_user.say_hi('lauren')

Article also mentions installable package (werkzerg project) extending this concept.

Answer 5

I don't think this is going to work. You'll need to import the module more than once and Python will execute its contents more than once. And that will reset the speed variable again. I think you're better off using a single Game class that stores the game's state. It will also keep your code a lot clearer and easier to follow.