py2dataclasses 3.14.112__py2-none-any.whl

_py2dataclasses/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import absolute_import
+from .abc_utils import ABC
+__all__ = ['dataclass',
+           'field',
+           '_Field',
+           'Field',
+           'of',
+           'FrozenInstanceError',
+           'InitVar',
+           'KW_ONLY',
+           'MISSING',
+
+           # Helper functions.
+           'fields',
+           'asdict',
+           'astuple',
+           'make_dataclass',
+           'replace',
+           'is_dataclass',
+           #'_oneshot',
+           'ABC',
+           '_dataclass_getstate',
+           '_dataclass_setstate',
+           #  'of_factory',
+           # 'of_typed',
+           # 'ann',
+           # 'IntField',
+           # 'typed'
+           ]
+
+
+from .dataclasses import dataclass, field, _Field, FrozenInstanceError, InitVar, KW_ONLY, MISSING, fields, asdict, \
+    astuple, make_dataclass, replace, is_dataclass, of, \
+    _dataclass_getstate, _dataclass_setstate, Field  # of_factory, of_typed, ann, IntField, typed

_py2dataclasses/abc_utils.py

@@ -0,0 +1,45 @@
+from abc import ABCMeta
+
+import six
+
+
+@six.add_metaclass(ABCMeta)
+class ABC(object): pass
+
+
+def update_abstractmethods(cls):
+    """Recalculate the set of abstract methods of an abstract class.
+
+    If a class has had one of its abstract methods implemented after the
+    class was created, the method will not be considered implemented until
+    this function is called. Alternatively, if a new abstract method has been
+    added to the class, it will only be considered an abstract method of the
+    class after this function is called.
+
+    This function should be called before any use is made of the class,
+    usually in class decorators that add methods to the subject class.
+
+    Returns cls, to allow usage as a class decorator.
+
+    If cls is not an instance of ABCMeta, does nothing.
+    """
+    if not hasattr(cls, '__abstractmethods__'):
+        # We check for __abstractmethods__ here because cls might by a C
+        # implementation or a python implementation (especially during
+        # testing), and we want to handle both cases.
+        return cls
+
+    abstracts = set()
+    # Check the existing abstract methods of the parents, keep only the ones
+    # that are not implemented.
+    for scls in cls.__bases__:
+        for name in getattr(scls, '__abstractmethods__', ()):
+            value = getattr(cls, name, None)
+            if getattr(value, "__isabstractmethod__", False):
+                abstracts.add(name)
+    # Also add any other newly added abstract methods.
+    for name, value in cls.__dict__.items():
+        if getattr(value, "__isabstractmethod__", False):
+            abstracts.add(name)
+    cls.__abstractmethods__ = frozenset(abstracts)
+    return cls

_py2dataclasses/class_utils.py

@@ -0,0 +1,57 @@
+
+
+def is_descriptor(obj):
+    """Returns True if obj is a descriptor, False otherwise."""
+    return (
+            hasattr(obj, '__get__') or
+            hasattr(obj, '__set__') or
+            hasattr(obj, '__delete__'))
+
+def type_qualname(o):
+    klass = o.__class__
+    return qualname(klass)
+
+def qualname(o):
+    #return compute_qualname(o)
+    existing = getattr(o, "__qualname__", None)
+    if existing:
+        return existing
+
+    return _qualname(o)
+def _qualname(o):
+    klass = o
+    module = klass.__module__
+    if module == '__builtin__':
+        return klass.__name__ # avoid outputs like '__builtin__.str'
+    return module + '.' + klass.__name__
+
+import inspect
+
+def compute_qualname(cls):
+    if hasattr(cls, "__qualname__"):
+        return cls.__qualname__
+
+    name = cls.__name__
+
+    frame = inspect.currentframe()
+    try:
+        frame = frame.f_back
+        parts = []
+
+        while frame:
+            code_name = frame.f_code.co_name
+            if code_name == '<module>':
+                break
+
+            if 'self' in frame.f_locals:
+                parts.append(frame.f_locals['self'].__class__.__name__)
+
+            parts.append(code_name)
+            parts.append('<locals>')
+            frame = frame.f_back
+
+        parts.reverse()
+        parts.append(name)
+        return ".".join(parts)
+    finally:
+        del frame