Prev: calling a class method from a menu in a different class
Next: Get sony/dell laptaps 100% free
From: samwyse on 2 Aug 2010 20:19
I'm writing for the Google app engine and have stubbed my toe yet
again on a simple obstacle. Non-trivial app engines programs require
the import of several modules that aren't normally in my PYTHONPATH.
I'd like to be able to test my code outside of the app engine
framework. I've tried several solutions in the past that worked but
weren't particularly elegant or portable. Now I've had a new idea.
Here's my latest attempt:

import os, re
if __name__ == '__main__':
pass
else
from google.appengine.ext import webapp
register = webapp.template.create_template_register()

This works great, except my code makes use of the resister object in
several places, like this:

register.filter(emptylines)

Fortunately, I don't need the functionality of the object, I just want
something that won't generate an error when I use it. So, what is the
quickest way to to create such an object (replacing the 'pass' in my
first snippet). My solution is this:

class C:
def filter(self, *args, **kwds):
pass
register = C()

but it seems like I should be able to do something "better", as
measured by lines of code, faking more than just a 'filter' method, or
both. Any ideas? Thanks!
From: Steven D'Aprano on 3 Aug 2010 02:20
On Mon, 02 Aug 2010 17:19:46 -0700, samwyse wrote:

> Fortunately, I don't need the functionality of the object, I just want
> something that won't generate an error when I use it. So, what is the
> quickest way to to create such an object (replacing the 'pass' in my
> first snippet). My solution is this:
>
> class C:
> def filter(self, *args, **kwds):
> pass
> register = C()
>
> but it seems like I should be able to do something "better", as measured
> by lines of code, faking more than just a 'filter' method, or both. Any
> ideas? Thanks!


You want a variation on the Null Object design pattern.

class NullWithMethods(object):
def __getattr__(self, name):
return self
def __call__(self, *args, **kwargs):
pass


And in action:

>>> c = NullWithMethods()
>>> c.spam("hello", "world")
>>> c.something_completely_unlikely.spam.ham("hello", "world", foo=42)



--
Steven
From: Jean-Michel Pichavant on 3 Aug 2010 06:09
samwyse wrote:
> I'm writing for the Google app engine and have stubbed my toe yet
> again on a simple obstacle. Non-trivial app engines programs require
> the import of several modules that aren't normally in my PYTHONPATH.
> I'd like to be able to test my code outside of the app engine
> framework. I've tried several solutions in the past that worked but
> weren't particularly elegant or portable. Now I've had a new idea.
> Here's my latest attempt:
>
> import os, re
> if __name__ == '__main__':
> pass
> else
> from google.appengine.ext import webapp
> register = webapp.template.create_template_register()
>
> This works great, except my code makes use of the resister object in
> several places, like this:
>
> register.filter(emptylines)
>
> Fortunately, I don't need the functionality of the object, I just want
> something that won't generate an error when I use it. So, what is the
> quickest way to to create such an object (replacing the 'pass' in my
> first snippet). My solution is this:
>
> class C:
> def filter(self, *args, **kwds):
> pass
> register = C()
>
> but it seems like I should be able to do something "better", as
> measured by lines of code, faking more than just a 'filter' method, or
> both. Any ideas? Thanks!
>

here is a class that accepts any method call without generating an error:

class Stub(object):
@staticmethod
def stub(*arg, **kwarg):
pass
def __getattribute__(self, name):
return Stub.stub


s = Stub()
s.foo('bar')
s.bar
s.bar('', '', 5)


JM
From: samwyse on 5 Aug 2010 01:43
On Aug 3, 1:20 am, Steven D'Aprano <steve-REMOVE-
T...(a)cybersource.com.au> wrote:
> On Mon, 02 Aug 2010 17:19:46 -0700, samwyse wrote:
> > Fortunately, I don't need the functionality of the object, I just want
> > something that won't generate an error when I use it.  So, what is the
> > quickest way to to create such an object (replacing the 'pass' in my
> > first snippet).  My solution is this:
>
> >     class C:
> >         def filter(self, *args, **kwds):
> >             pass
> >     register = C()
>
> > but it seems like I should be able to do something "better", as measured
> > by lines of code, faking more than just a 'filter' method, or both.  Any
> > ideas?  Thanks!
>
> You want a variation on the Null Object design pattern.
>
> class NullWithMethods(object):
>     def __getattr__(self, name):
>         return self
>     def __call__(self, *args, **kwargs):
>         pass
>
> And in action:
>
> >>> c = NullWithMethods()
> >>> c.spam("hello", "world")
> >>> c.something_completely_unlikely.spam.ham("hello", "world", foo=42)
>
> --
> Steven

JM emailed me a good solution, but yours is great! Thanks!
From: Jean-Michel Pichavant on 5 Aug 2010 05:32
samwyse wrote:
> On Aug 3, 1:20 am, Steven D'Aprano <steve-REMOVE-
> T...(a)cybersource.com.au> wrote:
>
>> On Mon, 02 Aug 2010 17:19:46 -0700, samwyse wrote:
>>
>>> Fortunately, I don't need the functionality of the object, I just want
>>> something that won't generate an error when I use it. So, what is the
>>> quickest way to to create such an object (replacing the 'pass' in my
>>> first snippet). My solution is this:
>>>
>>> class C:
>>> def filter(self, *args, **kwds):
>>> pass
>>> register = C()
>>>
>>> but it seems like I should be able to do something "better", as measured
>>> by lines of code, faking more than just a 'filter' method, or both. Any
>>> ideas? Thanks!
>>>
>> You want a variation on the Null Object design pattern.
>>
>> class NullWithMethods(object):
>> def __getattr__(self, name):
>> return self
>> def __call__(self, *args, **kwargs):
>> pass
>>
>> And in action:
>>
>>
>>>>> c = NullWithMethods()
>>>>> c.spam("hello", "world")
>>>>> c.something_completely_unlikely.spam.ham("hello", "world", foo=42)
>>>>>
>> --
>> Steven
>>
>
> JM emailed me a good solution, but yours is great! Thanks!
>
The version I gave you overrides __getattribute__. To be honest,
overriding __getattr__ is a better solution.Just in case you don't know
the difference, __getattr__ is called only if the attribute is not found
while __getattribute__ is actually called to find the attribute.

JM
 |  Next  |  Last
Pages: 1 2
Prev: calling a class method from a menu in a different class
Next: Get sony/dell laptaps 100% free