Return to Revisions

What do you think of this class? Is this simple to understand how it works and what it does? Do you think it is good piece of code?

class Field(object):
"""Class which contains logic of field-processing
"""
def __init__(self, routes, callback=None, is_iterable=False,default=None):
 """
 
 Arguments:
 - `routes`: sequence of xPath routes to the field, in order of descending priority.
 - `callback`: callable handler of field
 - `is_iterable`: if there may be a more then one field with a such route in the xml Document
 """
 self._routes = routes
 self._callback = callback
 self._is_iterable = is_iterable
 self._default = default
 
def _clean_up(self, r):
 """Cleans up the result of xpath in according to
 self._is_iterable value and some parameters qualiteies.
 Sometimes xpath method returns list containing one element, but field is not iterable, so we need not the list, but it's single element
 Arguments:
 - `r`: conversable to True result of lxml.etree._Element.xpath method.
 """
 if isinstance(r,list) and self._is_iterable:
 return map(self._callback,r) if callable(self._callback) else r
 if isinstance(r,list) and not self._is_iterable:
 if len(r) == 1:
 return self._callback(r.pop()) if callable(self._callback) else r.pop() 
 else:
 raise error.RuntimeError('Many instances of non-iterable field')
 else:
 return self._callback(r) if callable(self._callback) else r
def get_value(self,xml,nsmap = namespaces):
 """Returns value of the field in passed document
 If you passed False value of is_iterable to construct, you get a SINGLE result or error, not a list
 if you passed True, you get LIST, which may contain one element.
 if the field was not found, you get None. Anyway.
 Arguments:
 - `xml`: lxml.etree._Element instance
 - `nsmap`: dict with namespaces for xpath.
 """
 if not etree.iselement(xml):
 raise error.InvalidArgumentError('Passed document is not valid lxml.etree Element');
 for route in self._routes:
 if xml.xpath(route):
 return self._clean_up(xml.xpath(route,namespaces=nsmap))
 else:
 return self._default

And there are it's unit tests

<?xml version="1.0"?>
<root>
 <non-iterable>Non-ascii content.Привет.</non-iterable>
 <iterable>Раз</iterable>
 <iterable>Два</iterable>
 <iterable>Три</iterable>
</root>
document = etree.parse('examples/document_for_common_module_testing.xml').getroot()
class TestGetFieldValueMethod(unittest.TestCase):
"""
"""
def test_invalid_argument_exception(self):
 """An exception must be risen if passed document isn't 
 valid lxml.etree Element
 """
 f = common.Field(['/root/iterable/text()'])
 try:
 f.get_value('Not an element...')
 except error.InvalidArgumentError:
 return
 self.fail('There mus be an exception')
def test_non_iterable_value(self):
 """Testing if returned value is correct
 """
 f = common.Field(['/root/non-iterable/text()'])
 val = f.get_value(document)
 self.assertEqual(val,u'Non-ascii content.Привет.')
 #Now a callback is added
 f = common.Field(['string(/root/non-iterable/text())'],
 callback=(lambda x:x.upper()))
 val = f.get_value(document)
 self.assertEqual(val,u'NON-ASCII CONTENT.ПРИВЕТ.')
 #Now a default value is added.
 f = common.Field(['/unexisting'],default='Lol')
 val = f.get_value(document)
 self.assertEqual(val,'Lol')
 
def test_non_iterable_exception(self):
 """The error must be raisen if there are more then one
 non-iterable element
 """
 f = common.Field(['/root/iterable/text()'])
 try:
 f.get_value(document)
 except error.RuntimeError:
 return
 self.fail('There must be a runtime error')
 
def test_iterable_values(self, ):
 """
 """
 f = common.Field(['/root/iterable/text()'],is_iterable=True)#callback=(lambda x:x.upper())
 val = f.get_value(document)
 self.assertEqual(val,[u'Раз',u'Два',u'Три'])
 f = common.Field(['/root/iterable/text()'],is_iterable=True,
 callback=(lambda x:x.upper()))
 val = f.get_value(document)
 self.assertEqual(val,[u'РАЗ',u'ДВА',u'ТРИ'])
def test_unexisting_value(self):
 """
 """
 f = common.Field(['/unexisting/text()'])
 self.assertEqual(f.get_value(document),None)
 f = common.Field(['/unexisting/text()'],
 callback=(lambda x:x.upper()))
 self.assertEquals(f.get_value(document),None)

It is used for parsing xml documents with lxml library. For example i create

f=Field(['string(/root/non-iterable/text())'],callback=(lambda x: x.upper()))

then do

f.get_value(document)

and it returns /root/title/text() value where all chars are upcased.

Great thanks for your answers and pieces of advice in advance.