def test_frozendict(): efd = FrozenDict() assert isinstance(efd, dict) assert len(efd) == 0 assert not efd assert repr(efd) == "FrozenDict({})" data = {'a': 'A', 'b': 'B'} fd = FrozenDict(data) assert bool(fd) assert len(fd) == 2 assert fd['a'] == 'A' assert fd['b'] == 'B' assert sorted(fd.keys()) == ['a', 'b'] assert sorted(fd.values()) == ['A', 'B'] assert sorted(fd.items()) == [('a', 'A'), ('b', 'B')] assert 'a' in fd assert 'c' not in fd assert hash(fd) fd_map = {'fd': fd} assert fd_map['fd'] is fd with pytest.raises(TypeError): fd['c'] = 'C' with pytest.raises(TypeError): del fd['a'] with pytest.raises(TypeError): fd.update(x='X') with pytest.raises(TypeError): fd.setdefault('x', []) with pytest.raises(TypeError): fd.pop('c') with pytest.raises(TypeError): fd.popitem() with pytest.raises(TypeError): fd.clear() import pickle fkfd = FrozenDict.fromkeys([2, 4, 6], value=0) assert pickle.loads(pickle.dumps(fkfd)) == fkfd assert sorted(fkfd.updated({8: 0}).keys()) == [2, 4, 6, 8] # try something with an unhashable value unfd = FrozenDict({'a': ['A']}) with pytest.raises(TypeError) as excinfo: {unfd: 'val'} assert excinfo.type is FrozenHashError with pytest.raises(TypeError) as excinfo2: {unfd: 'val'} assert excinfo.value is excinfo2.value # test cached exception return
def is_windows(): """ Return `True` only if current platform is of the Windows family. """ return sys.platform in ['win32', 'cygwin'] # Map OS IDs to evaluation function and OS labels. OS_DEFINITIONS = FrozenDict({ LINUX: ('Linux', is_linux()), MACOS: ('macOS', is_macos()), WINDOWS: ('Windows', is_windows()) }) # Generare sets of recognized IDs and labels. ALL_OS_LABELS = frozenset([label for label, _ in OS_DEFINITIONS.values()]) def os_label(os_id): """ Return platform label for user-friendly output. """ return OS_DEFINITIONS[os_id][0] logger.debug(f"Raw platform ID: {sys.platform}.") def current_os(): """ Return a 2-items `tuple` with ID and label of current OS. """ for os_id, (os_name, os_flag) in OS_DEFINITIONS.items(): if os_flag is True: return os_id, os_name
# Generates our own box_type_id for use in CLI parameters. box_type_id = klass.__name__.lower() yield box_type_id, constructor # Mapping between supported box type IDs and their constructors. BOX_TYPES = FrozenDict(build_box_constructors()) # Categorize each box type into its structure type. BOX_STRUCTURES = FrozenDict({ "file": {"mbox", "mmdf", "babyl"}, "folder": {"maildir", "mh"}, }) # Check we did not forgot any box type. assert set(flatten(BOX_STRUCTURES.values())) == set(BOX_TYPES) # List of required sub-folders defining a properly structured maildir. MAILDIR_SUBDIRS = frozenset(("cur", "new", "tmp")) def autodetect_box_type(path): """Auto-detect the format of the mailbox located at the provided path. Returns a box type as indexed in the ``box_types`` dictionnary above. If the path is a file, then it is considered as an ``mbox``. Else, if th provided path is a folder and feature the expecteed sub-directories, it is parsed as a ``maildir``. Future finer autodetection heuristics should be implemented here. Some ideas: