Use module as class instance in Python
<h2>TL; DR</h2>

<p>Basically the question is about hiding from the user the fact that my modules have class implementations so that the user can use the module as if it has direct function definitions like <code>my_module.func()</code></p>

<h2>Details</h2>

<p>Suppose I have a module <code>my_module</code> and a class <code>MyThing</code> that lives in it. For example:</p>

<pre><code># my_module.py

class MyThing(object):
    def say():
        print("Hello!")
</code></pre>

<p>In another module, I might do something like this:</p>

<pre><code># another_module.py

from my_module import MyThing

thing = MyThing()
thing.say()
</code></pre>

<p>But suppose that I don't want to do all that. What I really want is for <code>my_module</code> to create an instance of MyThing automatically on <code>import</code> such that I can just do something like the following:</p>

<pre><code># yet_another_module.py

import my_module

my_module.say()
</code></pre>

<p>In other words, whatever method I call on the module, I want it to be forwarded directly to a default instance of the class contained in it. So, to the user of the module, it might seem that there is no class in it, just direct function definitions in the module itself (where the functions are actually methods of a class contained therein). Does that make sense? Is there a short way of doing this?</p>

<p>I know I could do the following in <code>my_module</code>:</p>

<pre><code>class MyThing(object):
    def say():
        print("Hello!")

default_thing = MyThing()

def say():
    default_thing.say()
</code></pre>

<p>But then suppose <code>MyThing</code> has many "public" methods that I want to use, then I'd have to explicitly define a "forwarding" function for every method, which I don't want to do.</p>

<p>As an extension to my question above, is there a way to achieve what I want above, but also be able to use code like <code>from my_module import *</code> and be able to use methods of <code>MyThing</code> directly in another module, like <code>say()</code>? </p>

<p>You could just replace:</p>

<pre><code>def say():
    return default_thing.say()
</code></pre>

<p>with:</p>

<pre><code>say = default_thing.say
</code></pre>

<p>You still have to list everything that's forwarded, but the boilerplate is fairly concise.</p>

<p>If you want to replace that boilerplate with something more automatic, note that (details depending on Python version), <code>MyThing.__dict__.keys()</code> is something along the lines of <code>['__dict__', '__weakref__', '__module__', 'say', '__doc__']</code>. So in principle you could iterate over that, skip the <code>__</code> Python internals, and call <code>setattr</code> on the current module (which is available as <code>sys.modules[__name__]</code>). You might later regret not listing this stuff explicitly in the code, but you could certainly do it.</p>

<p>Alternatively you <em>could</em> get rid of the class entirely as use the module as the unit of encapsulation. Wherever there is data on the object, replace it with global variables. "But", you might say, "I've been warned against using global variables because supposedly they cause problems". The bad news is that you've already created a global variable, <code>default_thing</code>, so the ship has sailed on that one. The even worse news is that if there is any data on the object, then the whole concept of what you want to do: module-level functions that mutate a shared global state, carries with it most of the problems of globals.</p>

python class module