signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def rlen(self): | n = <NUM_LIT:0><EOL>for a in self.real():<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT>return n<EOL> | Get the number of I{real} attributes which exclude xs and xml
attributes.
@return: A count of I{real} attributes.
@rtype: L{int} | f9714:c0:m2 |
def lang(self): | for a in self.raw:<EOL><INDENT>if a.qname() == '<STR_LIT>':<EOL><INDENT>return a.value<EOL><DEDENT>return None<EOL><DEDENT> | Get list of I{filtered} attributes which exclude xs.
@return: A list of I{filtered} attributes.
@rtype: I{generator} | f9714:c0:m3 |
def skip(self, attr): | ns = attr.namespace()<EOL>skip = (<EOL>Namespace.xmlns[<NUM_LIT:1>],<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>)<EOL>return Namespace.xs(ns) or ns[<NUM_LIT:1>] in skip<EOL> | Get whether to skip (filter-out) the specified attribute.
@param attr: An attribute.
@type attr: I{Attribute}
@return: True if should be skipped.
@rtype: bool | f9714:c0:m4 |
def process(self, content): | self.reset()<EOL>return self.append(content)<EOL> | Process an object graph representation of the xml I{node}.
@param content: The current content being unmarshalled.
@type content: L{Content}
@return: A suds object.
@rtype: L{Object} | f9716:c0:m0 |
def append(self, content): | self.start(content)<EOL>self.append_attributes(content)<EOL>self.append_children(content)<EOL>self.append_text(content)<EOL>self.end(content)<EOL>return self.postprocess(content)<EOL> | Process the specified node and convert the XML document into
a I{suds} L{object}.
@param content: The current content being unmarshalled.
@type content: L{Content}
@return: A I{append-result} tuple as: (L{Object}, I{value})
@rtype: I{append-result}
@note: This is not the proper entry point.
@see: L{process()} | f9716:c0:m1 |
def postprocess(self, content): | node = content.node<EOL>if len(node.children) and node.hasText():<EOL><INDENT>return node<EOL><DEDENT>attributes = AttrList(node.attributes)<EOL>if (<EOL>attributes.rlen() and<EOL>not len(node.children) and<EOL>node.hasText()<EOL>):<EOL><INDENT>p = Factory.property(node.name, node.getText())<EOL>return merge(content.data, p)<EOL><DEDENT>if len(content.data):<EOL><INDENT>return content.data<EOL><DEDENT>lang = attributes.lang()<EOL>if content.node.isnil():<EOL><INDENT>return None<EOL><DEDENT>if not len(node.children) and content.text is None:<EOL><INDENT>if self.nillable(content):<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return Text('<STR_LIT>', lang=lang)<EOL><DEDENT><DEDENT>if isinstance(content.text, basestring):<EOL><INDENT>return Text(content.text, lang=lang)<EOL><DEDENT>else:<EOL><INDENT>return content.text<EOL><DEDENT> | Perform final processing of the resulting data structure as follows:
- Mixed values (children and text) will have a result of the
I{content.node}.
- Semi-simple values (attributes, no-children and text) will have a
result of a property object.
- Simple values (no-attributes, no-children with text nodes) will
have a string result equal to the value of the
content.node.getText().
@param content: The current content being unmarshalled.
@type content: L{Content}
@return: The post-processed result.
@rtype: I{any} | f9716:c0:m2 |
def append_attributes(self, content): | attributes = AttrList(content.node.attributes)<EOL>for attr in attributes.real():<EOL><INDENT>name = attr.name<EOL>value = attr.value<EOL>self.append_attribute(name, value, content)<EOL><DEDENT> | Append attribute nodes into L{Content.data}.
Attributes in the I{schema} or I{xml} namespaces are skipped.
@param content: The current content being unmarshalled.
@type content: L{Content} | f9716:c0:m3 |
def append_attribute(self, name, value, content): | key = name<EOL>key = '<STR_LIT>' % reserved.get(key, key)<EOL>setattr(content.data, key, value)<EOL> | Append an attribute name/value into L{Content.data}.
@param name: The attribute name
@type name: basestring
@param value: The attribute's value
@type value: basestring
@param content: The current content being unmarshalled.
@type content: L{Content} | f9716:c0:m4 |
def append_children(self, content): | for child in content.node:<EOL><INDENT>cont = Content(child)<EOL>cval = self.append(cont)<EOL>key = reserved.get(child.name, child.name)<EOL>if key in content.data:<EOL><INDENT>v = getattr(content.data, key)<EOL>if isinstance(v, list):<EOL><INDENT>v.append(cval)<EOL><DEDENT>else:<EOL><INDENT>setattr(content.data, key, [v, cval])<EOL><DEDENT>continue<EOL><DEDENT>if self.unbounded(cont):<EOL><INDENT>if cval is None:<EOL><INDENT>setattr(content.data, key, [])<EOL><DEDENT>else:<EOL><INDENT>setattr(content.data, key, [cval, ])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>setattr(content.data, key, cval)<EOL><DEDENT><DEDENT> | Append child nodes into L{Content.data}
@param content: The current content being unmarshalled.
@type content: L{Content} | f9716:c0:m5 |
def append_text(self, content): | if content.node.hasText():<EOL><INDENT>content.text = content.node.getText()<EOL><DEDENT> | Append text nodes into L{Content.data}
@param content: The current content being unmarshalled.
@type content: L{Content} | f9716:c0:m6 |
def start(self, content): | content.data = Factory.object(content.node.name)<EOL> | Processing on I{node} has started. Build and return
the proper object.
@param content: The current content being unmarshalled.
@type content: L{Content}
@return: A subclass of Object.
@rtype: L{Object} | f9716:c0:m8 |
def end(self, content): | pass<EOL> | Processing on I{node} has ended.
@param content: The current content being unmarshalled.
@type content: L{Content} | f9716:c0:m9 |
def bounded(self, content): | return not self.unbounded(content)<EOL> | Get whether the content is bounded (not a list).
@param content: The current content being unmarshalled.
@type content: L{Content}
@return: True if bounded, else False
@rtype: boolean | f9716:c0:m10 |
def unbounded(self, content): | return False<EOL> | Get whether the object is unbounded (a list).
@param content: The current content being unmarshalled.
@type content: L{Content}
@return: True if unbounded, else False
@rtype: boolean | f9716:c0:m11 |
def nillable(self, content): | return False<EOL> | Get whether the object is nillable.
@param content: The current content being unmarshalled.
@type content: L{Content}
@return: True if nillable, else False
@rtype: boolean | f9716:c0:m12 |
def __init__(self, schema): | self.resolver = NodeResolver(schema)<EOL> | @param schema: A schema object.
@type schema: L{xsd.schema.Schema} | f9717:c0:m0 |
def process(self, node, type): | content = Content(node)<EOL>content.type = type<EOL>return Core.process(self, content)<EOL> | Process an object graph representation of the xml L{node}.
@param node: An XML tree.
@type node: L{sax.element.Element}
@param type: The I{optional} schema type.
@type type: L{xsd.sxbase.SchemaObject}
@return: A suds object.
@rtype: L{Object} | f9717:c0:m1 |
def append_attribute(self, name, value, content): | type = self.resolver.findattr(name)<EOL>if type is None:<EOL><INDENT>log.warn('<STR_LIT>', name)<EOL><DEDENT>else:<EOL><INDENT>value = self.translated(value, type)<EOL><DEDENT>Core.append_attribute(self, name, value, content)<EOL> | Append an attribute name/value into L{Content.data}.
@param name: The attribute name
@type name: basestring
@param value: The attribute's value
@type value: basestring
@param content: The current content being unmarshalled.
@type content: L{Content} | f9717:c0:m7 |
def append_text(self, content): | Core.append_text(self, content)<EOL>known = self.resolver.top().resolved<EOL>content.text = self.translated(content.text, known)<EOL> | Append text nodes into L{Content.data}
Here is where the I{true} type is used to translate the value
into the proper python type.
@param content: The current content being unmarshalled.
@type content: L{Content} | f9717:c0:m8 |
def translated(self, value, type): | if value is not None:<EOL><INDENT>resolved = type.resolve()<EOL>return resolved.translate(value)<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT> | translate using the schema type | f9717:c0:m9 |
def initialized(self, context): | pass<EOL> | Suds client initialization.
Called after wsdl the has been loaded. Provides the plugin
with the opportunity to inspect/modify the WSDL.
@param context: The init context.
@type context: L{InitContext} | f9719:c5:m0 |
def loaded(self, context): | pass<EOL> | Suds has loaded a WSDL/XSD document. Provides the plugin
with an opportunity to inspect/modify the unparsed document.
Called after each WSDL/XSD document is loaded.
@param context: The document context.
@type context: L{DocumentContext} | f9719:c6:m0 |
def parsed(self, context): | pass<EOL> | Suds has parsed a WSDL/XSD document. Provides the plugin
with an opportunity to inspect/modify the parsed document.
Called after each WSDL/XSD document is parsed.
@param context: The document context.
@type context: L{DocumentContext} | f9719:c6:m1 |
def marshalled(self, context): | pass<EOL> | Suds will send the specified soap envelope.
Provides the plugin with the opportunity to inspect/modify
the envelope Document before it is sent.
@param context: The send context.
The I{envelope} is the envelope docuemnt.
@type context: L{MessageContext} | f9719:c7:m0 |
def sending(self, context): | pass<EOL> | Suds will send the specified soap envelope.
Provides the plugin with the opportunity to inspect/modify
the message text it is sent.
@param context: The send context.
The I{envelope} is the envelope text.
@type context: L{MessageContext} | f9719:c7:m1 |
def received(self, context): | pass<EOL> | Suds has received the specified reply.
Provides the plugin with the opportunity to inspect/modify
the received XML text before it is SAX parsed.
@param context: The reply context.
The I{reply} is the raw text.
@type context: L{MessageContext} | f9719:c7:m2 |
def parsed(self, context): | pass<EOL> | Suds has sax parsed the received reply.
Provides the plugin with the opportunity to inspect/modify
the sax parsed DOM tree for the reply before it is unmarshalled.
@param context: The reply context.
The I{reply} is DOM tree.
@type context: L{MessageContext} | f9719:c7:m3 |
def unmarshalled(self, context): | pass<EOL> | Suds has unmarshalled the received reply.
Provides the plugin with the opportunity to inspect/modify
the unmarshalled reply object before it is returned.
@param context: The reply context.
The I{reply} is unmarshalled suds object.
@type context: L{MessageContext} | f9719:c7:m4 |
def __init__(self, plugins): | self.plugins = plugins<EOL> | @param plugins: A list of plugin objects.
@type plugins: [L{Plugin},] | f9719:c8:m0 |
def __init__(self, name, domain): | self.name = name<EOL>self.domain = domain<EOL> | @param name: The method name.
@type name: str
@param domain: A plugin domain.
@type domain: L{PluginDomain} | f9719:c10:m0 |
def __init__(self, url, message=None): | self.url = url<EOL>self.headers = {}<EOL>self.message = message<EOL> | @param url: The url for the request.
@type url: str
@param message: The (optional) message to be send in the request.
@type message: str | f9721:c1:m0 |
def __init__(self, code, headers, message): | self.code = code<EOL>self.headers = headers<EOL>self.message = message<EOL> | @param code: The http code returned.
@type code: int
@param headers: The http returned headers.
@type headers: dict
@param message: The (optional) reply message received.
@type message: str | f9721:c2:m0 |
def __init__(self): | from suds.transport.options import Options<EOL>self.options = Options()<EOL>del Options<EOL> | Constructor. | f9721:c3:m0 |
def open(self, request): | raise Exception('<STR_LIT>')<EOL> | Open the url in the specified request.
@param request: A transport request.
@type request: L{Request}
@return: An input stream.
@rtype: stream
@raise TransportError: On all transport errors. | f9721:c3:m1 |
def send(self, request): | raise Exception('<STR_LIT>')<EOL> | Send soap message. Implementations are expected to handle:
- proxies
- I{http} headers
- cookies
- sending message
- brokering exceptions into L{TransportError}
@param request: A transport request.
@type request: L{Request}
@return: The reply
@rtype: L{Reply}
@raise TransportError: On all transport errors. | f9721:c3:m2 |
def __init__(self, **kwargs): | Transport.__init__(self)<EOL>Unskin(self.options).update(kwargs)<EOL>self.cookiejar = CookieJar()<EOL>self.proxy = {}<EOL>self.urlopener = None<EOL> | @param kwargs: Keyword arguments.
- B{proxy} - An http proxy to be specified on requests.
The proxy is defined as {protocol:proxy,}
- type: I{dict}
- default: {}
- B{timeout} - Set the url open timeout (seconds).
- type: I{float}
- default: 90 | f9722:c0:m0 |
def addcookies(self, u2request): | self.cookiejar.add_cookie_header(u2request)<EOL> | Add cookies in the cookiejar to the request.
@param u2request: A urllib2 request.
@rtype: u2request: urllib2.Requet. | f9722:c0:m3 |
def getcookies(self, fp, u2request): | self.cookiejar.extract_cookies(fp, u2request)<EOL> | Add cookies in the request to the cookiejar.
@param u2request: A urllib2 request.
@rtype: u2request: urllib2.Requet. | f9722:c0:m4 |
def u2open(self, u2request): | tm = self.options.timeout<EOL>url = self.u2opener()<EOL>if self.u2ver() < <NUM_LIT>:<EOL><INDENT>socket.setdefaulttimeout(tm)<EOL>return url.open(u2request)<EOL><DEDENT>else:<EOL><INDENT>return url.open(u2request, timeout=tm)<EOL><DEDENT> | Open a connection.
@param u2request: A urllib2 request.
@type u2request: urllib2.Requet.
@return: The opened file-like urllib2 object.
@rtype: fp | f9722:c0:m5 |
def u2opener(self): | if self.urlopener is None:<EOL><INDENT>return u2.build_opener(*self.u2handlers())<EOL><DEDENT>else:<EOL><INDENT>return self.urlopener<EOL><DEDENT> | Create a urllib opener.
@return: An opener.
@rtype: I{OpenerDirector} | f9722:c0:m6 |
def u2handlers(self): | handlers = []<EOL>handlers.append(u2.ProxyHandler(self.proxy))<EOL>return handlers<EOL> | Get a collection of urllib handlers.
@return: A list of handlers to be installed in the opener.
@rtype: [Handler,...] | f9722:c0:m7 |
def u2ver(self): | try:<EOL><INDENT>part = u2.__version__.split('<STR_LIT:.>', <NUM_LIT:1>)<EOL>n = float('<STR_LIT:.>'.join(part))<EOL>return n<EOL><DEDENT>except Exception as e:<EOL><INDENT>log.exception(e)<EOL>return <NUM_LIT:0><EOL><DEDENT> | Get the major/minor version of the urllib2 lib.
@return: The urllib2 version.
@rtype: float | f9722:c0:m8 |
def __init__(self, **kwargs): | HttpTransport.__init__(self, **kwargs)<EOL>self.pm = HTTPPasswordMgrWithDefaultRealm()<EOL> | @param kwargs: Keyword arguments.
- B{proxy} - An http proxy to be specified on requests.
The proxy is defined as {protocol:proxy,}
- type: I{dict}
- default: {}
- B{timeout} - Set the url open timeout (seconds).
- type: I{float}
- default: 90
- B{username} - The username used for http authentication.
- type: I{str}
- default: None
- B{password} - The password used for http authentication.
- type: I{str}
- default: None | f9723:c0:m0 |
def load_module(filename): | path, name = os.path.split(filename)<EOL>name, ext = os.path.splitext(name)<EOL>(file, filename, desc) = imp.find_module(name, [path])<EOL>try:<EOL><INDENT>return imp.load_module(name, file, filename, desc)<EOL><DEDENT>finally:<EOL><INDENT>if file:<EOL><INDENT>file.close()<EOL><DEDENT><DEDENT> | Loads a module from anywhere in the system.
Does not depend on or modify sys.path. | f9733:m0 |
def execute(<EOL>command,<EOL>abort=True,<EOL>capture=False,<EOL>verbose=False,<EOL>echo=False,<EOL>stream=None,<EOL>): | stream = stream or sys.stdout<EOL>if echo:<EOL><INDENT>out = stream<EOL>out.write(u'<STR_LIT>' % command)<EOL><DEDENT>command = u'<STR_LIT>' % command<EOL>if verbose:<EOL><INDENT>out = stream<EOL>err = stream<EOL><DEDENT>else:<EOL><INDENT>out = subprocess.PIPE<EOL>err = subprocess.PIPE<EOL><DEDENT>process = subprocess.Popen(<EOL>command,<EOL>shell=True,<EOL>stdout=out,<EOL>stderr=err,<EOL>)<EOL>signal.signal(<EOL>signal.SIGTERM,<EOL>make_terminate_handler(process)<EOL>)<EOL>stdout, _ = process.communicate()<EOL>stdout = stdout.strip() if stdout else '<STR_LIT>'<EOL>if not isinstance(stdout, unicode):<EOL><INDENT>stdout = stdout.decode('<STR_LIT:utf-8>')<EOL><DEDENT>if abort and process.returncode != <NUM_LIT:0>:<EOL><INDENT>message = (<EOL>u'<STR_LIT>' % (<EOL>process.returncode,<EOL>command,<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (<EOL>stdout<EOL>) if stdout else '<STR_LIT>'<EOL>)<EOL>)<EOL>raise Exception(message)<EOL><DEDENT>if capture:<EOL><INDENT>return stdout<EOL><DEDENT>else:<EOL><INDENT>return process<EOL><DEDENT> | Run a command locally.
Arguments:
command: a command to execute.
abort: If True, a non-zero return code will trigger an exception.
capture: If True, returns the output of the command.
If False, returns a subprocess result.
echo: if True, prints the command before executing it.
verbose: If True, prints the output of the command.
stream: If set, stdout/stderr will be redirected to the given stream.
Ignored if `capture` is True. | f9734:m7 |
@click.command()<EOL>def version(): | stdout.write(VERSION)<EOL> | Display application version. | f9738:m0 |
@click.argument('<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True)<EOL>@click.option(<EOL>'<STR_LIT>',<EOL>is_flag=True,<EOL>default=True<EOL>)<EOL>@click.command()<EOL>def add(addon, dev, interactive): | application = get_current_application()<EOL>application.add(<EOL>addon,<EOL>dev=dev,<EOL>interactive=interactive<EOL>)<EOL> | Add a dependency.
Examples:
$ django add dynamic-rest==1.5.0
+ dynamic-rest == 1.5.0 | f9739:m0 |
@click.command()<EOL>def info(): | application = get_current_application()<EOL>info = application.info()<EOL>stdout.write(info)<EOL>return info<EOL> | Display app info.
Examples:
$ dj info
No application, try running dj init.
$ dj info
Application:
foo @ 2.7.9
Requirements:
Django == 1.10 | f9740:m0 |
@click.command(cls=GenerateCommand)<EOL>@click.option(<EOL>'<STR_LIT>',<EOL>default=True<EOL>)<EOL>def generate(*args, **kwargs): | pass<EOL> | Generate a code stub. | f9743:m0 |
@click.command()<EOL>@click.argument('<STR_LIT:name>')<EOL>@click.option(<EOL>'<STR_LIT>',<EOL>prompt=style.prompt('<STR_LIT>'),<EOL>default=style.default(Config.defaults['<STR_LIT>'])<EOL>)<EOL>def init(name, runtime): | runtime = click.unstyle(runtime)<EOL>stdout.write(<EOL>style.format_command(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % (name, style.gray('<STR_LIT:@>'), style.green(runtime))<EOL>)<EOL>)<EOL>config = Config(os.getcwd())<EOL>config.set('<STR_LIT>', runtime)<EOL>config.save()<EOL>generate.main(['<STR_LIT>', name], standalone_mode=False)<EOL>run.main(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL> | Create a new Django app. | f9744:m0 |
@click.command(cls=_MultiCommand)<EOL>def dj(*args, **kwargs): | pass<EOL> | DJ, the Django CLI. | f9745:m0 |
@click.command()<EOL>def help(): | from .dj import dj<EOL>dj.main(['<STR_LIT>'])<EOL> | Display usage info. | f9746:m0 |
@click.command()<EOL>@click.argument('<STR_LIT:port>', required=False)<EOL>def server(port): | args = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if port:<EOL><INDENT>args.append(port)<EOL><DEDENT>run.main(args)<EOL> | Start the Django dev server. | f9747:m0 |
@click.argument('<STR_LIT:args>', nargs=-<NUM_LIT:1>, type=click.UNPROCESSED)<EOL>@click.command(<EOL>context_settings={<EOL>'<STR_LIT>': True<EOL>}<EOL>)<EOL>def lint(args): | application = get_current_application()<EOL>if not args:<EOL><INDENT>args = [application.name, '<STR_LIT>']<EOL><DEDENT>args = ['<STR_LIT>'] + list(args)<EOL>run.main(args, standalone_mode=False)<EOL> | Run lint checks using flake8. | f9748:m0 |
@click.command()<EOL>def shell(): | run.main(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL> | Start the Django shell. | f9749:m0 |
@click.option('<STR_LIT>', is_flag=True, default=False)<EOL>@click.argument('<STR_LIT:args>', nargs=-<NUM_LIT:1>, type=click.UNPROCESSED)<EOL>@click.command(<EOL>context_settings={<EOL>'<STR_LIT>': True<EOL>}<EOL>)<EOL>def run(quiet, args): | if not args:<EOL><INDENT>raise ClickException('<STR_LIT>')<EOL><DEDENT>cmd = '<STR_LIT:U+0020>'.join(args)<EOL>application = get_current_application()<EOL>name = application.name<EOL>settings = os.environ.get('<STR_LIT>', '<STR_LIT>' % name)<EOL>return application.run(<EOL>cmd,<EOL>verbose=not quiet,<EOL>abort=False,<EOL>capture=True,<EOL>env={<EOL>'<STR_LIT>': settings<EOL>}<EOL>)<EOL> | Run a local command.
Examples:
$ django run manage.py runserver
... | f9750:m0 |
@click.command()<EOL>def migrate(): | run.main(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], standalone_mode=False)<EOL>run.main(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], standalone_mode=False)<EOL> | Run Django migrations.
This runs "makemigrations" and "migrate". | f9751:m0 |
@click.argument('<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True)<EOL>@click.command()<EOL>def remove(addon, dev): | application = get_current_application()<EOL>application.remove(addon, dev=dev)<EOL> | Remove a dependency.
Examples:
$ django remove dynamic-rest
- dynamic-rest == 1.5.0 | f9753:m0 |
@staticmethod<EOL><INDENT>def parse_application_name(setup_filename):<DEDENT> | with open(setup_filename, '<STR_LIT>') as setup_file:<EOL><INDENT>fst = RedBaron(setup_file.read())<EOL>for node in fst:<EOL><INDENT>if (<EOL>node.type == '<STR_LIT>' and<EOL>str(node.name) == '<STR_LIT>'<EOL>):<EOL><INDENT>for call in node.call:<EOL><INDENT>if str(call.name) == '<STR_LIT:name>':<EOL><INDENT>value = call.value<EOL>if hasattr(value, '<STR_LIT>'):<EOL><INDENT>value = value.to_python()<EOL><DEDENT>name = str(value)<EOL>break<EOL><DEDENT><DEDENT>if name:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return name<EOL> | Parse a setup.py file for the name.
Returns:
name, or None | f9754:c0:m3 |
def build(self): | if self.exists:<EOL><INDENT>self._build(<EOL>'<STR_LIT>',<EOL>self.requirements_last_modified,<EOL>'<STR_LIT>' % self.requirements_file<EOL>)<EOL>try:<EOL><INDENT>self._build(<EOL>'<STR_LIT>',<EOL>self.dev_requirements_last_modified,<EOL>'<STR_LIT>' % self.dev_requirements_file<EOL>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>if '<STR_LIT>' not in str(e):<EOL><INDENT>raise e<EOL><DEDENT>self.stdout.write(<EOL>style.yellow('<STR_LIT>')<EOL>)<EOL><DEDENT>try:<EOL><INDENT>self._build(<EOL>'<STR_LIT>',<EOL>self.local_requirements_last_modified,<EOL>'<STR_LIT>' % self.local_requirements_file<EOL>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>if '<STR_LIT>' not in str(e):<EOL><INDENT>raise e<EOL><DEDENT>self.stdout.write(<EOL>style.yellow('<STR_LIT>')<EOL>)<EOL><DEDENT>self._build(<EOL>'<STR_LIT>',<EOL>self.setup_last_modified,<EOL>'<STR_LIT>' % self.setup_file<EOL>)<EOL><DEDENT> | Builds the app in the app's environment.
Only builds if the build is out-of-date and is non-empty.
Builds in 3 stages: requirements, dev requirements, and app.
pip is used to install requirements, and setup.py is used to
install the app itself.
Raises:
ValidationError if the app fails to build. | f9754:c0:m18 |
def generate(self, blueprint, context, interactive=True): | if not isinstance(blueprint, Blueprint):<EOL><INDENT>bp = self.blueprints.get(blueprint)<EOL>if not bp:<EOL><INDENT>raise ValueError('<STR_LIT>' % blueprint)<EOL><DEDENT>blueprint = bp<EOL><DEDENT>self.stdout.write(<EOL>style.format_command(<EOL>'<STR_LIT>',<EOL>blueprint.full_name<EOL>)<EOL>)<EOL>generator = Generator(<EOL>self,<EOL>blueprint,<EOL>context,<EOL>interactive=interactive<EOL>)<EOL>result = generator.generate()<EOL>if blueprint.name == '<STR_LIT>':<EOL><INDENT>self.refresh()<EOL><DEDENT>return result<EOL> | Generate a blueprint within this application. | f9754:c0:m21 |
def add(self, addon, dev=False, interactive=True): | dependencies = self.get_dependency_manager(dev=dev)<EOL>other_dependencies = self.get_dependency_manager(dev=not dev)<EOL>existing = dependencies.get(addon)<EOL>self.stdout.write(style.format_command('<STR_LIT>', addon))<EOL>dependencies.add(addon)<EOL>try:<EOL><INDENT>self.build()<EOL>self.refresh()<EOL>other_dependencies.remove(addon, warn=False)<EOL>constructor_name = '<STR_LIT>' % Dependency(addon).module_name<EOL>constructor = self.blueprints.get(constructor_name)<EOL>if constructor:<EOL><INDENT>context = constructor.load_context().main(<EOL>[], standalone_mode=False<EOL>)<EOL>self.generate(constructor, context, interactive=interactive)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>self.stdout.write(style.red(str(e)))<EOL>self.stdout.write(<EOL>style.yellow('<STR_LIT>' % addon)<EOL>)<EOL>dependencies.remove(addon)<EOL>if existing:<EOL><INDENT>dependencies.add(existing)<EOL><DEDENT>return<EOL><DEDENT> | Add a new dependency and install it. | f9754:c0:m23 |
def remove(self, addon, dev=False): | dependencies = self.get_dependency_manager(dev=dev)<EOL>other_dependencies = self.get_dependency_manager(dev=not dev)<EOL>self.stdout.write(style.format_command('<STR_LIT>', addon))<EOL>removed = dependencies.remove(addon, warn=False)<EOL>if not removed:<EOL><INDENT>removed = other_dependencies.remove(addon, warn=False)<EOL><DEDENT>if removed:<EOL><INDENT>self.build()<EOL><DEDENT>else:<EOL><INDENT>exception = '<STR_LIT>' % Dependency(addon).to_stdout()<EOL>self.stdout.write(style.red(exception))<EOL><DEDENT> | Remove a dependency and uninstall it. | f9754:c0:m24 |
@click.command()<EOL>@click.argument('<STR_LIT:name>')<EOL>def get_context(name): | return {<EOL>'<STR_LIT:name>': inflection.underscore(name),<EOL>'<STR_LIT>': inflection.camelize(name)<EOL>}<EOL> | Generate a model with given name.
You will need to run "dj migrate" to create
the migration file and apply it to your local
development database.
For example:
dj generate model Foo
dj migrate | f9755:m0 |
@click.command()<EOL>@click.argument('<STR_LIT:name>')<EOL>@click.option('<STR_LIT>')<EOL>def get_context(name, doc): | name = inflection.underscore(name)<EOL>return {<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': doc or name<EOL>}<EOL> | Generate a command with given name.
The command can be run immediately after generation.
For example:
dj generate command bar
dj run manage.py bar | f9756:m0 |
def generate(self): | self.render()<EOL>self.merge()<EOL> | Generate the blueprint. | f9759:c0:m2 |
def render(self): | context = self.context<EOL>if '<STR_LIT>' not in context:<EOL><INDENT>context['<STR_LIT>'] = self.application.name<EOL><DEDENT>temp_dir = self.temp_dir<EOL>templates_root = self.blueprint.templates_directory<EOL>for root, dirs, files in os.walk(templates_root):<EOL><INDENT>for directory in dirs:<EOL><INDENT>directory = os.path.join(root, directory)<EOL>directory = render_from_string(directory, context)<EOL>directory = directory.replace(templates_root, temp_dir, <NUM_LIT:1>)<EOL>os.mkdir(directory)<EOL><DEDENT>for file in files:<EOL><INDENT>full_file = os.path.join(root, file)<EOL>stat = os.stat(full_file)<EOL>content = render_from_file(full_file, context)<EOL>full_file = strip_extension(<EOL>render_from_string(full_file, context))<EOL>full_file = full_file.replace(templates_root, temp_dir, <NUM_LIT:1>)<EOL>with open(full_file, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(content)<EOL><DEDENT>os.chmod(full_file, stat.st_mode)<EOL><DEDENT><DEDENT> | Render the blueprint into a temp directory using the context. | f9759:c0:m3 |
def merge(self): | temp_dir = self.temp_dir<EOL>app_dir = self.application.directory<EOL>for root, dirs, files in os.walk(temp_dir):<EOL><INDENT>for directory in dirs:<EOL><INDENT>directory = os.path.join(root, directory)<EOL>directory = directory.replace(temp_dir, app_dir, <NUM_LIT:1>)<EOL>try:<EOL><INDENT>os.mkdir(directory)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>for file in files:<EOL><INDENT>source = os.path.join(root, file)<EOL>target = source.replace(temp_dir, app_dir, <NUM_LIT:1>)<EOL>relative_target = target.replace(app_dir, '<STR_LIT:.>')<EOL>action = '<STR_LIT:r>'<EOL>if (<EOL>os.path.exists(target)<EOL>and not filecmp.cmp(source, target, shallow=False)<EOL>and os.stat(target).st_size > <NUM_LIT:0><EOL>):<EOL><INDENT>if target.endswith('<STR_LIT>'):<EOL><INDENT>action = '<STR_LIT:m>'<EOL><DEDENT>elif target.endswith('<STR_LIT>'):<EOL><INDENT>action = '<STR_LIT:s>'<EOL><DEDENT>else:<EOL><INDENT>default = '<STR_LIT:m>'<EOL>action = click.prompt(<EOL>style.prompt(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (<EOL>relative_target<EOL>),<EOL>),<EOL>default=style.default(default)<EOL>) if self.interactive else default<EOL>action = click.unstyle(action).lower()<EOL>if action not in {'<STR_LIT:r>', '<STR_LIT:m>', '<STR_LIT:s>'}:<EOL><INDENT>action = default<EOL><DEDENT><DEDENT><DEDENT>if action == '<STR_LIT:s>':<EOL><INDENT>self.stdout.write(<EOL>'<STR_LIT>' % style.white(relative_target),<EOL>fg='<STR_LIT>'<EOL>)<EOL>continue<EOL><DEDENT>if action == '<STR_LIT:r>':<EOL><INDENT>with open(source, '<STR_LIT:r>') as source_file:<EOL><INDENT>with open(target, '<STR_LIT:w>') as target_file:<EOL><INDENT>target_file.write(source_file.read())<EOL><DEDENT><DEDENT>self.stdout.write(<EOL>style.green(<EOL>'<STR_LIT>' % style.white(relative_target)<EOL>)<EOL>)<EOL><DEDENT>if action == '<STR_LIT:m>':<EOL><INDENT>with open(target, '<STR_LIT:r>') as target_file:<EOL><INDENT>with open(source, '<STR_LIT:r>') as source_file:<EOL><INDENT>merged = merge(<EOL>target_file.read(),<EOL>source_file.read()<EOL>)<EOL><DEDENT><DEDENT>with open(target, '<STR_LIT:w>') as target_file:<EOL><INDENT>target_file.write(merged)<EOL><DEDENT>self.stdout.write(<EOL>style.yellow('<STR_LIT>' % style.white(relative_target))<EOL>)<EOL><DEDENT><DEDENT><DEDENT> | Merges the rendered blueprint into the application. | f9759:c0:m4 |
def get_logger(logger_name): | <EOL>if logger_name is None:<EOL><INDENT>return __instance<EOL><DEDENT>assert isinstance(logger_name, str), '<STR_LIT>'<EOL>with __lock:<EOL><INDENT>if logger_name in __loggers:<EOL><INDENT>return __loggers[logger_name]<EOL><DEDENT>logger_instance = LogOne(logger_name=logger_name)<EOL>__loggers[logger_name] = logger_instance<EOL>return logger_instance<EOL><DEDENT> | Return a logger with the specified name, creating it if necessary. | f9761:m0 |
def __init__(self, logger_name,<EOL>level=logging.WARNING,<EOL>use_colors=True,<EOL>log_format=None,<EOL>date_format=None,<EOL>level_styles=None,<EOL>field_styles=None): | <EOL>self.logger = logging.getLogger(logger_name)<EOL>if not log_format:<EOL><INDENT>log_format = '<STR_LIT>''<STR_LIT>''<STR_LIT>'<EOL><DEDENT>coloredlogs.install(level=level,<EOL>logger=self.logger,<EOL>fmt=log_format,<EOL>datefmt=date_format,<EOL>level_styles=level_styles,<EOL>field_styles=field_styles,<EOL>isatty=use_colors,<EOL>stream=_original_stderr)<EOL>self.__stdout_wrapper = None<EOL>self.__stderr_wrapper = None<EOL>self.__stdout_stream = _original_stdout<EOL>self.__stderr_stream = _original_stderr<EOL>self.__file_handler = None<EOL>self.__loggly_handler = None<EOL>self.__coloredlogs_handlers = list(self.logger.handlers)<EOL>self.name = self.logger.name<EOL>self.add_handler = self.logger.addHandler<EOL>self.remove_handler = self.logger.removeHandler<EOL>self.add_filter = self.logger.addFilter<EOL>self.remove_filter = self.logger.removeFilter<EOL>self.log = self.logger.log<EOL>self.debug = self.logger.debug<EOL>self.info = self.logger.info<EOL>self.warning = self.logger.warning<EOL>self.error = self.logger.error<EOL>self.exception = self.logger.exception<EOL>self.critical = self.logger.critical<EOL> | Initialize the logger with a name and an optional level.
:param logger_name: The name of the logger.
:param level: The default logging level.
:param use_colors: Use ColoredFormatter class for coloring logs or not.
:param log_format: Use the specified format string for the handler.
:param date_format: Use the specified date/time format.
:param level_styles: A dictionary with custom level styles.
:param field_styles: A dictionary with custom field styles. | f9762:c0:m0 |
def set_level(self, level): | for handler in self.__coloredlogs_handlers:<EOL><INDENT>handler.setLevel(level=level)<EOL><DEDENT>self.logger.setLevel(level=level)<EOL> | Set the logging level of this logger.
:param level: must be an int or a str. | f9762:c0:m1 |
def disable_logger(self, disabled=True): | <EOL>if disabled:<EOL><INDENT>sys.stdout = _original_stdout<EOL>sys.stderr = _original_stderr<EOL><DEDENT>else:<EOL><INDENT>sys.stdout = self.__stdout_stream<EOL>sys.stderr = self.__stderr_stream<EOL><DEDENT>self.logger.disabled = disabled<EOL> | Disable all logging calls. | f9762:c0:m2 |
def redirect_stdout(self, enabled=True, log_level=logging.INFO): | if enabled:<EOL><INDENT>if self.__stdout_wrapper:<EOL><INDENT>self.__stdout_wrapper.update_log_level(log_level=log_level)<EOL><DEDENT>else:<EOL><INDENT>self.__stdout_wrapper = StdOutWrapper(logger=self, log_level=log_level)<EOL><DEDENT>self.__stdout_stream = self.__stdout_wrapper<EOL><DEDENT>else:<EOL><INDENT>self.__stdout_stream = _original_stdout<EOL><DEDENT>sys.stdout = self.__stdout_stream<EOL> | Redirect sys.stdout to file-like object. | f9762:c0:m3 |
def redirect_stderr(self, enabled=True, log_level=logging.ERROR): | if enabled:<EOL><INDENT>if self.__stderr_wrapper:<EOL><INDENT>self.__stderr_wrapper.update_log_level(log_level=log_level)<EOL><DEDENT>else:<EOL><INDENT>self.__stderr_wrapper = StdErrWrapper(logger=self, log_level=log_level)<EOL><DEDENT>self.__stderr_stream = self.__stderr_wrapper<EOL><DEDENT>else:<EOL><INDENT>self.__stderr_stream = _original_stderr<EOL><DEDENT>sys.stderr = self.__stderr_stream<EOL> | Redirect sys.stderr to file-like object. | f9762:c0:m4 |
def use_file(self, enabled=True,<EOL>file_name=None,<EOL>level=logging.WARNING,<EOL>when='<STR_LIT:d>',<EOL>interval=<NUM_LIT:1>,<EOL>backup_count=<NUM_LIT:30>,<EOL>delay=False,<EOL>utc=False,<EOL>at_time=None,<EOL>log_format=None,<EOL>date_format=None): | if enabled:<EOL><INDENT>if not self.__file_handler:<EOL><INDENT>assert file_name, '<STR_LIT>'<EOL>kwargs = {<EOL>'<STR_LIT:filename>': file_name,<EOL>'<STR_LIT>': when,<EOL>'<STR_LIT>': interval,<EOL>'<STR_LIT>': backup_count,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': delay,<EOL>'<STR_LIT>': utc,<EOL>}<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>kwargs['<STR_LIT>'] = at_time<EOL><DEDENT>self.__file_handler = TimedRotatingFileHandler(**kwargs)<EOL>if not log_format:<EOL><INDENT>log_format = '<STR_LIT>''<STR_LIT>''<STR_LIT>'<EOL><DEDENT>formatter = logging.Formatter(fmt=log_format, datefmt=date_format)<EOL>self.__file_handler.setFormatter(fmt=formatter)<EOL>self.__file_handler.setLevel(level=level)<EOL>self.add_handler(hdlr=self.__file_handler)<EOL><DEDENT><DEDENT>elif self.__file_handler:<EOL><INDENT>self.remove_handler(hdlr=self.__file_handler)<EOL>self.__file_handler = None<EOL><DEDENT> | Handler for logging to a file, rotating the log file at certain timed intervals. | f9762:c0:m5 |
def use_loggly(self, enabled=True,<EOL>loggly_token=None,<EOL>loggly_tag=None,<EOL>level=logging.WARNING,<EOL>log_format=None,<EOL>date_format=None): | if enabled:<EOL><INDENT>if not self.__loggly_handler:<EOL><INDENT>assert loggly_token, '<STR_LIT>'<EOL>if not loggly_tag:<EOL><INDENT>loggly_tag = self.name<EOL><DEDENT>self.__loggly_handler = LogglyHandler(token=loggly_token, tag=loggly_tag)<EOL>if not log_format:<EOL><INDENT>log_format = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'<EOL><DEDENT>formatter = logging.Formatter(fmt=log_format, datefmt=date_format)<EOL>self.__loggly_handler.setFormatter(fmt=formatter)<EOL>self.__loggly_handler.setLevel(level=level)<EOL>self.add_handler(hdlr=self.__loggly_handler)<EOL><DEDENT><DEDENT>elif self.__loggly_handler:<EOL><INDENT>self.remove_handler(hdlr=self.__loggly_handler)<EOL>self.__loggly_handler = None<EOL><DEDENT> | Enable handler for sending the record to Loggly service. | f9762:c0:m6 |
@staticmethod<EOL><INDENT>def __find_caller(stack_info=False):<DEDENT> | frame = logging.currentframe()<EOL>if frame:<EOL><INDENT>frame = frame.f_back<EOL><DEDENT>caller_info = '<STR_LIT>', <NUM_LIT:0>, '<STR_LIT>', None<EOL>while hasattr(frame, '<STR_LIT>'):<EOL><INDENT>co = frame.f_code<EOL>if _logone_src in os.path.normcase(co.co_filename):<EOL><INDENT>frame = frame.f_back<EOL>continue<EOL><DEDENT>tb_info = None<EOL>if stack_info:<EOL><INDENT>with StringIO() as _buffer:<EOL><INDENT>_buffer.write('<STR_LIT>')<EOL>traceback.print_stack(frame, file=_buffer)<EOL>tb_info = _buffer.getvalue().strip()<EOL><DEDENT><DEDENT>caller_info = co.co_filename, frame.f_lineno, co.co_name, tb_info<EOL>break<EOL><DEDENT>return caller_info<EOL> | Find the stack frame of the caller so that we can note the source file name,
line number and function name. | f9762:c0:m7 |
def _log(self, level, msg, *args, **kwargs): | if not isinstance(level, int):<EOL><INDENT>if logging.raiseExceptions:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT><DEDENT>if self.logger.isEnabledFor(level=level):<EOL><INDENT>"""<STR_LIT>"""<EOL>exc_info = kwargs.get('<STR_LIT>', None)<EOL>extra = kwargs.get('<STR_LIT>', None)<EOL>stack_info = kwargs.get('<STR_LIT>', False)<EOL>record_filter = kwargs.get('<STR_LIT>', None)<EOL>tb_info = None<EOL>if _logone_src:<EOL><INDENT>try:<EOL><INDENT>fn, lno, func, tb_info = self.__find_caller(stack_info=stack_info)<EOL><DEDENT>except ValueError: <EOL><INDENT>fn, lno, func = '<STR_LIT>', <NUM_LIT:0>, '<STR_LIT>'<EOL><DEDENT><DEDENT>else: <EOL><INDENT>fn, lno, func = '<STR_LIT>', <NUM_LIT:0>, '<STR_LIT>'<EOL><DEDENT>if exc_info:<EOL><INDENT>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>if isinstance(exc_info, BaseException):<EOL><INDENT>exc_info = type(exc_info), exc_info, exc_info.__traceback__<EOL><DEDENT>elif not isinstance(exc_info, tuple):<EOL><INDENT>exc_info = sys.exc_info()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not isinstance(exc_info, tuple):<EOL><INDENT>exc_info = sys.exc_info()<EOL><DEDENT><DEDENT><DEDENT>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>record = self.logger.makeRecord(self.name, level, fn, lno, msg, args,<EOL>exc_info, func, extra, tb_info)<EOL><DEDENT>else:<EOL><INDENT>record = self.logger.makeRecord(self.name, level, fn, lno, msg, args,<EOL>exc_info, func, extra)<EOL><DEDENT>if record_filter:<EOL><INDENT>record = record_filter(record)<EOL><DEDENT>self.logger.handle(record=record)<EOL><DEDENT> | Log 'msg % args' with the integer severity 'level'.
To pass exception information, use the keyword argument exc_info with
a true value, e.g.
logger.log(level, "We have a %s", "mysterious problem", exc_info=1) | f9762:c0:m8 |
def update_log_level(self, log_level=logging.INFO): | self.__log_level = log_level<EOL> | Update the logging level of this stream. | f9762:c3:m1 |
def flush(self): | if self.__buffer.tell() > <NUM_LIT:0>:<EOL><INDENT>self.__logger._log(level=self.__log_level, msg=self.__buffer.getvalue().strip())<EOL>self.__buffer.truncate(<NUM_LIT:0>)<EOL>self.__buffer.seek(<NUM_LIT:0>)<EOL><DEDENT> | Flush the buffer, if applicable. | f9762:c3:m2 |
def update_log_level(self, log_level=logging.ERROR): | self.__log_level = log_level<EOL> | Update the logging level of this stream. | f9762:c4:m1 |
def flush(self): | if self.__buffer.tell() > <NUM_LIT:0>:<EOL><INDENT>self.__logger._log(level=self.__log_level, msg=self.__buffer.getvalue().strip(),<EOL>record_filter=StdErrWrapper.__filter_record)<EOL>self.__buffer.truncate(<NUM_LIT:0>)<EOL>self.__buffer.seek(<NUM_LIT:0>)<EOL><DEDENT> | Flush the buffer, if applicable. | f9762:c4:m3 |
@verify_type(section=str, option=str)<EOL><INDENT>def split_option(self, section, option):<DEDENT> | value = self[section][option].strip()<EOL>if value == "<STR_LIT>":<EOL><INDENT>return []<EOL><DEDENT>return [x.strip() for x in (value.split("<STR_LIT:U+002C>"))]<EOL> | Return list of strings that are made by splitting coma-separated option value. Method returns
empty list if option value is empty string
:param section: option section name
:param option: option name
:return: list of strings | f9831:c0:m0 |
@verify_type(config=(str, ConfigParser))<EOL><INDENT>@verify_value(config=lambda x: isinstance(x, ConfigParser) or os.path.isfile(x))<EOL>def merge(self, config):<DEDENT> | if isinstance(config, ConfigParser) is True:<EOL><INDENT>self.update(config)<EOL><DEDENT>elif isinstance(config, str):<EOL><INDENT>self.read(config)<EOL><DEDENT> | Load configuration from given configuration.
:param config: config to load. If config is a string type, then it's treated as .ini filename
:return: None | f9831:c0:m1 |
@verify_type(config=ConfigParser, section_to=str, section_from=(str, None))<EOL><INDENT>def merge_section(self, config, section_to, section_from=None):<DEDENT> | section_from = section_from if section_from is not None else section_to<EOL>if section_from not in config.sections():<EOL><INDENT>raise ValueError('<STR_LIT>' % section_from)<EOL><DEDENT>if section_to not in self.sections():<EOL><INDENT>self.add_section(section_to)<EOL><DEDENT>for option in config[section_from].keys():<EOL><INDENT>self.set(section_to, option, config[section_from][option])<EOL><DEDENT> | Load configuration section from other configuration. If specified section doesn't exist in current
configuration, then it will be added automatically.
:param config: source configuration
:param section_to: destination section name
:param section_from: source section name (if it is None, then section_to is used as source section name)
:return: None | f9831:c0:m2 |
def select_options(self, section, options_prefix=None): | return WConfigSelection(self, section, options_prefix=options_prefix)<EOL> | Select options from section
:param section: target section
:param options_prefix: prefix of options that should be selected
:return: WConfigSelection | f9831:c0:m3 |
@verify_type(config=WConfig, section=str, options_prefix=(str, None))<EOL><INDENT>@verify_value(section=lambda x: len(x) > <NUM_LIT:0>)<EOL>def __init__(self, config, section, options_prefix=None):<DEDENT> | self.__config = config<EOL>self.__section = section<EOL>self.__options_prefix = options_prefix if options_prefix is not None else '<STR_LIT>'<EOL>if self.__config.has_section(section) is False:<EOL><INDENT>raise NoSectionError('<STR_LIT>' % section)<EOL><DEDENT> | Create a configuration selection
:param config: source configuration
:param section: source section name
:param options_prefix: name prefix of options that should be selected. If it is not specified, then \
it is treated as empty string | f9831:c1:m0 |
def config(self): | return self.__config<EOL> | Return source configuration
:return: WConfig | f9831:c1:m1 |
def section(self): | return self.__section<EOL> | Return source section name
:return: str | f9831:c1:m2 |
def option_prefix(self): | return self.__options_prefix<EOL> | Return name prefix of options that may be selected
:return: str | f9831:c1:m3 |
def __option(self): | section = self.section()<EOL>option = self.option_prefix()<EOL>if self.config().has_option(section, option) is False:<EOL><INDENT>raise NoOptionError(option, section)<EOL><DEDENT>return section, option<EOL> | Check and return option from section from configuration. Option name is equal to option prefix
:return: tuple of section name and option prefix | f9831:c1:m4 |
def __str__(self): | section, option = self.__option()<EOL>return self.config()[section][option]<EOL> | Return string value of this option
:return: str | f9831:c1:m5 |
def __int__(self): | section, option = self.__option()<EOL>return self.config().getint(section, option)<EOL> | Return integer value of this option
:return: int | f9831:c1:m6 |
def __float__(self): | section, option = self.__option()<EOL>return self.config().getfloat(section, option)<EOL> | Return float value of this option
:return: float | f9831:c1:m7 |
def __bool__(self): | section, option = self.__option()<EOL>return self.config().getboolean(section, option)<EOL> | Return boolean value of this option
:return: bool | f9831:c1:m8 |
@verify_type(option_prefix=str)<EOL><INDENT>@verify_value(option_prefix=lambda x: len(x) > <NUM_LIT:0>)<EOL>def select_options(self, options_prefix):<DEDENT> | return WConfigSelection(<EOL>self.config(), self.section(), self.option_prefix() + options_prefix<EOL>)<EOL> | Select options from this selection, that are started with the specified prefix
:param options_prefix: name prefix of options that should be selected
:return: WConfigSelection | f9831:c1:m9 |
@verify_type('<STR_LIT>', item=str)<EOL><INDENT>@verify_value('<STR_LIT>', item=lambda x: len(x) > <NUM_LIT:0>)<EOL>def __getitem__(self, item):<DEDENT> | return self.select_options(item)<EOL> | Alias for :meth:`.WConfigSelection.select_options` method
:param item:
:return: | f9831:c1:m10 |
@verify_type(option_name=(str, None))<EOL><INDENT>def has_option(self, option_name=None):<DEDENT> | if option_name is None:<EOL><INDENT>option_name = '<STR_LIT>'<EOL><DEDENT>return self.config().has_option(self.section(), self.option_prefix() + option_name)<EOL> | Check whether configuration selection has the specified option.
:param option_name: option name to check. If no option is specified, then check is made for this option
:return: bool | f9831:c1:m11 |
@verify_type(storage=(None, WCacheStorage))<EOL>@verify_value(validator=lambda x: x is None or callable(x))<EOL>def cache_control(validator=None, storage=None): | def default_validator(*args, **kwargs):<EOL><INDENT>return True<EOL><DEDENT>if validator is None:<EOL><INDENT>validator = default_validator<EOL><DEDENT>if storage is None:<EOL><INDENT>storage = WGlobalSingletonCacheStorage()<EOL><DEDENT>def first_level_decorator(decorated_function):<EOL><INDENT>def second_level_decorator(original_function, *args, **kwargs):<EOL><INDENT>validator_check = validator(original_function, *args, **kwargs)<EOL>cache_entry = storage.get_cache(original_function, *args, **kwargs)<EOL>if validator_check is not True or cache_entry.has_value is False:<EOL><INDENT>result = original_function(*args, **kwargs)<EOL>storage.put(result, original_function, *args, **kwargs)<EOL>return result<EOL><DEDENT>else:<EOL><INDENT>return cache_entry.cached_value<EOL><DEDENT><DEDENT>return decorator(second_level_decorator)(decorated_function)<EOL><DEDENT>return first_level_decorator<EOL> | Decorator that is used for caching result.
:param validator: function, that has following signature (decorated_function, \*args, \*\*kwargs), where \
decorated_function - original function, args - function arguments, kwargs - function keyword arguments. \
This function must return True if cache is valid (old result must be use if it there is one), or False - to \
generate and to store new result. So function that always return True can be used as singleton. And function \
that always return False won't cache anything at all. By default (if no validator is specified), it presumes \
that cache is always valid.
:param storage: storage that is used for caching results. see :class:`.WCacheStorage` class.
:return: decorated function | f9832:m0 |
@abstractmethod<EOL><INDENT>@verify_value(decorated_function=lambda x: callable(x))<EOL>def put(self, result, decorated_function, *args, **kwargs):<DEDENT> | raise NotImplementedError('<STR_LIT>')<EOL> | Save (or replace) result for given function
:param result: result to be saved
:param decorated_function: called function (original)
:param args: args with which function is called
:param kwargs: kwargs with which function is called
:return: None | f9832:c0:m0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.