def test_docs_table_any(): class Table(object): def __init__(self, height, width): self.height = height self.width = width def __repr__(self): return "<Table {self.height!r}x{self.width!r}>".format(self=self) from camel import Camel, CamelRegistry my_types = CamelRegistry() @my_types.loader('table', version=any) def _load_table(data, version): if 'size' in data: # version 1 edge = data['size']**0.5 return Table(edge, edge) else: # version 2?) return Table(data['height'], data['width']) camel = Camel([my_types]) table1, table2 = camel.load( "[!table;1 {size: 49}, !table;2 {height: 5, width: 9}]") assert table1.height == 7 assert table1.width == 7 assert table2.height == 5 assert table2.width == 9
def test_docs_deleted(): class DummyData(object): def __init__(self, data): self.data = data from camel import Camel, CamelRegistry my_types = CamelRegistry() @my_types.loader('deleted-type', version=all) def _load_deleted_type(data, version): return DummyData(data) camel = Camel([my_types]) assert isinstance(camel.load("""!deleted-type;4 foo"""), DummyData)
def test_docs_table_v2(): # Tables can be rectangles now! class Table(object): def __init__(self, height, width): self.height = height self.width = width def __repr__(self): return "<Table {self.height!r}x{self.width!r}>".format(self=self) from camel import Camel, CamelRegistry my_types = CamelRegistry() @my_types.dumper(Table, 'table', version=2) def _dump_table_v2(table): return { 'height': table.height, 'width': table.width, } @my_types.loader('table', version=2) def _load_table_v2(data, version): return Table(data["height"], data["width"]) @my_types.loader('table', version=1) def _load_table_v1(data, version): edge = data["size"]**0.5 return Table(edge, edge) table = Table(7, 10) assert Camel([my_types]).dump(table) == textwrap.dedent(""" !table;2 height: 7 width: 10 """).lstrip() @my_types.dumper(Table, 'table', version=1) def _dump_table_v1(table): return { # not really, but the best we can manage 'size': table.height * table.width, } camel = Camel([my_types]) camel.lock_version(Table, 1) assert camel.dump(Table(5, 7)) == "!table;1\nsize: 35\n"
def test_docs_table_v1(): class Table(object): def __init__(self, size): self.size = size def __repr__(self): return "<Table {self.size!r}>".format(self=self) from camel import CamelRegistry my_types = CamelRegistry() @my_types.dumper(Table, 'table', version=1) def _dump_table(table): return { 'size': table.size, } @my_types.loader('table', version=1) def _load_table(data, version): return Table(data["size"]) from camel import Camel table = Table(25) assert Camel([my_types]).dump(table) == "!table;1\nsize: 25\n" data = {'chairs': [], 'tables': [Table(25), Table(36)]} assert Camel([my_types]).dump(data) == textwrap.dedent(""" chairs: [] tables: - !table;1 size: 25 - !table;1 size: 36 """).lstrip() table, = Camel([my_types]).load("[!table;1 {size: 100}]") assert isinstance(table, Table) assert table.size == 100
assert vanilla_camel.load(dumped) == value # ----------------------------------------------------------------------------- # Simple custom type class DieRoll(tuple): def __new__(cls, a, b): return tuple.__new__(cls, [a, b]) def __repr__(self): return "DieRoll(%s,%s)" % self reg = CamelRegistry() @reg.dumper(DieRoll, 'roll', version=None) def dump_dice(data): return "{}d{}".format(*data) @reg.loader('roll', version=None) def load_dice(data, version): # TODO enforce incoming data is a string? a, _, b = data.partition('d') return DieRoll(int(a), int(b)) def test_dieroll():
import sys, zlib, logging, collections from concurrent.futures import ThreadPoolExecutor from abc import abstractmethod, ABC from camel import CamelRegistry, Camel _logger = logging.getLogger("apples.englishActions." + __name__) thing_camel_registry = CamelRegistry() misc_camel_registry = CamelRegistry() camel_registries = (thing_camel_registry, misc_camel_registry) thing_storage = [] dumper = thing_camel_registry.dumper loader = thing_camel_registry.loader misc_dumper = misc_camel_registry.dumper misc_loader = misc_camel_registry.loader def dump_raw(thing): raw = Camel(camel_registries).dump(thing) return raw def dump(thing): _logger.debug("Dumping %s.", thing.name) raw = dump_raw(thing).encode("utf-8") _logger.debug("Dumped %s to %s bytes.", thing.name, len(raw)) _logger.debug("Compressing dumped %s.", thing.name) data = zlib.compress(raw, level=9) _logger.debug("Compressed dumped %s to %s bytes.", thing.name, len(data))
@author: brian ''' from textwrap import dedent import pandas, numpy from pandas.api.types import CategoricalDtype from pyface.api import error from traits.api import DelegationError #### YAML serialization from camel import Camel, CamelRegistry, YAML_TAG_PREFIX # the camel registry singletons camel_registry = CamelRegistry() standard_types_registry = CamelRegistry(tag_prefix=YAML_TAG_PREFIX) def load_yaml(path): with open(path, 'r') as f: data = Camel([camel_registry]).load(f.read()) return data def save_yaml(data, path, lock_versions={}): with open(path, 'w') as f: c = Camel([standard_types_registry, camel_registry]) for klass, version in lock_versions.items(): c.lock_version(klass, version)
from camel import CamelRegistry # type: ignore from collections import defaultdict camelRegistry = CamelRegistry() @camelRegistry.dumper(defaultdict, "defaultdict", version=1) def _dump_defaultdict(defaultdict_): return dict(default_factory=defaultdict_.default_factory, dict_=dict(defaultdict_)) @camelRegistry.loader("defaultdict", version=1) def _load_defaultdict(data, version): return defaultdict(data["default_factory"], data["dict_"]) @camelRegistry.dumper(type, "type", version=1) def _dump_type(type_): return dict(name=type_.__name__, module=type_.__module__) @camelRegistry.loader("type", version=1) def _load_type(data, version): import importlib module_ = importlib.import_module(data["module"]) return getattr(module_, data["name"])
# ----------------------------------------------------------------------------- # Simple custom type class DieRoll(tuple): def __new__(cls, a, b): return tuple.__new__(cls, [a, b]) def __repr__(self): return "DieRoll(%s,%s)" % self # Dump/load as a compact string reg = CamelRegistry() @reg.dumper(DieRoll, 'roll', version=None) def dump_dice(data): return "{}d{}".format(*data) @reg.loader('roll', version=None) def load_dice(data, version): # TODO enforce incoming data is a string? a, _, b = data.partition('d') return DieRoll(int(a), int(b)) def test_dieroll():
# FSOS: Registries. # Do not import any other modules from here. # But add this to your file like this: # from reg import version, ui, fs, hw, c, gets, sets # Registries should always be of type "Dict". from addict import Dict import sys, traceback from html import escape import fsts from camel import Camel, CamelRegistry import pprint, config, os caramel = CamelRegistry() version = 0.5 ui = Dict() fs = Dict() hw = Dict() proc = Dict() cron = Dict() def extget(k): try: with open("/run/shm/" + k) as q: return q.read() except: return {} def extset(k, v):