enumplus 1.2.2__py3-none-any.whl → 1.2.3__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- enumplus/enum.py +136 -34
- enumplus/pydantic.py +2 -0
- enumplus/serialize.py +5 -1
- {enumplus-1.2.2.dist-info → enumplus-1.2.3.dist-info}/METADATA +4 -7
- enumplus-1.2.3.dist-info/RECORD +9 -0
- {enumplus-1.2.2.dist-info → enumplus-1.2.3.dist-info}/WHEEL +1 -1
- enumplus-1.2.2.dist-info/RECORD +0 -9
- {enumplus-1.2.2.dist-info → enumplus-1.2.3.dist-info}/licenses/LICENSE +0 -0
enumplus/enum.py
CHANGED
|
@@ -2,8 +2,9 @@ from __future__ import annotations
|
|
|
2
2
|
|
|
3
3
|
import enum
|
|
4
4
|
import sys
|
|
5
|
+
from collections.abc import Mapping
|
|
5
6
|
from types import NotImplementedType
|
|
6
|
-
from typing import Any, Self, TypeVar,
|
|
7
|
+
from typing import Any, Self, TypeVar, overload
|
|
7
8
|
|
|
8
9
|
if sys.version_info >= (3, 13):
|
|
9
10
|
from enum import EnumDict
|
|
@@ -12,6 +13,7 @@ else:
|
|
|
12
13
|
|
|
13
14
|
_SENTINEL = object()
|
|
14
15
|
_T = TypeVar("_T")
|
|
16
|
+
_PENDING_METADATA_ATTR = "_enumplus_pending_metadata"
|
|
15
17
|
|
|
16
18
|
|
|
17
19
|
class _EnumPlusDict(EnumDict):
|
|
@@ -52,7 +54,7 @@ class _EnumPlusDict(EnumDict):
|
|
|
52
54
|
return
|
|
53
55
|
|
|
54
56
|
if (
|
|
55
|
-
|
|
57
|
+
type(value) is tuple
|
|
56
58
|
and len(value) == 2
|
|
57
59
|
and isinstance(value[1], dict)
|
|
58
60
|
):
|
|
@@ -82,7 +84,21 @@ def _safe_equal(a: Any, b: Any) -> bool:
|
|
|
82
84
|
return False
|
|
83
85
|
|
|
84
86
|
|
|
85
|
-
|
|
87
|
+
def _match_enum_member(cls: Any, item: enum.Enum) -> Any | None:
|
|
88
|
+
"""Return the member linked to ``item`` by value-object identity.
|
|
89
|
+
|
|
90
|
+
An enum member input matches when it IS a member's value object
|
|
91
|
+
(``member.value is item``) or when its own value object IS a member
|
|
92
|
+
(``member is item.value``). Identity matching avoids the cross-enum
|
|
93
|
+
false positives that plain equality would produce.
|
|
94
|
+
"""
|
|
95
|
+
item_value = item.__dict__.get("_value_", _SENTINEL)
|
|
96
|
+
for member in cls:
|
|
97
|
+
if member.value is item or member is item_value:
|
|
98
|
+
return member
|
|
99
|
+
return None
|
|
100
|
+
|
|
101
|
+
|
|
86
102
|
class EnumMeta(enum.EnumMeta):
|
|
87
103
|
"""Metaclass for enumplus enums.
|
|
88
104
|
|
|
@@ -131,7 +147,7 @@ class EnumMeta(enum.EnumMeta):
|
|
|
131
147
|
class_config = {}
|
|
132
148
|
for key, value in list(namespace.items()):
|
|
133
149
|
if (
|
|
134
|
-
|
|
150
|
+
type(value) is tuple
|
|
135
151
|
and len(value) == 2
|
|
136
152
|
and isinstance(value[1], dict)
|
|
137
153
|
):
|
|
@@ -139,6 +155,13 @@ class EnumMeta(enum.EnumMeta):
|
|
|
139
155
|
member_metadata[key] = metadata
|
|
140
156
|
dict.__setitem__(namespace, key, actual_value)
|
|
141
157
|
|
|
158
|
+
# Expose the pending metadata map as a temporary class attribute so
|
|
159
|
+
# members can resolve it during __init__ — stdlib runs member
|
|
160
|
+
# __init__ inside super().__new__, before _metadata_ exists.
|
|
161
|
+
had_pending = _PENDING_METADATA_ATTR in namespace
|
|
162
|
+
previous_pending = dict.get(namespace, _PENDING_METADATA_ATTR)
|
|
163
|
+
dict.__setitem__(namespace, _PENDING_METADATA_ATTR, member_metadata)
|
|
164
|
+
|
|
142
165
|
new_cls = super().__new__(cls, name, bases, namespace, **kwargs)
|
|
143
166
|
|
|
144
167
|
for key, value in class_config.items():
|
|
@@ -161,6 +184,11 @@ class EnumMeta(enum.EnumMeta):
|
|
|
161
184
|
|
|
162
185
|
member._index_ = index
|
|
163
186
|
|
|
187
|
+
if had_pending:
|
|
188
|
+
setattr(new_cls, _PENDING_METADATA_ATTR, previous_pending)
|
|
189
|
+
else:
|
|
190
|
+
delattr(new_cls, _PENDING_METADATA_ATTR)
|
|
191
|
+
|
|
164
192
|
return new_cls
|
|
165
193
|
|
|
166
194
|
def __contains__(cls, item: Any) -> bool:
|
|
@@ -168,12 +196,7 @@ class EnumMeta(enum.EnumMeta):
|
|
|
168
196
|
return True
|
|
169
197
|
member: Any
|
|
170
198
|
if isinstance(item, enum.Enum):
|
|
171
|
-
|
|
172
|
-
# exact enum member (identity), not just equal by value.
|
|
173
|
-
for member in cls:
|
|
174
|
-
if member.value is item:
|
|
175
|
-
return True
|
|
176
|
-
return False
|
|
199
|
+
return _match_enum_member(cls, item) is not None
|
|
177
200
|
for member in cls:
|
|
178
201
|
if _safe_equal(member.value, item):
|
|
179
202
|
return True
|
|
@@ -203,6 +226,25 @@ class Enum(enum.Enum, metaclass=EnumMeta):
|
|
|
203
226
|
_metadata_: dict[str, Any]
|
|
204
227
|
_index_: int
|
|
205
228
|
|
|
229
|
+
def _resolve_metadata(self) -> dict[str, Any]:
|
|
230
|
+
"""Return this member's metadata, even while ``__init__`` is running.
|
|
231
|
+
|
|
232
|
+
stdlib runs member ``__init__`` before ``EnumMeta.__new__`` can attach
|
|
233
|
+
``_metadata_``; during that window the map is reachable through the
|
|
234
|
+
temporary ``_enumplus_pending_metadata`` class attribute. Members
|
|
235
|
+
created via ``enum._simple_enum`` never get ``_metadata_`` at all and
|
|
236
|
+
resolve to an empty dict.
|
|
237
|
+
"""
|
|
238
|
+
metadata: dict[str, Any] | None = self.__dict__.get("_metadata_")
|
|
239
|
+
if metadata is not None:
|
|
240
|
+
return metadata
|
|
241
|
+
pending = type(self).__dict__.get(_PENDING_METADATA_ATTR)
|
|
242
|
+
name: str | None = self.__dict__.get("_name_")
|
|
243
|
+
if not isinstance(pending, dict) or name is None:
|
|
244
|
+
return {}
|
|
245
|
+
found = pending.get(name, {})
|
|
246
|
+
return found if isinstance(found, dict) else {}
|
|
247
|
+
|
|
206
248
|
@property
|
|
207
249
|
def label(self) -> str:
|
|
208
250
|
"""Human-readable label for this member.
|
|
@@ -210,7 +252,12 @@ class Enum(enum.Enum, metaclass=EnumMeta):
|
|
|
210
252
|
If the label was set to a callable, it is evaluated on every access.
|
|
211
253
|
Falls back to ``name.replace("_", " ").title()`` when no label is set.
|
|
212
254
|
"""
|
|
213
|
-
label = self._label_
|
|
255
|
+
label = self.__dict__.get("_label_", _SENTINEL)
|
|
256
|
+
if label is _SENTINEL:
|
|
257
|
+
raw = self._resolve_metadata().get("label")
|
|
258
|
+
if raw is None:
|
|
259
|
+
raw = (self.__dict__.get("_name_") or "").replace("_", " ").title()
|
|
260
|
+
label = raw
|
|
214
261
|
if callable(label):
|
|
215
262
|
return str(label())
|
|
216
263
|
return str(label)
|
|
@@ -218,16 +265,17 @@ class Enum(enum.Enum, metaclass=EnumMeta):
|
|
|
218
265
|
@property
|
|
219
266
|
def metadata(self) -> dict[str, Any]:
|
|
220
267
|
"""Metadata dictionary attached to this member."""
|
|
221
|
-
return self.
|
|
268
|
+
return self._resolve_metadata()
|
|
222
269
|
|
|
223
270
|
def __getattr__(self, name: str) -> Any:
|
|
224
271
|
if name.startswith("_"):
|
|
225
272
|
raise AttributeError(name)
|
|
226
273
|
try:
|
|
227
|
-
return self.
|
|
274
|
+
return self._resolve_metadata()[name]
|
|
228
275
|
except KeyError:
|
|
276
|
+
member_name = self.__dict__.get("_name_", "?")
|
|
229
277
|
raise AttributeError(
|
|
230
|
-
f"{type(self).__name__}.{
|
|
278
|
+
f"{type(self).__name__}.{member_name!s} has no attribute {name!r}"
|
|
231
279
|
) from None
|
|
232
280
|
|
|
233
281
|
def __str__(self) -> str:
|
|
@@ -238,7 +286,14 @@ class Enum(enum.Enum, metaclass=EnumMeta):
|
|
|
238
286
|
|
|
239
287
|
def __eq__(self, other: object) -> bool:
|
|
240
288
|
if isinstance(other, enum.Enum):
|
|
241
|
-
|
|
289
|
+
# Identity only: a member equals another member when it is the same
|
|
290
|
+
# object, when it IS this member's value object, or when the other
|
|
291
|
+
# member's value object IS this member.
|
|
292
|
+
return (
|
|
293
|
+
self is other
|
|
294
|
+
or self.__dict__.get("_value_") is other
|
|
295
|
+
or other.__dict__.get("_value_") is self
|
|
296
|
+
)
|
|
242
297
|
return _safe_equal(self.value, other)
|
|
243
298
|
|
|
244
299
|
def __hash__(self) -> int:
|
|
@@ -247,6 +302,34 @@ class Enum(enum.Enum, metaclass=EnumMeta):
|
|
|
247
302
|
except TypeError:
|
|
248
303
|
return id(self)
|
|
249
304
|
|
|
305
|
+
@classmethod
|
|
306
|
+
def _missing_(cls, value: Any) -> Any:
|
|
307
|
+
"""Lookup fallback for ``cls(value)``, matching ``from_value()`` semantics.
|
|
308
|
+
|
|
309
|
+
Keeps ``cls(value)`` consistent with ``cls.from_value(value)``: enum
|
|
310
|
+
member inputs match by value-object identity, everything else by safe
|
|
311
|
+
equality. Without it, ``cls(value)`` raises for values that
|
|
312
|
+
``from_value()`` resolves (e.g. a member whose value is itself an enum
|
|
313
|
+
member compared through a non-hash-stable ``__eq__``).
|
|
314
|
+
|
|
315
|
+
Classes mixing in ``enum.Flag`` delegate to the stdlib implementation:
|
|
316
|
+
flag lookups need boundary handling and composite pseudo-members.
|
|
317
|
+
"""
|
|
318
|
+
if issubclass(cls, enum.Flag):
|
|
319
|
+
for base in cls.__mro__:
|
|
320
|
+
if not issubclass(base, enum.Flag):
|
|
321
|
+
continue
|
|
322
|
+
missing = base.__dict__.get("_missing_")
|
|
323
|
+
if missing is not None:
|
|
324
|
+
return missing.__get__(None, cls)(value)
|
|
325
|
+
return None
|
|
326
|
+
if isinstance(value, enum.Enum):
|
|
327
|
+
return _match_enum_member(cls, value)
|
|
328
|
+
for member in cls:
|
|
329
|
+
if _safe_equal(member.value, value):
|
|
330
|
+
return member
|
|
331
|
+
return None
|
|
332
|
+
|
|
250
333
|
@classmethod
|
|
251
334
|
def choices(cls) -> list[tuple[Any, str]]:
|
|
252
335
|
"""Return ``[(value, label), ...]`` for forms and dropdowns."""
|
|
@@ -289,11 +372,9 @@ class Enum(enum.Enum, metaclass=EnumMeta):
|
|
|
289
372
|
if isinstance(value, cls):
|
|
290
373
|
return value
|
|
291
374
|
if isinstance(value, enum.Enum):
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
if member.value is value:
|
|
296
|
-
return member
|
|
375
|
+
member = _match_enum_member(cls, value)
|
|
376
|
+
if member is not None:
|
|
377
|
+
return member
|
|
297
378
|
if default is not _SENTINEL:
|
|
298
379
|
return default
|
|
299
380
|
raise ValueError(f"{value!r} is not a valid {cls.__name__} value")
|
|
@@ -365,12 +446,7 @@ class Enum(enum.Enum, metaclass=EnumMeta):
|
|
|
365
446
|
if isinstance(value, cls):
|
|
366
447
|
return True
|
|
367
448
|
if isinstance(value, enum.Enum):
|
|
368
|
-
|
|
369
|
-
# exact enum member (identity), not just equal by value.
|
|
370
|
-
for member in cls:
|
|
371
|
-
if member.value is value:
|
|
372
|
-
return True
|
|
373
|
-
return False
|
|
449
|
+
return _match_enum_member(cls, value) is not None
|
|
374
450
|
for member in cls:
|
|
375
451
|
if member is value or _safe_equal(member.value, value):
|
|
376
452
|
return True
|
|
@@ -443,12 +519,19 @@ class Enum(enum.Enum, metaclass=EnumMeta):
|
|
|
443
519
|
return members[-1]
|
|
444
520
|
|
|
445
521
|
@classmethod
|
|
446
|
-
def map(cls, mapping:
|
|
522
|
+
def map(cls, mapping: Mapping[Self, Any]) -> dict[str, Any]:
|
|
447
523
|
"""Map each member to a value via ``mapping``.
|
|
448
524
|
|
|
449
525
|
Returns ``{name: mapped_value}`` for every member. Members not present
|
|
450
526
|
in ``mapping`` get ``None``.
|
|
527
|
+
|
|
528
|
+
Raises:
|
|
529
|
+
TypeError: If ``mapping`` is not a mapping.
|
|
451
530
|
"""
|
|
531
|
+
if not isinstance(mapping, Mapping):
|
|
532
|
+
raise TypeError(
|
|
533
|
+
f"map expects a mapping, got {type(mapping).__name__}"
|
|
534
|
+
)
|
|
452
535
|
result: dict[str, Any] = {}
|
|
453
536
|
for member in cls:
|
|
454
537
|
result[member.name] = mapping.get(member, None)
|
|
@@ -461,7 +544,7 @@ class Enum(enum.Enum, metaclass=EnumMeta):
|
|
|
461
544
|
for member in cls:
|
|
462
545
|
label = member.label
|
|
463
546
|
metadata: dict[str, Any] = {}
|
|
464
|
-
for k, v in member.
|
|
547
|
+
for k, v in member.metadata.items():
|
|
465
548
|
if k == "label" and callable(v):
|
|
466
549
|
metadata[k] = label
|
|
467
550
|
else:
|
|
@@ -484,11 +567,11 @@ class Enum(enum.Enum, metaclass=EnumMeta):
|
|
|
484
567
|
return list(cls)
|
|
485
568
|
result: list[Self] = []
|
|
486
569
|
for member in cls:
|
|
570
|
+
metadata = member.metadata
|
|
487
571
|
if all(
|
|
488
572
|
_safe_equal(member.label, value)
|
|
489
573
|
if key == "label"
|
|
490
|
-
else key in
|
|
491
|
-
and _safe_equal(member._metadata_[key], value)
|
|
574
|
+
else key in metadata and _safe_equal(metadata[key], value)
|
|
492
575
|
for key, value in kwargs.items()
|
|
493
576
|
):
|
|
494
577
|
result.append(member)
|
|
@@ -529,22 +612,41 @@ class OrderedEnum(Enum):
|
|
|
529
612
|
Also works with ``sorted()``, ``min()``, and ``max()``.
|
|
530
613
|
"""
|
|
531
614
|
|
|
615
|
+
def _sort_index(self) -> int:
|
|
616
|
+
"""Declaration-order index used by the comparison operators.
|
|
617
|
+
|
|
618
|
+
``_index_`` is attached by ``EnumMeta.__new__`` after member creation.
|
|
619
|
+
Members built outside that path (``enum._simple_enum``) fall back to
|
|
620
|
+
the stdlib ``_sort_order_``, and during member ``__init__`` — before
|
|
621
|
+
either exists — to the number of members registered so far.
|
|
622
|
+
"""
|
|
623
|
+
index: int | None = self.__dict__.get("_index_")
|
|
624
|
+
if index is not None:
|
|
625
|
+
return index
|
|
626
|
+
sort_order: int | None = self.__dict__.get("_sort_order_")
|
|
627
|
+
if sort_order is not None:
|
|
628
|
+
return sort_order
|
|
629
|
+
names: list[str] | None = type(self).__dict__.get("_member_names_")
|
|
630
|
+
if names is not None:
|
|
631
|
+
return len(names)
|
|
632
|
+
return 0
|
|
633
|
+
|
|
532
634
|
def __lt__(self, other: object) -> bool | NotImplementedType:
|
|
533
635
|
if not isinstance(other, type(self)):
|
|
534
636
|
return NotImplemented
|
|
535
|
-
return self.
|
|
637
|
+
return self._sort_index() < other._sort_index()
|
|
536
638
|
|
|
537
639
|
def __le__(self, other: object) -> bool | NotImplementedType:
|
|
538
640
|
if not isinstance(other, type(self)):
|
|
539
641
|
return NotImplemented
|
|
540
|
-
return self.
|
|
642
|
+
return self._sort_index() <= other._sort_index()
|
|
541
643
|
|
|
542
644
|
def __gt__(self, other: object) -> bool | NotImplementedType:
|
|
543
645
|
if not isinstance(other, type(self)):
|
|
544
646
|
return NotImplemented
|
|
545
|
-
return self.
|
|
647
|
+
return self._sort_index() > other._sort_index()
|
|
546
648
|
|
|
547
649
|
def __ge__(self, other: object) -> bool | NotImplementedType:
|
|
548
650
|
if not isinstance(other, type(self)):
|
|
549
651
|
return NotImplemented
|
|
550
|
-
return self.
|
|
652
|
+
return self._sort_index() >= other._sort_index()
|
enumplus/pydantic.py
CHANGED
|
@@ -31,6 +31,8 @@ def get_pydantic_core_schema(
|
|
|
31
31
|
from pydantic_core import core_schema
|
|
32
32
|
|
|
33
33
|
serialize_by_name = getattr(cls, "serialize_by_name", False)
|
|
34
|
+
if not isinstance(serialize_by_name, bool):
|
|
35
|
+
serialize_by_name = False
|
|
34
36
|
|
|
35
37
|
def validate(value: Any) -> Any:
|
|
36
38
|
if isinstance(value, cls):
|
enumplus/serialize.py
CHANGED
|
@@ -21,11 +21,15 @@ def to_json(cls: type[Enum]) -> str:
|
|
|
21
21
|
]
|
|
22
22
|
}
|
|
23
23
|
"""
|
|
24
|
+
if not isinstance(cls, type) or not issubclass(cls, Enum):
|
|
25
|
+
raise TypeError(
|
|
26
|
+
f"to_json expects an Enum subclass, got {type(cls).__name__}"
|
|
27
|
+
)
|
|
24
28
|
members: list[dict[str, Any]] = []
|
|
25
29
|
for member in cls:
|
|
26
30
|
label = member.label
|
|
27
31
|
metadata: dict[str, Any] = {}
|
|
28
|
-
for k, v in member.
|
|
32
|
+
for k, v in member.metadata.items():
|
|
29
33
|
if k == "label" and callable(v):
|
|
30
34
|
metadata[k] = label
|
|
31
35
|
else:
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
Metadata-Version: 2.5
|
|
2
2
|
Name: enumplus
|
|
3
|
-
Version: 1.2.
|
|
3
|
+
Version: 1.2.3
|
|
4
4
|
Summary: Enhanced Python enums with metadata, serialization, and choices
|
|
5
5
|
Project-URL: Homepage, https://pypi.org/project/enumplus/
|
|
6
6
|
Project-URL: Repository, https://github.com/MathiasPaulenko/enumplus
|
|
@@ -438,20 +438,17 @@ Callable labels work everywhere: `choices()`, `to_dict()`, `to_json()`, `labels(
|
|
|
438
438
|
|
|
439
439
|
### Type hints in metadata
|
|
440
440
|
|
|
441
|
-
|
|
441
|
+
Metadata attributes are resolved at runtime through `__getattr__`, which
|
|
442
|
+
returns `Any`. Type checkers therefore accept `member.<key>` accesses as
|
|
443
|
+
`Any`, but cannot verify individual key names or value types.
|
|
442
444
|
|
|
443
445
|
```python
|
|
444
446
|
class Color(Enum):
|
|
445
447
|
RED = ("red", {"hex": "#FF0000"})
|
|
446
448
|
|
|
447
|
-
# Type checkers recognize .hex as a valid attribute
|
|
448
449
|
Color.RED.hex # inferred as Any via __getattr__
|
|
449
450
|
```
|
|
450
451
|
|
|
451
|
-
> **Note:** Type inference for metadata attributes depends on the type checker.
|
|
452
|
-
> The `@dataclass_transform()` decorator provides the structural hint, but
|
|
453
|
-
> runtime attribute access goes through `__getattr__`, which returns `Any`.
|
|
454
|
-
|
|
455
452
|
## Migration from stdlib
|
|
456
453
|
|
|
457
454
|
Just change one import:
|
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
enumplus/__init__.py,sha256=SL5Ha239lvjWylYXhQwOXHhn5aoJ6gwrPacqWUJBIdE,559
|
|
2
|
+
enumplus/enum.py,sha256=2kHo1ywj9vfafjULGVoVQhrCJC2dPjUFRYoXwTQSuFY,23023
|
|
3
|
+
enumplus/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
4
|
+
enumplus/pydantic.py,sha256=yJI2CelmRF8Dcc2D__GF_3xw3AHAUa0jY6ff73iU7oU,1726
|
|
5
|
+
enumplus/serialize.py,sha256=xp7e8gA-Bb4LFYsxummYil_DTMzAT-OpT_RSVFuBLLM,2399
|
|
6
|
+
enumplus-1.2.3.dist-info/METADATA,sha256=5jZDknbGRG9Jca6Y0LmpUk8fM1fslJ3Py-7U9C5rWo4,13667
|
|
7
|
+
enumplus-1.2.3.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
|
|
8
|
+
enumplus-1.2.3.dist-info/licenses/LICENSE,sha256=-u49HL0SZacgwXQDMirUyEbyPVnB1lWwjNOj79ho2Qs,1078
|
|
9
|
+
enumplus-1.2.3.dist-info/RECORD,,
|
enumplus-1.2.2.dist-info/RECORD
DELETED
|
@@ -1,9 +0,0 @@
|
|
|
1
|
-
enumplus/__init__.py,sha256=SL5Ha239lvjWylYXhQwOXHhn5aoJ6gwrPacqWUJBIdE,559
|
|
2
|
-
enumplus/enum.py,sha256=R4vX8ta5QmnTwLj3SD_rWkUQrk5iV1_OUobWQekUfU4,18423
|
|
3
|
-
enumplus/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
4
|
-
enumplus/pydantic.py,sha256=a7X_ugDxQGUt6ssICoQfp8Cb1wrcN5JUkFZoIMzqBts,1644
|
|
5
|
-
enumplus/serialize.py,sha256=_NAhc9TSnEAU04Il8BFgbcKiHpRkCHcnEJbKFhB1zss,2229
|
|
6
|
-
enumplus-1.2.2.dist-info/METADATA,sha256=pgO6tGFeQgXlgr8vG2BpYigfBOzJmrHkKJSjaYYUt1k,13851
|
|
7
|
-
enumplus-1.2.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
|
|
8
|
-
enumplus-1.2.2.dist-info/licenses/LICENSE,sha256=-u49HL0SZacgwXQDMirUyEbyPVnB1lWwjNOj79ho2Qs,1078
|
|
9
|
-
enumplus-1.2.2.dist-info/RECORD,,
|
|
File without changes
|