Develop Reference

How to make a polymorphic dataclass constructor method

I have 3 dataclass objects say:
class Message1:
def __init__(a):
...
class Message2:
def __init__(d,e,f):
...
class Message3:
def __init__(g,i):
...
For these 3 messages I want to make a factory type method which can return one of the three objects if it succeeds and if not it should return either the one it identified as the correct message to be created but failed at creation or it should notify the user that it could not create any of the messages. Are there any OOP patterns for this?
My initial thought was to do a:
def factory_method(**parameters):
try:
Message1(**parameters)
except TypeError:
try:
Message2(**parameters)
except:
try:
Message3(**parameters)
except:
print("Could not deduce message type")
My issue with this idea is that:
It's not a dynamically scalable solution, with each new message class I introduce I need to add a new try catch block
If the whole nested block structure fails, I have no feedback as to why, was the parameters correct for one of the message but wrong value, or was it plain gibberish?
I realize this might be a bit opinion based on what the best outcome is. At the same time it might be the solution is not too elegant and the simplest way is to just tell the factory_method what kind of message to initialize. Any suggestions or ideas would be appreciated.

If you can't join them all in a single class and you can't point a call to a single class, i would match the arguments to the posible class. To make it work a type hint and a "proxy" class is required. This example asumes that any of the classes wont contain a __init__(*args, **kwargs), and to add a new class you just add it to Message.msg_cls, you can eval the global scope if you don't want to add manually each class.
class Message1:
def __init__(self, a: int, alt=None, num=10):
print('Message 1')
class Message2:
def __init__(self, d: str, e: str, f: int):
print('Message 2')
class Message3:
def __init__(self, g: int, i: any):
print('Message 3')
class Message:
msg_cls = (
Message1,
Message2,
Message3
)
#staticmethod
def eq_kwargs(cls, kwargs):
cls_kwargs = cls.__init__.__defaults__
if cls_kwargs is None:
if len(kwargs) > 0:
return False
else:
return True
cls_astr = cls.__init__.__code__
kw_types = [type(t) for t in cls_kwargs]
for k in kwargs:
if k in cls_astr.co_varnames:
if type(kwargs[k]) in kw_types:
kw_types.remove(type(kwargs[k]))
else:
if type(None) in kw_types:
kw_types.remove(type(None))
else:
return False
else:
return False
return True
#staticmethod
def eq_args(cls, args):
cls_args = cls.__init__.__annotations__
if len(cls_args) != len(args):
return False
for a, b in zip(args, cls_args):
if type(a) != cls_args[b] and cls_args[b] != any:
return False
return True
def __new__(cls, *args, **kwargs):
for mc in Message.msg_cls:
if Message.eq_args(mc, args):
if Message.eq_kwargs(mc, kwargs):
return mc(*args, **kwargs)
raise ValueError('Message.__new__, no match')
if __name__ == '__main__':
ms_1_a = Message(1, alt='a')
ms_1_b = Message(2, alt='a', num=5)
ms_2 = Message('X', 'Y', 5)
ms_3_a = Message(1, [1, 4])
ms_3_b = Message(2, Message(10))

Pulling an object out of a queue based on a data member

I need to extend Queue so that I can pluck an object out of the Queue based on the value of one of the object's data members.
I've solved the problem like this and I wonder if I'm being dense. Do I really need to do the list conversion to find the object?
class Datum:
def __init__(self, id):
self.id = id
def __str__(self):
return str(self.id)
class PluckQueue(Queue):
def pluck(self, id):
with self.not_empty:
plucked = None
while plucked is None:
pluck_list = list(self.queue)
try:
plucked = next(xx for xx in pluck_list if xx.id == id )
except StopIteration:
plucked = None
if plucked is None:
self.not_empty.wait()
else:
index = pluck_list.index(plucked)
self.queue.remove(pluck_list[index])
return plucked
def __str__(self):
return str([str(xx) for xx in self.queue])
pq = PluckQueue()
pq.put(Datum('a'))
pq.put(Datum('b'))
pq.put(Datum('c'))
plucked = pq.pluck('b')
print(plucked)
print(pq)
This gives the result:
b
['a', 'c']
Am I missing an easier way to do this?

This approach has worked fine and isn't so kludgy after all. The big difference one might make is to pass a predicate instead of having the test hardcoded into the next statement.

how to implement a interface to keep track of runtime of each sub-sections and also the total run time of the section in python

is there any one know about: how to design a interface in python so that for the caller, it can track where time is being spent between two points in a piece of code?
For example: if we have several pieces of code we labeled them as A, B, C, D, so how could we track the runtime of these pieces and also about the runtime of the total piece of code?

This sounds like something that you could make good use of a decorator for something like the entryExit decorator could log the time spent inside each decorated function:
class entryExit(object):
def __init__(self, f):
self.f = f
def __call__(self):
print "Entering", self.f.__name__
self.f()
print "Exited", self.f.__name__
#entryExit
def func1():
print "inside func1()"
#entryExit
def func2():
print "inside func2()"

Edit: Now with function/method decorator support
I've done something like:
import timeit
from collections import OrderedDict
class TimeMarkContextManager(object):
def __init__(self, mgr, key):
self.mgr = mgr
self.key = key
def __enter__(self):
self.mgr.mark("%s.start" % self.key)
def __exit__(self, *args, **kwargs):
self.mgr.mark("%s.stop" % self.key)
class TimeMark(object):
def __init__(self):
self.marks = OrderedDict()
def mark(self, key):
self.marks[key] = timeit.default_timer()
def manager(self, key):
return TimeMarkContextManager(self, key)
def pprint(self):
base = self.marks.values()[0]
last = None
for (k,v) in self.marks.iteritems():
delta_base = "%.3f" % (v - base)
delta_last = "%.3f" % (v - last) if last is not None else "---"
print("%-20s %8s %8s" % (k, delta_base, delta_last))
last = v
def TimeMe(mgr, key=None):
def TimeDeco(f):
def func_wrapper(*args, **kwargs):
k = f.__name__ if key is None else key
mgr.mark("%s.start" % k)
rv = f(*args, **kwargs)
mgr.mark("%s.stop" % k)
return rv
return func_wrapper
return TimeDeco
Which you could then use as follows:
import time # Only required for time.sleep()
tm = TimeMark() # Initialize the TimeMark object
#TimeMe(tm) # Decorate a function, don't give it a special key
def sleep_four(): # (it will use the function name as a key)
time.sleep(4)
#TimeMe(tm, "sleep-five") # Decorate a function, override the default tag
def sleep_five():
time.sleep(5)
tm.mark("start") # Create a mark called "start"
time.sleep(2)
# Use a context manager to time a block
with tm.manager("sleep-thirty"):
time.sleep(10)
time.sleep(10)
time.sleep(10)
time.sleep(2)
sleep_four() # Call the sleep_four function.
# It'll show up as "sleep_four" (note underscore)
sleep_five() # Call the sleep_five function.
# It'll show up as "sleep-five" (note hyphen)
tm.mark("end") # Create a mark called "stop"
tm.pprint() # Print a list of timemarks
Which outputs:
start 0.000 ---
sleep-thirty.start 1.999 1.999
sleep-thirty.stop 32.001 30.002
sleep_four.start 34.001 2.000
sleep_four.stop 38.001 4.000
sleep-five.start 38.001 0.000
sleep-five.stop 43.002 5.000
end 43.002 0.000
The first column is the specified key, the second column is the time delta since the first mark was set, the third column is the time delta since the previous mark.
And now that I see Steve Barnes' answer, adding decorator support wouldn't be a very nice complement.

python generator

I have homework that I am stuck on. I have gone as far as I can but I am stuck, can someone point me in the right direction.... I am getting stick in making each data row a new object. Normally i would think I could just iterate over the rows, but that will only return last row
Question:
Modify the classFactory.py source code so that the DataRow class returned by the build_row function has another method:
retrieve(self, curs, condition=None)
self is (as usual) the instance whose method is being called, curs is a database cursor on an existing database connection, and condition (if present) is a string of condition(s) which must be true of all received rows.
The retrieve method should be a generator, yielding successive rows of the result set until it is completely exhausted. Each row should be a new object of type DataRow.
This is what I have------
the test:
import unittest
from classFactory import build_row
class DBTest(unittest.TestCase):
def setUp(self):
C = build_row("user", "id name email")
self.c = C([1, "Steve Holden", "steve#holdenweb.com"])
def test_attributes(self):
self.assertEqual(self.c.id, 1)
self.assertEqual(self.c.name, "Steve Holden")
self.assertEqual(self.c.email, "steve#holdenweb.com")
def test_repr(self):
self.assertEqual(repr(self.c),
"user_record(1, 'Steve Holden', 'steve#holdenweb.com')")
if __name__ == "__main__":
unittest.main()
the script I am testing
def build_row(table, cols):
"""Build a class that creates instances of specific rows"""
class DataRow:
"""Generic data row class, specialized by surrounding function"""
def __init__(self, data):
"""Uses data and column names to inject attributes"""
assert len(data)==len(self.cols)
for colname, dat in zip(self.cols, data):
setattr(self, colname, dat)
def __repr__(self):
return "{0}_record({1})".format(self.table, ", ".join([" {0!r}".format(getattr(self, c)) for c in self.cols]))
DataRow.table = table
DataRow.cols = cols.split()
return DataRow

It should roughly be something like the following:
def retrieve(self, curs, condition=None):
query_ = "SELECT * FROM rows"
if condition is not None:
query_ += " %s" %condition
curs.execute(query_)
for row in curs.fetchall(): # iterate over the retrieved results
yield row # and yield each row in turn

Iterate over the rows as normal, but use yield instead of return.

Python, function quit if it has been run the last 5 minutes

I have a python script that gets data from a USB weather station, now it puts the data into MySQL whenever the data is received from the station.
I have a MySQL class with an insert function, what i want i that the function checks if it has been run the last 5 minutes if it has, quit.
Could not find any code on the internet that does this.
Maybe I need to have a sub-process, but I am not familiar with that at all.
Does anyone have an example that I can use?

Use this timeout decorator.
import signal
class TimeoutError(Exception):
def __init__(self, value = "Timed Out"):
self.value = value
def __str__(self):
return repr(self.value)
def timeout(seconds_before_timeout):
def decorate(f):
def handler(signum, frame):
raise TimeoutError()
def new_f(*args, **kwargs):
old = signal.signal(signal.SIGALRM, handler)
signal.alarm(seconds_before_timeout)
try:
result = f(*args, **kwargs)
finally:
signal.signal(signal.SIGALRM, old)
signal.alarm(0)
return result
new_f.func_name = f.func_name
return new_f
return decorate
Usage:
import time
#timeout(5)
def mytest():
print "Start"
for i in range(1,10):
time.sleep(1)
print "%d seconds have passed" % i
if __name__ == '__main__':
mytest()

Probably the most straight-forward approach (you can put this into a decorator if you like, but that's just cosmetics I think):
import time
import datetime
class MySQLWrapper:
def __init__(self, min_period_seconds):
self.min_period = datetime.timedelta(seconds=min_period_seconds)
self.last_calltime = datetime.datetime.now() - self.min_period
def insert(self, item):
now = datetime.datetime.now()
if now-self.last_calltime < self.min_period:
print "not insert"
else:
self.last_calltime = now
print "insert", item
m = MySQLWrapper(5)
m.insert(1) # insert 1
m.insert(2) # not insert
time.sleep(5)
m.insert(3) # insert 3
As a side-note: Have you noticed RRDTool during your web-search for related stuff? It does apparantly what you want to achieve, i.e.
a database to store the most recent values of arbitrary resolution/update frequency.
extrapolation/interpolation of values if updates are too frequent or missing.
generates graphs from the data.
An approach could be to store all data you can get into your MySQL database and forward a subset to such RRDTool database to generate a nice time series visualization of it. Depending on what you might need.

import time
def timeout(f, k, n):
last_time = [time.time()]
count = [0]
def inner(*args, **kwargs):
distance = time.time() - last_time[0]
if distance > k:
last_time[0] = time.time()
count[0] = 0
return f(*args, **kwargs)
elif distance < k and (count[0]+1) == n:
return False
else:
count[0] += 1
return f(*args, **kwargs)
return inner
timed = timeout(lambda x, y : x + y, 300, 1)
print timed(2, 4)
First argument is the function you want run, second is the time interval, and the third is the number of times it's allowed to run in that time interval.

Each time the function is run save a file with the current time. When the function is run again check the time stored in the file and make sure it is old enough.

Just derive to a new class and override the insert function. In the overwriting function, check last insert time and call father's insert method if it has been more than five minutes, and of course update the most recent insert time.