text: import operator
  from collections import OrderedDict
  from itertools import islice
  from .module import Module
  
  
  class Sequential(Module):
      """A sequential container. 
      
      Modules will be added to it in the order they are passed in the constructor.
      Alternatively, an ordered dict of modules can also be passed in.
      """
  
      def __init__(self, *args):
          super(Sequential, self).__init__()
          if len(args) == 1 and isinstance(args[0], OrderedDict):
              for key, module in args[0].items():
                  self.add_module(key, module)
          else:
              for idx, module in enumerate(args):
                  self.add_module(str(idx), module)
  
      def _get_item_by_idx(self, iterator, idx):
          """Get the idx-th item of the iterator"""
          size = len(self)
          idx = operator.index(idx)
          if not -size <= idx < size:
              raise IndexError('index {} is out of range'.format(idx))
          idx %= size
          return next(islice(iterator, idx, None))
  
      def __getitem__(self, idx):
          if isinstance(idx, slice):
              return Sequential(OrderedDict(list(self._modules.items())[idx]))
          else:
              return self._get_item_by_idx(self._modules.values(), idx)
  
      def __setitem__(self, idx, module):
          key = self._get_item_by_idx(self._modules.keys(), idx)
          return setattr(self, key, module)
  
      def __delitem__(self, idx):
          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)
  
      def __len__(self):
          return len(self._modules)
  
      def __dir__(self):
          keys = super(Sequential, self).__dir__()
          keys = [key for key in keys if not key.isdigit()]
          return keys
  
      def forward(self, x):
          for module in self._modules.values():
              x = module.forward(x)
          return x
  
      def backward(self, delta):
          for module in reversed(self._modules.values()):
              delta = module.backward(delta)
  