def test_no_args(self): try: flip() except TypeError: pass else: self.fail("Failed to raise TypeError")
def test_bad_first_arg(self): try: flip("foo") except TypeError: pass else: self.fail("Failed to raise TypeError")
class Signature(object): '''A Signature of types for a function. Can be ordered, though it's only a partial ordering. ''' def __init__(self, tsig): #Explicitly convert to tuple to prevent Bad Things from happening with #generator expressions. self.tsig = tuple(tsig) def supertypes(self, other): '''Returns True if our types supertype or are equal to the operand's types. ''' if self.tsig == other.tsig: return True return self.strict_supertypes(other) def strict_supertypes(self, other): '''Returns True if all of our types supertype the operand's types. This also returns True if only some do, and the rest are equal. ''' if len(self.tsig) != len(other.tsig): return False if self.tsig == other.tsig: return False zipped_types = zip(self.tsig, other.tsig) #Is it just me, or is the argument order for issubclass completely #arbitrary? I've tripped up on that so many times - my preferred #method of turning it into a Haskell style infix thingy and then #reading it aloud ("b `issubclass` a") doesn't help. I think it ought #to be renamed 'issubclassof' and the argument order reversed. if all(_cooler_issubclass(theirs, ours) for ours, theirs in zipped_types): return True return False __ge__ = supertypes __le__ = flip(supertypes) __gt__ = strict_supertypes __lt__ = flip(strict_supertypes) def __repr__(self): return "Signature%s" % repr(self.tsig) def __hash__(self): return hash(self.tsig) def __eq__(self, other): return self.tsig == other.tsig
def test_weakrefs(self): import weakref f = flip(flip) w = weakref.ref(f) assert w() is f
def test_bad_call(self): flipped_sub = flip(sub) try: flipped_sub(4) except TypeError: pass else: self.fail("Failed to raise TypeError")
def test_all_kw(self): flipped_sub = flip(sub) try: flipped_sub(f=4, g=3) except TypeError: pass else: self.fail("Failed to raise TypeError")
class OrderedSet(list): '''A collection of unique elements, kept in order. Mutable.''' #Possibly todo: write an immutable ordered set? Inheriting from tuple? def __init__(self, seq=()): list.__init__(self) self.extend(seq) _overwrite = list.__init__ def __contains__(self, item): hash(item) return list.__contains__(self, item) def __repr__(self): return '%s(%s)' % (type(self).__name__, list.__repr__(self)) def __setslice__(self, i, j, sequence): self.__setitem__(slice(i, j), sequence) def __setitem__(self, key, value): if isinstance(key, slice): res = self.intersection(value) else: res = value in self if res: raise ValueError('Item is already a member.') list.__setitem__(self, key, value) def __getitem__(self, key): res = list.__getitem__(self, key) if isinstance(key, slice): return OrderedSet(res) return res def __getslice__(self, i, j): return self.__getitem__(slice(i, j)) #List methods, suitably wrapped and checked. def append(self, item): '''Append an element to the end of the ordered set. Quietly returns if it is already a member. ''' hash(item) if item in self: #raise ValueError("Item is already a member.") return #silently ignore. #XXX: strict option? list.append(self, item) def count(self, value): '''Return the number of times an element occurs. Due to the very nature of sets, this will either be 0 or 1. ''' return int(value in self) def extend(self, values): '''Extend the ordered set with a sequence of elements. This preserves the order of the elements. Duplicates are silently ignored. ''' appending = [] for value in values: hash(value) appending.append(value) for value in appending: self.add(value) def insert(self, key, value): '''Set a given index to a value. Raises a ValueError if the element is already a member. ''' #why not just self[key] = value? hash(value) self[key:key] = value #methods for frozenset compatability. #These two could be done using itertools.imap and the boolean operations. def issubset(self, other): '''Returns True if a given set is a subset of the ordered set.''' #don't blow up with generators other = list(other) if len(self) > len(other): return False for elem in self: if elem not in other: return False return True def issuperset(self, other): '''Returns True if a given set is a superset of the ordered set.''' #don't blow up with generators other = list(other) if len(self) < len(other): return False for elem in other: if elem not in self: return False return True def union(self, other): '''Return an OrderedSet of elements in both operands.''' res = OrderedSet(self) res.extend(other) return res def intersection(self, other): '''Return an OrderedSet of elements common to both operands.''' res = OrderedSet() other = list(other) if len(self) > len(other): #speed: this check is not needed other than to minimise the number #of iterations. other, self = self, other for elem in self: if elem in other: res.add(elem) return res def difference(self, other): '''Return the elements that do not appear in the other operand which do appear in this one. ''' res = OrderedSet() other = list(other) for elem in self: if elem not in other: res.add(elem) return res def symmetric_difference(self, other): '''Return the elements that appear in one operand but not the other.''' res = self.difference(other) for elem in other: if elem not in self: res.add(elem) return res def copy(self): '''Return a new OrderedSet with the same elements. The elements are not copied. ''' return OrderedSet(self) __copy__ = copy #Set methods. update = extend def intersection_update(self, other): '''Overwrite this OrderedSet with the operands' intersection.''' self._overwrite(self.intersection(other)) def difference_update(self, other): '''Overwrite this OrderedSet instance with the operands' assymetric difference. ''' self._overwrite(self.difference(other)) def symmetric_difference_update(self, other): '''Overwrite this OrderedSet instance with the operands' symmetric difference. ''' self._overwrite(self.symmetric_difference(other)) def add(self, elem): '''Add an element to the OrderedSet, at the end.''' hash(elem) if elem not in self: list.append(self, elem) #remove is already implemented in the list inheritance: it'll raise the #wrong error, though (ValueError instead of KeyError). So we must wrap it, #making sure the error raised can be caught by ValueError and KeyError. def remove(self, elem): '''Remove an element from the OrderedSet, raising an error if the element is not present. ''' hash(elem) try: list.remove(self, elem) except ValueError: raise DualValueError() def discard(self, elem): '''Remove an element from the OrderedSet quietly.''' if elem in self: self.remove(elem) #ditto as for remove, but we can do some dispatching. Thanks to Python's #amazing consistency, we have to raise a different error here: lists #throw a ValueError in remove but an IndexError in pop. def pop(self, index=None): '''Remove an object at a given index from the OrderedSet, or at the end if not specified. ''' if index is None: #if index is None, it might be a set method, so the error raised #must be caught by "except IndexError" and "except KeyError". try: return list.pop(self, -1) except IndexError: raise DualError() else: #if not, it's a list thing: IndexError is expected, and list.pop #will raise that anyway. return list.pop(self, index) __or__ = _operand_set_checking(union) __ror__ = _operand_set_checking(flip(union)) __and__ = _operand_set_checking(intersection) __rand__ = _operand_set_checking(flip(intersection)) __sub__ = _operand_set_checking(difference) __rsub__ = _operand_set_checking(flip(difference)) __xor__ = _operand_set_checking(symmetric_difference) __rxor__ = _operand_set_checking(flip(symmetric_difference)) __ior__ = _operand_set_checking(update) __iand__ = _operand_set_checking(intersection_update) __isub__ = _operand_set_checking(difference_update) __ixor__ = _operand_set_checking(symmetric_difference_update) def clear(self): '''Remove all elements from the instance.''' self._overwrite([]) #Comparisons are difficult, as sets and lists do wildly different things. #Since the list comparisons are undefined in the library reference, AFAIK, #and the set ones are, those are what OrderedSets will support. #Should equality just test for membership (ie, set-style), or should #position count as well (list-style)? Of course, I could always do #dispatching to sniff out sets and compare them according to set rules, #and then use the list style on everything else. #The problem here is that __eq__ is overloaded, with two fundamentally #different operations. What would be more handy is two wholly separate #comparison functions. Then, code writers could pick and choose. def __lt__(self, other): if len(self) >= len(other): return False return self.issubset(other) __ge__ = issuperset def __gt__(self, other): if len(self) <= len(other): return False return self.issuperset(other) __le__ = issubset def __eq__(self, other): if isinstance(other, _set_types): return self.setcompare(other) else: return self.listcompare(other) listcompare = list.__eq__ #we can't convert to set because we might have unhashable elements. #This assumes that neither operand will have non-unique elements. #obviously, we can't have non-unique elements, but they might. def setcompare(self, other): '''Compare the OrderedSet to another set type as a set.''' return not self.symmetric_difference(other) def __ne__(self, other): return not (self == other) #my convenience methods. def rmapp(self, elem): '''Remove an element from the OrderedSet if it is present, then place it at the end. ''' try: self.remove(elem) except IndexError: pass self.append(elem)
def test_flips_all(self): def sub_m(*args, **kwargs): return args, kwargs assert flip(sub_m)(4, 5, 6, d=5, e=7) == ((6, 5, 4), {'d': 5, 'e': 7})
def test(self): flipped_sub = flip(sub) self.assertEqual(sub(4, 5), -1) self.assertEqual(flipped_sub(4, 5), 1)
self.url = url self.count = count def __repr__(self): return "<Link %s (%d)>" % (self.url, self.count) # create the table if it doesn't exist engine = sql.create_engine('sqlite:///tweets.db') Tweet.metadata.create_all(engine) Link.metadata.create_all(engine) # get the timeline and links in it timeline = urllib.urlopen('http://www.twitter.com/statuses/public_timeline.json').read() timeline = json.loads(timeline) encode = partial(flip(encode), 'ascii') find_urls = re.compile(r'http://[^\s]+[^\s\.]') links = [] tweets = [Tweet(t['id']) for t in timeline] for matches in [map(encode, find_urls.findall(t['text'])) for t in timeline]: if len(matches) > 0: tweet_links = [] for url in matches: # find the real URL (after redirects) url = urllib.urlopen(url) url = url.geturl() tweet_links.append(Link(url, 1)) links.append(tweet_links) else: links.append(None)
def __call__(self, img): return F.flip(img, self.flip_mode)
def __call__(self, img): flip_mode = random.randint(-1, 2) if flip_mode == 2: return img else: return F.flip(img, flip_mode)
def __call__(self, img): if random.random() > 0.5: return F.flip(img, 0) else: return img
def test_flip(): def subtract(x, y): return x - y assert subtract(4, 2) == 2 assert functional.flip(subtract)(4, 2) == -2