Skip to content

Human-readable text syntax

TODO

Formatter(format_embedded=lambda x: x, indent=None, with_commas=False, trailing_comma=False, include_annotations=True)

Bases: TextCodec

TODO

TODO

Source code in preserves/text.py
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
def __init__(self,
             format_embedded=lambda x: x,
             indent=None,
             with_commas=False,
             trailing_comma=False,
             include_annotations=True):
    """TODO"""
    super(Formatter, self).__init__()
    self.indent_delta = 0 if indent is None else indent
    self.indent_distance = 0
    self.with_commas = with_commas
    self.trailing_comma = trailing_comma
    self.chunks = []
    self._format_embedded = format_embedded
    self.include_annotations = include_annotations

append(v)

TODO

Source code in preserves/text.py
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
def append(self, v):
    """TODO"""
    v = preserve(v)
    if hasattr(v, '__preserve_write_text__'):
        v.__preserve_write_text__(self)
    elif v is False:
        self.chunks.append('#f')
    elif v is True:
        self.chunks.append('#t')
    elif isinstance(v, float):
        if math.isnan(v) or math.isinf(v):
            self.chunks.append('#xd"' + struct.pack('>d', v).hex() + '"')
        else:
            self.chunks.append(repr(v))
    elif isinstance(v, numbers.Number):
        self.chunks.append('%d' % (v,))
    elif isinstance(v, bytes):
        self.chunks.append('#[%s]' % (base64.b64encode(v).decode('ascii'),))
    elif isinstance(v, basestring_):
        self.chunks.append('"')
        for c in v:
            if c == '"': self.chunks.append('\\"')
            else: self.write_stringlike_char(c)
        self.chunks.append('"')
    elif isinstance(v, list):
        self.write_seq('[', ']', v, self.append)
    elif isinstance(v, tuple):
        self.write_seq('[', ']', v, self.append)
    elif isinstance(v, set):
        self.write_seq('#{', '}', v, self.append)
    elif isinstance(v, frozenset):
        self.write_seq('#{', '}', v, self.append)
    elif isinstance(v, dict):
        def append_kv(kv):
            self.append(kv[0])
            self.chunks.append(': ')
            self.append(kv[1])
        self.write_seq('{', '}', v.items(), append_kv)
    else:
        try:
            i = iter(v)
        except TypeError:
            i = None
        if i is None:
            self.cannot_format(v)
        else:
            self.write_seq('[', ']', i, self.append)

contents()

TODO

Source code in preserves/text.py
325
326
327
def contents(self):
    """TODO"""
    return u''.join(self.chunks)

Parser(input_buffer='', include_annotations=False, parse_embedded=lambda x: x)

Bases: TextCodec

TODO

TODO

Source code in preserves/text.py
22
23
24
25
26
27
28
def __init__(self, input_buffer=u'', include_annotations=False, parse_embedded=lambda x: x):
    """TODO"""
    super(Parser, self).__init__()
    self.input_buffer = input_buffer
    self.index = 0
    self.include_annotations = include_annotations
    self.parse_embedded = parse_embedded

__iter__()

TODO

Source code in preserves/text.py
284
285
286
def __iter__(self):
    """TODO"""
    return self

extend(text)

TODO

Source code in preserves/text.py
30
31
32
33
def extend(self, text):
    """TODO"""
    self.input_buffer = self.input_buffer[self.index:] + text
    self.index = 0

next()

TODO

Source code in preserves/text.py
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
def next(self):
    """TODO"""
    self.skip_whitespace()
    c = self.peek()
    if c == '"':
        self.skip()
        return self.wrap(self.read_string('"'))
    if c == '|':
        self.skip()
        return self.wrap(Symbol(self.read_string('|')))
    if c in ';@':
        annotations = self.gather_annotations()
        v = self.next()
        if self.include_annotations:
            v.annotations = annotations + v.annotations
        return v
    if c == ':':
        raise DecodeError('Unexpected key/value separator between items')
    if c == '#':
        self.skip()
        c = self.nextchar()
        if c == 'f': return self.wrap(False)
        if c == 't': return self.wrap(True)
        if c == '{': return self.wrap(frozenset(self.upto('}')))
        if c == '"': return self.wrap(self.read_literal_binary())
        if c == 'x':
            c = self.nextchar()
            if c == '"': return self.wrap(self.read_hex_binary())
            if c == 'f': return self.wrap(self.read_hex_float(4))
            if c == 'd': return self.wrap(self.read_hex_float(8))
            raise DecodeError('Invalid #x syntax')
        if c == '[': return self.wrap(self.read_base64_binary())
        if c == '=':
            old_ann = self.include_annotations
            self.include_annotations = True
            bs_val = self.next()
            self.include_annotations = old_ann
            if len(bs_val.annotations) > 0:
                raise DecodeError('Annotations not permitted after #=')
            bs_val = bs_val.item
            if not isinstance(bs_val, bytes):
                raise DecodeError('ByteString must follow #=')
            return self.wrap(Decoder(bs_val, include_annotations = self.include_annotations).next())
        if c == '!':
            if self.parse_embedded is None:
                raise DecodeError('No parse_embedded function supplied')
            return self.wrap(Embedded(self.parse_embedded(self.next())))
        raise DecodeError('Invalid # syntax')
    if c == '<':
        self.skip()
        vs = self.upto('>')
        if len(vs) == 0:
            raise DecodeError('Missing record label')
        return self.wrap(Record(vs[0], vs[1:]))
    if c == '[':
        self.skip()
        return self.wrap(self.upto(']'))
    if c == '{':
        self.skip()
        return self.wrap(self.read_dictionary())
    if c in '>]}':
        raise DecodeError('Unexpected ' + c)
    self.skip()
    return self.wrap(self.read_raw_symbol_or_number([c]))

try_next()

TODO

Source code in preserves/text.py
275
276
277
278
279
280
281
282
def try_next(self):
    """TODO"""
    start = self.index
    try:
        return self.next()
    except ShortPacket:
        self.index = start
        return None

TextCodec

Bases: object

TODO

parse(bs, **kwargs)

TODO

Source code in preserves/text.py
294
295
296
def parse(bs, **kwargs):
    """TODO"""
    return Parser(input_buffer=bs, **kwargs).next()

parse_with_annotations(bs, **kwargs)

TODO

Source code in preserves/text.py
298
299
300
def parse_with_annotations(bs, **kwargs):
    """TODO"""
    return Parser(input_buffer=bs, include_annotations=True, **kwargs).next()

stringify(v, **kwargs)

TODO

Source code in preserves/text.py
423
424
425
426
427
def stringify(v, **kwargs):
    """TODO"""
    e = Formatter(**kwargs)
    e.append(v)
    return e.contents()