def _get_log_item(line): if not line: return None values = line.split(split_by) if len(values) != len(columns): return None ob = {'filename': filename} try: for n, column in enumerate(columns): ob[column] = values[n].strip() except: if IsDebug and IsPrintExceptions: print_exception() try: x = datetime.datetime.strptime('%s' % ob['Date'], fmt[1]) ob['Date'] = cdate(x, date_format) except: if IsDebug and IsPrintExceptions: print_exception() if 'Code' in ob: ob['Code'] = re.sub(r'[\[\]]', '', ob['Code'].upper()) return ob
def index(): debug, kw = init_response('WebPerso Order State Page') kw['product_version'] = product_version command = get_request_item('command') if IsDebug: print('--> command:%s, order_id:%s, event_id:%s' % ( command, kw.get('order_id'), kw.get('event_id') )) refresh() errors = [] if command and command.startswith('admin'): pass kw['errors'] = '<br>'.join(errors) kw['OK'] = '' try: kw = _make_page_default(kw) if IsTrace: print_to(errorlog, '--> orderstate:%s %s %s' % (command, current_user.login, str(kw.get('current_file')),), request=request) except: print_exception() kw['vsc'] = (IsDebug or IsIE or IsForceRefresh) and ('?%s' % str(int(random.random()*10**12))) or '' if command and command.startswith('admin'): pass elif command == 'export': columns = kw['config']['orders']['export'] rows = [] for data in kw['orders']: row = [] for column in columns: if column == 'FinalMessage': continue v = data[column] if 'Date' in column: v = re.sub(r'\s+', ' ', re.sub(r'<.*?>', ' ', v)) row.append(v) rows.append(row) rows.insert(0, columns) xls = makeXLSContent(rows, 'Журнал заказов (OrderState)', True) response = make_response(xls) response.headers["Content-Disposition"] = "attachment; filename=orders.xls" return response return make_response(render_template('orderstate.html', debug=debug, **kw))
def run(self, sql, args=None, no_cursor=False): self.open() if self.engine is None or self.conn is None or self.conn.closed: return None rows = [] with self.conn.begin() as trans: try: if args: cursor = self.conn.execute(sql, args) else: cursor = self.conn.execute(sql) if not no_cursor: rows = [row for row in cursor if cursor] trans.commit() except: try: trans.rollback() except: pass print_to(None, 'NO SQL EXEC: %s' % sql) if IsPrintExceptions: print_exception() self.engine_error = True rows = None self.close() return rows
def getItems(self, query=None, id=None, **kw): """ Get reference items list with SQL-query. Arguments: query -- Dict, query parameters: {'key':'value', ...} id -- Int or String, selected item id Returns: rows -- List, mappings list: [{'key':'value', ...}]. """ rows = [] try: columns = self.columns where = self._set_where(query) order = self._set_order(kw.get('order')) encode_columns = self._set_encoding() rows = self.engine.runQuery( self.view, columns=columns, where=where, order=order, encode_columns=encode_columns, as_dict=True, config=self._config, ) self._selected(rows, id) except: if IsPrintExceptions: print_exception() return rows
def _make_export(kw): """ Экспорт журнала заказов в Excel """ view = kw['config'][default_template] columns = view['columns'] headers = [view['headers'][x][0] for x in columns] rows = [] for data in kw['orders']: row = [] for column in columns: if column not in data: continue try: v = data[column] if 'Date' in column and v: v = re.sub(r'\s+', ' ', re.sub(r'<.*?>', ' ', str(v))).strip() v = getDate(v, UTC_FULL_TIMESTAMP, is_date=True) v = getDate(v, LOCAL_EXCEL_TIMESTAMP) row.append(v) except: print_exception() rows.append(row) rows.insert(0, headers) return rows
def _decode(text, mode): errors = 'ignore' try: if not mode: pass elif mode == 'dostowin': text = text.encode(default_print_encoding).decode( default_encoding) elif mode == 'wintodos': text = text.encode(default_encoding, errors).decode(default_print_encoding) elif mode == 'wintowin': text = text.encode(default_encoding, errors).decode(default_encoding) elif mode == 'dostodos': text = text.encode(default_print_encoding).decode( default_print_encoding) elif mode == 'iso': try: text = text.encode(default_print_encoding).decode( default_encoding) except: text = text.encode(default_unicode).decode( default_unicode) except: if IsPrintExceptions: print_exception() return text
def getBodyState(self, file_status=None, limit=None, is_extra=False, no_cyrillic=False): """ Get $ Make readable file body content """ self.decodeBody(file_status=file_status) try: if self.image is not None: if not no_cyrillic: self.decodeCyrillic(self.image) if not is_extra: self.maskContent(self.image) self.makeIndents(self.image, limit=limit and MAX_XML_TREE_NODES or None) return self.upload(header=self.header(parser='ET.fromstring')) except: if IsPrintExceptions: print_exception() finally: self.flash()
def main(self, **kw): self._processed = 0 self._found = {} self.stop_requested = False self.ReportServiceStatus(win32service.SERVICE_RUNNING) self._start_logger() if IsTrace and not IsDisableOutput: self._out('root: %s' % self._config.get('root')) date_from = None while True: self.restart_requested = False try: app = self.create_app() app._init_state(date_from=date_from, callback=self) self.run(app) self.start_observer(app) if app is not None: app.should_be_stop() is_dead = 0 while True: is_finished = app.is_finished() is_dead = app.is_dead(force=1) self._out('... stopping: %s %s' % (is_finished, is_dead)) time.sleep(5) if is_finished or is_dead: break if not is_dead: app._term() del app except: self._out('main thread exception (look at traceback.log)', is_error=True) print_exception(1) if not self.restart_requested or self.stop_requested: break self._out('==> Restart...') time.sleep(15) self._out('==> Finish') self._stop_logger()
def getTabEventInfo(event_id): data = [] number = str(event_id) try: if event_id: params = "%s, 1, ''" % (event_id) cursor = engine.runQuery('orderstate-eventinfo', as_dict=True, params=params) for n, row in enumerate(cursor): row['PName'] = row['PName'].encode(default_iso).decode(default_encoding) row['PValue'] = row['PValue'].encode(default_iso).decode(default_encoding) #row['RD'] = getDate(row['RD'], DEFAULT_DATETIME_INLINE_FORMAT) data.append(row) where = 'TID=%s' % event_id cursor = engine.runQuery('orderstate-events', columns=('Action',), where=where) if cursor is not None and len(cursor): number += ' %s' % str(cursor[0][0]) except: print_exception() event = {'id':event_id, 'number':number} return number and data or [], event
def loader_with_logger(): # # Codes of action: # 100 - confirmation for an order # 203 - base calculation # 204 - custom calculation # 205 - save of state # 206 - finalize (internal) # 207 - order # 208 - close of session # 209 - cancel (Flash only) # 210 - continue (Flash only) # 301 - load log page # 302 - load selected log item content # 303 - load and refresh saved calculation # 304 - custom calculation (log+db) # 305 - price statistics # 307 - order (log+db) # 308 - remove log item # try: return loader() except: #traceback.print_exc(file=open(errorlog, 'a')) print_exception() raise
def getLinks(self, query, attrs, id, **kw): """ Get linked reference items list with SQL-query. Arguments: query -- Dict, query parameters: {'key':'value', ...} attrs -- Dict, query attributes: 'FileTypeID' : Int, file type ID 'FileTypeBatchTypeID' : Int, file type batch type ID 'FBLinkID' : Int, file type batch type ID ... 'BatchTypeID' : Int, filtered batch type ID 'Tag' : Int or String, filtered tag ID/Name 'TagValue' : String, filtered tag value id -- Int or String, selected item id Class attributes: filtered_columns -- List, list of columns used to filter data by the query Returns: rows -- List, mappings list: [{'key':'value', ...}]. """ rows = [] try: columns = self.columns filtered_columns = self.filtered_columns or columns where = self._set_where(query) s = ' AND '.join([ '%s=%s' % (name, isinstance(value, int) and value or ("'%s'" % value)) for name, value in attrs.items() if name in filtered_columns and value ]) if s: where = where and '(%s) AND (%s)' % (where, s) or s order = self._set_order(kw.get('order')) encode_columns = self._set_encoding() rows = self.engine.runQuery( self.view, columns=columns, where=where, order=order, encode_columns=encode_columns, as_dict=True, config=self._config, ) self._selected(rows, id) except: if IsPrintExceptions: print_exception() return rows
def mdate(filename): try: t = os.path.getmtime(filename) return datetime.datetime.fromtimestamp(t) except: if IsPrintExceptions: print_exception() return None
def log_with_logger(): if not request.referrer: return redirect(url_for('_ext', _method='GET', **request.args)) # values , _external=True try: return log(0) except: print_exception() raise
def getTabParams(order_id, batch_id, param_name=None, format=None, **kw): data = [] number = 0 props = {'id' : batch_id} try: if order_id and batch_id: keys = ('OperatorName', 'RD',) columns = ('Operator', 'OperatorName', 'OperatorFullName', 'RD',) encode_columns = ('OperatorName', 'OperatorFullName',) where = "OrderID=%s and BatchID=%s" % (order_id, batch_id) cursor = engine.runQuery(_views['actions'], columns=columns, where=where, as_dict=True, encode_columns=encode_columns) for n, row in enumerate(cursor): try: data = [{'PName':key, 'PType':1, 'PValue':row[key]} for key in keys] except: print_exception() # ------------------- # Информация о партии # ------------------- view = _views['batches'] columns = database_config[view]['export'] encode_columns = ('BatchType', 'BatchName',) where = 'TID=%s' % batch_id cursor = engine.runQuery(view, columns=columns, top=1, where=where, as_dict=True, encode_columns=encode_columns) if cursor is not None and len(cursor): row = cursor[0] if row: number = row['TZ'] props.update({ 'number' : number, 'name' : row['BatchName'], 'no' : row['ElementQty'], }) view = _views['orders'] where = 'TID=%s' % order_id cursor = engine.runQuery(view, top=1, where=where, as_dict=True) if cursor is not None and len(cursor): row = cursor[0] if row: props.update({ 'file' : row['FName'], 'cards' : row['FQty'], }) except: print_exception() return number and data or [], props
def loader(): exchange_error = '' exchange_message = '' refresh() action = get_request_item('action') or '401' response = { 'action': action, } preload_id = int(get_request_item('preload_id') or '0') article = int(get_request_item('article') or '0') if IsDebug: print('--> action:%s preload_id:%s article:%s' % (action, preload_id, article)) data = '' number = '' columns = [] try: if not action: pass elif action == '401': view = database_config['persolog'] columns = _get_view_columns(view) data = getTabPersoLog(columns=view['columns'], preload_id=preload_id) except: print_exception() response.update({ # -------------- # Service Errors # -------------- 'exchange_error': exchange_error, 'exchange_message': exchange_message, # ----------------------------- # Results (Log page parameters) # ----------------------------- 'preload_id': preload_id, 'article': article, # -------------------------- # Results (Log page content) # -------------------------- 'total': len(data), 'data': data, 'number': number, 'columns': columns, }) return jsonify(response)
def _decompress(self, xml, body): try: self.file_setter(xml, zlib.decompress(body)) except: if IsTrace: print_to( errorlog, 'FileImageDecoder._decompress Error:%s' % self._file_id) if IsPrintExceptions: print_exception()
def _generate_barcode(barcode_type, value, text, readable, filename, format, options, **kw): """ Internal generator """ scale = kw.get('scale') or 0.05 * _INCH font = kw.get('font') or ('Arial', 12, False) # ---------------------- # Generate barcode image # ---------------------- try: GEN = barcode.get_barcode_class(barcode_type) except: if print_exception is not None and IsPrintExceptions: print_exception() else: raise # ---------------- # Save as SVG-file # ---------------- if filename and format == _default_barcode_format: output = GEN(value) return output.save(filename) # ----------------------------------- # Save as image-file (PNG by default) # ----------------------------------- try: from PIL import Image from barcode.writer import ImageWriter, SVGWriter except: if print_exception is not None and IsPrintExceptions: print_exception() else: raise output = GEN(value, writer=ImageWriter()) if filename: return output.save(filename, options={'type':format}) # ------------------------- # Make output BASE64 stream # ------------------------- data = { 'output' : _generate(output, options, text), 'default' : _generate(output, None, text), 'code' : output.code, } return data
def send_message(user, params): subject = params.get('subject') or gettext('Announcement') message = params.get('message') is_with_greeting = params.get('with_greeting') and True or False is_with_signature = params.get('with_signature') and True or False done = 1 html = _EMAIL_HTML % { 'Subject': subject, 'Message': re.sub(r'\n', r'<br>', message), 'Greeting': _GREETING, 'Signature': _SIGNATURE % (current_user.post, current_user.full_name()), 'hidden_g': params.get('with_greeting') != 1 and 'hidden' or '', 'hidden_s': params.get('with_signature') != 1 and 'hidden' or '', } try: users = map(User.get_by_id, params.get('ids') or []) default_email = current_user.email addr_to = list(filter( None, [x.email for x in users if x.confirmed ])) if params.get('to_everybody') else [user.email] addr_cc = [default_email] if default_email not in addr_to else None if not message or not addr_to: return 0 addr_to = ';'.join(addr_to) addr_cc = addr_cc and ';'.join(addr_cc) or '' timestamp = getDate(getToday(), format=UTC_FULL_TIMESTAMP) if not IsNoEmail: done = send_simple_mail(subject, html, addr_to, addr_cc=addr_cc) if IsTrace: print_to( None, '>>> mail sent %s, login:%s, to:%s, cc:%s, subject: [%s], done:%s' % (timestamp, current_user.login, addr_to, addr_cc, subject, done)) except: if IsPrintExceptions: print_exception() done = 0 return done
def index(): debug, kw = init_response('WebPerso Preload Page') command = get_request_item('command') if IsDebug: print('--> command:%s, preload_id:%s, article:%s' % (command, kw.get('preload_id'), kw.get('article'))) refresh() errors = [] if command and command.startswith('admin'): pass kw['errors'] = '<br>'.join(errors) kw['OK'] = '' try: kw = _make_page_default(kw) except: print_exception() kw['vsc'] = IsDebug and ('?%s' % str(int(random.random() * 10**12))) or '' if command and command.startswith('admin'): pass elif command == 'export': columns = kw['config']['preloads']['export'] rows = [] for data in kw['preloads']: row = [] for column in columns: if column == 'FinalMessage': continue v = data[column] if 'Date' in column: v = re.sub(r'\s+', ' ', re.sub(r'<.*?>', ' ', v)) row.append(v) rows.append(row) rows.insert(0, columns) xls = makeXLSContent(rows, 'Журнал предобработки заказов', True) response = make_response(xls) response.headers[ "Content-Disposition"] = "attachment; filename=preloads.xls" return response return make_response(render_template('preload.html', debug=debug, **kw))
def loader_ext1(): exchange_error = '' exchange_message = '' action = get_request_item('action') or default_action selected_menu_action = get_request_item('selected_menu_action') or action != default_action and action or default_log_action response = {} params = get_request_item('params') or None refresh() if IsDebug: print('--> action:%s' % action) if IsTrace: print_to(errorlog, '--> loader:%s %s %s' % ( action, current_user.login, params and ' params:[%s]' % params or '', )) data = [] errors = None try: if action == default_action: data = calculate(params) if not action: pass except: print_exception() response.update({ 'action' : action, # -------------- # Service Errors # -------------- 'exchange_error' : exchange_error, 'exchange_message' : exchange_message, # -------------------------- # Results (Log page content) # -------------------------- 'total' : len(data), 'data' : data, 'errors' : errors, }) return jsonify(response)
def loader(): exchange_error = '' exchange_message = '' refresh() action = get_request_item('action') or default_action selected_menu_action = get_request_item( 'selected_menu_action') or action != default_action and action or '901' response = {} template = get_request_item('template') or default_template lid = get_request_item('lid') if IsDebug: print('--> action:%s %s lid:%s' % (action, template, lid)) if IsSemaphoreTrace: print_to( errorlog, '--> loader:%s [%s:%s:%s] %s' % (action, template, lid, selected_menu_action, getTime(UTC_FULL_TIMESTAMP))) state = {} try: if action == default_action: action = selected_menu_action if not action: pass elif action == '901': state = getCurrentState(template, lid) except: print_exception() response.update({ \ 'action' : action, # -------------- # Service Errors # -------------- 'exchange_error' : exchange_error, 'exchange_message' : exchange_message, # ------------------------- # Results (Semaphore state) # ------------------------- 'state' : state, }) return jsonify(response)
def run(**kw): global _processed global _found ctype = config['ctype'].lower() emitter = config.get('emitter') or False limit = config.get('limit') or 0 try: if not ctype: app = AbstractSource(config, logger) elif ctype == 'bankperso': app = Bankperso(config, logger) elif ctype == 'sdc': app = SDC(config, logger) elif ctype == 'exchange': app = Exchange(config, logger) else: app = Bankperso(config, logger) app._init_state(**kw) print_to(None, '>>> Logger Started[%s], date_from: %s, root: %s' % ( \ config['ctype'], kw.get('date_from'), config['root'], )) if app.is_ready(): if emitter: _processed, _found = app.emitter(limit=limit) else: _processed, _found = app(limit=limit) if not IsDisableOutput: _pout('>>> New messages found: %d' % (sum([_found[x] for x in _found]) or 0)) _pout('>>> Total processed: %d orders' % _processed) _pout('>>> Unresolved: %d lines' % app._unresolved_lines()) start_observer(app, **kw) app._term() print_to(None, '%s>>> Logger Finished[%s]%s' % ( \ cr, config['ctype'], cr, )) except: print_exception()
def index(): debug, kw = init_response('WebPerso Calculator Page') kw['product_version'] = product_version is_admin = current_user.is_administrator() command = get_request_item('command') refresh() IsMakePageDefault = True info = '' errors = [] if command.startswith('admin'): command = command.split(DEFAULT_HTML_SPLITTER)[1] if get_request_item('OK') != 'run': command = '' if IsDebug: print('--> %s' % info) if IsTrace: print_to(errorlog, '--> command:%s %s [%s]' % (command, current_user.login, info)) kw['errors'] = '<br>'.join(errors) kw['OK'] = '' try: if IsMakePageDefault: kw = _make_page_default(kw) if IsTrace: print_to(errorlog, '--> calculator:%s %s [%s] %s %s' % ( \ command, current_user.login, request.remote_addr, str(kw.get('current_file')), info,), request=request) except: print_exception() kw['vsc'] = vsc() if command: if not command.strip(): pass elif command == 'export': return _make_xls_content(_make_export(kw), 'Себестоимость ...') return make_response(render_template('calculator/%s.html' % default_locator, debug=debug, **kw))
def getExchangeLogInfo(**kw): global config logs = [] encoding, root, filemask, options = kw.get('config') or getExchangeConfig( kw.get('client')) if root is None: return logs set_globals(kw.get('globals')) config = exchange_log_config root = normpath(os.path.join(root, config['root'])) kw['filemask'] = filemask kw['options'] = options if IsTrace: keys = _extract_keys(kw.get('keys')) or [] print_to( None, '\n==> CHECK_EXCHANGE_LOG: %s STARTED [%s:%s:%s]' % ( datetime.datetime.now().strftime(UTC_FULL_TIMESTAMP), len(keys) > 0 and keys[0] or '', kw.get('client'), kw.get('dates'), )) try: if IsCheckFolders: logger = Logger('./folders.txt', encoding=default_encoding) check_path(".", logger) logger.close() walk(logs, check_exchange_log, root, encoding=encoding, **kw) except Exception as e: _register_error(logs, e, **kw) if IsPrintExceptions: print_exception() logs = sorted(logs, key=itemgetter('Date')) if IsTrace: print_to( None, '==> CHECK_EXCHANGE_LOG: %s FINISHED' % datetime.datetime.now().strftime(UTC_FULL_TIMESTAMP)) return logs
def refresh(check, key=None): if check and ExchangeRate.is_uptodate(): return rating = 'https://www.alphavantage.co' is_error = is_changed = is_add = False ob = None for source_code, code in ExchangeRate.currency_codes(): currency = '%s:%s' % (source_code, code) url = '%s/query?function=CURRENCY_EXCHANGE_RATE&from_currency=%s&to_currency=%s&apikey=%s' % ( rating, source_code, code, key or 'CRRAPQKU6BGLZG7Q') is_add = False try: ob = requests.get(url) if ob is not None: data = ob.json().get('Realtime Currency Exchange Rate') if data and isinstance(data, dict): cross = float(data.get('5. Exchange Rate')) timezone = data.get('7. Time Zone') rate = ExchangeRate.query.filter_by(rating=rating).filter_by(currency=currency).first() if rate is None: rate = ExchangeRate(rating, currency, timezone) is_add = True rate.update(cross) if is_add: db.session.add(rate) is_changed = True except ConnectionError: is_error = True except: if IsDebug: print(url, repr(ob), ob and ob.json()) #raise if IsPrintExceptions: print_exception() is_error = True break if is_changed and not is_error: _commit(1)
def _clean(self): if not IsTmpClean: return if not (self._tmp and self.tmp_folder in self._tmp): return try: del_file(self.tmp_body) del_file(self.tmp_image) del_file(self.tmp_xml) except Exception as ex: print_to( None, 'FileImageDecoder.clean Error: [%s] %s' % (self.tmp_folder, str(ex))) if IsPrintExceptions: print_exception()
def execute(self, sql, no_traceback=None, raise_error=None): rows = [] if IsDebug: print('>>> execute: %s' % sql) cursor = self.engine.execute(sql, no_traceback=no_traceback, raise_error=raise_error) try: rows = list(cursor.fetchall()) except: if IsPrintExceptions: print_exception() return rows
def index(): debug, kw = init_response('WebPerso Configurator Page') kw['product_version'] = product_version command = get_request_item('command') if IsDebug: print('--> command:%s, file_id:%s, batch_id:%s' % (command, kw.get('file_id'), kw.get('batch_id'))) refresh() errors = [] if command and command.startswith('admin'): pass kw['errors'] = '<br>'.join(errors) kw['OK'] = '' try: kw = _make_page_default(kw) if IsTrace: print_to(errorlog, '--> profile:%s %s %s' % ( command, current_user.login, str(kw.get('current_file')), ), request=request) except: print_exception() kw['vsc'] = (IsDebug or IsIE or IsForceRefresh) and ( '?%s' % str(int(random.random() * 10**12))) or '' if command and command.startswith('admin'): pass return make_response(render_template('profile.html', debug=debug, **kw))
def get_page_params(view=None): is_admin = current_user.is_administrator(private=True) is_manager = current_user.is_manager(private=True) is_operator = current_user.is_operator(private=True) page = 0 per_page = int( get_request_item('per_page') or get_request_item('per-page') or 0) default_per_page = view and current_user.get_pagesize(view) or ( #view in ('admin',) and DEFAULT_ADMIN_PER_PAGE or is_manager and DEFAULT_MANAGER_PER_PAGE or #is_operator and DEFAULT_OPER_PER_PAGE or view in ('cards', ) and DEFAULT_PER_PAGE * 2 or DEFAULT_PER_PAGE) try: if not per_page: per_page = default_per_page else: current_user.set_pagesize(view, per_page) page = int(get_request_item('page') or DEFAULT_PAGE) except: if IsPrintExceptions: print_exception() per_page = default_per_page page = DEFAULT_PAGE finally: if per_page <= 0 or per_page > 1000: per_page = default_per_page if page <= 0: page = DEFAULT_PAGE next = get_request_item('next') and True or False prev = get_request_item('prev') and True or False if next: page += 1 if prev and page > 1: page -= 1 return page, per_page
def execute(self, sql): self.open() if self.engine is None: return None res = None try: res = self.engine.execute(sql) except: print_to(None, 'NO SQL EXEC: %s' % sql) if IsPrintExceptions: print_exception() self.engine_error = True self.close() return res
def run(self, app): emitter = self._config.get('emitter') or False limit = self._config.get('limit') or 0 print_to( None, '>>> Logger Started[%s], root: %s' % ( self._config['ctype'], self._config['root'], )) base = BaseEmitter(args=( app, emitter, limit, self._logger, )) try: base.start() while not (self.stop_requested or base.is_finished()): time.sleep(5) if self.stop_requested: base.should_be_stop() self._processed, self._found = base.stop() except: print_exception() self._out('run exception (look at traceback.log)', is_error=True) finally: base.join() if not IsDisableOutput: self._out('>>> New messages found: %d' % (sum([self._found[x] for x in self._found]) or 0)) self._out('>>> Total processed: %d orders' % self._processed) self._out('>>> Unresolved: %d lines' % app._unresolved_lines())
def getBodyRaw(self, file_status=None, limit=None, is_extra=False): """ Get $ Make raw file body content """ self.getBody(file_status=file_status) try: if self.root is not None: if not is_extra: self.maskContent(self.root) self.makeIndents(self.root, limit=limit and MAX_XML_TREE_NODES or None) return self.upload(item=self.root, header=self.header(parser='ET.parse')) except: if IsPrintExceptions: print_exception() finally: self.flash()
def index_with_logger(mode, document=None, region=None, country=None, user=None): try: return index(mode, document=document, region=region, country=country, user=user) except: print_exception() raise