Exemple #1
0
 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)
Exemple #2
0
 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
Exemple #3
0
 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)
Exemple #4
0
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 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 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)
Exemple #9
0
 def test_list_append_empty_other(self):
     xs = List.unit(42)
     ys = List()
     zs = xs.append(ys)
     self.assertEqual(xs, zs)
Exemple #10
0
 def test_list_append_empty(self):
     xs = List()
     ys = List.unit(42)
     zs = xs.append(ys)
     self.assertEqual(ys, zs)
Exemple #11
0
 def test_list_length_non_empty(self):
     xs = List.unit(42)
     self.assertEqual(1, len(xs))
Exemple #12
0
 def test_list_append_empty_other(self):
     xs = List.unit(42)
     ys = List()
     zs = xs.append(ys)
     self.assertEqual(xs, zs)
Exemple #13
0
 def test_list_append_empty(self):
     xs = List()
     ys = List.unit(42)
     zs = xs.append(ys)
     self.assertEqual(ys, zs)
Exemple #14
0
 def test_list_length_non_empty(self):
     xs = List.unit(42)
     self.assertEqual(1, len(xs))