def _extract_loc2d(self, row_key: GetItemKeyType = NULL_SLICE, column_key: GetItemKeyType = NULL_SLICE, ) -> tp.Union['Frame', 'Series']: ''' NOTE: keys are loc keys; None is interpreted as selector, not a NULL_SLICE ''' from static_frame.core.series import Series from static_frame.core.container_util import get_col_fill_value_factory fill_value = self._fill_value container = self._container # always a Frame row_key, row_is_multiple, row_is_null_slice = self._extract_key_attrs( row_key, container._index, ) column_key, column_is_multiple, column_is_null_slice = self._extract_key_attrs( column_key, container._columns, #type: ignore ) if row_is_multiple and column_is_multiple: # cannot reindex if loc keys are elements return container.reindex( # type: ignore index=row_key if not row_is_null_slice else None, columns=column_key if not column_is_null_slice else None, fill_value=fill_value, ) elif not row_is_multiple and not column_is_multiple: # selecting an element try: return container.loc[row_key, column_key] except KeyError: fv = get_col_fill_value_factory(fill_value, None)(0, None) return fv #type: ignore elif not row_is_multiple: # row is an element, return Series indexed by columns if row_key in container._index: #type: ignore s = container.loc[row_key] return s.reindex(column_key, fill_value=fill_value) #type: ignore fv = get_col_fill_value_factory(fill_value, None)(0, None) return Series.from_element(fv, index=column_key, name=row_key, ) # columns is an element, return Series indexed by index if column_key in container._columns: #type: ignore s = container[column_key] return s.reindex(row_key, fill_value=fill_value) #type: ignore fv = get_col_fill_value_factory(fill_value, None)(0, None) return Series.from_element(fv, index=row_key, name=column_key, )
def reload(self): if isinstance(self.source, Frame): frame = self.source else: # vd.fail(f'no support for loading {self.source.__class__}') raise NotImplementedError( f'no support for loading a Frame from {self.source}') # If the index is not an IndexAutoFactory, try to move it onto the Frame. If this fails it might mean we are trying to unset an auto index post selection if frame.index.depth > 1 or frame.index._map: # if it is not an IndexAutoFactory frame = frame.unset_index() # VisiData assumes string column names if frame.columns.dtype != str: frame = frame.relabel(columns=frame.columns.astype(str)) dtypes = frame.dtypes self.columns = [] for col in (c for c in frame.columns if not c.startswith('__vd_')): self.addColumn( Column( col, type=self.dtype_to_type(dtypes[col]), getter=self.getValue, setter=self.setValue, expr=col, )) self.rows = StaticFrameAdapter(frame) self._selectedMask = Series.from_element(False, index=frame.index)
def _checkSelectedIndex(self): if self._selectedMask.index is not self.frame.index: # selection is no longer valid vd.status('frame.index updated, clearing {} selected rows'.format( self._selectedMask.sum())) self._selectedMask = Series.from_element(False, index=self.frame.index)
def _deferred_series(labels: tp.Iterable[str]) -> Series: ''' Return an object ``Series`` of ``FrameDeferred`` objects, based on the passed in ``labels``. ''' # make an object dtype return tp.cast( Series, Series.from_element(FrameDeferred, index=labels, dtype=object))
def call_attr( bundle: tp.Tuple[FrameOrSeries, str, tp.Any, tp.Any]) -> FrameOrSeries: # process pool requires a single argument frame, attr, args, kwargs = bundle func = getattr(frame, attr) post = func(*args, **kwargs) # post might be an element if not isinstance(post, (Frame, Series)): # promote to a Series to permit concatenation return Series.from_element(post, index=(frame.name, )) return post
def normalize_container(post: tp.Any) -> FrameOrSeries: # post might be an element, promote to a Series to permit concatenation if post.__class__ is np.ndarray: if post.ndim == 1: return Series(post) elif post.ndim == 2: return Frame(post) # let ndim 0 pass if not isinstance(post, (Frame, Series)): # NOTE: do not set index as (container.name,), as this can lead to diagonal formations; will already be paired with stored labels return Series.from_element(post, index=ELEMENT_TUPLE) return post
def mloc(self) -> Series: '''Returns a Series of tuples of dtypes, one for each loaded Frame. ''' if not self._loaded.any(): return Series.from_element(None, index=self._series._index) def gen() -> tp.Iterator[tp.Tuple[tp.Hashable, tp.Optional[tp.Tuple[int, ...]]]]: for label, f in zip(self._series._index, self._series.values): if f is FrameDeferred: yield label, None else: yield label, tuple(f.mloc) return Series.from_items(gen())
def mloc(self) -> Series: '''Returns a :obj:`Series` showing a tuple of memory locations within each loaded Frame. ''' if not self._loaded.any(): return Series.from_element(None, index=self._index) def gen() -> tp.Iterator[tp.Tuple[tp.Hashable, tp.Optional[tp.Tuple[int, ...]]]]: for label, f in zip(self._index, self._values_mutable): if f is FrameDeferred: yield label, None else: yield label, tuple(f.mloc) return Series.from_items(gen())
def _deferred_series( labels: tp.Iterable[tp.Hashable], *, index_constructor: IndexConstructor = None, ) -> Series: ''' Return an object ``Series`` of ``FrameDeferred`` objects, based on the passed in ``labels``. ''' # NOTE: need to accept an IndexConstructor to support reanimating Index subtypes, IH return Series.from_element(FrameDeferred, index=labels, dtype=DTYPE_OBJECT, index_constructor=index_constructor, )
def clearSelected(self): self._selectedMask = Series.from_element(False, index=self.frame.index)