def test_ordered_dict(self):
try:
from collections import OrderedDict
except ImportError:
pass
else:
self.assertFalse(is_listy(OrderedDict()))
self.assertFalse(is_listy(OrderedDict({"a": "A"})))
def test_ordered_dict(self):
try:
from collections import OrderedDict
except ImportError:
pass
else:
assert not is_listy(OrderedDict())
assert not is_listy(OrderedDict({'a': 'A'}))
def test_sized_builtin(self):
sized = [(), (1,), [], [1], set(), set([1]), frozenset(),
frozenset([1]), bytearray(), bytearray(1)]
if six.PY2:
sized.extend(
[xrange(0), xrange(2), buffer(''), buffer('x')]) # noqa: F821
for x in sized:
assert is_listy(x)
def test_user_defined_types(self):
class AlwaysEmptySequence(Sequence):
def __len__(self): return 0
def __getitem__(self, i): return [][i]
assert is_listy(AlwaysEmptySequence())
class AlwaysEmptySet(Set):
def __len__(self): return 0
def __iter__(self): return iter([])
def __contains__(self, x): return False
assert is_listy(AlwaysEmptySet())
def splitify(value, separator=",", strip=True, include_empty=False):
"""
Convert a value to a list using a supercharged `split()`.
If `value` is a string, it is split by `separator`. If `separator` is
`None` or empty, no attempt to split is made, and `value` is returned as
the only item in a list.
If `strip` is `True`, then the split strings will be stripped of
whitespace. If `strip` is a string, then the split strings will be
stripped of the given string.
If `include_empty` is `False`, then empty split strings will not be
included in the returned list.
If `value` is `None` an empty list is returned.
If `value` is already "listy", it is returned as-is.
If `value` is any other type, it is returned as the only item in a list.
>>> splitify("first item, second item")
['first item', 'second item']
>>> splitify("first path: second path: :skipped empty path", ":")
['first path', 'second path', 'skipped empty path']
>>> splitify(["already", "split"])
['already', 'split']
>>> splitify(None)
[]
>>> splitify(1969)
[1969]
"""
if is_listy(value):
return value
if isinstance(value, str) and separator:
parts = value.split(separator)
if strip:
strip = None if strip is True else strip
parts = [s.strip(strip) for s in parts]
return [s for s in parts if include_empty or s]
return listify(value)
def test_frozenset(self):
assert is_listy(frozenset())
assert is_listy(frozenset(['a', 'b', 'c']))
def test_dict(self):
assert not is_listy({})
assert not is_listy({'a': 'A'})
def test_tuple(self):
self.assertTrue(is_listy(tuple()))
self.assertTrue(is_listy(("a", "b", "c")))
def test_tuple(self):
assert is_listy(tuple())
assert is_listy(('a', 'b', 'c'))
def test_list(self):
assert is_listy([])
assert is_listy(['a', 'b', 'c'])
def test_frozenset(self):
self.assertTrue(is_listy(frozenset()))
self.assertTrue(is_listy(frozenset(["a", "b", "c"])))
def test_string(self):
assert not is_listy('')
assert not is_listy('test')
assert not is_listy(u(''))
assert not is_listy(u('test'))
def test_miscellaneous(self):
class Foo(object):
pass
for x in [0, 1, False, True, Foo, object, object()]:
assert not is_listy(x)
def test_none(self):
assert not is_listy(None)
def test_unsized_builtin(self):
assert not is_listy(iter([]))
assert not is_listy(i for i in range(2))
def test_string(self):
self.assertFalse(is_listy(""))
self.assertFalse(is_listy("test"))
self.assertFalse(is_listy(u("")))
self.assertFalse(is_listy(u("test")))
def test_excluded(self):
assert not is_listy({})
assert not is_listy(u(''))
assert not is_listy('')
assert not is_listy(b'')
def test_list(self):
self.assertTrue(is_listy([]))
self.assertTrue(is_listy(["a", "b", "c"]))
def test_object(self):
self.assertFalse(is_listy(object()))
def test_object(self):
assert not is_listy(object())
def test_set(self):
assert is_listy(set())
assert is_listy(set(['a', 'b', 'c']))
def test_none(self):
self.assertFalse(is_listy(None))
def test_dict(self):
self.assertFalse(is_listy({}))
self.assertFalse(is_listy({"a": "A"}))