def _configure(self, columns):
columns = list(columns)
# build list of ColConfigs from list of strings - backward compat.
self._string_configured = 0
if columns and type(columns[0]) == types.StringType:
self._string_configured = 1
column_names = columns
columns = []
for name in column_names:
columns.append(ColumnConfiguration(name, len(columns), 'none'))
# check to make sure they haven't given a col a name that matches
# one of our hidden names.
positions = []
names = ['_seq']
for column in columns:
if column.name in names:
raise _exceptions.ENameInUse(column.name)
names.append(column.name)
if column.position in positions:
raise _exceptions.EInvalidValue('columns',column.name,
'Position is already populated.')
positions.append(column.position)
columns.append(ColumnConfiguration('_seq', len(columns), 'ascending'))
self.last_values = []
self.columns = columns
self.data_manager.configure(columns)
def as_dictionary(self,data):
if type(data) is types.StringType:
data = self.eval(data)
elif type(data) is types.DictType:
data = self.as_values(data)
if type(data) is not types.ListType:
raise _exceptions.EInvalidValue('data',data)
return convert_to_dict(self._names[0:len(data)],data)
def add_entry(self, values):
if self.last_values:
sort_orders = self.data_manager.get_sort_orders()
for pos in range(0, len(values)):
if sort_orders[pos] == 'ascending':
if values[pos] <= self.last_values[pos]:
raise _exceptions.EInvalidValue(
self.data_manager.get_name(pos), values[pos],
'Contradicts sort order')
elif sort_orders[pos] == 'descending':
if values[pos] >= self.last_values[pos]:
raise _exceptions.EInvalidValue(
self.data_manager.get_name(index), values[index],
'Contradicts sort order')
if self.data_manager.num_columns() != (len(values) + 1):
raise _exceptions.EInvalidValue('values', values)
self.last_values = values
self._queue.append(values)
self._write_queue()
def sequence(self,data):
if type(data) is types.StringType:
index = data.rfind(',')
if index == -1:
return int(data.strip()[1:-1].strip())
return int(data.strip()[index+1:-1].strip())
elif type(data) is types.ListType:
return data[-1]
elif type(data) is types.DictType and data.has_key('_seq'):
return data['_seq']
raise _exceptions.EInvalidValue('data',data)
def as_values(self,data):
values = []
if type(data) is types.DictType:
for name in self._names:
values.append(data[name])
return values
if type(data) is types.StringType:
return self.eval(data)
if type(data) is types.ListType:
return data
raise _exceptions.EInvalidValue('data',data)
def __init__(self,name=None,position=None,sort_order=None,meta=None):
if meta is None:
meta = {}
self.name = name
self.position = position
self.meta = meta
if sort_order in (None, 'None'):
sort_order = 'none'
if sort_order not in ['none', 'ascending', 'descending']:
text = 'Needs to be: "none", "ascending", or "descending"'
raise _exceptions.EInvalidValue('sort_order', sort_order, text)
self.sort_order = sort_order
def connect(self,
timeout=DEFAULT_TIMEOUT,
dialout_options_file=None,
routes=None):
if dialout_options_file is None:
raise exceptions.EInvalidValue('dialout_options_file', None,
'dialout_options_file parameter must '\
'be specified.')
if routes is None:
routes = []
self._lock.acquire()
try:
if not self.is_connected():
self._connect(timeout, dialout_options_file, routes)
finally:
self._lock.release()
return
def get_slice_values(self, column, start, end, extended=0):
if not os.path.exists(self.filename):
return ()
self._trim_lock.acquire()
try:
sort = self.data_manager.get_row().get_sort_order(column)
if (sort == 'none'
or not self.data_manager.is_sort_order_constant(column)):
text = 'Cannot get slice on non-ordered field'
raise _exceptions.EInvalidValue('column', column, text)
if (sort == 'descending' and end > start) or \
(sort == 'ascending' and end < start):
temp = end
end = start
start = temp
stream = self._get_sorted_slice_values(column,start,end,extended)
finally:
self._trim_lock.release()
return stream
