| | |
| |
|
| | from typing import Any, Tuple, Type |
| | import torch |
| |
|
| |
|
| | class BaseConverter: |
| | """ |
| | Converter base class to be reused by various converters. |
| | Converter allows one to convert data from various source types to a particular |
| | destination type. Each source type needs to register its converter. The |
| | registration for each source type is valid for all descendants of that type. |
| | """ |
| |
|
| | @classmethod |
| | def register(cls, from_type: Type, converter: Any = None): |
| | """ |
| | Registers a converter for the specified type. |
| | Can be used as a decorator (if converter is None), or called as a method. |
| | |
| | Args: |
| | from_type (type): type to register the converter for; |
| | all instances of this type will use the same converter |
| | converter (callable): converter to be registered for the given |
| | type; if None, this method is assumed to be a decorator for the converter |
| | """ |
| |
|
| | if converter is not None: |
| | cls._do_register(from_type, converter) |
| |
|
| | def wrapper(converter: Any) -> Any: |
| | cls._do_register(from_type, converter) |
| | return converter |
| |
|
| | return wrapper |
| |
|
| | @classmethod |
| | def _do_register(cls, from_type: Type, converter: Any): |
| | cls.registry[from_type] = converter |
| |
|
| | @classmethod |
| | def _lookup_converter(cls, from_type: Type) -> Any: |
| | """ |
| | Perform recursive lookup for the given type |
| | to find registered converter. If a converter was found for some base |
| | class, it gets registered for this class to save on further lookups. |
| | |
| | Args: |
| | from_type: type for which to find a converter |
| | Return: |
| | callable or None - registered converter or None |
| | if no suitable entry was found in the registry |
| | """ |
| | if from_type in cls.registry: |
| | return cls.registry[from_type] |
| | for base in from_type.__bases__: |
| | converter = cls._lookup_converter(base) |
| | if converter is not None: |
| | cls._do_register(from_type, converter) |
| | return converter |
| | return None |
| |
|
| | @classmethod |
| | def convert(cls, instance: Any, *args, **kwargs): |
| | """ |
| | Convert an instance to the destination type using some registered |
| | converter. Does recursive lookup for base classes, so there's no need |
| | for explicit registration for derived classes. |
| | |
| | Args: |
| | instance: source instance to convert to the destination type |
| | Return: |
| | An instance of the destination type obtained from the source instance |
| | Raises KeyError, if no suitable converter found |
| | """ |
| | instance_type = type(instance) |
| | converter = cls._lookup_converter(instance_type) |
| | if converter is None: |
| | if cls.dst_type is None: |
| | output_type_str = "itself" |
| | else: |
| | output_type_str = cls.dst_type |
| | raise KeyError(f"Could not find converter from {instance_type} to {output_type_str}") |
| | return converter(instance, *args, **kwargs) |
| |
|
| |
|
| | IntTupleBox = Tuple[int, int, int, int] |
| |
|
| |
|
| | def make_int_box(box: torch.Tensor) -> IntTupleBox: |
| | int_box = [0, 0, 0, 0] |
| | int_box[0], int_box[1], int_box[2], int_box[3] = tuple(box.long().tolist()) |
| | return int_box[0], int_box[1], int_box[2], int_box[3] |
| |
|
