The purview of the repertoire.

    Args:
        repertoire (np.ndarray): A repertoire

    Returns:
        tuple[int]: The purview that the repertoire was computed over.
773670
def purview(repertoire):
    
    if repertoire is None:
        return None

    return tuple(i for i, dim in enumerate(repertoire.shape) if dim == 2)
236702
def data(self) -> Sequence[Tuple[float, float]]:
        
        return [(angle, prob) for angle, prob in zip(self._rabi_angles,
                                                     self._excited_state_probs)]
1013505
def items(self):
        
        if ver == (2, 7):
            return self.viewitems()
        elif ver == (2, 6):
            return self.iteritems()
        elif ver >= (3, 0):
            return self.items()
60418
def values(cls):
        
        if not hasattr(cls, '__values_'):
            cls.__values_ = tuple([c.value for c in list(cls)])
        return cls.__values_
845001
def cache_info(self):
        """"""
        return {
            'single_node_repertoire':
                self._single_node_repertoire_cache.info(),
            'repertoire': self._repertoire_cache.info(),
            'mice': self._mice_cache.info()
        }
484865
def absolute(self):
        
        return Timeseries(np.absolute(self), self.tspan, self.labels)
137552
def evaluate(self, sequence, transformations):
        
        # pylint: disable=no-self-use
        result = sequence
        for transform in transformations:
            strategies = transform.execution_strategies
            if strategies is not None and ExecutionStrategies.PRE_COMPUTE in strategies:
                result = transform.function(list(result))
            else:
                result = transform.function(result)
        return iter(result)
332798
def marginal(repertoire, node_index):
    """"""
    index = tuple(i for i in range(repertoire.ndim) if i != node_index)

    return repertoire.sum(index, keepdims=True)
1035929
def native(self):
        

        if self.contents is None:
            return None

        if self._native is None:
            self._native = self._map[self.__int__()]
        return self._native
1138962
def iter_schemas(self, schema: Schema) -> Iterable[Tuple[str, Any]]:
        
        if not schema:
            return

        yield self.to_tuple(schema)

        for name, field in self.iter_fields(schema):
            if isinstance(field, Nested):
                yield self.to_tuple(field.schema)
                yield from self.iter_schemas(field.schema)

            if isinstance(field, List) and isinstance(field.container, Nested):
                yield self.to_tuple(field.container.schema)
                yield from self.iter_schemas(field.container.schema)
1000469
def tuple(self):
        
        return tuple(getattr(self, k) for k in self.__class__.defaults)
182905
def _coerce_to_ndarray(cls, data):
        

        if not isinstance(data, (np.ndarray, Index)):
            if data is None or is_scalar(data):
                cls._scalar_data_error(data)

            # other iterable of some kind
            if not isinstance(data, (ABCSeries, list, tuple)):
                data = list(data)
            data = np.asarray(data)
        return data
606482
def to_tuple(self):
        
        return self._body, self._channel, self._method, self._properties
757089
def portfolio(self) -> List[PortfolioItem]:
        
        account = self.wrapper.accounts[0]
        return [v for v in self.wrapper.portfolio[account].values()]
261564
def block_view(arr, block=(3, 3)):
    

    # simple shape and strides computations may seem at first strange
    # unless one is able to recognize the 'tuple additions' involved ;-)
    shape = (arr.shape[0] // block[0], arr.shape[1] // block[1]) + block
    strides = (block[0] * arr.strides[0], block[1] * arr.strides[1]) + arr.strides
    return ast(arr, shape=shape, strides=strides)
1153606
def worldview(self) -> str:
        
        views = self._data['worldview']
        return self.random.choice(views)
84534
def synset(self):
            
        return synset('%s.%s.%s.%s'%(self.synset_literal,self.synset_pos,self.synset_sense,self.literal))