What are your (concrete) use-cases for metaclasses in Python?

What are your (concrete) use-cases for metaclasses in Python?

I have a friend who likes to use metaclasses, and regularly offers them as a solution.

I am of the mind that you almost never need to use metaclasses. Why? because I figure if you are doing something like that to a class, you should probably be doing it to an object. And a small redesign/refactor is in order.

Being able to use metaclasses has caused a lot of people in a lot of places to use classes as some kind of second rate object, which just seems disastrous to me. Is programming to be replaced by meta-programming? The addition of class decorators has unfortunately made it even more acceptable.

So please, I am desperate to know your valid (concrete) use-cases for metaclasses in Python. Or to be enlightened as to why mutating classes is better than mutating objects, sometimes.

I will start:

Sometimes when using a third-party library it is useful to be able to mutate the class in a certain way.

(this is the only case I can think of, and it's not concrete)

Answer by Charlie Martin for What are your (concrete) use-cases for metaclasses in Python?

You never absolutely need to use a metaclass, since you can always construct a class that does what you want using inheritance or aggregation of the class you want to modify.

That said, it can be very handy in Smalltalk and Ruby to be able to modify an existing class, but Python doesn't like to do that directly.

There's an excellent DeveloperWorks article on metaclassing in Python that might help. The Wikipedia article is also pretty good.

Answer by Triptych for What are your (concrete) use-cases for metaclasses in Python?

The only time I used metaclasses in Python was when writing a wrapper for the Flickr API.

My goal was to scrape flickr's api site and dynamically generate a complete class hierarchy to allow API access using Python objects:

# Both the photo type and the flickr.photos.search API method   # are generated at "run-time"  for photo in flickr.photos.search(text=balloons):      print photo.description  

So in that example, because I generated the entire Python Flickr API from the website, I really don't know the class definitions at runtime. Being able to dynamically generate types was very useful.

Answer by Brian for What are your (concrete) use-cases for metaclasses in Python?

The purpose of metaclasses isn't to replace the class/object distinction with metaclass/class - it's to change the behaviour of class definitions (and thus their instances) in some way. Effectively it's to alter the behaviour of the class statement in ways that may be more useful for your particular domain than the default. The things I have used them for are:

• Tracking subclasses, usually to register handlers. This is handy when using a plugin style setup, where you wish to register a handler for a particular thing simply by subclassing and setting up a few class attributes. eg. suppose you write a handler for various music formats, where each class implements appropriate methods (play / get tags etc) for its type. Adding a handler for a new type becomes:

  class Mp3File(MusicFile):      extensions = ['.mp3']  # Register this type as a handler for mp3 files      ...      # Implementation of mp3 methods go here  

  The metaclass then maintains a dictionary of {'.mp3' : MP3File, ... } etc, and constructs an object of the appropriate type when you request a handler through a factory function.

• Changing behaviour. You may want to attach a special meaning to certain attributes, resulting in altered behaviour when they are present. For example, you may want to look for methods with the name _get_foo and _set_foo and transparently convert them to properties. As a real-world example, here's a recipe I wrote to give more C-like struct definitions. The metaclass is used to convert the declared items into a struct format string, handling inheritance etc, and produce a class capable of dealing with it.

  For other real-world examples, take a look at various ORMs, like sqlalchemy's ORM or sqlobject. Again, the purpose is to interpret defintions (here SQL column definitions) with a particular meaning.

Answer by Benjamin Peterson for What are your (concrete) use-cases for metaclasses in Python?

Metaclasses aren't replacing programming! They're just a trick which can automate or make more elegant some tasks. A good example of this is Pygments syntax highlighting library. It has a class called RegexLexer which lets the user define a set of lexing rules as regular expressions on a class. A metaclass is used to turn the definitions into a useful parser.

They're like salt; it's easy to use too much.

Answer by J.F. Sebastian for What are your (concrete) use-cases for metaclasses in Python?

Metaclasses can be handy for construction of Domain Specific Languages in Python. Concrete examples are Django, SQLObject 's declarative syntax of database schemata.

A basic example from A Conservative Metaclass by Ian Bicking:

The metaclasses I've used have been primarily to support a sort of declarative style of programming. For instance, consider a validation schema:

class Registration(schema.Schema):      first_name = validators.String(notEmpty=True)      last_name = validators.String(notEmpty=True)      mi = validators.MaxLength(1)      class Numbers(foreach.ForEach):          class Number(schema.Schema):              type = validators.OneOf(['home', 'work'])              phone_number = validators.PhoneNumber()  

Some other techniques: Ingredients for Building a DSL in Python (pdf).

Edit (by Ali): An example of doing this using collections and instances is what I would prefer. The important fact is the instances, which give you more power, and eliminate reason to use metaclasses. Further worth noting that your example uses a mixture of classes and instances, which is surely an indication that you can't just do it all with metaclasses. And creates a truly non-uniform way of doing it.

number_validator = [      v.OneOf('type', ['home', 'work']),      v.PhoneNumber('phone_number'),  ]    validators = [      v.String('first_name', notEmpty=True),      v.String('last_name', notEmpty=True),      v.MaxLength('mi', 1),      v.ForEach([number_validator,])  ]  

It's not perfect, but already there is almost zero magic, no need for metaclasses, and improved uniformity.

Answer by Peter Rowell for What are your (concrete) use-cases for metaclasses in Python?

Let's start with Tim Peter's classic quote:

Metaclasses are deeper magic than 99% of users should ever worry about. If you wonder whether you need them, you don't (the people who actually need them know with certainty that they need them, and don't need an explanation about why). Tim Peters (c.l.p post 2002-12-22)

Having said that, I have (periodically) run across true uses of metaclasses. The one that comes to mind is in Django where all of your models inherit from models.Model. models.Model, in turn, does some serious magic to wrap your DB models with Django's ORM goodness. That magic happens by way of metaclasses. It creates all manner of exception classes, manager classes, etc. etc.

See django/db/models/base.py, class ModelBase() for the beginning of the story.

Answer by hyperboreean for What are your (concrete) use-cases for metaclasses in Python?

The way I used metaclasses was to provide some attributes to classes. Take for example:

class NameClass(type):      def __init__(cls, *args, **kwargs):         type.__init__(cls, *args, **kwargs)         cls.name = cls.__name__  

will put the name attribute on every class that will have the metaclass set to point to NameClass.

Answer by Matt for What are your (concrete) use-cases for metaclasses in Python?

I have a class that handles non-interactive plotting, as a frontend to Matplotlib. However, on occasion one wants to do interactive plotting. With only a couple functions I found that I was able to increment the figure count, call draw manually, etc, but I needed to do these before and after every plotting call. So to create both an interactive plotting wrapper and an offscreen plotting wrapper, I found it was more efficient to do this via metaclasses, wrapping the appropriate methods, than to do something like:

class PlottingInteractive:      add_slice = wrap_pylab_newplot(add_slice)  

This method doesn't keep up with API changes and so on, but one that iterates over the class attributes in __init__ before re-setting the class attributes is more efficient and keeps things up to date:

class _Interactify(type):      def __init__(cls, name, bases, d):          super(_Interactify, cls).__init__(name, bases, d)          for base in bases:              for attrname in dir(base):                  if attrname in d: continue # If overridden, don't reset                  attr = getattr(cls, attrname)                  if type(attr) == types.MethodType:                      if attrname.startswith("add_"):                          setattr(cls, attrname, wrap_pylab_newplot(attr))                      elif attrname.startswith("set_"):                          setattr(cls, attrname, wrap_pylab_show(attr))  

Of course, there might be better ways to do this, but I've found this to be effective. Of course, this could also be done in __new__ or __init__, but this was the solution I found the most straightforward.

Answer by David Raznick for What are your (concrete) use-cases for metaclasses in Python?

I was thinking the same thing just yesterday and completely agree. The complications in the code caused by attempts to make it more declarative generally make the codebase harder to maintain, harder to read and less pythonic in my opinion. It also normally requires a lot of copy.copy()ing (to maintain inheritance and to copy from class to instance) and means you have to look in many places to see whats going on (always looking from metaclass up) which goes against the python grain also. I have been picking through formencode and sqlalchemy code to see if such a declarative style was worth it and its clearly not. Such style should be left to descriptors (such as property and methods) and immutable data. Ruby has better support for such declarative styles and I am glad the core python language is not going down that route.

I can see their use for debugging, add a metaclass to all your base classes to get richer info. I also see their use only in (very) large projects to get rid of some boilerplate code (but at the loss of clarity). sqlalchemy for example does use them elsewhere, to add a particular custom method to all subclasses based on an attribute value in their class definition e.g a toy example

class test(baseclass_with_metaclass):      method_maker_value = "hello"  

could have a metaclass that generated a method in that class with special properties based on "hello" (say a method that added "hello" to the end of a string). It could be good for maintainability to make sure you did not have to write a method in every subclass you make instead all you have to define is method_maker_value.

The need for this is so rare though and only cuts down on a bit of typing that its not really worth considering unless you have a large enough codebase.

Answer by Mike A for What are your (concrete) use-cases for metaclasses in Python?

The only legitimate use-case of a metaclass is to keep other nosy developers from touching your code. Once a nosy developer masters metaclasses and starts poking around with yours, throw in another level or two to keep them out. If that doesn't work, start using type.new or perhaps some scheme using a recursive metaclass.

(written tongue in cheek, but I've seen this kind of obfuscation done. Django is a perfect example)

Answer by user412090 for What are your (concrete) use-cases for metaclasses in Python?

A reasonable pattern of metaclass use is doing something once when a class is defined rather than repeatedly whenever the same class is instantiated.

When multiple classes share the same special behaviour, repeating __metaclass__=X is obviously better than repeating the special purpose code and/or introducing ad-hoc shared superclasses.

But even with only one special class and no foreseeable extension, __new__ and __init__ of a metaclass are a cleaner way to initialize class variables or other global data than intermixing special-purpose code and normal def and class statements in the class definition body.

Answer by Eli Collins for What are your (concrete) use-cases for metaclasses in Python?

This is a minor use, but... one thing I've found metaclasses useful for is to invoke a function whenever a subclass is created. I codified this into a metaclass which looks for an __initsubclass__ attribute: whenever a subclass is created, all parent classes which define that method are invoked with __initsubclass__(cls, subcls). This allows creation of a parent class which then registers all subclasses with some global registry, runs invariant checks on subclasses whenever they are defined, perform late-binding operations, etc... all without have to manually call functions or to create custom metaclasses that perform each of these separate duties.

Mind you, I've slowly come to realize the implicit magicalness of this behavior is somewhat undesirable, since it's unexpected if looking at a class definition out of context... and so I've moved away from using that solution for anything serious besides initializing a __super attribute for each class and instance.

Answer by Noctis Skytower for What are your (concrete) use-cases for metaclasses in Python?

Some GUI libraries have trouble when multiple threads try to interact with them. tkinter is one such example; and while one can explicitly handle the problem with events and queues, it can be far simpler to use the library in a manner that ignores the problem altogether. Behold -- the magic of metaclasses.

Being able to dynamically rewrite an entire library seamlessly so that it works properly as expected in a multithreaded application can be extremely helpful in some circumstances. The safetkinter module does that with the help of a metaclass provided by the threadbox module -- events and queues not needed.

One neat aspect of threadbox is that it does not care what class it clones. It provides an example of how all base classes can be touched by a metaclass if needed. A further benefit that comes with metaclasses is that they run on inheriting classes as well. Programs that write themselves -- why not?

Answer by Geoffrey Hing for What are your (concrete) use-cases for metaclasses in Python?

I recently had to use a metaclass to help declaratively define an SQLAlchemy model around a database table populated with U.S. Census data from http://census.ire.org/data/bulkdata.html

IRE provides database shells for the census data tables, which create integer columns following a naming convention from the Census Bureau of p012015, p012016, p012017, etc.

I wanted to a) be able to access these columns using a model_instance.p012017 syntax, b) be fairly explicit about what I was doing and c) not have to explicitly define dozens of fields on the model, so I subclassed SQLAlchemy's DeclarativeMeta to iterate through a range of the columns and automatically create model fields corresponding to the columns:

from sqlalchemy.ext.declarative.api import DeclarativeMeta    class CensusTableMeta(DeclarativeMeta):      def __init__(cls, classname, bases, dict_):          table = 'p012'          for i in range(1, 49):              fname = "%s%03d" % (table, i)              dict_[fname] = Column(Integer)              setattr(cls, fname, dict_[fname])            super(CensusTableMeta, cls).__init__(classname, bases, dict_)  

I could then use this metaclass for my model definition and access the automatically enumerated fields on the model:

CensusTableBase = declarative_base(metaclass=CensusTableMeta)    class P12Tract(CensusTableBase):      __tablename__ = 'ire_p12'        geoid = Column(String(12), primary_key=True)        @property      def male_under_5(self):          return self.p012003        ...  

Answer by mistermarko for What are your (concrete) use-cases for metaclasses in Python?

There seems to be a legitimate use described here - Rewriting Python Docstrings with a Metaclass.

Answer by Dan Gittik for What are your (concrete) use-cases for metaclasses in Python?

I was asked the same question recently, and came up with several answers. I hope it's OK to revive this thread, as I wanted to elaborate on a few of the use cases mentioned, and add a few new ones.

Most metaclasses I've seen do one of two things:

1. Registration (adding a class to a data structure):

   models = {}    class ModelMetaclass(type):      def __new__(meta, name, bases, attrs):          models[name] = cls = type.__new__(meta, name, bases, attrs)          return cls    class Model(object):      __metaclass__ = ModelMetaclass  

   Whenever you subclass Model, your class is registered in the models dictionary:

   >>> class A(Model):  ...     pass  ...  >>> class B(A):  ...     pass  ...  >>> models  {'A': <__main__.A class at 0x...>,   'B': <__main__.B class at 0x...>}  

   This can also be done with class decorators:

   models = {}    def model(cls):      models[cls.__name__] = cls      return cls    @model  class A(object):      pass  

   Or with an explicit registration function:

   models = {}    def register_model(cls):      models[cls.__name__] = cls    class A(object):      pass    register_model(A)  

   Actually, this is pretty much the same: you mention class decorators unfavorably, but it's really nothing more than syntactic sugar for a function invocation on a class, so there's no magic about it.

   Anyway, the advantage of metaclasses in this case is inheritance, as they work for any subclasses, whereas the other solutions only work for subclasses explicitly decorated or registered.

   >>> class B(A):  ...     pass  ...  >>> models  {'A': <__main__.A class at 0x...> # No B :(  

2. Refactoring (modifying class attributes or adding new ones):

   class ModelMetaclass(type):      def __new__(meta, name, bases, attrs):          fields = {}          for key, value in attrs.items():              if isinstance(value, Field):                  value.name = '%s.%s' % (name, key)                  fields[key] = value          for base in bases:              if hasattr(base, '_fields'):                  fields.update(base._fields)          attrs['_fields'] = fields          return type.__new__(meta, name, bases, attrs)    class Model(object):      __metaclass__ = ModelMetaclass  

   Whenever you subclass Model and define some Field attributes, they are injected with their names (for more informative error messages, for example), and grouped into a _fields dictionary (for easy iteration, without having to look through all the class attributes and all its base classes' attributes every time):

   >>> class A(Model):  ...     foo = Integer()  ...  >>> class B(A):  ...     bar = String()  ...  >>> B._fields  {'foo': Integer('A.foo'), 'bar': String('B.bar')}  

   Again, this can be done (without inheritance) with a class decorator:

   def model(cls):      fields = {}      for key, value in vars(cls).items():          if isinstance(value, Field):              value.name = '%s.%s' % (cls.__name__, key)              fields[key] = value      for base in cls.__bases__:          if hasattr(base, '_fields'):              fields.update(base._fields)      cls._fields = fields      return cls    @model  class A(object):      foo = Integer()    class B(A):      bar = String()    # B.bar has no name :(  # B._fields is {'foo': Integer('A.foo')} :(  

   Or explicitly:

   class A(object):      foo = Integer('A.foo')      _fields = {'foo': foo} # Don't forget all the base classes' fields, too!  

   Although, on the contrary to your advocacy for readable and maintainable non-meta programming, this is much more cumbersome, redundant and error prone:

   class B(A):      bar = String()    # vs.    class B(A):      bar = String('bar')      _fields = {'B.bar': bar, 'A.foo': A.foo}  

Having considered the most common and concrete use cases, the only cases where you absolutely HAVE to use metaclasses are when you want to modify the class name or list of base classes, because once defined, these parameters are baked into the class, and no decorator or function can unbake them.

class Metaclass(type):      def __new__(meta, name, bases, attrs):          return type.__new__(meta, 'foo', (int,), attrs)    class Baseclass(object):      __metaclass__ = Metaclass    class A(Baseclass):      pass    class B(A):      pass    print A.__name__ # foo  print B.__name__ # foo  print issubclass(B, A)   # False  print issubclass(B, int) # True  

This may be useful in frameworks for issuing warnings whenever classes with similar names or incomplete inheritance trees are defined, but I can't think of a reason beside trolling to actually change these values. Maybe David Beazley can.

Anyway, in Python 3, metaclasses also have the __prepare__ method, which lets you evaluate the class body into a mapping other than a dict, thus supporting ordered attributes, overloaded attributes, and other wicked cool stuff:

import collections    class Metaclass(type):        @classmethod      def __prepare__(meta, name, bases, **kwds):          return collections.OrderedDict()        def __new__(meta, name, bases, attrs, **kwds):          print(list(attrs))          # Do more stuff...    class A(metaclass=Metaclass):      x = 1      y = 2    # prints ['x', 'y'] rather than ['y', 'x']  

class ListDict(dict):      def __setitem__(self, key, value):          self.setdefault(key, []).append(value)    class Metaclass(type):        @classmethod      def __prepare__(meta, name, bases, **kwds):          return ListDict()        def __new__(meta, name, bases, attrs, **kwds):          print(attrs['foo'])          # Do more stuff...    class A(metaclass=Metaclass):        def foo(self):          pass        def foo(self, x):          pass    # prints [, ] rather than   

You might argue ordered attributes can be achieved with creation counters, and overloading can be simulated with default arguments:

import itertools    class Attribute(object):      _counter = itertools.count()      def __init__(self):          self._count = Attribute._counter.next()    class A(object):      x = Attribute()      y = Attribute()    A._order = sorted([(k, v) for k, v in vars(A).items() if isinstance(v, Attribute)],                    key = lambda (k, v): v._count)  

class A(object):        def _foo0(self):          pass        def _foo1(self, x):          pass        def foo(self, x=None):          if x is None:              return self._foo0()          else:              return self._foo1(x)  

Besides being much more ugly, it's also less flexible: what if you want ordered literal attributes, like integers and strings? What if None is a valid value for x?

Here's a creative way to solve the first problem:

import sys    class Builder(object):      def __call__(self, cls):          cls._order = self.frame.f_code.co_names          return cls    def ordered():      builder = Builder()      def trace(frame, event, arg):          builder.frame = frame          sys.settrace(None)      sys.settrace(trace)      return builder    @ordered()  class A(object):      x = 1      y = 'foo'    print A._order # ['x', 'y']  

And here's a creative way to solve the second one:

_undefined = object()    class A(object):        def _foo0(self):          pass        def _foo1(self, x):          pass        def foo(self, x=_undefined):          if x is _undefined:              return self._foo0()          else:              return self._foo1(x)  

But this is much, MUCH voodoo-er than a simple metaclass (especially the first one, which really melts your brain). My point is, you look at metaclasses as unfamiliar and counter-intuitive, but you can also look at them as the next step of evolution in programming languages: you just have to adjust your mindset. After all, you could probably do everything in C, including defining a struct with function pointers and passing it as the first argument to its functions. A person seeing C++ for the first time might say, "what is this magic? Why is the compiler implicitly passing this to methods, but not to regular and static functions? It's better to be explicit and verbose about your arguments". But then, object-oriented programming is much more powerful once you get it; and so is this, uh... quasi-aspect-oriented programming, I guess. And once you understand metaclasses, they're actually very simple, so why not use them when convenient?

And finally, metaclasses are rad, and programming should be fun. Using standard programming constructs and design patterns all the time is boring and uninspiring, and hinders your imagination. Live a little! Here's a metametaclass, just for you.

class MetaMetaclass(type):      def __new__(meta, name, bases, attrs):          def __new__(meta, name, bases, attrs):              cls = type.__new__(meta, name, bases, attrs)              cls._label = 'Made in %s' % meta.__name__              return cls           attrs['__new__'] = __new__          return type.__new__(meta, name, bases, attrs)    class China(type):      __metaclass__ = MetaMetaclass    class Taiwan(type):      __metaclass__ = MetaMetaclass    class A(object):      __metaclass__ = China    class B(object):      __metaclass__ = Taiwan    print A._label # Made in China  print B._label # Made in Taiwan  

Answer by GeeF for What are your (concrete) use-cases for metaclasses in Python?

I had to use them once for a binary parser to make it easier to use. You define a message class with attributes of the fields present on the wire. They needed to be ordered in the way they were declared to construct the final wire format from it. You can do that with metaclasses, if you use an ordered namespace dict. In fact, its in the examples for Metaclasses:

https://docs.python.org/3/reference/datamodel.html#metaclass-example

But in general: Very carefully evaluate, if you really really need the added complexity of metaclasses.

Fatal error: Call to a member function getElementsByTagName() on a non-object in D:\XAMPP INSTALLASTION\xampp\htdocs\endunpratama9i\www-stackoverflow-info-proses.php on line 72