Dear All,
My aim is to obtain all unique call stacks where model classes are
accessed.
To implement it, I thought of overriding save(), delete(), and
get_query_set() methods, as follows -
class MyModelClass(CallStackMixin, models.Model) # Mixin to override save,
and delete
objects = CallStackManager() # Manager which overrides the
get_query_set
Overriding those methods as follows -
class CallStackMixin(object):
""" A mixin class for getting call stacks when Save() and Delete()
methods are called
"""
def save(self, *args, **kwargs):
"""
Logs before save and overrides respective model API save()
"""
capture_call_stack(type(self))
return super(CallStackMixin, self).save(*args, **kwargs)
def delete(self, *args, **kwargs):
"""
Logs before delete and overrides respective model API delete()
"""
capture_call_stack(type(self))
return super(CallStackMixin, self).delete(*args, **kwargs)
class CallStackManager(Manager):
""" A Manager class which overrides the default Manager class for
getting call stacks
"""
def get_query_set(self):
"""overriding the default queryset API method
"""
capture_call_stack(type(self))
return super(CallStackManager, self).get_query_set()
where *capture_call_stack *is a method which logs call stacks.
There is also a functionality of *@donottrack* which is a decorator that
avoids logging obvious calls made where we know the call stack.
The *@donottrack* is as follows -
def donottrack(*classes_not_to_be_tracked):
"""function decorator which deals with toggling call stack
Args:
classes_not_to_be_tracked: model classes where tracking is
undesirable
Returns:
wrapped function
"""
@wrapt.decorator
def real_donottrack(wrapped, instance, args, kwargs): # pylint:
disable=W0613
"""takes function to be decorated and returns wrapped function
Args:
function - wrapped function i.e. real_donottrack
"""
global HALT_TRACKING # pylint: disable=W0603
HALT_TRACKING.append(classes_not_to_be_tracked)
HALT_TRACKING[-1] = list(set([x for sublist in HALT_TRACKING for x
in sublist]))
return_value = wrapped(*args, **kwargs)
HALT_TRACKING.pop()
return return_value
return real_donottrack
Where *HALT_TRACKING *is a stack which is a global data structure, and it
pops wrt to value associated with function.
I am using *@wrapt *for retaining identity of functions, and *ModelBase*
class. Strangely, *HALT_TRACKING.pop() *executes first and then wrapped
function seems to be in action. However, I desire to execute wrapped first
and then pop *HALT_TRACKING*
Any idea what exactly is going wrong here?
--
You received this message because you are subscribed to the Google Groups
"Django users" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/django-users.
To view this discussion on the web visit
https://groups.google.com/d/msgid/django-users/b386f27f-bea1-4d0f-a4e2-ee0ddbf71625%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
