Python Serializer.from_string方法代码示例

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def put(environ, start_response):
    """
    Put a bag to the server, meaning the description and
    policy of the bag, if policy allows.
    """
    bag_name = web.get_route_value(environ, 'bag_name')
    bag_name = web.handle_extension(environ, bag_name)

    bag = Bag(bag_name)
    store = environ['tiddlyweb.store']
    length, _ = web.content_length_and_type(environ)

    usersign = environ['tiddlyweb.usersign']

    try:
        bag = store.get(bag)
        bag.policy.allows(usersign, 'manage')
    except NoBagError:
        create_policy_check(environ, 'bag', usersign)

    try:
        serialize_type = web.get_serialize_type(environ)[0]
        serializer = Serializer(serialize_type, environ)
        serializer.object = bag
        content = web.read_request_body(environ, length)
        serializer.from_string(content.decode('utf-8'))

        bag.policy.owner = usersign['name']

        _validate_bag(environ, bag)
        store.put(bag)
    except BagFormatError, exc:
        raise HTTP400('unable to put bag: %s' % exc)

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def post_request(environ, start_response):
    length = int(environ["CONTENT_LENGTH"])
    post_content = environ["wsgi.input"].read(length)
    serializer = Serializer("json")  # TODO: use content-type to determine serialization
    rev = Tiddler("untitled")  # N.B.: Serializations need not contain title.
    serializer.object = rev
    serializer.from_string(post_content.decode("utf-8"))

    query = environ["tiddlyweb.query"]
    store = environ["tiddlyweb.store"]

    rev1_id = query.get("rev1", [None])[0]
    rev2_id = query.get("rev2", [None])[0]
    try:
        if not rev1_id:
            rev1 = rev
            rev2 = _get_tiddler(rev2_id, store)
        elif not rev2_id:
            rev1 = _get_tiddler(rev1_id, store)
            rev2 = rev
        else:
            raise HTTP400("ambiguous request")
    except AttributeError:
        raise HTTP400("missing revision parameter")

    format = query.get("format", [None])[0]

    content = compare_tiddlers(rev1, rev2, format)
    return _generate_response(content, environ, start_response)

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def put(environ, start_response):
    """
    Put a bag to the server, meaning the description and
    policy of the bag, if policy allows.
    """
    bag_name = _determine_bag_name(environ)
    bag_name = web.handle_extension(environ, bag_name)

    bag = Bag(bag_name)
    store = environ["tiddlyweb.store"]
    length = environ["CONTENT_LENGTH"]

    usersign = environ["tiddlyweb.usersign"]

    try:
        bag = store.get(bag)
        bag.policy.allows(usersign, "manage")
    except NoBagError:
        create_policy_check(environ, "bag", usersign)

    try:
        serialize_type = web.get_serialize_type(environ)[0]
        serializer = Serializer(serialize_type, environ)
        serializer.object = bag
        content = environ["wsgi.input"].read(int(length))
        serializer.from_string(content.decode("utf-8"))

        bag.policy.owner = usersign["name"]

        _validate_bag(environ, bag)
        store.put(bag)
    except BagFormatError, exc:
        raise HTTP400("unable to put bag: %s" % exc)

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def import_plugin(bag, url):
    """
    Import one plugin, at svn url, into bag, retrieving
    both the .js and .js.meta files.

    If there is no meta file, then set title and tags
    to something appropriate before de-serializing.
    """
    meta_url = "%s.meta" % url
    plugin_content = get_url(url)
    try:
        meta_content = _get_url(meta_url)
    except HTTPError:
        meta_content = "title: %s\ntags: systemConfig\n" % _strip_extension(url, ".js").split("/")[-1]

    title = [line for line in meta_content.split("\n") if line.startswith("title:")][0]
    title = title.split(":", 1)[1].lstrip().rstrip()
    tiddler_meta = "\n".join([line for line in meta_content.split("\n") if not line.startswith("title:")])

    tiddler_meta.rstrip()
    tiddler_text = "%s\n\n%s" % (tiddler_meta, plugin_content)

    tiddler = Tiddler(title, bag)
    serializer = Serializer("text")
    serializer.object = tiddler
    serializer.from_string(tiddler_text)

    _store().put(tiddler)

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def _process_request_body(environ, tiddler):
    """
    Read request body to set tiddler content.

    If a serializer exists for the content type, use it,
    otherwise treat the content as binary or pseudo-binary
    tiddler.
    """
    length, content_type = content_length_and_type(environ)
    content = read_request_body(environ, length)

    try:
        try:
            serialize_type = get_serialize_type(environ)[0]
            serializer = Serializer(serialize_type, environ)
            # Short circuit de-serialization attempt to avoid
            # decoding content multiple times.
            if hasattr(serializer.serialization, 'as_tiddler'):
                serializer.object = tiddler
                try:
                    serializer.from_string(content.decode('utf-8'))
                except TiddlerFormatError as exc:
                    raise HTTP400('unable to put tiddler: %s' % exc)
            else:
                raise NoSerializationError()
        except NoSerializationError:
            tiddler.type = content_type
            if pseudo_binary(tiddler.type):
                tiddler.text = content.decode('utf-8')
            else:
                tiddler.text = content
    except UnicodeDecodeError as exc:
        raise HTTP400('unable to decode tiddler, utf-8 expected: %s' % exc)

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def test_json_recipe():
    """
    JSON serializer roundtrips.
    """
    recipe = Recipe('other')
    recipe.set_recipe([['bagbuzz', '']])
    recipe.policy.manage = ['a']
    recipe.policy.read = ['b']
    recipe.policy.create = ['c']
    recipe.policy.delete = ['d']
    recipe.policy.owner = 'e'
    serializer = Serializer('json')
    serializer.object = recipe
    string = serializer.to_string()

    other_recipe = Recipe('other')
    serializer.object = other_recipe
    serializer.from_string(string)

    assert recipe == other_recipe

    serializer.object = other_recipe
    other_string = serializer.to_string()

    assert string == other_string

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def test_tiddler_from_json():
    serializer = Serializer('json')
    tiddler = Tiddler('test tiddler')
    serializer.object = tiddler
    serializer.from_string(expected_json_string)

    assert tiddler.title == 'test tiddler'
    assert tiddler.text == "Hello, I'm the content."

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def process_tid_tiddler(tiddler, content):
    """
    Deserialize a tid.
    """
    serializer = Serializer("text")
    serializer.object = tiddler
    serializer.from_string(content)
    return tiddler

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
 def _put(entity, content, serialization):
     """
     Put entity to store, by serializing content
     using the named serialization.
     """
     serializer = Serializer(serialization)
     serializer.object = entity
     serializer.from_string(content)
     _store().put(entity)

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def save_tiddler(store, tiddler):
    title = tiddler['title']
    bag = tiddler['bag']
    tiddler_json = simplejson.dumps(tiddler)
    tid = Tiddler(title)
    s = Serializer('json')
    s.object = tid
    s.from_string(tiddler_json)
    tid.bag = bag
    store.put(tid)

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def setup_module(module):
    init(config)
    module.environ = { 'tiddlyweb.config': config }
    serializer = Serializer('json')
    module.tiddlers = Tiddlers()
    for title, json in test_tiddlers:
        tiddler = Tiddler(title)
        serializer.object = tiddler
        serializer.from_string(json)
        module.tiddlers.add(tiddler)

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def _from_text(title, content):
    """
    generates Tiddler from an RFC822-style string

    This corresponds to TiddlyWeb's text serialization of TiddlerS.
    """
    tiddler = Tiddler(title)
    serializer = Serializer("text")
    serializer.object = tiddler
    serializer.from_string(content)
    return tiddler

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def test_json_to_bag():
    serializer = Serializer('json')
    json_string = simplejson.dumps(dict(policy=dict(read=['user1'],
        manage=['NONE']), desc='simply the best'))
    newbag = Bag('bagho')
    serializer.object = newbag
    serializer.from_string(json_string)

    assert newbag.name == 'bagho'
    assert newbag.policy.read == ['user1']
    assert newbag.policy.manage == ['NONE']
    assert newbag.desc == 'simply the best'

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def test_json_to_bag():
    serializer = Serializer("json")

    json_string = simplejson.dumps(dict(policy=dict(read=["user1"], manage=["NONE"]), desc="simply the best"))
    newbag = Bag("bagho")
    serializer.object = newbag
    serializer.from_string(json_string)

    assert newbag.name == "bagho"
    assert newbag.policy.read == ["user1"]
    assert newbag.policy.manage == ["NONE"]
    assert newbag.desc == "simply the best"

# 需要导入模块: from tiddlyweb.serializer import Serializer [as 别名]
# 或者: from tiddlyweb.serializer.Serializer import from_string [as 别名]
def test_old_text():
    """
    Send in text without a description
    and make sure we are able to accept it.
    """
    recipe = Recipe('other')
    serializer = Serializer('text')
    serializer.object = recipe
    serializer.from_string(no_desc)

    output = serializer.to_string()

    assert output == expected_string