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 __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 __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 _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
def test_is_string_like(string, res):
"""Unit test for is_string_like"""
assert is_string_like(string) == res
