def __init__(self, name, **kwargs):
if 'values' not in kwargs and 'callback' not in kwargs:
raise NoSelectionError("Selection check must have iterable values or a callback function")
self.callback = kwargs.pop('callback', None)
self.use_callback = True if self.callback is not None else False
self.allow_none = kwargs.pop('allow_none', False)
self.required = kwargs.get('required', True)
if not self.required:
self.allow_none = True
try:
self._values = list(kwargs.pop('values', []))
except:
raise BadSelectionsError("Selection must be iterable")
self._values = [val for val in self._values if val]
self.ignore_case = self._boolCheck(kwargs.pop('ignore_case', True),
normalize=True)
XCheck.__init__(self, name, **kwargs)
self._object_atts.extend(['ignore_case', 'values',
'use_callback', 'allow_none'])
if not self.use_callback and not self.values:
raise NoSelectionError("must have values for selection test")
for v in self._values:
if not isinstance(v, basestring):
raise BadSelectionsError("value %s is not string type" % v)
def __init__(self, name, **kwargs):
self.min = NINF
self.max = INF
self.error = XCheckError
XCheck.__init__(self, name, **kwargs)
self._object_atts.extend(["min", "max"])
self.as_string = False
def __init__(self, name, **kwargs):
self.delimiter = kwargs.pop('delimiter', ',')
try:
self._values = list(kwargs.pop('values', []))
except:
raise BadSelectionsError('List values must be iterable')
self.callback = kwargs.pop('callback', None)
self.allow_duplicates = kwargs.pop('allow_duplicates', False)
self.min_items = int(kwargs.pop('min_items', 0) )
self.max_items = int(kwargs.pop('max_items', -1) )
self.ignore_case = self._boolCheck(
kwargs.pop('ignore_case', False),
normalize=True)
if self.max_items in [ -1, INF]:
self.max_items = INF
self.as_string = self._boolCheck(
kwargs.pop('as_string', False),
normalize=True)
XCheck.__init__(self, name, **kwargs)
self._object_atts.extend(['delimiter', 'values', 'allow_duplicates',
'min_items', 'max_items', 'ignore_case', 'as_string'])
def __init__(self, name, **kwargs):
self.allow_none = get_bool(kwargs.pop('ignore_case', False))
self.format = kwargs.pop('format', "%a %b %d %H:%M:%S %Y")
self.formats = kwargs.pop('formats', [])
self.min_datetime = kwargs.pop('min_datetime',
datetime.datetime.min.replace(year=1900))
self.max_datetime = kwargs.pop('max_datetime', datetime.datetime.max)
#print self.min_datetime
XCheck.__init__(self, name, **kwargs)
self._object_atts.extend(['allow_none', 'format', 'formats',
'min_datetime', 'max_datetime'])
if not isinstance(self.min_datetime, datetime.datetime):
try:
self.min_datetime = datetime.datetime.strptime(
self.min_datetime, self.format)
except:
raise self.error("cannot parse minimum date")
if not isinstance(self.max_datetime, datetime.datetime):
try:
self.max_datetime = datetime.datetime.strptime(
self.max_datetime, self.format)
except:
raise self.error("cannot parse maximum date")
self.as_datetime = False
self.as_struct = False
self.as_string = True
self.as_date = False
def test_get_optional_elem_value(self):
ch = XCheck('thing')
ch.add_child(TextCheck('item', min_occurs = 0))
elem = ET.Element('thing')
w = Wrap(ch, elem)
self.assertEqual(w._get_elem_value('item'), '')
def __call__(self, item, **kwargs):
self.logger.debug('__call__ %s with %s (allow_none is %s)',
self.name, item, self.allow_none)
if item is None and self.allow_none:
return True
return XCheck.__call__(self, item, **kwargs)
def issue7():
whenCheck = DatetimeCheck('when', format="%m/%d/%Y")
when = ET.fromstring('<when>10/12/2013</when>')
print whenCheck(when)
when_dict = whenCheck.to_dict(when)
print when_dict
new_when = whenCheck.from_dict(when_dict)
ET.dump( new_when )
print whenCheck(new_when)
event = XCheck('event')
event.addattribute(whenCheck)
party = ET.fromstring('<event when="10/12/2013" />')
print "Checking Party:", event(party)
party_as_dict = event.to_dict(party)
print party_as_dict
def setUp(self):
#~ dude = XCheck('dude')
nick = BoolCheck('nick', required=False)
fname = TextCheck('first', min_length = 1)
fname.addattribute(nick)
lname = TextCheck('last', min_length = 1)
code = IntCheck('code', min_occurs = 1, max_occurs = 5)
code.addattribute(TextCheck('word', required=False) )
name = XCheck('name', children=[fname, lname, code])
emailtype = SelectionCheck('type', values = ['home','work', 'personal'])
email = EmailCheck('email', max_occurs=2)
email.addattribute(emailtype)
street = TextCheck('street')
city = TextCheck('city')
address = XCheck('address', children = [street, city, email], max_occurs = 4)
self.address = address
dude = XCheck('dude', children=[name, address])
idch = IntCheck('id', required=True)
dude.addattribute(idch)
elem = ET.fromstring("""<dude id="1">
<name>
<first nick="true">Josh</first>
<last>English</last>
<code>12</code>
<code word="answer">42</code>
</name>
<address>
<street>100 Main St</street>
<city>Podunk</city>
<email type="home">[email protected]</email>
<email type="work">[email protected]</email>
</address>
<address>
<street>318 West Nowhere Ln</street>
<city>East Podunk</city>
<email type="personal">[email protected]</email>
</address>
</dude>""")
self.w = Wrap(dude, elem)
def setUp(self):
nick = BoolCheck('nick', required=False)
fname = TextCheck('first', min_length = 1)
fname.addattribute(nick)
lname = TextCheck('last', min_length = 1)
code = IntCheck('code', min_occurs = 1, max_occurs = 5)
code.addattribute(TextCheck('word', required=False) )
ch = XCheck('name', children=[fname, lname, code])
idch = IntCheck('id', required=True)
ch.addattribute(idch)
elem = ET.fromstring("""<name id="1">
<first nick="true">Josh</first>
<last>English</last>
<code>12</code>
<code word="answer">42</code>
</name>""")
self.w = Wrap(ch, elem)
def __call__(self, item, **kwargs):
self.as_datetime = kwargs.pop('as_datetime', False)
self.as_struct = kwargs.pop('as_struct', False)
self.as_string = kwargs.pop('as_string', False)
self.as_date = kwargs.pop('as_date', False)
kwargs['normalize'] = any(
[self.as_datetime, self.as_struct, self.as_string, self.as_date])
return XCheck.__call__(self, item, **kwargs)
class Issue10Test(unittest.TestCase):
def setUp(self):
self.ch = XCheck('test')
self.ch.addattribute(SelectionCheck('value', values=['a', 'b'], required=False))
def tearDown(self):
del self.ch
def testGoodValues(self):
self.assertTrue(self.ch('<test value="a" />'))
self.assertTrue(self.ch('<test value="b" />'))
def testBadValues(self):
self.assertRaises(self.ch.error, self.ch, "<test value='c' />")
def testMissing(self):
self.assertTrue(self.ch('<test />'))
def testPassingNone(self):
v = self.ch.get('value')
## v.logger.setLevel(logging.DEBUG)
self.assertTrue(v(None))
def __call__(self, item, **kwargs):
self.as_string = kwargs.pop('as_string', False)
if self.as_string:
kwargs['normalize'] = True
return XCheck.__call__(self, item, **kwargs)
def __init__(self, name, **kwargs):
self.none_is_false = kwargs.pop('none_is_false', True)
XCheck.__init__(self, name, **kwargs)
self._object_atts.append('none_is_false')
self.as_string = False
def setUp(self):
self.ch = XCheck('test')
self.ch.addattribute(SelectionCheck('value', values=['a', 'b'], required=False))
def __call__(self, item, **kwargs):
self.as_string = kwargs.pop("as_string", False)
if self.as_string:
kwargs["normalize"] = True
return XCheck.__call__(self, item, **kwargs)
def test_month_and_day_only_as_attribute(self):
x = XCheck('a')
x.add_attribute(DatetimeCheck('d', format='%m-%d'))
self.assertTrue(x('<a d="01-01"/>'))
