class TableAnnotation(object):
"""
Annotations for Table objects, to annotate as needed, the notion
is that the annotation keys correspond to column, and values correspond
to application specific column metadata.
"""
_marker = object()
schema_invariants = ()
def __init__(self,
table_name,
columns=(),
properties=(),
schema_order=(),
listing_columns=(),
order_by=()):
self.table_name = table_name
self._options = {}
self._annot = OrderedDict()
for info in columns:
self._annot[info['name']] = info
self.properties = properties
self.schema_order = schema_order
self.listing_columns = listing_columns
self.order_by = order_by
def setOption(self, name, value):
self._options[name] = value
def getOption(self, name, default=None):
return self._options.get(name, default)
def __call__(self, iface):
return self
def __setitem__(self, name, value):
self._annot[name] = value
def get(self, name, default=None):
return self._annot.get(name, default)
def __getitem__(self, name):
return self.get(name)
def values(self):
return self._annot.values()
def __contains__(self, name):
return not self._marker == self.get(name, self._marker)
class TableAnnotation(object):
#__slots__ = ("table_name", "_annot", "_options")
def __init__(self,
table_name,
columns=(),
properties=(),
schema_order=(),
table_columns=(),
order_by=()):
self.table_name = table_name
self._options = {}
self._annot = OrderedDict()
for info in columns:
self._annot[info['name']] = info
self.properties = properties
self.schema_order = schema_order
self.table_columns = table_columns
self.order_by = order_by
def setOption(self, name, value):
self._options[name] = value
def getOption(self, name, default=None):
return self._options.get(name, default)
def __call__(self, context):
return ModelAnnotation(context, self)
def __setitem__(self, name, value):
self._annot[name] = value
def get(self, name, default=None):
return self._annot.get(name, default)
def __getitem__(self, anme):
return self.get(name)
def values(self):
return self._annot.values()
def __contains__(self, name):
marker = object()
return not marker == self.get(name, marker)
class TableAnnotation( object ):
"""
Annotations for Table objects, to annotate as needed, the notion
is that the annotation keys correspond to column, and values correspond
to application specific column metadata.
"""
_marker = object()
schema_invariants = ()
def __init__(self, table_name, columns=(), properties=(), schema_order=(), listing_columns=(), order_by=()):
self.table_name = table_name
self._options = {}
self._annot = OrderedDict()
for info in columns:
self._annot[ info['name'] ] = info
self.properties = properties
self.schema_order = schema_order
self.listing_columns = listing_columns
self.order_by = order_by
def setOption( self, name, value ):
self._options[ name ] = value
def getOption( self, name, default=None ):
return self._options.get( name, default )
def __call__( self, iface ):
return self
def __setitem__(self, name, value ):
self._annot[name] = value
def get( self, name, default=None ):
return self._annot.get( name, default )
def __getitem__(self, name):
return self.get( name )
def values( self ):
return self._annot.values()
def __contains__(self, name ):
return not self._marker == self.get( name, self._marker )
class TableAnnotation( object ):
#__slots__ = ("table_name", "_annot", "_options")
def __init__(self, table_name, columns=(), properties=(), schema_order=(), table_columns=(), order_by=()):
self.table_name = table_name
self._options = {}
self._annot = OrderedDict()
for info in columns:
self._annot[ info['name'] ] = info
self.properties = properties
self.schema_order = schema_order
self.table_columns = table_columns
self.order_by = order_by
def setOption( self, name, value ):
self._options[ name ] = value
def getOption( self, name, default=None ):
return self._options.get( name, default )
def __call__( self, context ):
return ModelAnnotation( context, self )
def __setitem__(self, name, value ):
self._annot[name] = value
def get( self, name, default=None ):
return self._annot.get( name, default )
def __getitem__(self, anme):
return self.get( name )
def values( self ):
return self._annot.values()
def __contains__(self, name ):
marker = object()
return not marker == self.get( name, marker )
class Relationship(object):
def __init__(self, source_cls, target_cls):
super(Relationship, self).__init__()
self.source_cls = source_cls
self.target_cls = target_cls
self.kwargs = OrderedDict()
self.backref = False
# I'll leave the backref code here, but I'll need to see it working with a
# ManyToMany relationship
def add_backref(self, name_backref=None):
"""
This must be called after kwargs has been fill to leverage the uselist value
"""
if name_backref is None:
name_backref = self.source_cls
if self.kwargs.get("uselist", False):
backref_text = 'backref("{}", uselist=False, passive_deletes=True)'.format(
name_backref)
else:
backref_text = 'backref("{}", passive_deletes=True)'.format(
name_backref)
self.kwargs["backref"] = backref_text
self.backref = True
def get(self):
args = self.parser.parse_args()
if args.get('summary'):
logs = RequestLog.query.order_by(RequestLog.created).all()
if len(logs) < 1:
return {}
first_d = logs[0].created.date()
last_d = logs[-1].created.date()
result = OrderedDict()
t_date = ddate(first_d.year, first_d.month, first_d.day)
while t_date != last_d:
result[str(t_date)] = 0
t_date += timedelta(days=1)
for log in logs:
date = log.created.date()
sdate = str(date)
if result.get(sdate):
result[sdate] += 1
else:
result[sdate] = 1
if args.get('csv'):
csv_tmp = tempfile.NamedTemporaryFile(mode='w+',
prefix='logs_csv_',
delete=False)
csv_writer = csv.writer(csv_tmp)
csv_writer.writerow(['DATE', 'N_REQUESTS'])
for k, v in result.items():
csv_writer.writerow([k, v])
csv_tmp.close()
tmp_send = BytesIO()
with open(csv_tmp.name, mode='rb') as f:
tmp_send.write(f.read())
tmp_send.seek(0)
response = send_file(tmp_send,
mimetype='text/csv',
as_attachment=True,
attachment_filename='logs.csv')
os.remove(csv_tmp.name)
return response
else:
return result
else:
startdate = datetime.today().date() - timedelta(days=7)
logs = RequestLog.query.filter(
RequestLog.created > startdate).all()
result = []
for log in logs:
result.append({
"client_id":
clientserializer.dumps(log.client_id),
"test_id":
testserializer.dumps(log.test_id),
"result":
log.result,
"error":
log.error,
"timestamp":
log.created.isoformat()
})
return {"results": result, "startdate": startdate.isoformat()}
