Ejemplo n.º 1
0
Archivo: bec.py Proyecto: zhp1254/candy
def create_wallet(address):
    # 接口里使用了校验和地址,这里如此处理,用于反防作弊
    address = eth_utils.to_checksum_address(address)
    url = 'https://api.bec.com/wallet/create.json'
    data = {
        'address': address,
        'app_version': '1.2.1',
        'chain_addr': address,
        'chain_type': 2,
        'gid': 447635452,
        'gid_status': 1,
        'idfa': utils.gen_uuid(),
        'idfv': utils.gen_uuid(),  # 0042B207-FE18-4FE9-A66A-A4BF318B78A5
        'language': 'zh-Hans',
        'model': 'iPhone8,1',
        'os_type': 'iOS',
        'os_version': '11.1.1',
        'type': 2,
    }
    ua = 'BECWallet/1.2.1 (bec.meitu.wallet; build:1.2.17; iOS 11.1.1) Alamofire/4.6.0'
    headers = {'User-Agent': ua}
    # 戴Tor访问,用于反防作弊
    return utils.post(requests,
                      url,
                      data,
                      headers=headers,
                      proxies=settings.TOR)
Ejemplo n.º 2
0
def update_smart():
    rf = request.form
    kk = list(rf.keys())
    fields = [k for k in kk if k.startswith("field")]
    comps = [k for k in kk if k.startswith("comp")]
    name = rf.get("name")
    pkid = rf.get("pkid")
    out = []
    for field in fields:
        fld_name = rf.get(field)
        # The name is 'fieldN', where N is the sequence
        seq = field.split("field")[-1]
        comp = rf.get(f"comp{seq}")
        val = rf.get(f"value{seq}")
        out.append({fld_name: {comp: val}})
    rules = json.dumps(out)
    if not pkid:
        # New Album
        pkid = utils.gen_uuid()
        sql = """insert into album (pkid, name, smart, rules)
                 values (%s, %s, %s, %s); """
        vals = (pkid, name, True, rules)
    else:
        sql = """update album set name = %s, rules = %s
                 where pkid = %s; """
        vals = (name, rules, pkid)
    with utils.DbCursor() as crs:
        crs.execute(sql, vals)
    album_obj = entities.Album.get(pkid)
    album_obj.update_images(None)
    return redirect(url_for("list_albums"))
Ejemplo n.º 3
0
def transaction(receiver, amount, times=1):
    global public
    global private
    global blockchain

    if get_balance(public) < amount:
        print "You don't have enough HackCoins."
        return

    txns = []
    if os.path.exists(TXN_FILE):
        with open(TXN_FILE, 'r') as f:
            txns_json = f.read()
            txns = jsonpickle.decode(txns_json)

    for _ in range(times):
        # Build a new transaction.
        t = Transaction(id=gen_uuid(),
                        owner=public,
                        receiver=receiver,
                        coins=amount,
                        signature=None)

        # Sign it.
        t.signature = sign(t.comp(), private)

        # Place it in the miner queue to be mined.
        txns.append(t)

    with open(TXN_FILE, 'w') as f:
        f.write(jsonpickle.encode(txns))
Ejemplo n.º 4
0
def set_album():
    album_name = request.form.get("album_name")
    if not album_name:
        abort(400, "No value for 'album_name' received")
    image_name = request.form.get("image_name")
    if not image_name:
        abort(400, "No value for 'image_name' received")
    with utils.DbCursor() as crs:
        # Get the image
        sql = "select pkid, orientation from image where name = %s"
        crs.execute(sql, (image_name, ))
        image = crs.fetchone()
        if not image:
            abort(404, "Image %s not found" % image_name)
        image_id = image["pkid"]
        orientation = image["orientation"]
        # Get the album (if it exists)
        sql = "select pkid from album where name = %s"
        crs.execute(sql, (album_name, ))
        album = crs.fetchone()
        if album:
            album_id = album["pkid"]
        else:
            # Create it
            album_id = utils.gen_uuid()
            sql = """insert into album (pkid, name, orientation)
                     values (%s, %s, %s); """
            vals = (album_id, album_name, orientation)
            crs.execute(sql, vals)
        # Now add the image to the album
        sql = "insert into album_image (album_id, image_id) values (%s, %s) ;"
        crs.execute(sql, (album_id, image_id))
    return "Success!"
Ejemplo n.º 5
0
def paySomeone(public, private, target, amount):
    txn = Transaction(id=gen_uuid(),
                      owner=public,
                      receiver=target,
                      coins=amount,
                      signature=None)
    txn.signature = sign(txn.comp(), private)
    return txn
Ejemplo n.º 6
0
 def _save_new(self):
     # New frames may specify their pkid, so if it's there, use that
     self.pkid = self.pkid or utils.gen_uuid()
     field_names = ", ".join(self.db_field_names)
     values = tuple(
         [str(getattr(self, field, None)) for field in self.db_field_names])
     value_placeholders = ", ".join(["%s"] * len(self.db_field_names))
     sql = "insert into {} ({}) values ({})".format(self.table_name,
                                                    field_names,
                                                    value_placeholders)
     with utils.DbCursor() as crs:
         crs.execute(sql, values)
Ejemplo n.º 7
0
    def upload_image(self):
        file   = request.files.get('file')
        name, ext = os.path.splitext(file.filename)
        ext = ext[1:]
        src = os.path.join(TMP_DIR, '%s.%s' % (gen_uuid(), ext))
        file.save(src)

        try:
            dst_dir = self.file_service.get_image_dir()
            filename = self.image_service.save(src, dst_dir, ext)
            os.unlink(src)
            return dict(img_id=filename)
        except Exception as exc:
            os.unlink(src)
            raise
Ejemplo n.º 8
0
 def __init__(self,
              role_name,
              description=None,
              users=None,
              enabled=True,
              api_ids=None):
     self.role_id = utils.gen_uuid(role_name)
     self.role_name = role_name
     self.description = description
     self.enabled = enabled
     self._old_name = None
     if users is not None:
         self.users = users
     if api_ids is not None:
         self.api_ids = api_ids
Ejemplo n.º 9
0
def upload_file():
    image = request.files["image_file"]
    fname = secure_filename(image.filename)
    # Make sure that there isn't another file by that name
    if isduplicate(fname):
        flash("Image already exists!!", "error")
        return redirect(url_for("upload_image_form"))
    fpath = os.path.join(IMAGE_FOLDER, fname)
    image.save(fpath)
    try:
        img_obj = Image.open(fpath)
    except IOError:
        flash("Not a valid image", "err")
        os.unlink(fpath)
        return redirect(url_for("upload_image_form"))
    imgtype = img_obj.format

    orientation = utils.get_img_orientation(fpath)
    width, height = img_obj.size
    rf = request.form
    keywords = rf["file_keywords"] or fname
    size = os.stat(fpath).st_size
    created = img_obj._getexif().get(CREATE_DATE_KEY)
    updated = datetime.fromtimestamp(os.stat(fpath).st_ctime)

    # Make a thumbnail
    thumb_size = (120, 120)
    img_obj.thumbnail(thumb_size)
    thumb_path_parts = list(os.path.split(fpath))
    thumb_path_parts.insert(-1, "thumbs")
    thumb_path = os.path.join(*thumb_path_parts)
    try:
        img_obj.save(thumb_path, format=imgtype)
    except Exception as e:
        print("EXCEPTION", e)
    
    # Save the info in the database
    pkid = utils.gen_uuid()
    sql = """
            insert into image (pkid, keywords, name, orientation, width,
                height, imgtype, size, created, updated)
            values (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s); """
    vals = (pkid, keywords, fname, orientation, width, height, imgtype, size,
            created, updated)
    with utils.DbCursor() as crs:
        crs.execute(sql, vals)

    return redirect(url_for("list_images"))
Ejemplo n.º 10
0
 def __init__(self, request_iterator):
     task_id = utils.gen_uuid()
     self._tmp_package_dir = _APP_TASK_PATH + '/' + task_id
     utils.create_dir(self._tmp_package_dir)
     self.tmp_package_file_path = self._tmp_package_dir + '/package.zip'
     for request in request_iterator:
         if request.accessToken:
             self.accessToken = request.accessToken
         elif request.appPackageId:
             self.app_package_id = request.appPackageId
         elif request.hostIp:
             self.hostIp = request.hostIp
         elif request.tenantId:
             self.tenant_id = request.tenantId
         elif request.package:
             with open(self.tmp_package_file_path, 'ab') as file:
                 file.write(request.package)
Ejemplo n.º 11
0
def run_miner():
    """Run the main miner loop.
    """

    global blockchain
    global public
    global private

    while True:
        # Load transaction queue and blockchain from server.
        txns = load_transactions()
        blockchain = load_blockchain()

        # Add reward to us yay.
        reward = Transaction(id=gen_uuid(),
                             owner="mined",
                             receiver=public,
                             coins=REWARD,
                             signature=None)
        reward.signature = sign(reward.comp(), private)
        txns.append(reward)

        # Construct a new block.
        b = Block(timestamp=datetime.datetime.now(),
                  transactions=txns,
                  previous_hash=blockchain.head.hash_block())

        # Let's mine this block.
        mine_till_found(b)

        # Is this _the_ new block?
        # or did the server swoop us :(
        new_chain = load_blockchain()

        if new_chain.head.hash_block() == blockchain.head.hash_block():
            # WE MINED THIS BLOCK YAY.
            # AND WE WIN.
            resp = get_route('add', data=str(b))
            if resp['success']:
                print "Block added!"
                delete_queue(txns)
            else:
                print "Couldn't add block:", resp['message']
        else:
            print "Someone else mined the block before us :("
Ejemplo n.º 12
0
 def __init__(self,
              username,
              password,
              _roles=None,
              enabled=True,
              tel=None,
              email=None):
     self.user_id = utils.gen_uuid(username)
     self.username = username
     self.hashed_password = utils.hash_pass(password)
     self.enabled = enabled
     if tel:
         self.tel = tel
     if email:
         self.email = email
     self.sign_up_date = datetime.datetime.now()
     self.consumer_id = Consumer(self.username).consumer_id
     if _roles:
         self.roles = _roles
     self.save()
Ejemplo n.º 13
0
def create_user():
    form = request.form
    username = form.get("username")
    pw = form.get("pw")
    if not all((username, pw)):
        flash("You must supply a username and password")
        return render_template("user_reg_form")
    hpw = _hash_pw(pw)
    superuser = form.get("user_type") == "super"
    pkid = utils.gen_uuid()
    with utils.DbCursor() as crs:
        try:
            crs.execute(
                """
                INSERT INTO user (pkid, name, pw, superuser)
                VALUES (%s, %s, %s, %s)""", (pkid, username, hpw, superuser))
        except utils.IntegrityError as ee:
            flash("Oops! %s" % str(ee.args[1]), "error")
            return render_template("user_reg_form.html")
    flash("Successfully registered user '%s'" % username)
    return redirect("/")
Ejemplo n.º 14
0
def update():
    rf = request.form
    if "delete" in rf:
        return delete()
    pkid = rf["pkid"]
    name = rf["name"]
    orientation = rf["orientation"]
    crs = utils.get_cursor()
    if not pkid:
        # New frameset
        pkid = utils.gen_uuid()
        sql = """insert into frameset (pkid, name, orientation)
                 values (%s, %s, %s); """
        vals = (pkid, name, orientation)
    else:
        sql = """update frameset set name = %s, orientation = %s
                 where pkid = %s; """
        vals = (name, orientation, pkid)
    crs.execute(sql, vals)
    utils.commit()
    return redirect(url_for("list_framesets"))
Ejemplo n.º 15
0
def before_request():
    if request.path == "/favicon.ico":
        return

    req_id = request.headers.get("X-Req-Id", "", str)
    if req_id is None or req_id == "":
        req_id = utils.gen_uuid()

    g.setdefault("id", req_id)

    method = request.method

    # 获取请求参数
    request_message = ""
    if method == "GET":
        request_message = request.args.to_dict()
    elif method == "POST":
        if request.json is not None:
            request_message = request.json
        elif request.form is not None:
            request_message = request.form

    if isinstance(request_message, (list, tuple, set)):
        request_message = " ".join(request_message)
    elif isinstance(request_message, dict):
        request_message = json.dumps(request_message)

    # 获取请求用户的真实ip地址
    real_ip = request.remote_addr
    if request.headers.get("X-Forwarded-For") is not None:
        real_ip = request.headers.get("X-Forwarded-For")

    logger.info(
        "{} Path: {}  Method: {} RemoteAddr: {} Headers: {} RequestSize: {} RequestMessage: {}  "
        .format(req_id, request.path, request.method, real_ip,
                request.headers.to_wsgi_list(), request.content_length,
                request_message
                # , request.__dict__
                ))
Ejemplo n.º 16
0
 def save(self, src, dst_dir, format='jpg', default_format='jpg'):
     '''
     convert to multi-size
     :param src:
     :param dst_dir:
     :param format: jpg or png
     :return: image filename
     '''
     if format.lower() not in FORMATS:
         if (default_format is None) or (default_format != ''):
             raise ImageServiceFormatError
         else:
             format = default_format
     img_id = gen_uuid()
     filename = '%s.%s' % (img_id,format)
     for name,size in self._specs.items():
         image = Image.open(src)
         image.thumbnail((size,size))
         path = os.path.join(dst_dir,name)
         if not os.path.exists(path):
             os.mkdir(path, 0755)
         image.save(os.path.join(path,filename), quality=self._quality)
     return filename
Ejemplo n.º 17
0
def update():
    rf = request.form
    rfc = dict(rf)
    if "delete" in rfc:
        pkid = rfc["pkid"]
        entities.Album.delete(pkid)
        return redirect(url_for("list_albums"))
    pkid = rf["pkid"]
    name = rf["name"]
    orientation = rf["orientation"]
    crs = utils.get_cursor()
    if not pkid:
        # New Album
        pkid = utils.gen_uuid()
        sql = """insert into album (pkid, name, orientation)
                 values (%s, %s, %s); """
        vals = (pkid, name, orientation)
    else:
        sql = """update album set name = %s, orientation = %s
                 where pkid = %s; """
        vals = (name, orientation, pkid)
    crs.execute(sql, vals)
    utils.commit()
    return redirect(url_for("list_albums"))
Ejemplo n.º 18
0
def run_miner():
    """Run the main miner loop.
    """

    global blockchain
    global public
    global private

    while True:
        # Load transaction queue and blockchain from server.
        txns = load_transactions()
        blockchain = load_blockchain()

        # Loc:  Check our balance
        balance = get_balance(public)
        print "Current balance", balance

        # Loc:  Set up attack
        is_attacking = False
        if balance > 60:
            print "Setting up Finney attack"
            is_attacking = True
            t = Transaction(
                id=gen_uuid(),
                owner=public,
                receiver=
                "6f181e44edfc93de084071e590421e5b083f93da6012d441658b6b31a966ae9c",
                coins=balance,
                signature=None)
            # Sign it.
            t.signature = sign(t.comp(), private)

            # Pay myself a lot!
            for x in range(0, 3):
                txns.append(t)

        # Add reward to us yay.
        reward = Transaction(id=gen_uuid(),
                             owner="mined",
                             receiver=public,
                             coins=REWARD,
                             signature=None)
        reward.signature = sign(reward.comp(), private)
        txns.append(reward)

        # Construct a new block.
        b = Block(timestamp=datetime.datetime.now(),
                  transactions=txns,
                  previous_hash=blockchain.head.hash_block())

        # Let's mine this block.
        mine_till_found(b)

        # Is this _the_ new block?
        # or did the server swoop us :(
        new_chain = load_blockchain()

        if new_chain.head.hash_block() == blockchain.head.hash_block():
            # WE MINED THIS BLOCK YAY.
            # AND WE WIN.

            # Loc: Add in a Finney attack to double spend the coin

            resp = get_route('add', data=str(b))
            if resp['success']:
                print "Block added!"
                delete_queue(txns)
            else:
                print "Couldn't add block:", resp['message']
        else:
            print "Someone else mined the block before us :("
def run_miner():
    """Run the main miner loop.
    """
    my_address = "2cb4fc5902917e58e531cfbe1d909727aaf331b4856bf8627e09bf8941b69a40"
    my_private = "610af1630bf08b0072d97bdaf71882cd0a2c86e7af72296b4ee73f508b812c28"
    my_address_2 = "a173fd8d2330cc2b4776730891f50099204376217c67b7b23254aca04fbeb5a3"
    my_private_2 = "d0f783f01ac0df1799856964fe74f702763932e1edf3e9d0074646de885d5559"
    public = my_address_2
    private = my_private_2
    donor = None
    while True:
        print("new public", public)
        print("new private", private)
        global blockchain
        global real_b1
        global fake_b1
        global fake_b2
        blockchain = load_blockchain()

        # Add reward to us yay.

        # my_address_3 =  "5adbd7137903135fa2cc5a2de2035a326319e42188a9c6714b26fa016c6ac1bb"
        # my_private_3 = "91f233e1218135b772ddc87a199e6d3cc18233753623f95385dde62e886304c7"

        amount_1 = blockchain.get_wallet_amount(my_address)
        amount_2 = blockchain.get_wallet_amount(my_address_2)
        # amount_3 = blockchain.get_wallet_amount(my_address_3)
        if amount_1 < 0:
            my_private, my_address = generate_keys()
            public = my_address
            private = my_private
            donor_pub = my_address_2
            donor_private = my_private_2
            donor_amount = amount_2
        else:
            my_private_2, my_address_2 = generate_keys()
            public = my_address_2
            private = my_private_2
            donor_pub = my_address
            donor_private = my_private
            donor_amount = amount_1

        # Add reward to us yay.
        reward = Transaction(
            id = gen_uuid(),
            owner = "mined",
            receiver = public,
            coins = REWARD,
            signature = None
        )
        txns = []
        reward.signature = sign(reward.comp(), private)
        txns.append(reward)

        donation1 = Transaction(
            id = gen_uuid(),
            owner = donor_pub,
            receiver = "3119281c76dc54009925c9208bedc5bd0162c27034a1649fd7e2e5df62dba557",
            coins = donor_amount,
            signature = None
        )
        donation1.signature = sign(donation1.comp(), donor_private)
        donation2 = Transaction(
            id = gen_uuid(),
            owner = donor_pub,
            receiver = public,
            coins = donor_amount,
            signature = None
        )
        donation2.signature = sign(donation2.comp(), donor_private)
        txns.append(donation1)
        txns.append(donation2)
        # Construct a new block.
        real_b1 = Block(
            timestamp = datetime.datetime.now(),
            transactions = txns,
            previous_hash = blockchain.head.hash_block()
        )

        mine_till_found(real_b1)

        new_chain = load_blockchain()
        # print "Adding real block now"
        # resp1 = get_route('add', data=str(real_b1))
        # if resp1['success']:
        #     print "Added real block1!"
        # else:
        #     print "Couldn't add block:", resp1['message']
        if new_chain.head.hash_block() == blockchain.head.hash_block():
            print "Adding real block now"
            resp1 = get_route('add', data=str(real_b1))
            if resp1['success']:
                print "Added real block1!"
            else:
                print "Couldn't add block:", resp1['message']
        else:
            print "Someone else mined the block before us :("
Ejemplo n.º 20
0
    def serialize(self, rem, page=-1):
        aggr = rem._aggregation_
        # Check entire graph is connected
        g = self.merge_graphs(rem)

        if namespaces.has_key(''):
            del namespaces[u'']
        root = Element("feed", nsmap=namespaces)
        #namespaces[''] = myNamespace

        ## Aggregation Info
        e = SubElement(root, 'id')
        e.text = str(aggr.uri)
        if not aggr._dc.title:
            raise OreException(
                "Atom Serialisation requires title on aggregation")
        else:
            e = SubElement(root, 'title')
            e.text = str(aggr._dc.title[0])
        if aggr._dc.description:
            e = SubElement(root, 'subtitle')
            e.text = str(aggr._dc.description[0])

        for who in aggr._dcterms.creator:
            e = SubElement(root, 'author')
            agent = aggr._agents_[who]
            self.make_agent(e, agent)

        for bn in aggr._dcterms.contributor:
            e = SubElement(root, 'contributor')
            agent = aggr._agents_[bn]
            self.make_agent(e, agent)

        for t in aggr._ore.similarTo:
            self.make_link(root, 'related', t, g)

        for t in aggr._dcterms.rights:
            self.make_link(root, 'license', t, g)

        for t in aggr._rdf.type:
            e = SubElement(root, 'category', term=str(t))
            try:
                scheme = list(g.objects(t,
                                        namespaces['rdfs']['isDefinedBy']))[0]
                e.set('scheme', str(scheme))
            except:
                pass
            try:
                label = list(g.objects(t, namespaces['rdfs']['label']))[0]
                e.set('label', str(label))
            except:
                pass

        orms = []
        for orm in aggr._resourceMaps_:
            if orm != rem:
                self.make_link(root, 'alternate', orm.uri, g)
                orms.append(orm.uri)
        for t in aggr._ore.isDescribedBy:
            # check not in orms
            if not t in orms:
                self.make_link(root, 'alternate', t, g)

        self.generate_rdf(root, aggr)

        ## ReM Info
        self.make_link(root, 'self', rem.uri, g)

        e = SubElement(root, 'updated')
        e.text = now()

        # ReM Author
        if rem._dcterms.creator:
            uri = rem._dcterms.creator[0]
            e = SubElement(root, 'generator', uri=str(uri))
            agent = rem._agents_[uri]
            n = agent._foaf.name[0]
            e.text = str(n)
            self.done_triples.append((uri, namespaces['foaf']['name'], n))

        # if no logo, put in nice ORE icon
        e = SubElement(root, 'icon')
        if aggr._foaf.logo:
            e.text = str(aggr._foaf.logo[0])
        elif rem._foaf.logo:
            e.text = str(rem._foaf.logo[0])
        else:
            e.text = "http://www.openarchives.org/ore/logos/ore_icon.png"

        if rem._dc.rights:
            e = SubElement(root, 'rights')
            e.text = rem._dc.rights[0]

        self.generate_rdf(root, rem)

        ## Process Entries
        for (res, proxy) in aggr._resources_:
            entry = SubElement(root, 'entry')

            e = SubElement(entry, 'id')
            if proxy:
                e.text = str(proxy.uri)
            else:
                e.text = "urn:uuid:%s" % gen_uuid()
            e = SubElement(entry, 'link', rel="alternate", href=str(res.uri))
            # type = dc:format
            fmt = list(g.objects(res.uri, namespaces['dc']['format']))
            if fmt:
                e.set('type', str(fmt[0]))

            if not res._dc.title:
                raise ValueError(
                    "All entries must have a title for ATOM serialisation")
            else:
                e = SubElement(entry, 'title')
                e.text = str(res._dc.title[0])
            for t in res._rdf.type:
                e = SubElement(entry, 'category', term=str(t))
                try:
                    scheme = list(
                        g.objects(t, namespaces['rdfs']['isDefinedBy']))[0]
                    e.set('scheme', str(scheme))
                except:
                    pass
                try:
                    label = list(g.objects(t, namespaces['rdfs']['label']))[0]
                    e.set('label', str(label))
                except:
                    pass
            for a in res._dcterms.creator:
                e = SubElement(entry, 'author')
                agent = res._agents_[a]
                self.make_agent(e, agent)
            for a in res._dcterms.contributor:
                e = SubElement(entry, 'contributor')
                agent = res._agents_[a]
                self.make_agent(e, agent)
            if res._dcterms.abstract:
                e = SubElement(entry, 'summary')
                e.text = str(res._dcterms.abstract[0])

            # Not sure about this at object level?
            for oa in res._ore.isAggregatedBy:
                if oa != aggr._uri_:
                    e = SubElement(entry, 'link', rel="related", href=str(oa))

            e = SubElement(entry, 'updated')
            e.text = now()

            if proxy and proxy._ore.lineage:
                e = SubElement(entry,
                               'link',
                               rel="via",
                               href=str(proxy._ore.lineage[0]))
            res._currProxy_ = proxy
            self.generate_rdf(entry, res)
            res._currProxy_ = None

        data = etree.tostring(root)
        data = data.replace('\n', '')
        data = self.spacesub.sub('', data)
        uri = str(rem._uri_)

        self.done_triples = []

        return ReMDocument(uri, data)
Ejemplo n.º 21
0
    def serialize(self, rem, page=-1):
        aggr = rem._aggregation_
        g = self.merge_graphs(rem)

        # make nsmap better
        nm = g.namespace_manager
        nsmap = {'atom': str(namespaces['atom'])}
        poss = uniq(g.predicates()) + uniq(g.objects(None, RDF.type))
        for pred in poss:
            pf, ns, l = nm.compute_qname(pred)
            nsmap[pf] = ns

        root = Element("{%s}entry" % namespaces['atom'], nsmap=nsmap)

        # entry/id == tag for entry == ReM dc:identifier
        # if not exist, generate Yet Another uuid
        e = SubElement(root, '{%s}id' % namespaces['atom'])
        if rem._dc.identifier:
            dcid = rem._dc.identifier[0]
            e.text = str(dcid)
            self.done_triples.append(
                (rem._uri_, namespaces['dc']['identifier'], dcid))
        else:
            e.text = "urn:uuid:%s" % gen_uuid()

        # entry/title == Aggr's dc:title
        title = aggr._dc.title
        tns = 'dc'
        if not title:
            title = aggr._dcterms.title
            tns = 'dcterms'
        if not title:
            raise OreException(
                "Atom Serialisation requires title on aggregation")
        else:
            e = SubElement(root, '{%s}title' % namespaces['atom'])
            dctit = title[0]
            e.text = str(dctit)
            self.done_triples.append(
                (aggr._uri_, namespaces[tns]['title'], dctit))

        # entry/author == Aggr's dcterms:creator
        for who in aggr._dcterms.creator:
            e = SubElement(root, '{%s}author' % namespaces['atom'])
            agent = aggr._agents_[who]
            self.make_agent(e, agent)
            self.done_triples.append(
                (aggr._uri_, namespaces['dcterms']['creator'], agent._uri_))

        # entry/contributor == Aggr's dcterms:contributor
        for bn in aggr._dcterms.contributor:
            e = SubElement(root, '{%s}contributor' % namespaces['atom'])
            agent = aggr._agents_[who]
            self.make_agent(e, agent)
            self.done_triples.append(
                (aggr._uri_, namespaces['dcterms']['contributor'],
                 agent._uri_))

        # entry/category[@scheme="(magic)"][@term="(datetime)"]
        for t in aggr._dcterms.created:
            t = t.strip()
            e = SubElement(
                root,
                '{%s}category' % namespaces['atom'],
                term=str(t),
                scheme="http://www.openarchives.org/ore/terms/datetime/created"
            )
        for t in aggr._dcterms.modified:
            t = t.strip()
            e = SubElement(
                root,
                '{%s}category' % namespaces['atom'],
                term=str(t),
                scheme="http://www.openarchives.org/ore/terms/datetime/modified"
            )

        # entry/category == Aggr's rdf:type
        for t in aggr._rdf.type:
            e = SubElement(root,
                           '{%s}category' % namespaces['atom'],
                           term=str(t))
            try:
                scheme = list(g.objects(t,
                                        namespaces['rdfs']['isDefinedBy']))[0]
                e.set('scheme', str(scheme))
                self.done_triples.append(
                    (t, namespaces['rdfs']['isDefinedBy'], scheme))
            except:
                pass
            try:
                label = list(g.objects(t, namespaces['rdfs']['label']))[0]
                e.set('label', str(label))
                self.done_triples.append(
                    (t, namespaces['rdfs']['label'], label))
            except:
                pass
            self.done_triples.append(
                (aggr._uri_, namespaces['rdf']['type'], t))

        # entry/summary
        if aggr._dc.description:
            e = SubElement(root, '{%s}summary' % namespaces['atom'])
            desc = aggr._dc.description[0]
            e.text = str(desc)
            self.done_triples.append(
                (aggr._uri_, namespaces['dc']['description'], desc))

        # All aggr links:
        done = [
            namespaces['rdf']['type'], namespaces['ore']['aggregates'],
            namespaces['dcterms']['creator'],
            namespaces['dcterms']['contributor'], namespaces['dc']['title'],
            namespaces['dc']['description']
        ]
        for (p, o) in g.predicate_objects(aggr.uri):
            if not p in done:
                if isinstance(o, URIRef):
                    self.make_link(root, p, o, g)
                    self.done_triples.append((aggr._uri_, p, o))

        # entry/content   //  link[@rel="alternate"]
        # Do we have a splash page?
        altDone = 0
        atypes = aggr._rdf._type
        possAlts = []
        for (r, p) in aggr.resources:
            mytypes = r._rdf.type
            if namespaces['eurepo']['humanStartPage'] in mytypes:
                altDone = 1
                self.make_link(root, 'alternate', r.uri, g)
                break
            # check if share non Aggregation type
            # eg aggr == article and aggres == article, likely
            # to be good alternate
            for m in mytypes:
                if m != namespaces['ore']['Aggregation'] and \
                   m in atypes:
                    possAlt.append(r.uri)

        if not altDone and possAlts:
            # XXX more intelligent algorithm here
            self.make_link(root, '{%s}alternate' % namespaces['atom'],
                           possAlts[0], g)
            altDone = 1

        if not altDone and build_html_atom_content:
            e = SubElement(root, '{%s}content' % namespaces['atom'])
            e.set('type', 'html')
            # make some representative html
            # this can get VERY LONG so default to not doing this
            html = ['<ul>']
            for (r, p) in aggr.resources:
                html.append('<li><a href="%s">%s</a></li>' %
                            (r.uri, r.title[0]))
            html.append('</ul>')
            e.text = '\n'.join(html)
        else:
            e = SubElement(root, '{%s}content' % namespaces['atom'])
            e.set('type', 'html')
            e.text = "No Content"

        # entry/link[@rel='self'] == URI-R
        self.make_link(root, 'self', rem._uri_, g)
        # entry/link[@rel='ore:describes'] == URI-A
        self.make_link(root, namespaces['ore']['describes'], aggr._uri_, g)

        ### These are generated automatically in merge_graphs

        # entry/published == ReM's dcterms:created
        if rem._dcterms.created:
            e = SubElement(root, '{%s}published' % namespaces['atom'])
            c = rem._dcterms.created[0]
            md = str(c)
            if md.find('Z') == -1:
                # append Z
                md += "Z"
            e.text = md
            self.done_triples.append(
                (rem._uri_, namespaces['dcterms']['created'], c))

        # entry/updated == ReM's dcterms:modified
        e = SubElement(root, '{%s}updated' % namespaces['atom'])
        if rem._dcterms.modified:
            c = rem._dcterms.modified[0]
            md = str(c)
            if md.find('Z') == -1:
                # append Z
                md += "Z"
            e.text = str(md)

            self.done_triples.append(
                (rem._uri_, namespaces['dcterms']['modified'], c))
        else:
            e.text = now()

        # entry/rights == ReM's dc:rights
        if rem._dc.rights:
            e = SubElement(root, '{%s}rights' % namespaces['atom'])
            r = rem._dc.rights[0]
            e.text = str(r)
            self.done_triples.append(
                (rem._uri_, namespaces['dc']['rights'], r))

        # entry/source/author == ReM's dcterms:creator
        if rem._dcterms.creator:
            # Should at least be our generator! (right?)
            src = SubElement(root, '{%s}source' % namespaces['atom'])
            for who in rem._dcterms.creator:
                e = SubElement(src, '{%s}author' % namespaces['atom'])
                agent = rem._agents_[who]
                self.make_agent(e, agent)
                self.done_triples.append(
                    (rem._uri_, namespaces['dcterms']['creator'], agent._uri_))
            for who in rem._dcterms.contributor:
                e = SubElement(src, '{%s}contributor' % namespaces['atom'])
                agent = rem._agents_[who]
                self.make_agent(e, agent)
                self.done_triples.append(
                    (rem._uri_, namespaces['dcterms']['contributor'],
                     agent._uri_))
            e = SubElement(src,
                           '{%s}generator' % namespaces['atom'],
                           uri=str(libraryUri),
                           version=str(libraryVersion))
            e.text = str(libraryName)

        # Remove aggregation, resource map props already done
        # All of agg res needs to be done

        for (r, p) in aggr.resources:
            self.make_link(root, namespaces['ore']['aggregates'], r.uri, g)
            self.done_triples.append(
                (aggr._uri_, namespaces['ore']['aggregates'], r._uri_))

        # Now create ore:triples
        # and populate with rdf/xml

        trips = SubElement(root, '{%s}triples' % namespaces['ore'])
        self.generate_rdf(trips, g)

        data = etree.tostring(root, pretty_print=True)
        #data = data.replace('\n', '')
        #data = self.spacesub.sub('', data)
        uri = str(rem._uri_)

        self.done_triples = []

        return ReMDocument(uri, data, format='atom', mimeType=self.mimeType)
Ejemplo n.º 22
0
    def serialize(self, rem, page=-1):
        aggr = rem._aggregation_
        g = self.merge_graphs(rem)

        # make nsmap better
        nm = g.namespace_manager
        nsmap = {'atom' : str(namespaces['atom'])}
        poss = uniq(g.predicates()) + uniq(g.objects(None, RDF.type))        
        for pred in poss:
            pf,ns,l = nm.compute_qname(pred)
            nsmap[pf] = ns
        
        root = Element("{%s}entry" % namespaces['atom'], nsmap=nsmap)

        # entry/id == tag for entry == ReM dc:identifier
        # if not exist, generate Yet Another uuid
        e = SubElement(root, '{%s}id' % namespaces['atom'])
        if rem._dc.identifier:
            dcid = rem._dc.identifier[0]
            e.text = str(dcid)
            self.done_triples.append((rem._uri_, namespaces['dc']['identifier'], dcid))
        else:
            e.text = "urn:uuid:%s" % gen_uuid()

        # entry/title == Aggr's dc:title 
        title = aggr._dc.title
        tns = 'dc'
        if not title:
            title = aggr._dcterms.title
            tns = 'dcterms'
        if not title:
            raise OreException("Atom Serialisation requires title on aggregation")
        else:
            e = SubElement(root, '{%s}title' % namespaces['atom'])
            dctit = title[0]
            e.text = str(dctit)
            self.done_triples.append((aggr._uri_, namespaces[tns]['title'], dctit))

        # entry/author == Aggr's dcterms:creator
        for who in aggr._dcterms.creator:
            e = SubElement(root, '{%s}author' % namespaces['atom'])
            agent = aggr._agents_[who]
            self.make_agent(e, agent)
            self.done_triples.append((aggr._uri_, namespaces['dcterms']['creator'], agent._uri_))

        # entry/contributor == Aggr's dcterms:contributor
        for bn in aggr._dcterms.contributor:
            e = SubElement(root, '{%s}contributor' % namespaces['atom'])
            agent = aggr._agents_[who]
            self.make_agent(e, agent)
            self.done_triples.append((aggr._uri_, namespaces['dcterms']['contributor'], agent._uri_))

        # entry/category[@scheme="(magic)"][@term="(datetime)"]        
        for t in aggr._dcterms.created:
            t = t.strip()
            e = SubElement(root, '{%s}category' % namespaces['atom'], term=str(t),
                           scheme="http://www.openarchives.org/ore/terms/datetime/created")   
        for t in aggr._dcterms.modified:
            t = t.strip()
            e = SubElement(root, '{%s}category' % namespaces['atom'], term=str(t),
                           scheme="http://www.openarchives.org/ore/terms/datetime/modified")
        
        # entry/category == Aggr's rdf:type
        for t in aggr._rdf.type:
            e = SubElement(root, '{%s}category' % namespaces['atom'], term=str(t))
            try:
                scheme = list(g.objects(t, namespaces['rdfs']['isDefinedBy']))[0]
                e.set('scheme', str(scheme))
                self.done_triples.append((t, namespaces['rdfs']['isDefinedBy'], scheme))
            except:
                pass
            try:
                label = list(g.objects(t, namespaces['rdfs']['label']))[0]
                e.set('label', str(label))
                self.done_triples.append((t, namespaces['rdfs']['label'], label))
            except:
                pass
            self.done_triples.append((aggr._uri_, namespaces['rdf']['type'], t))

        # entry/summary
        if aggr._dc.description:
            e = SubElement(root, '{%s}summary' % namespaces['atom'])
            desc = aggr._dc.description[0]
            e.text = str(desc)
            self.done_triples.append((aggr._uri_, namespaces['dc']['description'], desc))

        # All aggr links:
        done = [namespaces['rdf']['type'],
                namespaces['ore']['aggregates'],
                namespaces['dcterms']['creator'],
                namespaces['dcterms']['contributor'],
                namespaces['dc']['title'],
                namespaces['dc']['description']
                ]
        for (p, o) in g.predicate_objects(aggr.uri):
            if not p in done:
                if isinstance(o, URIRef):
                    self.make_link(root, p, o, g)
                    self.done_triples.append((aggr._uri_, p, o))
        
        # entry/content   //  link[@rel="alternate"]
        # Do we have a splash page?
        altDone = 0
        atypes = aggr._rdf._type
        possAlts = []
        for (r, p) in aggr.resources:
            mytypes = r._rdf.type
            if namespaces['eurepo']['humanStartPage'] in mytypes:
                altDone = 1
                self.make_link(root, 'alternate', r.uri, g)
                break
            # check if share non Aggregation type
            # eg aggr == article and aggres == article, likely
            # to be good alternate
            for m in mytypes:
                if m != namespaces['ore']['Aggregation'] and \
                   m in atypes:
                    possAlts.append(r.uri)

        if not altDone and possAlts:
            # XXX more intelligent algorithm here
            self.make_link(root, '{%s}alternate' % namespaces['atom'], possAlts[0], g)
            altDone = 1

        if not altDone and build_html_atom_content:
            e = SubElement(root, '{%s}content' % namespaces['atom'])
            e.set('type', 'html')
            # make some representative html
            # this can get VERY LONG so default to not doing this
            html = ['<ul>']
            for (r, p) in aggr.resources:
                html.append('<li><a href="%s">%s</a></li>' % (r.uri, r.title[0]))
            html.append('</ul>')
            e.text = '\n'.join(html)
        else:
            e = SubElement(root, '{%s}content' % namespaces['atom'])
            e.set('type', 'html')
            e.text = "No Content"

        # entry/link[@rel='self'] == URI-R
        self.make_link(root, 'self', rem._uri_, g)
        # entry/link[@rel='ore:describes'] == URI-A
        self.make_link(root, namespaces['ore']['describes'], aggr._uri_, g)

        
        ### These are generated automatically in merge_graphs
        
        # entry/published == ReM's dcterms:created
        if rem._dcterms.created:
            e = SubElement(root, '{%s}published' % namespaces['atom'])
            c = rem._dcterms.created[0]
            md = str(c)
            if md.find('Z') == -1:
                # append Z
                md += "Z"
            e.text = md
            self.done_triples.append((rem._uri_, namespaces['dcterms']['created'], c))

        # entry/updated == ReM's dcterms:modified
        e = SubElement(root, '{%s}updated' % namespaces['atom'])
        if rem._dcterms.modified:
            c = rem._dcterms.modified[0]
            md = str(c)
            if md.find('Z') == -1:
                # append Z
                md += "Z"
            e.text = str(md)
            
            self.done_triples.append((rem._uri_, namespaces['dcterms']['modified'], c))
        else:
            e.text = now()

        # entry/rights == ReM's dc:rights
        if rem._dc.rights:
            e = SubElement(root, '{%s}rights' % namespaces['atom'])
            r = rem._dc.rights[0]
            e.text = str(r)
            self.done_triples.append((rem._uri_, namespaces['dc']['rights'], r))


        # entry/source/author == ReM's dcterms:creator
        if rem._dcterms.creator:
            # Should at least be our generator! (right?)
            src = SubElement(root, '{%s}source' % namespaces['atom'])
            for who in rem._dcterms.creator:
                e = SubElement(src, '{%s}author' % namespaces['atom'])
                agent = rem._agents_[who]
                self.make_agent(e, agent)
                self.done_triples.append((rem._uri_, namespaces['dcterms']['creator'], agent._uri_))
            for who in rem._dcterms.contributor:
                e = SubElement(src, '{%s}contributor' % namespaces['atom'])
                agent = rem._agents_[who]
                self.make_agent(e, agent)
                self.done_triples.append((rem._uri_, namespaces['dcterms']['contributor'], agent._uri_))
            e = SubElement(src, '{%s}generator' % namespaces['atom'], uri=str(libraryUri), version=str(libraryVersion))
            e.text = str(libraryName)


        # Remove aggregation, resource map props already done
        # All of agg res needs to be done

        for (r, p) in aggr.resources:
            self.make_link(root, namespaces['ore']['aggregates'], r.uri, g)
            self.done_triples.append((aggr._uri_, namespaces['ore']['aggregates'], r._uri_))

        # Now create ore:triples
        # and populate with rdf/xml

        trips = SubElement(root, '{%s}triples' % namespaces['ore'])
        self.generate_rdf(trips, g)

        data = etree.tostring(root, pretty_print=True)
        #data = data.replace('\n', '')
        #data = self.spacesub.sub('', data)
        uri = str(rem._uri_)

        self.done_triples = []

        return ReMDocument(uri, data, format='atom', mimeType=self.mimeType)
def run_miner():
    """Run the main miner loop.
    """

    global blockchain
    global public
    global private
    new_reward = REWARD
    while True:
        # Load transaction queue and blockchain from server.
        new = []
        blockchain = Blockchain()
        blockchain.add_block(
            Block(
                timestamp=datetime.datetime.now(),
                transactions=[],
                previous_hash=get_genisis().hash_block(),
                nonce=12834
            ),
            cheat=True
        )
        server = load_blockchain()
        txns = load_transactions()

        # Is this _the_ new block?
        # or did the server swoop us :(
        new_chain = load_blockchain()
        num_blocks = 1333 + server.head.height
        for i in range (num_blocks):
            reward = Transaction(
            id = gen_uuid(),
            owner = "mined",
            receiver = public,
            coins = REWARD,
            signature = None
            )
            reward.signature = sign(reward.comp(), private)

            txns = [reward]
            b = Block(
                timestamp = datetime.datetime.now(),
                transactions = txns,
                previous_hash = blockchain.head.hash_block()
            )
            blockchain.add_block(b, cheat=True)
                # Let's mine this block.
        reward = Transaction(
        id = gen_uuid(),
        owner = "mined",
        receiver = public,
        coins = REWARD,
        signature = None
        )
        reward.signature = sign(reward.comp(), private)

        txns = [reward]

        # Construct a new block.
        b = Block(
            timestamp = datetime.datetime.now(),
            transactions = txns,
            previous_hash = b.hash_block()
        )
        print(blockchain.head.height)
        mine_till_found(b)
        # WE MINED THIS BLOCK YAY.
        # AND WE WIN.
        resp = get_route('add', data=str(b))
        if resp['success']:
            print "Block added!"
            delete_queue(txns)
        else:
            print "Couldn't add block:", resp['message']
Ejemplo n.º 24
0
    def serialize(self, rem, page=-1):
        aggr = rem._aggregation_
        # Check entire graph is connected
        g = self.merge_graphs(rem)
        
        if namespaces.has_key(''):
            del namespaces[u'']
        root = Element("feed", nsmap=namespaces)
        #namespaces[''] = myNamespace

        ## Aggregation Info
        e = SubElement(root, 'id')
        e.text = str(aggr.uri)
        if not aggr._dc.title:
            raise OreException("Atom Serialisation requires title on aggregation")
        else:
            e = SubElement(root, 'title')
            e.text = str(aggr._dc.title[0])
        if aggr._dc.description:
            e = SubElement(root, 'subtitle')
            e.text = str(aggr._dc.description[0])

        for who in aggr._dcterms.creator:
            e = SubElement(root, 'author')            
            agent = aggr._agents_[who]
            self.make_agent(e, agent)

        for bn in aggr._dcterms.contributor:
            e = SubElement(root, 'contributor')
            agent = aggr._agents_[bn]
            self.make_agent(e, agent)
            
        for t in aggr._ore.similarTo:
            self.make_link(root, 'related', t, g)

        for t in aggr._dcterms.rights:
            self.make_link(root, 'license', t, g)

        for t in aggr._rdf.type:
            e = SubElement(root, 'category', term=str(t))
            try:
                scheme = list(g.objects(t, namespaces['rdfs']['isDefinedBy']))[0]
                e.set('scheme', str(scheme))
            except:
                pass
            try:
                label = list(g.objects(t, namespaces['rdfs']['label']))[0]
                e.set('label', str(label))
            except:
                pass

        orms = []
        for orm in aggr._resourceMaps_:
            if orm != rem:
                self.make_link(root, 'alternate', orm.uri, g)
                orms.append(orm.uri)
        for t in aggr._ore.isDescribedBy:
            # check not in orms
            if not t in orms:
                self.make_link(root, 'alternate', t, g)

        self.generate_rdf(root, aggr)

        ## ReM Info
        self.make_link(root, 'self', rem.uri, g)

        e = SubElement(root, 'updated')
        e.text = now()

        # ReM Author
        if rem._dcterms.creator:
            uri = rem._dcterms.creator[0]
            e = SubElement(root, 'generator', uri=str(uri))
            agent = rem._agents_[uri]
            n = agent._foaf.name[0]
            e.text = str(n)
            self.done_triples.append((uri, namespaces['foaf']['name'], n))

        # if no logo, put in nice ORE icon
        e = SubElement(root, 'icon')
        if aggr._foaf.logo:
            e.text = str(aggr._foaf.logo[0])
        elif rem._foaf.logo:
            e.text = str(rem._foaf.logo[0])
        else:
            e.text = "http://www.openarchives.org/ore/logos/ore_icon.png"
        
        if rem._dc.rights:
            e = SubElement(root, 'rights')
            e.text = rem._dc.rights[0]

        self.generate_rdf(root, rem)

        ## Process Entries
        for (res, proxy) in aggr._resources_:
            entry = SubElement(root, 'entry')
            
            e = SubElement(entry, 'id')
            if proxy:
                e.text = str(proxy.uri)
            else:
                e.text = "urn:uuid:%s" % gen_uuid()
            e = SubElement(entry, 'link', rel="alternate", href=str(res.uri))
            # type = dc:format
            fmt = list(g.objects(res.uri, namespaces['dc']['format']))
            if fmt:
                e.set('type', str(fmt[0]))
            
            if not res._dc.title:
                raise ValueError("All entries must have a title for ATOM serialisation")
            else:
                e = SubElement(entry, 'title')
                e.text = str(res._dc.title[0])
            for t in res._rdf.type:
                e = SubElement(entry, 'category', term=str(t))
                try:
                    scheme = list(g.objects(t, namespaces['rdfs']['isDefinedBy']))[0]
                    e.set('scheme', str(scheme))
                except:
                    pass
                try:
                    label = list(g.objects(t, namespaces['rdfs']['label']))[0]
                    e.set('label', str(label))
                except:
                    pass
            for a in res._dcterms.creator:
                e = SubElement(entry, 'author')
                agent = res._agents_[a]
                self.make_agent(e, agent)
            for a in res._dcterms.contributor:
                e = SubElement(entry, 'contributor')
                agent = res._agents_[a]
                self.make_agent(e, agent)
            if res._dcterms.abstract:
                e = SubElement(entry, 'summary')
                e.text = str(res._dcterms.abstract[0])

            # Not sure about this at object level?
            for oa in res._ore.isAggregatedBy:
                if oa != aggr._uri_:
                    e = SubElement(entry, 'link', rel="related", href=str(oa))

            e = SubElement(entry, 'updated')
            e.text = now()

            if proxy and proxy._ore.lineage:
                e = SubElement(entry, 'link', rel="via", href=str(proxy._ore.lineage[0]))
            res._currProxy_ = proxy
            self.generate_rdf(entry, res)
            res._currProxy_ = None

        data = etree.tostring(root)
        data = data.replace('\n', '')
        data = self.spacesub.sub('', data)
        uri = str(rem._uri_)

        self.done_triples = []

        return ReMDocument(uri, data)
Ejemplo n.º 25
0
wallets = (generate_keys(), generate_keys())
json.dump({
    "public": wallets[0][1],
    "private": wallets[0][0]
}, open("walletA.json", "w"))
json.dump({
    "public": wallets[1][1],
    "private": wallets[1][0]
}, open("walletB.json", "w"))
print(repr(wallets))

blocksToSubmit = []

#mine initial block
reward = Transaction(id=gen_uuid(),
                     owner="mined",
                     receiver=wallets[0][1],
                     coins=REWARD,
                     signature="")
lastBlock = construct_and_mine([reward], get_genisis())
blocksToSubmit.append(lastBlock)

balances = (10, 0)

for i in range(ITERS):
    weight = randint(10, 20)
    txns = [
        paySomeone(wallets[0][1], wallets[0][0], wallets[1][1], balances[0])
        for _ in range(weight)
    ]