def __getitem__(self, key): """Adds slicing access to cell code retrieval The cells are returned as a generator of generators, of ... of unicode. Parameters ---------- key: n-tuple of integer or slice \tKeys of the cell code that is returned Note ---- Classical Excel type addressing (A$1, ...) may be added here """ for key_ele in key: if is_slice_like(key_ele): # We have something slice-like here return self.cell_array_generator(key) elif is_string_like(key_ele): # We have something string-like here msg = "Cell string based access not implemented" raise NotImplementedError(msg) # key_ele should be a single cell return self.dict_grid[key]
def __setitem__(self, key, value): """Accepts index and slice keys Parameters ---------- key: 3-tuple of Integer or Slice object \tCell key(s) that shall be set value: Object (should be Unicode or similar) \tCode for cell(s) to be set """ single_keys_per_dim = [] for axis, key_ele in enumerate(key): if is_slice_like(key_ele): # We have something slice-like here length = key[axis] slice_range = xrange(*key_ele.indices(length)) single_keys_per_dim.append(slice_range) elif is_string_like(key_ele): # We have something string-like here raise NotImplementedError else: # key_ele is a single cell single_keys_per_dim.append((key_ele, )) single_keys = product(*single_keys_per_dim) for single_key in single_keys: if value: # Never change merged cells merging_cell = \ self.cell_attributes.get_merging_cell(single_key) if merging_cell is None or merging_cell == single_key: self.dict_grid[single_key] = value else: # Value is empty --> delete cell try: self.pop(key) except (KeyError, TypeError): pass
def _make_nested_list(self, gen): """Makes nested list from generator for creating numpy.array""" res = [] for ele in gen: if ele is None: res.append(None) elif not is_string_like(ele) and is_generator_like(ele): # Nested generator res.append(self._make_nested_list(ele)) else: res.append(ele) return res
def __setitem__(self, key, value, mark_unredo=True): """Accepts index and slice keys Parameters ---------- key: 3-tuple of Integer or Slice object \tCell key(s) that shall be set value: Object (should be Unicode or similar) \tCode for cell(s) to be set mark_unredo: Boolean, defaults to True \tIf True then an unredo marker is set after the operation """ single_keys_per_dim = [] for axis, key_ele in enumerate(key): if is_slice_like(key_ele): # We have something slice-like here length = key[axis] slice_range = xrange(*key_ele.indices(length)) single_keys_per_dim.append(slice_range) elif is_string_like(key_ele): # We have something string-like here raise NotImplementedError else: # key_ele is a single cell single_keys_per_dim.append((key_ele, )) single_keys = product(*single_keys_per_dim) unredo_mark = False for single_key in single_keys: if value: # UnRedo support old_value = self(key) try: old_value = unicode(old_value, encoding="utf-8") except TypeError: pass # We seem to have double calls on __setitem__ # This hack catches them if old_value != value: unredo_mark = True undo_operation = (self.__setitem__, [key, old_value, mark_unredo]) redo_operation = (self.__setitem__, [key, value, mark_unredo]) self.unredo.append(undo_operation, redo_operation) # End UnRedo support # Never change merged cells merging_cell = \ self.cell_attributes.get_merging_cell(single_key) if merging_cell is None or merging_cell == single_key: self.dict_grid[single_key] = value else: # Value is empty --> delete cell try: self.pop(key) except (KeyError, TypeError): pass if mark_unredo and unredo_mark: self.unredo.mark()
def __setitem__(self, key, value, mark_unredo=True): """Accepts index and slice keys Parameters ---------- key: 3-tuple of Integer or Slice object \tCell key(s) that shall be set value: Object (should be Unicode or similar) \tCode for cell(s) to be set mark_unredo: Boolean, defaults to True \tIf True then an unredo marker is set after the operation """ single_keys_per_dim = [] for axis, key_ele in enumerate(key): if is_slice_like(key_ele): # We have something slice-like here length = key[axis] slice_range = xrange(*key_ele.indices(length)) single_keys_per_dim.append(slice_range) elif is_string_like(key_ele): # We have something string-like here raise NotImplementedError else: # key_ele is a single cell single_keys_per_dim.append((key_ele, )) single_keys = product(*single_keys_per_dim) unredo_mark = False for single_key in single_keys: if value: # UnRedo support old_value = self(key) try: old_value = unicode(old_value, encoding="utf-8") except TypeError: pass # We seem to have double calls on __setitem__ # This hack catches them if old_value != value: unredo_mark = True undo_operation = (self.__setitem__, [key, old_value, mark_unredo]) redo_operation = (self.__setitem__, [key, value, mark_unredo]) self.unredo.append(undo_operation, redo_operation) # End UnRedo support self.dict_grid[single_key] = value else: # Value is empty --> delete cell try: self.dict_grid.pop(key) except (KeyError, TypeError): pass if mark_unredo and unredo_mark: self.unredo.mark()
def __setitem__(self, key, value): """Accepts index and slice keys""" single_keys_per_dim = [] for axis, key_ele in enumerate(key): if is_slice_like(key_ele): # We have something slice-like here length = key[axis] slice_range = xrange(*key_ele.indices(length)) single_keys_per_dim.append(slice_range) elif is_string_like(key_ele): # We have something string-like here raise NotImplementedError else: # key_ele is a single cell single_keys_per_dim.append((key_ele, )) single_keys = product(*single_keys_per_dim) unredo_mark = False for single_key in single_keys: if value: # UnRedo support old_value = self(key) try: old_value = unicode(old_value, encoding="utf-8") except TypeError: pass # We seem to have double calls on __setitem__ # This hack catches them if old_value != value: unredo_mark = True undo_operation = (self.__setitem__, [key, old_value]) redo_operation = (self.__setitem__, [key, value]) self.unredo.append(undo_operation, redo_operation) # End UnRedo support self.dict_grid[single_key] = value else: # Value is empty --> delete cell try: self.dict_grid.pop(key) except (KeyError, TypeError): pass if unredo_mark: self.unredo.mark()
def test_is_string_like(string, res): """Unit test for is_string_like""" assert is_string_like(string) == res