Did I find the right examples for you? yes no      Crawl my project      Python Jobs

All Samples(101)  |  Call(62)  |  Derive(3)  |  Import(36)

src/c/o/CommandTool-0.5.3/commandtool/__init__.py   CommandTool(Download)
from logging.config import fileConfig
from recipes_267662 import wrap_onspace_strict, indent
from bn import AttributeDict, OrderedDict, MarbleLike
log = logging.getLogger(__name__)
def to_internal(option_spec, parsed_options):
    internal = AttributeDict()
                internal[k] = False
    options_used = AttributeDict()
    values_used = AttributeDict()
    position = AttributeDict()

src/f/l/FlashMessage-0.2.0/flashmessage/__init__.py   FlashMessage(Download)
import logging
import urllib
from bn import AttributeDict
from pipestack.pipe import Pipe, Marble
from httpkit.helper.cookie import set_cookie, get_cookie, unset_cookie, delete_cookie
        service[self.name] = AttributeDict(

src/a/r/Archiver-0.2.2/archiver/api.py   Archiver(Download)
import uuid
from bn import relpath, uniform_path, AttributeDict
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey,\
    DateTime, Enum, select, and_, create_engine, not_
def schema2():
    metadata = MetaData()
    return AttributeDict(
        metadata = metadata,
        file_records = Table('file', metadata,
            result = []
            for x in res:
                p = AttributeDict(x)
                p['accessed'] = to_date(x['accessed'])
                p['modified'] = to_date(x['modified'])
                            path=relpath(path, base_path),

src/p/i/PipeStack-0.5.3/pipestack/app.py   PipeStack(Download)
import warnings
from bn import AttributeDict, uniform_path, OrderedDict
from commandtool import handle_command, Cmd, LoggingCmd
from configconvert import parse_and_split_options_change_dir, parse_config_string, split_options
def pipe(name, class_, aliases=None, **p):
    return AttributeDict(name=name, class_=class_, aliases=aliases, extras=p)
def command(name, class_, aliases=None, **p):
    return AttributeDict(name=name, class_=class_, aliases=aliases, extras=p)
class Bag(AttributeDict):
class App(object):
    pipes = []
        self._commands_structure = OrderedDict()
        self._instantiated_pipes = {}
        self.config = AttributeDict()
        self.config_file = None
        if isinstance(option, (str, unicode)):

src/e/r/ErrorReport-0.3.2/errorreport/__init__.py   ErrorReport(Download)
import datetime
from bn import AttributeDict, str_dict
from configconvert import stringToObject
from pipestack.pipe import Marble, MarblePipe
class ErrorReportPipe(MarblePipe):
    marble_class = ErrorReportMarble
    default_aliases = AttributeDict(mail='mail', errordocument='errordocument', database='database', ticket='ticket')
    options = dict(
        subject = Field(to_unicode),

src/c/o/ConfigConvert-0.2.2/configconvert/__init__.py   ConfigConvert(Download)
from configconvert.internal import eval_import, simple_import, import_module
from bn import uniform_path as up, AttributeDict
from nestedrecord import decodeNestedRecord, encode_error
from conversionkit import Conversion
                    raise PipeConfigError("Alias %r on line %r should contain exactly one `=' sign"%(alias, counter))
                    aliases.append(AttributeDict(src=alias.split('=')[0].strip(), dst=alias.split('=')[1].strip()))
            name, path = parts
            aliases = []
        name = name.strip()
        path = path.strip()
        pipes.append(AttributeDict(name=name, path=path, aliases=aliases))

src/m/a/Mail-2.1.0/mail/service.py   Mail(Download)
log = logging.getLogger(__name__)
from bn import AttributeDict, str_dict
from conversionkit import set_error
        def start(service):
            service[name] = AttributeDict(send=send)
        def leave(service, error=False):
        return AttributeDict(start=start, enter=start, leave=leave)

src/p/i/PipeStack-0.5.3/pipestack/pipe.py   PipeStack(Download)
import logging
import warnings
from bn import AttributeDict, MarbleLike
log = logging.getLogger(__name__)
    def __init__(self, bag, name, aliases=None, **pextras):
        # Don't keep a reference to the bag, just the name this pipe from the ``.name`` attribute given
        self.name = name
        self.aliases = AttributeDict()
        # Update the default aliases with the default aliases of the immediate parent (which should itself have been updated with the default aliases of its parents when it was initialised.
        if hasattr(super(self.__class__, self), 'default_aliases'):
            default_aliases = AttributeDict()
    def parse_options(self, bag):
        # If the pipe doesn't have an options, don't parse them
        if not self.options and not self.post_converters and not self.required_section_error_message:
            self.config = bag.app.config[self.name] = AttributeDict()
        conversion = Conversion(decode(bag.app.option.get(self.name, {}))).perform(
            AttributeDict(bag=bag, pipe=self),
        if not conversion.successful:

src/a/p/AppDispatch-0.3.4/appdispatch/__init__.py   AppDispatch(Download)
import os
import sys
import logging
from bn import AttributeDict, absimport, uniform_path
        # Now set up the marble
        marble.vars = AttributeDict(vars)
        marble.url_parts = url_parts
        marble.area = area = marble._area_cache[area_name]
                        raise Exception('The path %r specified for %r had already been registered with URLManager by %r'%(path, name, k))
                # Since this shouldn't change, we cache it here
                self.persistent_state['apps'][args['pipe']] = AttributeDict(path=path, ruleset=ruleset)
            if not self.url_parts:
                self.url_parts = extract_url_parts(self.bag)

src/d/a/DatabasePipe-2.2.1/databasepipe/setup.py   DatabasePipe(Download)
import getopt
import logging
from commandtool import Cmd
from pipestack.ensure import ensure_method_bag
from bn import AttributeDict
         # ... convert opts and args if needed
         bag = AttributeDict(

  1 | 2 | 3 | 4  Next