object object mapping - Page 421

What's the best way to create a static utility class in python? Is using metaclasses code smell?

- by rsimp

Ok so I need to create a bunch of utility classes in python. Normally I would just use a simple module for this but I need to be able to inherit in order to share common code between them. The common code needs to reference the state of the module using it so simple imports wouldn't work well. I don't like singletons, and classes that use the classmethod decorator do not have proper support for python properties. One pattern I see used a lot is creating an internal python class prefixed with an underscore and creating a single instance which is then explicitly imported or set as the module itself. This is also used by fabric to create a common environment object (fabric.api.env). I've realized another way to accomplish this would be with metaclasses. For example: #util.py class MetaFooBase(type): @property def file_path(cls): raise NotImplementedError def inherited_method(cls): print cls.file_path #foo.py from util import * import env class MetaFoo(MetaFooBase): @property def file_path(cls): return env.base_path + "relative/path" def another_class_method(cls): pass class Foo(object): __metaclass__ = MetaFoo #client.py from foo import Foo file_path = Foo.file_path I like this approach better than the first pattern for a few reasons: First, instantiating Foo would be meaningless as it has no attributes or methods, which insures this class acts like a true single interface utility, unlike the first pattern which relies on the underscore convention to dissuade client code from creating more instances of the internal class. Second, sub-classing MetaFoo in a different module wouldn't be as awkward because I wouldn't be importing a class with an underscore which is inherently going against its private naming convention. Third, this seems to be the closest approximation to a static class that exists in python, as all the meta code applies only to the class and not to its instances. This is shown by the common convention of using cls instead of self in the class methods. As well, the base class inherits from type instead of object which would prevent users from trying to use it as a base for other non-static classes. It's implementation as a static class is also apparent when using it by the naming convention Foo, as opposed to foo, which denotes a static class method is being used. As much as I think this is a good fit, I feel that others might feel its not pythonic because its not a sanctioned use for metaclasses which should be avoided 99% of the time. I also find most python devs tend to shy away from metaclasses which might affect code reuse/maintainability. Is this code considered code smell in the python community? I ask because I'm creating a pypi package, and would like to do everything I can to increase adoption.

Search Results

Search found 32116 results on 1285 pages for 'object object mapping'.

Page 421/1285 | < Previous Page | 417 418 419 420 421 422 423 424 425 426 427 428 | Next Page >

- by rsimp

- by Konsta

- by Jonathan Hobbs

- by Mark Ingram

- by lasseespeholt

- by csharp-source.net

- by Robin92

- by aspdotnetuser

- by Simon Cooper

- by hari

- by koevoeter

- by TheBigO

- by samkea

- by swedishhh

- by Richard Lefebvre

- by Nigel Rivett

- by Yanick Rochon

- by lavanyadeepak

- by Aneesh karthik C

- by Khaled Musleh

- by Muhnamana

- by Michael Freidgeim

- by sebf

- by Antony Reynolds

< Previous Page | 417 418 419 420 421 422 423 424 425 426 427 428 | Next Page >