def __new_

def new()

in core/maxframe/serialization/serializables/core.py [0:0]
82 lines of code
13 McCabe index (conditional complexity)

    def __new__(mcs, name: str, bases: Tuple[Type], properties: Dict):
        # All the fields including misc fields.
        legacy_name_hash = hash(
            f"{get_legacy_module_name(properties.get('__module__'))}.{name}"
        )
        name_hash = hash(
            f"{properties.get('__module__')}.{properties.get('__qualname__')}"
        )
        all_fields = dict()
        # mapping field names to base classes
        field_to_cls_hash = dict()
        # mapping legacy name hash to name hashes
        legacy_to_new_name_hash = {legacy_name_hash: name_hash}

        for base in bases:
            if not hasattr(base, "_FIELDS"):
                continue
            all_fields.update(base._FIELDS)
            field_to_cls_hash.update(base._FIELD_TO_NAME_HASH)
            legacy_to_new_name_hash.update(base._LEGACY_TO_NEW_NAME_HASH)

        properties_without_fields = {}
        properties_field_slot_names = []
        for k, v in properties.items():
            if not isinstance(v, Field):
                properties_without_fields[k] = v
                continue

            field = all_fields.get(k)
            # record the field for the class being created
            field_to_cls_hash[k] = name_hash
            if field is None:
                properties_field_slot_names.append(k)
            else:
                v.name = field.name
                v.get = field.get
                v.set = field.set
                v.__delete__ = field.__delete__
            all_fields[k] = v

        # Make field order deterministic to serialize it as list instead of dict.
        field_order = list(all_fields)
        primitive_fields = []
        primitive_field_names = set()
        non_primitive_fields = []
        for field_name, v in all_fields.items():
            if _is_field_primitive_compound(v):
                primitive_fields.append(v)
                primitive_field_names.add(field_name)
            else:
                non_primitive_fields.append(v)

        # count number of fields for every base class
        cls_to_primitive_field_count = OrderedDict()
        cls_to_non_primitive_field_count = OrderedDict()
        for field_name in field_order:
            cls_hash = field_to_cls_hash[field_name]
            if field_name in primitive_field_names:
                cls_to_primitive_field_count[cls_hash] = (
                    cls_to_primitive_field_count.get(cls_hash, 0) + 1
                )
            else:
                cls_to_non_primitive_field_count[cls_hash] = (
                    cls_to_non_primitive_field_count.get(cls_hash, 0) + 1
                )

        slots = set(properties.pop("__slots__", set()))
        slots.update(properties_field_slot_names)

        properties = properties_without_fields

        # todo remove this prop when all versions below v1.0.0rc1 is eliminated
        properties["_LEGACY_NAME_HASH"] = legacy_name_hash
        properties["_NAME_HASH"] = name_hash
        properties["_LEGACY_TO_NEW_NAME_HASH"] = legacy_to_new_name_hash

        properties["_FIELDS"] = all_fields
        properties["_FIELD_ORDER"] = field_order
        properties["_FIELD_TO_NAME_HASH"] = field_to_cls_hash
        properties["_PRIMITIVE_FIELDS"] = primitive_fields
        properties["_CLS_TO_PRIMITIVE_FIELD_COUNT"] = OrderedDict(
            cls_to_primitive_field_count
        )
        properties["_NON_PRIMITIVE_FIELDS"] = non_primitive_fields
        properties["_CLS_TO_NON_PRIMITIVE_FIELD_COUNT"] = OrderedDict(
            cls_to_non_primitive_field_count
        )
        properties["__slots__"] = tuple(slots)

        clz = type.__new__(mcs, name, bases, properties)
        # Bind slot member_descriptor with field.
        for name in properties_field_slot_names:
            member_descriptor = getattr(clz, name)
            field = all_fields[name]
            field.name = member_descriptor.__name__
            field.get = member_descriptor.__get__
            field.set = member_descriptor.__set__
            field.__delete__ = member_descriptor.__delete__
            setattr(clz, name, field)

        return clz
def __new__()

def new()
