def test_do_scoping_correct(self): try: l = lambda *items: List.from_iterable(items) do(let(a=l(1, 2, 3)), let(b=lambda e: List.unit(e.a)), lambda e: List.unit(e.a * e.b)) except AttributeError: assert False
def test_list_applicative_binary_func(self): f = lambda x, y: x + y v = List.from_iterable([1, 2]) w = List.from_iterable([4, 8]) self.assertEquals( pure(f).apply(v).apply(w), List.from_iterable([5, 9, 6, 10]))
def test_do_list_basic(self): l = lambda *items: List.from_iterable(items) out1 = do(let(a=l(3, 10, 6)), let(b=l(100, 200)), lambda e: List.unit(e.a + e.b)) out2 = l(3, 10, 6) | (lambda a: l(100, 200) | (lambda b: List.unit(a + b))) self.assertEqual(out1, out2)
def test_list_functor_map(self): # fmap f (return v) = return (f v) x = unit(42) f = lambda x: x * 10 self.assertEqual(x.map(f), unit(420)) y = List.from_iterable([1, 2, 3, 4]) g = lambda x: x * 10 self.assertEqual(y.map(g), List.from_iterable([10, 20, 30, 40]))
def test_do_list_pythag(self): r = lambda low, high: List.from_iterable(range(low, high)) out1 = do(let(z=r(1, 21)), let(x=lambda e: r(1, e.z + 1)), let(y=lambda e: r(e.x, e.z + 1)), lambda e: guard(List, e.x * e.x + e.y * e.y == e.z * e.z), lambda e: List.unit((e.x, e.y, e.z))) out2 = r(1, 21) | ( lambda z: r(1, z + 1) | (lambda x: r(x, z + 1) | (lambda y: guard(List, x * x + y * y == z * z) >> List.unit( (x, y, z))))) self.assertEqual(out1, out2)
def test_list_applicative_law_identity(self): # pure id <*> v = v # Singleton list x = unit(42) self.assertEquals(pure(identity).apply(x), x) # Empty list y = List.empty() self.assertEquals(pure(identity).apply(y), y) # Log list y = List.from_iterable(range(42)) self.assertEquals(pure(identity).apply(y), y)
def _get_setup_args(path): rtn = List.empty() with open(path, 'rU') as file: t = compile(file.read(), path, 'exec', ast.PyCF_ONLY_AST) for node in (n for n in t.body if isinstance(n, ast.Expr)): if isinstance(node.value, ast.Call): if hasattr(node.value.func, 'id') and node.value.func.id == 'setup': rtn = List.from_iterable(node.value.keywords) break else: print(dir(node.value.func), node.value.func.value) return rtn
def test_list_functor_law_1(self): # fmap id = id # Singleton list using return x = unit(42) self.assertEqual(x.map(identity), x) # Empty list y = List() self.assertEqual(y.map(identity), y) # Long list z = List.from_iterable(range(42)) self.assertEqual(z.map(identity), z)
def test_list_applicative_law_functor(self): # pure f <*> x = fmap f x f = lambda x: x * 42 x = unit(42) self.assertEquals(pure(f).apply(x), x.map(f)) # Empty list z = List() self.assertEquals(pure(f).apply(z), z.map(f)) # Long list z = List.from_iterable(range(42)) self.assertEquals(pure(f).apply(z), z.map(f))
def _get_value(keyname, alias_list, kw): name = kw.arg rtn = {} def get_list_value(v): r = [] for e in v.elts: if isinstance(e, ast.Str): r.append(e.s) elif isinstance(e, ast.Num): r.append(str(e.n)) return r get_tuple_value = get_list_value if name in alias_list: v = kw.value if isinstance(v, ast.Str): rtn[keyname] = v.s elif isinstance(v, ast.Tuple): rtn[keyname] = get_tuple_value(v) elif isinstance(v, ast.List): rtn[keyname] = get_list_value(v) elif isinstance(v, ast.BinOp): if isinstance(v.left, ast.List): rtn[keyname] = get_list_value(v.left) else: #print(name, dir(v)) pass return List.unit(rtn)
def test_list_monad_law_associativity_empty(self): # (m >>= f) >>= g is just like doing m >>= (\x -> f x >>= g) f = lambda x: unit(x + 1000) g = lambda y: unit(y * 42) # Empty list m = List() self.assertEqual(m.bind(f).bind(g), m.bind(lambda x: f(x).bind(g)))
def test_list_monad_law_associativity_range(self): # (m >>= f) >>= g is just like doing m >>= (\x -> f x >>= g) f = lambda x: unit(x + 1000) g = lambda y: unit(y * 42) # Long list m = List.from_iterable(range(42)) self.assertEqual(m.bind(f).bind(g), m.bind(lambda x: f(x).bind(g)))
def get_result(name, version): theurl = "https://pypi.python.org/pypi/%s" % name if version != None and version.strip() != "": theurl = theurl + "/" + version print(theurl) thepage = urllib.request.urlopen(theurl) soup = BeautifulSoup(thepage, "lxml") return List.unit(soup)
def test_identity_applicative_law_composition_empty(self): # pure (.) <*> u <*> v <*> w = u <*> (v <*> w) u = pure(lambda x: x * 42) v = pure(lambda x: x + 42) # Empty list w = List() self.assertEquals( pure(fmap).apply(u).apply(v).apply(w), u.apply(v.apply(w)))
def test_list_functor_law2(self): # fmap (f . g) x = fmap f (fmap g x) def f(x): return x + 10 def g(x): return x * 10 # Singleton list x = unit(42) self.assertEquals(x.map(compose(f, g)), x.map(g).map(f)) # Empty list y = List.empty() self.assertEquals(y.map(compose(f, g)), y.map(g).map(f)) # Long list z = List.from_iterable(range(42)) self.assertEquals(z.map(compose(f, g)), z.map(g).map(f))
def test_identity_applicative_law_composition_range(self): # pure (.) <*> u <*> v <*> w = u <*> (v <*> w) u = pure(lambda x: x * 42) v = pure(lambda x: x + 42) # Long list w = List.from_iterable(range(42)) self.assertEquals( pure(fmap).apply(u).apply(v).apply(w), u.apply(v.apply(w)))
def get_index(soup): data = {} data["index"] = {} for div in soup("div", id="download-button"): lst = div.parent.find("h1").text.split() data["index"]['name_version'] = (lst[0], lst[1]) data["index"]['description'] = div.parent.findNext('p').text data["index"]['download_url'] = div.find('a')["href"] break return List.unit(data)
def get_table(soup): data = {} data["files"] = [] for table in soup("table", class_="list")[-1:]: if "File" not in table("th")[0].string: continue for entry in table("tr")[1:-1]: fields = entry("td") FILE = 0 URL = 0 MD5 = 1 TYPE = 1 PYVERSION = 2 UPLOADED = 3 SIZE = 4 file_inf = fields[FILE]("a")[0]["href"].split("#") file_url = file_inf[URL] file_md5 = file_inf[MD5][4:] file_type = fields[TYPE].string file_pyversion = fields[PYVERSION].string file_uploaded = fields[UPLOADED].string file_size = fields[SIZE].string data["files"].append({ "url": file_url, "md5": file_md5, "type": file_type, "pyversion": file_pyversion, "uploaded": file_uploaded, "size": file_size }) entry.decompose() table.decompose() return List.unit(data)
def get_ul(soup): data = {} data["info"] = {} uls = soup("ul", class_="nodot") if uls: if "Downloads (All Versions):" in uls[0]("strong")[0].string: ul = uls[1] else: ul = uls[0] for entry in ul.contents: if not hasattr(entry, "name") or entry.name != "li": continue entry_name = entry("strong")[0].string if not entry_name: continue if entry_name == "Categories": data["info"][entry_name] = {} for cat_entry in entry("a"): cat_data = cat_entry.string.split(" :: ") if not cat_data[0] in data["info"][entry_name]: data["info"][entry_name][cat_data[0]] = cat_data[1:] else: data["info"][entry_name][cat_data[0]].extend( cat_data[1:]) continue if entry("span"): data["info"][entry_name] = entry("span")[0].string continue if entry("a"): data["info"][entry_name] = entry("a")[0]["href"] continue entry.decompose() ul.decompose() return List.unit(data)
def test_list_length_empty(self): xs = List() self.assertEqual(0, len(xs))
def test_list_list(self): xs = List().cons(List().cons(42)) self.assertEqual(42, xs.head().head())
def test_list_tail_tail_null(self): xs = List().cons("b").cons("a") assert (xs.tail().tail().null())
def test_list_applicative_empty_arg_2(self): a = List.pure(lambda x, y: x+y).apply(List(42)).apply(List([])) self.assertEquals(a, List([]))
def test_list_append_non_empty(self): xs = List.from_iterable(range(5)) ys = List.from_iterable(range(5, 10)) zs = xs.append(ys) self.assertEqual(List.from_iterable(range(10)), zs)
def test_list_append_empty(self): xs = List() ys = List.unit(42) zs = xs.append(ys) self.assertEqual(ys, zs)
def test_list_head(self): x = List().cons(42).head() self.assertEqual(42, x)
def test_list_applicative_1(self): a = List.pure(lambda x, y: x+y).apply(List(2)).apply(List(40)) self.assertEquals(a, List(42))
def test_list_applicative_2(self): a = List.pure(lambda x: x * 2).apply(List([1, 2])) #.apply(List([3, 4])) self.assertEquals(a, List([2, 4]))
def test_list_applicative_3(self): a = List.pure(lambda x, y: x+y).apply(List([1, 2])).apply(List([4, 8])) self.assertEquals(a, List([5, 9, 6, 10]))
def test_list_length_non_empty(self): xs = List.unit(42) self.assertEqual(1, len(xs))
def test_list_length_multiple(self): xs = List.from_iterable(range(42)) self.assertEqual(42, len(xs))
def test_list_monad_empty_bind(self): m = List() f = lambda x: unit(x * 10) self.assertEqual(m.bind(f), List())
def test_list_append_empty_other(self): xs = List.unit(42) ys = List() zs = xs.append(ys) self.assertEqual(xs, zs)
def test_list_tail_head(self): xs = List().cons("b").cons("a") self.assertEqual("a", xs.head())
def test_list_applicative_empty_func(self): a = List.pure([]).apply(List(42)).apply(List([1, 2, 3])) self.assertEquals(a, List([]))