forked from opencobra/cobrapy
-
Notifications
You must be signed in to change notification settings - Fork 1
/
keyvaluepairs.py
101 lines (80 loc) · 2.65 KB
/
keyvaluepairs.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
from collections import OrderedDict
from collections.abc import MutableMapping
from typing import Dict, Iterable, Union
class KeyValueEntry:
""" Single key-value entry.
The key is an attribute on the entry.
Parameters
----------
id : str
name : str
key : str
value : str
uri : str
"""
def __init__(
self,
id: str = None,
name: str = None,
key: str = None,
value: str = None,
uri: str = None,
):
self.id = id
self.name = name
self.key = key
self.value = value
self.uri = uri
@staticmethod
def from_data(data: Union[Dict, "KeyValueEntry"]) -> "KeyValueEntry":
""" Makes a KeyValueDict object using the data passed. """
if data is None:
return KeyValueEntry()
elif isinstance(data, KeyValueEntry):
return data
elif isinstance(data, dict):
return KeyValueEntry(**data)
else:
raise TypeError(f"Invalid format for KeyValueEntry: '{data}'")
def to_dict(self) -> dict:
return {
"id": self.id,
"name": self.name,
"key": self.key,
"value": self.value,
"uri": self.uri,
}
def __str__(self) -> str:
return str(self.to_dict())
def __repr__(self) -> str:
return f"<{self.__class__.__name__} ({self.key}, {self.value}, {self.uri})>"
class KeyValuePairs(MutableMapping):
"""An OrderedDict extension to store KeyValueEntries
Parameters
----------
entries : Iterable
an iterable containing entry information
"""
def __init__(self, entries: Iterable[Union[Dict, KeyValueEntry]] = None):
self.mapping = OrderedDict() # type: OrderedDict[str, KeyValueEntry]
if entries:
for item in entries:
entry = KeyValueEntry.from_data(item)
self.mapping[entry.key] = entry
def __getitem__(self, key: str) -> KeyValueEntry:
return self.mapping.__getitem__(key)
def __setitem__(self, key: str, item: Union[Dict, KeyValueEntry]) -> None:
entry = KeyValueEntry.from_data(item)
self.mapping[key] = entry
def __len__(self) -> int:
return len(self.mapping)
def __iter__(self):
return iter(self.mapping)
def __delitem__(self, key: str) -> None:
del self.mapping[key]
def __str__(self) -> str:
return str(self.to_dict())
def __repr__(self) -> str:
return f"<{self.__class__.__name__} [{len(self)}]>"
def to_dict(self) -> dict:
return {k: v.to_dict() for k, v in self.mapping.items()}