Python Storage.update方法代码示例

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import update [as 别名]
class EvernoteController(object):
    def __init__(self, token, isSpecialToken = False, sandbox = False, isInternational = False, notebooks = None):
        self.token = token
        if sandbox:
            self.client = EvernoteClient(token=self.token)
        elif isInternational:
            self.client = EvernoteClient(token=self.token, service_host='www.evernote.com')
        else:
            self.client = EvernoteClient(token=self.token, service_host='app.yinxiang.com')
        self.isSpecialToken = isSpecialToken
        self.userStore = self.client.get_user_store()
        self.noteStore = self.client.get_note_store()
        self.storage = Storage(notebooks)
    def get_upload_limit(self):
        return {
            1: 25 * 1024 * 1024,
            3: 100 * 1024 * 1024,
            5: 200 * 1024 * 1024,
        }.get(self.userStore.getUser().privilege, 0)
    def create_notebook(self, noteFullPath):
        if self.get(noteFullPath): return False
        notebook = Types.Notebook()
        notebook.name = noteFullPath
        try:
            notebook = self.noteStore.createNotebook(notebook)
        except EDAMUserException, e:
            if e.errorCode == 10 and e.parameter == 'Notebook.name':
                self.storage.update(self.token, self.noteStore)
                return True
            else:
                raise e
        self.storage.create_notebook(notebook)
        return True

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import update [as 别名]
def read_config(config_file):
    '''Reads the ~/.goobookrc and ~/.netrc.
    returns the configuration as a dictionary.

    '''
    config = Storage({ # Default values
        'email': '',
        'password': '',
        'max_results': '9999',
        'cache_filename': '~/.goobook_cache',
        'cache_expiry_hours': '24',
        })
    config_file = os.path.expanduser(config_file)
    if os.path.lexists(config_file) or os.path.lexists(config_file + '.gpg'):
        try:
            parser = ConfigParser.SafeConfigParser()
            if os.path.lexists(config_file):
                log.info('Reading config: %s', config_file)
                f = open(config_file)
            else:
                log.info('Reading config: %s', config_file + '.gpg')
                sp = subprocess.Popen(['gpg', '--no-tty', '-q', '-d', config_file + ".gpg"], stdout=subprocess.PIPE)
                f = sp.stdout
            parser.readfp(f)
            config.update(dict(parser.items('DEFAULT', raw=True)))
        except (IOError, ConfigParser.ParsingError), e:
            print >> sys.stderr, "Failed to read configuration %s\n%s" % (config_file, e)
            sys.exit(1)

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import update [as 别名]
 def get_env(self, env=None):
     e = Storage(self.env.copy())
     if env:
         e.update(env)
     return e

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import update [as 别名]
class FORM(DIV):

    """
    example::

        >>> form=FORM(INPUT(_name=\"test\", requires=IS_NOT_EMPTY()))
        >>> form.xml()
        '<form action=\"\" enctype=\"multipart/form-data\" method=\"post\"><input name=\"test\" type=\"text\" /></form>'

    a FORM is container for INPUT, TEXTAREA, SELECT and other helpers

    form has one important method::

        form.accepts(request.vars, session)

    if form is accepted (and all validators pass) form.vars contains the
    accepted vars, otherwise form.errors contains the errors.
    in case of errors the form is modified to present the errors to the user.
    """

    tag = 'form'

    def __init__(self, *components, **attributes):
        if self.tag[-1:] == '/' and components:
            raise SyntaxError, '<%s> tags cannot have components' % self.tag
        if len(components) == 1 and isinstance(components[0], (list,
                tuple)):
            self.components = list(components[0])
        else:
            self.components = list(components)
        self.attributes = attributes
        self._fixup()
        # converts special attributes in components attributes
        self._postprocessing()
        self.vars = Storage()
        self.errors = Storage()
        self.latest = Storage()

    def accepts(
        self,
        vars,
        session=None,
        formname='default',
        keepvalues=False,
        onvalidation=None,
        ):
        self.errors.clear()
        self.request_vars = Storage()
        self.request_vars.update(vars)
        self.session = session
        self.formname = formname
        self.keepvalues = keepvalues

        # if this tag is a form and we are in accepting mode (status=True)
        # check formname and formkey

        status = True
        if self.session and self.session.get('_formkey[%s]'
                 % self.formname, None) != self.request_vars._formkey:
            status = False
        if self.formname != self.request_vars._formname:
            status = False
        status = self._traverse(status)
        if status and onvalidation:
            onvalidation(self)
        if self.errors:
            status = False
        if session != None:
            self.formkey = session['_formkey[%s]' % formname] = web2py_uuid()
        if status and not keepvalues:
            self._traverse(False)
        return status

    def _postprocessing(self):
        if not '_action' in self.attributes:
            self['_action'] = ''
        if not '_method' in self.attributes:
            self['_method'] = 'post'
        if not '_enctype' in self.attributes:
            self['_enctype'] = 'multipart/form-data'

    def hidden_fields(self):
        c = []
        if 'hidden' in self.attributes:
            for (key, value) in self.attributes.get('hidden',
                    {}).items():
                c.append(INPUT(_type='hidden', _name=key, _value=value))
        if hasattr(self, 'formkey') and self.formkey:
            c.append(INPUT(_type='hidden', _name='_formkey',
                     _value=self.formkey))
        if hasattr(self, 'formname') and self.formname:
            c.append(INPUT(_type='hidden', _name='_formname',
                     _value=self.formname))
        return DIV(c, _class="hidden")

    def xml(self):
        newform = FORM(*self.components, **self.attributes)
        hidden_fields = self.hidden_fields()
        if hidden_fields.components:
            newform.append(hidden_fields)
#.........这里部分代码省略.........

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import update [as 别名]
def load_routers(all_apps):
    "load-time post-processing of routers"

    for app in routers.keys():
        # initialize apps with routers that aren't present, on behalf of unit tests
        if app not in all_apps:
            all_apps.append(app)
            router = Storage(routers.BASE)   # new copy
            if app != 'BASE':
                for key in routers[app].keys():
                    if key in ROUTER_BASE_KEYS:
                        raise SyntaxError, "BASE-only key '%s' in router '%s'" % (key, app)
            router.update(routers[app])
            routers[app] = router
        router = routers[app]
        for key in router.keys():
            if key not in ROUTER_KEYS:
                raise SyntaxError, "unknown key '%s' in router '%s'" % (key, app)
        if not router.controllers:
            router.controllers = set()
        elif not isinstance(router.controllers, str):
            router.controllers = set(router.controllers)
        if router.languages:
            router.languages = set(router.languages)
        else:
            router.languages = set()
        if app != 'BASE':
            for base_only in ROUTER_BASE_KEYS:
                router.pop(base_only, None)
            if 'domain' in router:
                routers.BASE.domains[router.domain] = app
            if isinstance(router.controllers, str) and router.controllers == 'DEFAULT':
                router.controllers = set()
                if os.path.isdir(abspath('applications', app)):
                    cpath = abspath('applications', app, 'controllers')
                    for cname in os.listdir(cpath):
                        if os.path.isfile(abspath(cpath, cname)) and cname.endswith('.py'):
                            router.controllers.add(cname[:-3])
            if router.controllers:
                router.controllers.add('static')
                router.controllers.add(router.default_controller)
            if router.functions:
                if isinstance(router.functions, (set, tuple, list)):
                    functions = set(router.functions)
                    if isinstance(router.default_function, str):
                        functions.add(router.default_function)  # legacy compatibility
                    router.functions = { router.default_controller: functions }
                for controller in router.functions:
                    router.functions[controller] = set(router.functions[controller])
            else:
                router.functions = dict()

    if isinstance(routers.BASE.applications, str) and routers.BASE.applications == 'ALL':
        routers.BASE.applications = list(all_apps)
    if routers.BASE.applications:
        routers.BASE.applications = set(routers.BASE.applications)
    else:
        routers.BASE.applications = set()

    for app in routers.keys():
        # set router name
        router = routers[app]
        router.name = app
        # compile URL validation patterns
        router._acfe_match = re.compile(router.acfe_match)
        router._file_match = re.compile(router.file_match)
        if router.args_match:
            router._args_match = re.compile(router.args_match)
        # convert path_prefix to a list of path elements
        if router.path_prefix:
            if isinstance(router.path_prefix, str):
                router.path_prefix = router.path_prefix.strip('/').split('/')

    #  rewrite BASE.domains as tuples
    #
    #      key:   'domain[:port]' -> (domain, port)
    #      value: 'application[/controller] -> (application, controller)
    #      (port and controller may be None)
    #
    domains = dict()
    if routers.BASE.domains:
        for (domain, app) in [(d.strip(':'), a.strip('/')) for (d, a) in routers.BASE.domains.items()]:
            port = None
            if ':' in domain:
                (domain, port) = domain.split(':')
            ctlr = None
            fcn = None
            if '/' in app:
                (app, ctlr) = app.split('/', 1)
            if ctlr and '/' in ctlr:
                (ctlr, fcn) = ctlr.split('/')
            if app not in all_apps and app not in routers:
                raise SyntaxError, "unknown app '%s' in domains" % app
            domains[(domain, port)] = (app, ctlr, fcn)
    routers.BASE.domains = domains

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import update [as 别名]
        #  scan each app in applications/
        #    create a router, if routers are in use
        #    parse the app-specific routes.py if present
        #
        all_apps = []
        for appname in [app for app in os.listdir(abspath('applications')) if not app.startswith('.')]:
            if os.path.isdir(abspath('applications', appname)) and \
               os.path.isdir(abspath('applications', appname, 'controllers')):
                all_apps.append(appname)
                if routers:
                    router = Storage(routers.BASE)   # new copy
                    if appname in routers:
                        for key in routers[appname].keys():
                            if key in ROUTER_BASE_KEYS:
                                raise SyntaxError, "BASE-only key '%s' in router '%s'" % (key, appname)
                        router.update(routers[appname])
                    routers[appname] = router
                if os.path.exists(abspath('applications', appname, routes)):
                    load(routes, appname)

        if routers:
            load_routers(all_apps)

    else: # app
        params_apps[app] = p
        if routers and p.routers:
            if app in p.routers:
                routers[app].update(p.routers[app])

    logger.debug('URL rewrite is on. configuration in %s' % path)

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import update [as 别名]
class FORM(DIV):

    """
    example::

        >>> from validators import IS_NOT_EMPTY
        >>> form=FORM(INPUT(_name=\"test\", requires=IS_NOT_EMPTY()))
        >>> form.xml()
        '<form action=\"\" enctype=\"multipart/form-data\" method=\"post\"><input name=\"test\" type=\"text\" /></form>'

    a FORM is container for INPUT, TEXTAREA, SELECT and other helpers

    form has one important method::

        form.accepts(request.vars, session)

    if form is accepted (and all validators pass) form.vars contains the
    accepted vars, otherwise form.errors contains the errors.
    in case of errors the form is modified to present the errors to the user.
    """

    tag = "form"

    def __init__(self, *components, **attributes):
        DIV.__init__(self, *components, **attributes)
        self.vars = Storage()
        self.errors = Storage()
        self.latest = Storage()

    def accepts(self, vars, formname="default", keepvalues=False, onvalidation=None, hideerror=False):
        if vars.__class__.__name__ == "Request":
            vars = vars.post_vars
        self.errors.clear()
        self.request_vars = Storage()
        self.request_vars.update(vars)
        self.formname = formname
        self.keepvalues = keepvalues

        # if this tag is a form and we are in accepting mode (status=True)
        # check formname and formkey

        status = True
        status = self._traverse(status, hideerror)
        if onvalidation:
            if isinstance(onvalidation, dict):
                onsuccess = onvalidation.get("onsuccess", None)
                onfailure = onvalidation.get("onfailure", None)
                if onsuccess and status:
                    onsuccess(self)
                if onfailure and vars and not status:
                    onfailure(self)
                    status = len(self.errors) == 0
            elif status:
                if isinstance(onvalidation, (list, tuple)):
                    [f(self) for f in onvalidation]
                else:
                    onvalidation(self)
        if self.errors:
            status = False
        if status and not keepvalues:
            self._traverse(False, hideerror)
        return status

    def _postprocessing(self):
        if not "_action" in self.attributes:
            self["_action"] = ""
        if not "_method" in self.attributes:
            self["_method"] = "post"
        if not "_enctype" in self.attributes:
            self["_enctype"] = "multipart/form-data"

    def hidden_fields(self):
        c = []
        if "hidden" in self.attributes:
            for (key, value) in self.attributes.get("hidden", {}).items():
                c.append(INPUT(_type="hidden", _name=key, _value=value))

        if hasattr(self, "formkey") and self.formkey:
            c.append(INPUT(_type="hidden", _name="_formkey", _value=self.formkey))
        if hasattr(self, "formname") and self.formname:
            c.append(INPUT(_type="hidden", _name="_formname", _value=self.formname))
        return DIV(c, _class="hidden")

    def xml(self):
        newform = FORM(*self.components, **self.attributes)
        hidden_fields = self.hidden_fields()
        if hidden_fields.components:
            newform.append(hidden_fields)
        return DIV.xml(newform)

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import update [as 别名]
class Request(Storage):

    """
    defines the request object and the default values of its members

    - env: environment variables, by gluon.main.wsgibase()
    - cookies
    - get_vars
    - post_vars
    - vars
    - folder
    - application
    - function
    - args
    - extension
    - now: datetime.datetime.today()
    - restful()
    """

    def __init__(self, env):
        Storage.__init__(self)
        self.env = Storage(env)
        self.env.web2py_path = global_settings.applications_parent
        self.env.update(global_settings)
        self.cookies = Cookie.SimpleCookie()
        self._get_vars = None
        self._post_vars = None
        self._vars = None
        self._body = None
        self.folder = None
        self.application = None
        self.function = None
        self.args = List()
        self.extension = 'html'
        self.now = datetime.datetime.now()
        self.utcnow = datetime.datetime.utcnow()
        self.is_restful = False
        self.is_https = False
        self.is_local = False
        self.global_settings = settings.global_settings


    def parse_get_vars(self):
        query_string = self.env.get('QUERY_STRING','')
        dget = cgi.parse_qs(query_string, keep_blank_values=1)
        get_vars = self._get_vars = Storage(dget)
        for (key, value) in get_vars.iteritems():
            if isinstance(value,list) and len(value)==1:
                get_vars[key] = value[0]

    def parse_post_vars(self):
        env = self.env
        post_vars = self._post_vars = Storage()
        body = self.body
        #if content-type is application/json, we must read the body
        is_json = env.get('content_type', '')[:16] == 'application/json'

        if is_json:
            try:
                json_vars = sj.load(body)
            except:
                # incoherent request bodies can still be parsed "ad-hoc"
                json_vars = {}
                pass
            # update vars and get_vars with what was posted as json
            if isinstance(json_vars, dict):
                post_vars.update(json_vars)

            body.seek(0)

        # parse POST variables on POST, PUT, BOTH only in post_vars
        if (body and
                env.request_method in ('POST', 'PUT', 'DELETE', 'BOTH') and
                not is_json):
            dpost = cgi.FieldStorage(fp=body, environ=env, keep_blank_values=1)
            post_vars.update(dpost)
            # The same detection used by FieldStorage to detect multipart POSTs
            is_multipart = dpost.type[:10] == 'multipart/'
            body.seek(0)

            def listify(a):
                return (not isinstance(a, list) and [a]) or a
            try:
                keys = sorted(dpost)
            except TypeError:
                keys = []
            for key in keys:
                if key is None:
                    continue  # not sure why cgi.FieldStorage returns None key
                dpk = dpost[key]
                # if an element is not a file replace it with its value else leave it alone
                if isinstance(dpk, list):
                    value = []
                    for _dpk in dpk:
                        if not _dpk.filename:
                            value.append(_dpk.value)
                        else:
                            value.append(_dpk)
                elif not dpk.filename:
                    value = dpk.value
#.........这里部分代码省略.........

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import update [as 别名]
class Main(Frame):
    """
    Main class of the system.
    """

    def __init__(self, master=None):
        """
        Main contstructor. Creates an instance of :class:`Storage<storage.Storage>` and starts the graphics-window.
        """
        args = {
            "fields": ["name", "date", "lifetime"],
            "ident": "name",
            "uniqueident": True,
            "objectname": "person",
            "gui": self,
        }
        self.storage = Storage(**args)
        self.is_clicked = False
        self.clicked_id = -1
        Frame.__init__(self, master)
        self.master.title("Medlemsregister Cybernetisk Selskab")
        self.grid(padx=15, pady=15)

        if not self.storage._testfile():
            path = os.path.abspath(__file__).rsplit("/", 1)[0]
            self._popup(
                "ERROR!",
                'Cannot write to file! make sure folder "{}/medlemslister" exists, then restart..'.format(path),
                "error",
            )
            self.destroy()
            self.master.destroy()
            return

        self.create_elements()

        loadmsg = self.storage.load()
        if "error" in loadmsg:
            self.infotext.set("ERROR! {}".format(loadmsg["error"]))
        elif "success" in loadmsg:
            self.infotext.set("Success! {}".format(loadmsg["success"]))

        self._populate_list()

    def create_elements(self):
        """
        creates all graphics elements and places them in the graphics grid.
        """

        # global shortcuts
        self.master.bind("<F1>", self.display_help)
        self.master.bind("<Control-f>", self.search)
        self.master.bind("<Control-d>", self.delete)
        self.master.bind("<Control-r>", self._populate_list)
        self.master.bind("<Control-s>", self.save_to_file)

        monospace = tkFont.Font(family="Courier", size=10, weight="normal")

        # menubar:
        menubar = Menu(self.master)

        backupmenu = Menu(menubar, tearoff=0)
        backupmenu.add_command(label="Backup to Google (Note: Slow!)", command=self.google_write)
        backupmenu.add_command(label="Read backup from Google", command=self.google_read)
        backupmenu.add_separator()
        backupmenu.add_command(label="Merge with Wiki", command=self.wiki_merge)
        backupmenu.add_command(label="Overwrite Wiki with local storage", command=self.wiki_overwrite)

        specialmenu = Menu(menubar, tearoff=0)
        specialmenu.add_command(label="Set as lifetime member", command=self.set_lifetime)
        specialmenu.add_command(label="Remove lifetime membership", command=self.unset_lifetime)
        specialmenu.add_command(label="Change a users id", command=self.update_id)

        menubar.add_cascade(label="Backup", menu=backupmenu)
        menubar.add_cascade(label="Special Actions", menu=specialmenu)
        menubar.add_command(label="Help (F1)", command=self.display_help)

        self.master.config(menu=menubar)

        # Info-label
        self.infotext = StringVar()
        self.info = Label(self, textvariable=self.infotext)
        self.info.pack()
        self.info.grid(row=0, column=0, columnspan=10)
        self.infotext.set("Welcome")

        # Save-button
        self.savebtn = Button(self, text="Save (enter)", command=self.create, width=11)
        self.savebtn.grid(row=3, column=7)

        # Omnibar (entry-field for add/search/delete)
        self.omnibar = Entry(self, width=28)
        self.omnibar.grid(row=3, column=0, columnspan=1)
        self.omnibar.bind("<Return>", self.create)
        self.omnibar.configure(font=monospace)

        # List of members
        self.memlist = SL(self, height=25, width=71, callback=self._click_list)
        self.memlist.grid(row=7, column=0, columnspan=10)
        self.memlist.listbox.configure(font=monospace)
#.........这里部分代码省略.........