Re: @classmethod question

[Gabriel Genellina]

En Thu, 24 Apr 2008 00:27:13 -0300, Scott SA <py***@rscorp.ab.caescribió:

I'm using the @classemethod decorator for some convenience methods and
for some reason, either mental block or otherwise, can't seem to figure
out how to elegantly detect if the call is from an instance or not.

Here's the problem: Within the class definition, 'isinstance' has
nothing to compare to because the class does not appear to exist.

This is NOT a great example, but it outlines the the code:

class RecipieClass:
def __init__(self):
pass
@classmethod
def get_ingrendients(self, recipie_list=None):
if isinstnace(self,RecipieClass):
return self.do_something_interesting()
else:
return do_something_boring(recipie_list)

Yes, I can test to see if the param exists, but that makes the call
exclusive i.e. I can _only_ call it as an instance or with a parameter.

Then you can't use a classmethod. A class method can *only* be called on
the defining class or a subclass of it, or using an instance of those
classes, but in any case the first argument (usually called "cls", not
"self") is the *class* on which you called it.

>
Why am I doing this?

It is a series of convenience methods, in this case I'm interacting with
a database via an ORM (object-relational model). I want the ability to
call a class-ojbect and get related values, or pass some criteria and
get related values for them without collecting the records first as
instances, then iterating them. I need to call this from several places
so I want to be DRY (don't repeat yourself).

The easiest way to describe this as an analogy would be like having a
recipie for cookies and wanting to know all of the ingredients ahead of
time. Then, at another time, wanting to know what all the ingredients
would be to make cookies, cake and bread (i.e. complete shopping list).
cookie_recipie = RecipieClass.get_recipie('cookies')
cookie_recipie.get_ingredients()
2C Flour
0.5 C Sugar
...
RecipieClass.get_ingrendients(['cookies','cake','bread'])
8C Flour
2C Sugar
...

Of course any suggestions on how this might be better approached would
be interesting too.

I'm not sure if I get the idea right, but it looks like two different
classes to me, a Recipe and a RecipeSet:

class Recipe:
def __init__(self, recipe_name)
"""a Recipe given its name"""

def get_ingredients(self)
"""a list of ingredients for this recipe"""

class RecipeSet:
def __init__(self, recipe_names):
"""a set of recipes considered together"""
self.recipe_names = recipe_names

def get_ingredients(self)
"""a summarized list of ingredients
for all given recipes"""
cookie_recipie = Recipe('cookies')
cookie_recipie.get_ingredients()
2C Flour
0.5 C Sugar
...
all_ingredients = RecipeSet(['cookies','cake','bread']).get_ingrendients()
8C Flour
2C Sugar
...

--
Gabriel Genellina