def shapes(self) -> Series: '''A :obj:`Series` describing the shape of each loaded :obj:`Frame`. Unloaded :obj:`Frame` will have a shape of None. Returns: :obj:`tp.Series` ''' return Series.from_concat((b.shapes for b in self._series.values), index=self._index)
def from_concat(cls, containers: tp.Iterable['Bus'], *, index: tp.Optional[tp.Union[IndexInitializer, IndexAutoFactoryType]] = None, name: NameType = NAME_DEFAULT, ) -> 'Bus': ''' Concatenate multiple :obj:`Bus` into a new :obj:`Bus`. All :obj:`Bus` will load all :obj:`Frame` into memory if any are deferred. ''' # will extract .values, .index from Bus, which will correct load from Store as needed series = Series.from_concat(containers, index=index, name=name) return cls(series, own_data=True)
def _extract(self, row_key: GetItemKeyType = None, column_key: GetItemKeyType = None, ) -> tp.Union[Frame, Series]: ''' Extract Container based on iloc selection. ''' assert self._axis_hierarchy is not None #mypy extractor = get_extractor( self._deepcopy_from_bus, is_array=False, memo_active=False, ) row_key = NULL_SLICE if row_key is None else row_key row_key_is_array = isinstance(row_key, np.ndarray) column_key = NULL_SLICE if column_key is None else column_key column_key_is_array = isinstance(column_key, np.ndarray) if (not row_key_is_array and row_key == NULL_SLICE and not column_key_is_array and column_key == NULL_SLICE): if self._retain_labels and self._axis == 0: frames = (extractor(f.relabel_level_add(index=k)) for k, f in self._bus.items()) elif self._retain_labels and self._axis == 1: frames = (extractor(f.relabel_level_add(columns=k)) for k, f in self._bus.items()) else: frames = (extractor(f) for _, f in self._bus.items()) return Frame.from_concat( #type: ignore frames, axis=self._axis, ) parts: tp.List[tp.Any] = [] frame_labels: tp.Iterable[tp.Hashable] if self._axis == 0: sel_key = row_key opposite_key = column_key else: sel_key = column_key opposite_key = row_key sel_reduces = isinstance(sel_key, INT_TYPES) sel = np.full(len(self._axis_hierarchy), False) sel[sel_key] = True # get ordered unique Bus labels axis_map_sub = self._axis_hierarchy.iloc[sel_key] if isinstance(axis_map_sub, tuple): #type: ignore frame_labels = (axis_map_sub[0],) #type: ignore else: # get the outer level, or just the unique frame labels needed frame_labels = axis_map_sub._levels.index for key_count, key in enumerate(frame_labels): # get Boolean segment for this Frame sel_component = sel[self._axis_hierarchy._loc_to_iloc(HLoc[key])] if self._axis == 0: component = self._bus.loc[key].iloc[sel_component, opposite_key] if key_count == 0: component_is_series = isinstance(component, Series) if self._retain_labels: # component might be a Series, can call the same with first arg component = component.relabel_level_add(key) if sel_reduces: # make Frame into a Series, Series into an element component = component.iloc[0] else: component = self._bus.loc[key].iloc[opposite_key, sel_component] if key_count == 0: component_is_series = isinstance(component, Series) if self._retain_labels: if component_is_series: component = component.relabel_level_add(key) else: component = component.relabel_level_add(columns=key) if sel_reduces: # make Frame into a Series, Series into an element if component_is_series: component = component.iloc[0] else: component = component.iloc[NULL_SLICE, 0] parts.append(extractor(component)) if len(parts) == 1: return parts.pop() #type: ignore # NOTE: Series/Frame from_concate will attempt to re-use ndarrays, and thus using extractor above is appropriate if component_is_series: return Series.from_concat(parts) return Frame.from_concat(parts, axis=self._axis) #type: ignore
def mloc(self) -> Series: '''Returns a :obj:`Series` showing a tuple of memory locations within each loaded Frame. ''' return Series.from_concat((b.mloc for b in self._series.values), index=self._index)