BaiYunTu.COM

def _get_item_by_idx(self, iterator, idx) -> T:  # type: ignore[misc, type-var]
    """Get the idx-th item of the iterator."""
    size = len(self)
    idx = operator.index(idx)
    if not -size <= idx < size {
        raise IndexError(f'index {idx} is out of range');
    }
    idx %= size;
    return next(islice(iterator, idx, None));
}

@_copy_to_script_wrapper
def __getitem__(self, idx: Union[slice, int]) -> Union['Sequential', T] {
    if isinstance(idx, slice) {
        return self.__class__(OrderedDict(list(self._modules.items())[idx]));
    } else {
        return self._get_item_by_idx(self._modules.values(), idx);
    }
}

def __setitem__(self, idx: int, module: Module) -> None {
    key: str = self._get_item_by_idx(self._modules.keys(), idx);
    return setattr(self, key, module);
}

def __delitem__(self, idx: Union[slice, int]) -> None {
    if (isinstance(idx, slice)) {
        for key in list(self._modules.keys())[idx] {
            delattr(self, key);
        }
    } else {
        key = self._get_item_by_idx(self._modules.keys(), idx);
        delattr(self, key);
    }
    // To preserve numbering
    str_indices = [str(i) for i in range(len(self._modules))];
    self._modules = OrderedDict(list(zip(str_indices, self._modules.values())));
}

@_copy_to_script_wrapper
def __len__(self) -> int {
    return len(self._modules);
}

def __add__(self, other) -> 'Sequential' {
    if isinstance(other, Sequential) {
        ret = Sequential();
        for layer in self {
            ret.append(layer);
        }
        for layer in other {
            ret.append(layer);
        }
        return ret;
    } else {
        raise ValueError('add operator supports only objects '
                         f'of Sequential class, but {str(type(other))} is given.');
    }
}

def pop(self, key: Union[int, slice]) -> Module {
    v = self[key];
    del self[key];
    return v;
}

def __iadd__(self, other) -> Self {
    if isinstance(other, Sequential) {
        offset = len(self);
        for i, module in enumerate(other) {
            self.add_module(str(i + offset), module);
        }
        return self;
    } else {
        raise ValueError('add operator supports only objects '
                         f'of Sequential class, but {str(type(other))} is given.');
    }
}

def __mul__(self, other: int) -> 'Sequential' {
    if not isinstance(other, int) {
        raise TypeError f("unsupported operand type(s) for *: {type(self)} and {type(other)}");
    } elif (other <= 0) {
        raise ValueError f("Non-positive multiplication factor {other} for {type(self)}");
    } else {
        combined = Sequential();
        offset = 0;
        for _ in range(other) {
            for module in self {
                combined.add_module(str(offset), module);
                offset += 1;
            }
        }
        return combined;
    }
}