Пример #1
0
 def _import(self, db, data, flags):
     # clrln()
     # sys.stdout.write("writing node %s" % self.node)
     if self.node_type is str:
         f = bytemaps.StrStorage
         method = todb.import_string
     elif self.node_type is list:
         f = bytemaps.ListStorage
         method = todb.import_list
     elif self.node_type is dict:
         f = bytemaps.DictStorage
         for key in data:
             data[key] = self.wrap(key, data[key])
         method = todb.import_dict
     elif self.node_type is Set:
         f = bytemaps.ListStorage
         method = todb.import_set
     else:
         raise NodeTypeError(self)
     merge = bytemaps.is_set(flags, f.is_merge)
     assume_yes = bytemaps.is_set(flags, f.assume_yes)
     node_exists = self.exists(db)
     verbose = bytemaps.is_set(flags, f.verbose)
     if not merge and node_exists:
         if assume_yes and not verbose:
             c = True
         else:
             c = confirm("%s already exists. It will be DELETED before writing new data." % self.node, assume_yes)
         if not c:
             return
         else:
             db.delete(self.node)
     method(db, self.node, data, flags)
Пример #2
0
def import_dict (db, node, data, flags):
    """
    @param db the redis database connection
    @param prefix everything up to the specific dictionary being
        imported (widgets.numero_uno.events)
    @name The specific name of this particular dictionary
        (1) -> widgets.numero_uno.events.1
    @data the dictionary
    @flags a bit-masked integral type that will determine certain 
        specifics (merge/replace, etc.)
    There is no return type for this function.
    """
    testing = b.is_set(flags, b.DictStorage.is_test)
    if testing:
        b.set_bit(flags, b.DictStorage.assume_yes)
    for entry in data:
        entry_exists = db.hexists(node, entry)
        if entry_exists and not b.is_set(flags, b.DictStorage.is_merge):
            __continue = confirm(
                    "%s:%s already exists in your node and will be overwritten." % (node, entry),
                    (b.is_set(flags, b.DictStorage.assume_yes)))
            if not __continue:
                continue
            data[entry] = clean_string(data[entry])
        if not testing:
            db.hset(node, entry, data[entry])
Пример #3
0
def import_string(db, node, data, flags):
    data = clean_string(data)
    testing = b.is_set(flags, b.StrStorage.is_test) 
    merge = b.is_set(flags, b.StrStorage.is_merge) #unimplemented
    yes = b.is_set(flags, b.StrStorage.assume_yes)

    entry_exists = db.exists(node)
    if entry_exists and not merge:
        __continue = confirm(
                "%s already exists in the database and will be overwritten." %node,
                (b.is_set(flags, b.DictStorage.assume_yes)))
        if not __continue:
            return
    if not testing:
        db.set(node, data)
Пример #4
0
def import_list(db, node, data, flags):
    testing = b.is_set(flags, b.ListStorage.is_test)
    if testing:
        b.set_bit(flags, b.ListStorage.assume_yes)
    if isinstance(data[0], (str,int)):
        new_list = []
        merging     = b.is_set(flags, b.ListStorage.is_merge)
        
        if merging:
            no_repeat   = b.is_set(flags, b.ListStorage.merge_no_repeat)
            current_list = r.full_list(db, node)
            new_list.extend(current_list)

            for entry in data:
                if entry in new_list and no_repeat:
                    while entry in new_list:
                        new_list.remove(entry)
                new_list.append(entry)
        else:
            new_list.extend(data)
       
        for entry in new_list:
            if not testing:
                db.rpush(node, entry)
   
    elif isinstance(data[0], dict):
        if not merging:
            dictset = db.keys(node+".*")
            for n in dictset:
                db.delete(n)
        dictset = db.keys(node+".*")
        num = len(dictset)
        for entry in data:
            nn = "%s.%d" % (node,num)
            fl =0
            if testing:
                b.set_bit(fl, b.DictStorage.is_test)
            if merging:
                set_bit(fl, b.DictStorage.is_merge)
            if b.is_set(flags, b.ListStorage.assume_yes):
                set_bit(fl, b.DictStorage.assume_yes)
            import_dict(db, nn, data[num], fl)
            num += 1
Пример #5
0
def import_set(db, node, data, flags):
    testing = b.is_set(flags, b.ListStorage.is_test)
    for element in data:
        db.sadd(node, element)