Avoiding namespace pollution in python by using Classes

Question

A bit of background

I'm writing a python module for my own use, and I'm using Python's logging module. There are handlers and formatters and even a pair of functions I create that (for the most part) won't be used anywhere else. However, I still want to be able to access and modify these variables elsewhere (for instance, other closely-coupled modules or scripts)

A simple namespace

What I'm currently doing is using a class definition to group all of my variables together, like this:

class _Logging:
    '''A little namespace for our logging facilities. Don't try to instantiate
    it: all it does is group together some logging objects and keep them out of
    the global namespace'''
    global logger

    def __init__(self):
        raise TypeError("that's not how this works...")

    def gz_log_rotator(source, dest):
        '''accept a source filename and a destination filename. copy source to
        dest and add gzip compression. for use with
        logging.handlers.RotatingFileHandler.rotator.'''
        with gzip.open(dest, 'wb', 1) as ofile, open(source, 'rb') as ifile:
            ofile.write(ifile.read())
        os.remove(source)

    def gz_log_namer(name):
        '''accept a filename, and return it with ".gz" appended. for use with
        logging.handlers.RotatingFileHandler.namer.'''
        return name + ".gz"

    fmtr = logging.Formatter(
        '[%(asctime)s:%(name)s:%(thread)05d:%(levelname)-8s] %(message)s')

    gz_rotfile_loghandler = logging.handlers.RotatingFileHandler(
        '%s.log' % __name__, mode='a', maxBytes=(1024**2 * 20), backupCount=3)
    gz_rotfile_loghandler.setLevel(5)
    gz_rotfile_loghandler.setFormatter(fmtr)
    gz_rotfile_loghandler.rotator = gz_log_rotator
    gz_rotfile_loghandler.namer = gz_log_namer

    simplefile_loghandler = logging.FileHandler(
        '%s.simple.log' % __name__, mode='w')
    simplefile_loghandler.setLevel(15)
    simplefile_loghandler.setFormatter(fmtr)

    stream_loghandler = logging.StreamHandler()
    stream_loghandler.setLevel(25)
    stream_loghandler.setFormatter(fmtr)

    logger = logging.getLogger(__name__)
    logger.setLevel(5)
    logger.addHandler(gz_rotfile_loghandler)
    logger.addHandler(simplefile_loghandler)
    logger.addHandler(stream_loghandler)

However, pylint complains (and i agree) that methods defined in a class should either be static methods, or follow the naming conventions for first parameters (e.g. gz_log_rotator(self, dest)), which is not how the function is used, and would be much more confusing.

Fun Fact

During this process i've also discovered that instances of classmethod and staticmethod are not in and of themselves callable (???). While a method defined in a class namespace is callable both within and without, classmethods and staticmethods are only callable when accessed through their class (at which point they refer to the underlying function, not the classmethod/staticmethod object)

>>> class Thing:
...   global one_, two_, three_
...   def one(self):
...      print('one')
...   @classmethod
...   def two(cls):
...     print('two')
...   @staticmethod
...   def three():
...     print('three')
...   one_, two_, three_ = one, two, three
...
>>> Thing.one()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: one() missing 1 required positional argument: 'self'
>>> Thing.two()
two
>>> Thing.three()
three
>>> # all as expected
>>> one_()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: one() missing 1 required positional argument: 'self'
>>> # so far so good
>>> two_()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'classmethod' object is not callable
>>> # what?
>>> three_()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'staticmethod' object is not callable
>>> # ???

My Question

Is there a better way to hold these variables without polluting my namespace?

The code I have works correctly, but it makes me feel a little unclean. I could define a function that would only be called once and then immediately call it, but then I either lose references to everything I don't return, or i'm back to polluting the global namespace. I could just make everything _hidden, but I feel like they should be logically grouped. I could make _Logging a bona fide class, put all of my stuff in an __init__ function and tack all my little variables onto self, but that also feels inelegant. I could create another file for this, but so far I've gotten by with everything held in the same file. The only other option that seemed palatable is to make the two functions staticmethods and only refer to them through our class (i.e. _Logging.gz_log_namer), but it would seem that is also impossible.

>>> class Thing:
...   @staticmethod
...   def say_hello():
...     print('hello!')
...   Thing.say_hello()
...
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 5, in Thing
AttributeError: type object 'Thing' has no attribute 'say_hello'
>>>

As it stands, the best option I see is to use the selfless methods.

Why not use a module instead of a class, and functions instead of methods? That would avoid all the problems with self/cls arguments and also that of having a class that shouldn't be instantiated. — snakecharmerb
– snakecharmerb, Commented Apr 19, 2016 at 4:39
I'm trying to keep to holding all of my core code in a single file for as long as possible. Otherwise, a module would be exactly what i'm looking for. — tboz203
– tboz203, Commented Apr 20, 2016 at 20:06

alimsk · Accepted Answer · 2021-09-22 23:56:48Z

1

you can create a new class that inherit from staticmethod class, and add __call__ method to the class.
for example:

class callablestatic(staticmethod):
    def __init__(self, func):
        super().__init__(func)
        self.func = func
    def __call__(self, *args, **kwargs):
        # the __call__ method allows you to call the class instance
        return self.func(*args, **kwargs)

then use it in your class:

class Thing:
    @callablestatic
    def hello(name):
        print(f"hello {name}")
    hello("John") # works

but better create new file and import it as a module

edited Sep 22, 2021 at 23:56

answered Sep 22, 2021 at 9:13

alimsk

112 gold badges2 silver badges6 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Božo Stojković · Accepted Answer · 2018-04-11 19:10:55Z

Sorry for answering 2 years later, but this could help someone.

You could make your methods static, and create another static method (ex. init), calling it right after initializing the class. Then use setattr to keep the references to your variables.

For setting multiple class variables, you can use

[setattr(Class, name, value) for name,value in locals().items()]

inside the method.

Full code:

class _Logging:
    '''A little namespace for our logging facilities. Don't try to instantiate
    it: all it does is group together some logging objects and keep them out of
    the global namespace'''
    def __init__(self):
        raise TypeError("that's not how this works...")

    @staticmethod
    def gz_log_rotator(source, dest):
        '''accept a source filename and a destination filename. copy source to
        dest and add gzip compression. for use with
        logging.handlers.RotatingFileHandler.rotator.'''
        with gzip.open(dest, 'wb', 1) as ofile, open(source, 'rb') as ifile:
            ofile.write(ifile.read())
        os.remove(source)

    @staticmethod
    def gz_log_namer(name):
        '''accept a filename, and return it with ".gz" appended. for use with
        logging.handlers.RotatingFileHandler.namer.'''
        return name + ".gz"

    @staticmethod
    def init():
        global logger

        fmtr = logging.Formatter(
            '[%(asctime)s:%(name)s:%(thread)05d:%(levelname)-8s] %(message)s')

        gz_rotfile_loghandler = logging.handlers.RotatingFileHandler(
            '%s.log' % __name__, mode='a', maxBytes=(1024**2 * 20), backupCount=3)
        gz_rotfile_loghandler.setLevel(5)
        gz_rotfile_loghandler.setFormatter(fmtr)
        gz_rotfile_loghandler.rotator = _Logging.gz_log_rotator
        gz_rotfile_loghandler.namer = _Logging.gz_log_namer

        simplefile_loghandler = logging.FileHandler(
            '%s.simple.log' % __name__, mode='w')
        simplefile_loghandler.setLevel(15)
        simplefile_loghandler.setFormatter(fmtr)

        stream_loghandler = logging.StreamHandler()
        stream_loghandler.setLevel(25)
        stream_loghandler.setFormatter(fmtr)

        logger = logging.getLogger(__name__)
        logger.setLevel(5)
        logger.addHandler(gz_rotfile_loghandler)
        logger.addHandler(simplefile_loghandler)
        logger.addHandler(stream_loghandler)

        [setattr(_Logging, name, value) for name,value in locals().items()]

_Logging.init()

Collectives™ on Stack Overflow

Avoiding namespace pollution in python by using Classes

A bit of background

A simple namespace

Fun Fact

My Question

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

A bit of background

A simple namespace

Fun Fact

My Question

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related