Esempio n. 1
0
 def sendMail(self, subject, text):
     if self.mail_server and self.mail_sender and self.mail_receiver:
         retry = 0
         ready = False
         while not ready:
             try:
                 msg = MIMEText('%s\n\n%s' % (text, mail_footer), 'plain')
                 msg['Subject'] = subject
                 msg['From'] = self.mail_sender
                 msg['To'] = self.mail_receiver
                 s = smtplib.SMTP(self.mail_server)
                 s.sendmail(self.mail_sender, self.mail_receiver.split(','), msg.as_string())
                 s.quit()
                 self.logger.debug('Sent email notification.')
                 ready = True
             except socket.gaierror as e:
                 if e.errno == socket.EAI_AGAIN:
                     time.sleep(100)
                     retry = retry + 1
                     ready = retry > 10
                 else:
                     ready = True
                 if ready:
                     et, ev, tb = sys.exc_info()
                     self.logger.error('got exception "%s"' % str(ev))
                     self.logger.error('%s' % str(traceback.format_exception(et, ev, tb)))
             except:
                 et, ev, tb = sys.exc_info()
                 self.logger.error('got exception "%s"' % str(ev))
                 self.logger.error('%s' % str(traceback.format_exception(et, ev, tb)))
                 ready = True
Esempio n. 2
0
def xmlrpc_handle_exception_int(e):
    if isinstance(e, odoo.exceptions.UserError):
        fault = xmlrpclib.Fault(RPC_FAULT_CODE_WARNING, odoo.tools.ustr(e.value))
    elif isinstance(e, odoo.exceptions.RedirectWarning):
        fault = xmlrpclib.Fault(RPC_FAULT_CODE_WARNING, str(e))
    elif isinstance(e, odoo.exceptions.MissingError):
        fault = xmlrpclib.Fault(RPC_FAULT_CODE_WARNING, str(e))
    elif isinstance (e, odoo.exceptions.AccessError):
        fault = xmlrpclib.Fault(RPC_FAULT_CODE_ACCESS_ERROR, str(e))
    elif isinstance(e, odoo.exceptions.AccessDenied):
        fault = xmlrpclib.Fault(RPC_FAULT_CODE_ACCESS_DENIED, str(e))
    elif isinstance(e, odoo.exceptions.DeferredException):
        info = e.traceback
        # Which one is the best ?
        formatted_info = "".join(traceback.format_exception(*info))
        #formatted_info = odoo.tools.exception_to_unicode(e) + '\n' + info
        fault = xmlrpclib.Fault(RPC_FAULT_CODE_APPLICATION_ERROR, formatted_info)
    else:
        info = sys.exc_info()
        # Which one is the best ?
        formatted_info = "".join(traceback.format_exception(*info))
        #formatted_info = odoo.tools.exception_to_unicode(e) + '\n' + info
        fault = xmlrpclib.Fault(RPC_FAULT_CODE_APPLICATION_ERROR, formatted_info)

    return xmlrpclib.dumps(fault, allow_none=None)
Esempio n. 3
0
def xmlrpc_handle_exception_string(e):
    if isinstance(e, ecore.exceptions.UserError):
        fault = xmlrpclib.Fault('warning -- %s\n\n%s' % (e.name, e.value), '')
        response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
    elif isinstance(e, ecore.exceptions.RedirectWarning):
        fault = xmlrpclib.Fault('warning -- Warning\n\n' + str(e), '')
    elif isinstance(e, ecore.exceptions.MissingError):
        fault = xmlrpclib.Fault('warning -- MissingError\n\n' + str(e), '')
        response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
    elif isinstance(e, ecore.exceptions.AccessError):
        fault = xmlrpclib.Fault('warning -- AccessError\n\n' + str(e), '')
        response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
    elif isinstance(e, ecore.exceptions.AccessDenied):
        fault = xmlrpclib.Fault('AccessDenied', str(e))
        response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
    elif isinstance(e, ecore.exceptions.DeferredException):
        info = e.traceback
        formatted_info = "".join(traceback.format_exception(*info))
        fault = xmlrpclib.Fault(ecore.tools.ustr(e.message), formatted_info)
        response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
    #InternalError
    else:
        info = sys.exc_info()
        formatted_info = "".join(traceback.format_exception(*info))
        fault = xmlrpclib.Fault(ecore.tools.exception_to_unicode(e), formatted_info)
        response = xmlrpclib.dumps(fault, allow_none=None, encoding=None)
    return response
 def apply(catalog, goal):
     """
     Apply the goal configuration to live catalog
     """
     print 'applying...'
     counter = 0
     ready = False
     while ready == False:
         try:
             catalog.applyCatalogConfig(goal)
             ready = True
         except HTTPError as err:
             print err
             print err.errno
             if err.errno == CONFLICT:
                 et, ev, tb = sys.exc_info()
                 print 'Conflict Exception "%s"' % str(ev)
                 counter = counter + 1
                 if counter >= 5:
                     print '%s' % str(traceback.format_exception(et, ev, tb))
                     ready = True
                 else:
                     print 'Retrying...'
         except:
             et, ev, tb = sys.exc_info()
             print str(et)
             print 'Exception "%s"' % str(ev)
             print '%s' % str(traceback.format_exception(et, ev, tb))
             ready = True
Esempio n. 5
0
    def _exc_info_to_string(self, err, test):
        """Converts a sys.exc_info()-style tuple of values into a string."""
        exctype, value, tb = err
        # Skip test runner traceback levels
        while tb and self._is_relevant_tb_level(tb):
            tb = tb.tb_next

        if exctype is test.failureException:
            # Skip assert*() traceback levels
            length = self._count_relevant_tb_levels(tb)
            msgLines = traceback.format_exception(exctype, value, tb, length)
        else:
            msgLines = traceback.format_exception(exctype, value, tb)

        if self.buffer:
            output = sys.stdout.getvalue()
            error = sys.stderr.getvalue()
            if output:
                if not output.endswith('\n'):
                    output += '\n'
                msgLines.append(STDOUT_LINE % output)
            if error:
                if not error.endswith('\n'):
                    error += '\n'
                msgLines.append(STDERR_LINE % error)
        return ''.join(msgLines)
Esempio n. 6
0
def xmlrpc_handle_exception(e):
    if isinstance(e, openerp.osv.osv.except_osv): # legacy
        fault = xmlrpclib.Fault(RPC_FAULT_CODE_WARNING, openerp.tools.ustr(e.value))
        response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
    elif isinstance(e, openerp.exceptions.Warning):
        fault = xmlrpclib.Fault(RPC_FAULT_CODE_WARNING, str(e))
        response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
    elif isinstance (e, openerp.exceptions.AccessError):
        fault = xmlrpclib.Fault(RPC_FAULT_CODE_ACCESS_ERROR, str(e))
        response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
    elif isinstance(e, openerp.exceptions.AccessDenied):
        fault = xmlrpclib.Fault(RPC_FAULT_CODE_ACCESS_DENIED, str(e))
        response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
    elif isinstance(e, openerp.exceptions.DeferredException):
        info = e.traceback
        # Which one is the best ?
        formatted_info = "".join(traceback.format_exception(*info))
        #formatted_info = openerp.tools.exception_to_unicode(e) + '\n' + info
        fault = xmlrpclib.Fault(RPC_FAULT_CODE_APPLICATION_ERROR, formatted_info)
        response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
    else:
        if hasattr(e, 'message') and e.message == 'AccessDenied': # legacy
            fault = xmlrpclib.Fault(RPC_FAULT_CODE_ACCESS_DENIED, str(e))
            response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
        else:
            info = sys.exc_info()
            # Which one is the best ?
            formatted_info = "".join(traceback.format_exception(*info))
            #formatted_info = openerp.tools.exception_to_unicode(e) + '\n' + info
            fault = xmlrpclib.Fault(RPC_FAULT_CODE_APPLICATION_ERROR, formatted_info)
            response = xmlrpclib.dumps(fault, allow_none=None, encoding=None)
    return response
    def process_feed_wrapper(self, feed):
        """ wrapper for ProcessFeed
        """
        start_time = datetime.datetime.now()
        try:
            pfeed = ProcessFeed(feed, self.options)
            ret_feed, ret_entries = pfeed.process()
            del pfeed
        except:
            (etype, eobj, etb) = sys.exc_info()
            print '[%d] ! -------------------------' % (feed.id,)
            print traceback.format_exception(etype, eobj, etb)
            traceback.print_exception(etype, eobj, etb)
            print '[%d] ! -------------------------' % (feed.id,)
            ret_feed = FEED_ERREXC
            ret_entries = {}

        delta = datetime.datetime.now() - start_time
        if delta.seconds > SLOWFEED_WARNING:
            comment = u' (SLOW FEED!)'
        else:
            comment = u''
        prints(u'[%d] Processed %s in %s [%s] [%s]%s' % (
            feed.id, feed.feed_url, unicode(delta),
            self.feed_trans[ret_feed],
            u' '.join(u'%s=%d' % (self.entry_trans[key],
                      ret_entries[key]) for key in self.entry_keys),
            comment))

        self.feed_stats[ret_feed] += 1
        for key, val in ret_entries.items():
            self.entry_stats[key] += val

        return ret_feed, ret_entries
  def StopTracing(self):
    assert self.is_tracing_running, 'Can only stop tracing when tracing is on.'
    self._IssueClockSyncMarker()
    builder = self._current_state.builder

    raised_exception_messages = []
    for agent in self._active_agents_instances + [self]:
      try:
        agent.StopAgentTracing()
      except Exception: # pylint: disable=broad-except
        raised_exception_messages.append(
            ''.join(traceback.format_exception(*sys.exc_info())))

    for agent in self._active_agents_instances + [self]:
      try:
        agent.CollectAgentTraceData(builder)
      except Exception: # pylint: disable=broad-except
        raised_exception_messages.append(
            ''.join(traceback.format_exception(*sys.exc_info())))

    self._iteration_info = None
    self._active_agents_instances = []
    self._current_state = None

    if raised_exception_messages:
      raise TracingControllerStoppedError(
          'Exceptions raised when trying to stop tracing:\n' +
          '\n'.join(raised_exception_messages))

    return builder.AsData()
def build_error_response(e):

    if hasattr(e,'get_stacks'):
        #Process potentially multiple stacks.
        full_error = ''
        for i in range(len(e.get_stacks())):
            full_error += e.get_stacks()[i][0] + "\n"
            if i == 0:
                full_error += string.join(traceback.format_exception(*sys.exc_info()), '')
            else:
                for ln in e.get_stacks()[i][1]:
                    full_error += str(ln)  + "\n"

        exec_name = e.__class__.__name__
    else:
        exc_type, exc_obj, exc_tb = sys.exc_info()
        exec_name = exc_type.__name__
        full_error = traceback.format_exception(*sys.exc_info())

    if service_gateway_instance.log_errors:
        log.error(full_error)

    result = {
        GATEWAY_ERROR_EXCEPTION : exec_name,
        GATEWAY_ERROR_MESSAGE : str(e.message),
        GATEWAY_ERROR_TRACE : full_error
    }

    if request.args.has_key(RETURN_FORMAT_PARAM):
        return_format = convert_unicode(request.args[RETURN_FORMAT_PARAM])
        if return_format == RETURN_FORMAT_RAW_JSON:
            return service_gateway_app.response_class(result, mimetype='application/json')

    return json_response({'data': {GATEWAY_ERROR: result }} )
Esempio n. 10
0
 def notify(self, obj, event):
     try:
         return QtGui.QApplication.notify(self, obj, event)
     except Exception:
         print "fix me!"
         print traceback.format_exception(*sys.exc_info())
         return False
Esempio n. 11
0
 def __printFail(self, test, err):
     elapsed = time.time() - self.startTime
     t, val, trace = err
     if args.testpilot_json:
         print(
             json.dumps(
                 {
                     "op": "test_done",
                     "status": "failed",
                     "test": test.id(),
                     "details": "".join(traceback.format_exception(t, val, trace)),
                     "start_time": self.startTime,
                     "end_time": time.time(),
                 }
             )
         )
     else:
         print(
             "\033[31mFAIL\033[0m %s (%.3fs)%s\n%s"
             % (
                 test.id(),
                 elapsed,
                 self._attempts(),
                 "".join(traceback.format_exception(t, val, trace)),
             )
         )
Esempio n. 12
0
def MachineMachine():
    LATTICE = "star"  ##, 'diamond'
    DIMENSION = (5, 11)
    PLAYERS = "a", "b", " "
    ##mc = Mangorona(PLAYERS,'cubic', DIMENSION, None)
    ##maximum=True
    ##getall=True
    mc = Mangorona(PLAYERS, "diamond", (7, 11), None)
    maximum = True
    getall = False
    t = PLAYERS[:2]
    tab = 0
    print(Board(mc).Display())
    while True:
        try:
            turn = t[tab % 2]
            movable = AllowableMovement(mc, turn).Move(maximum=maximum, getall=getall)
            machine = random.choice(movable)
            print(turn, "move:", machine[0], machine[1])
            mc.Move(turn, machine[0], machine[1])
            print(Board(mc).Display())
            print(mc.gain["a"], mc.gain["b"])  ##, t1-t0
            print()
            tab += 1
        except IllegalMove:
            exc = traceback.format_exception(*sys.exc_info())[-1]
            print(exc)
        except NoMoreMove:
            exc = traceback.format_exception(*sys.exc_info())[-1]
            print(exc)
            print("winner:", mc.Winner())
            break
def unix_mainloop(repodir, port, logfilename):

    try:
        port = int(port)
    except ValueError:
        port = None

    if not os.path.isdir(repodir):
        sys.stderr.write("Specified directory, %s, is not a directory!\n" % repodir)
        usage()
    elif port is None:
        sys.stderr.write("Bad port number, %s, specified.\n", portnum)
        usage()

    try:
        repo = start_angel(repodir, port, logfilename)
    except:
        sys.stderr.write("%s: exception initializing angel:\n%s" % (
            time.ctime(), ''.join(traceback.format_exception(*sys.exc_info()))))
        sys.exit(1)

    # Finally, start up the server loop!  This loop will not exit until
    # all clients and servers are closed.  You may cleanly shut the system
    # down by sending SIGINT (a.k.a. KeyboardInterrupt).

    from uplib.plibUtil import note
    while True:
        try:
            asyncore.loop()
        except (KeyboardInterrupt, SystemExit), x:
            note(4, "Exited from main loop due to exception:\n%s", ''.join(traceback.format_exception(*sys.exc_info())))
            raise
        except:
Esempio n. 14
0
def main():
    # Initialize color support
    colorama.init()
    try:
        run()
    except util.DeviceException as e:
        typ, val, tb = sys.exc_info()
        logging.debug("".join(traceback.format_exception(typ, val, tb)))
        print(colorama.Fore.RED + "There is a problem with your device"
                                  " configuration:")
        print(colorama.Fore.RED + e.message)
    except ConfigError as e:
        typ, val, tb = sys.exc_info()
        logging.debug("".join(traceback.format_exception(typ, val, tb)))
        print(colorama.Fore.RED +
              "There is a problem with your configuration file(s):")
        print(colorama.Fore.RED + e.message)
    except util.MissingDependencyException as e:
        typ, val, tb = sys.exc_info()
        logging.debug("".join(traceback.format_exception(typ, val, tb)))
        print(colorama.Fore.RED +
              "You are missing a dependency for one of your enabled plugins:")
        print(colorama.Fore.RED + e.message)
    except KeyboardInterrupt:
        colorama.deinit()
        sys.exit(1)
    except Exception as e:
        typ, val, tb = sys.exc_info()
        print(colorama.Fore.RED + "spreads encountered an error:")
        print(colorama.Fore.RED +
              "".join(traceback.format_exception(typ, val, tb)))
    # Deinitialize color support
    colorama.deinit()
Esempio n. 15
0
    def run(self):
        """
        Thread main part
        """

##        testlink = threading.Timer(3.0,gprs_source.writeTest)
##        testlink.start()
        while not self.exitEvent.isSet(): 
            asyncore.poll(0.5) # socket IO
            try: ## lower device IO
                for i in self.device: #如果连接网关的本地客户端不为空,那么循环读取数据,发送命令
                    try:
                        pkts = i.readPackets()#返回的就是python字典形式的包
                    except:
                        pass
                    else:
                        if pkts:
                            self.clientMessageSource.setMessage(pkts)
                    command = self.clientMessageSource.getLowerPacket()
                    
                    print "+++++++"+str(command)
                    i.writePackets(command)
 
            except:
                type, value, tb = sys.exc_info()
                print traceback.format_exception(type, value, tb)
                pass
Esempio n. 16
0
def _format_exception(err, is_failure, stdout=None, stderr=None):
    """Converts a sys.exc_info()-style tuple of values into a string."""
    exctype, value, tb = err
    # Skip test runner traceback levels
    while tb and _is_relevant_tb_level(tb):
        tb = tb.tb_next

    if is_failure:
        # Skip assert*() traceback levels
        length = _count_relevant_tb_levels(tb)
        msgLines = traceback.format_exception(exctype, value, tb, length)
    else:
        msgLines = traceback.format_exception(exctype, value, tb)

    encoding = locale.getpreferredencoding()
    msgLines = [_decode(line, encoding) for line in msgLines]

    if stdout:
        if not stdout.endswith('\n'):
            stdout += '\n'
        msgLines.append(STDOUT_LINE % stdout)
    if stderr:
        if not stderr.endswith('\n'):
            stderr += '\n'
        msgLines.append(STDERR_LINE % stderr)
    return ''.join(msgLines)
Esempio n. 17
0
    def format(self, record):
        """Formatting function

          @param object record: :logging.LogRecord:
        """
        entry = {
                'name': record.name,
                'timestamp': self.formatTime(record,
                    datefmt="%Y-%m-%d %H:%M:%S"),
                'level': record.levelname
        }
        if hasattr(record, 'message'):
            entry['message'] = record.message
        else:
            entry['message'] = super().format(record)
        # add exception information if available
        if record.exc_info is not None:
            entry['exception'] = {
                    'message': traceback.format_exception(
                        *record.exc_info)[-1][:-1],
                    'traceback': traceback.format_exception(
                        *record.exc_info)[:-1]
                    }

        return entry
Esempio n. 18
0
 def post(self):
   user = User.query().get()
   key = self.request.get('key')
   feed = Feed.retrieve(key)
   try:
     content = Feed.fetch_feed(feed.url)
     d = feedparser.parse(content)
     for entry in d.entries:
       try:
         story_date = None
         try:
           story_date = datetime.datetime(*(entry.published_parsed[0:6]))
         except:
           story_date = datetime.datetime.now()
         yesterday = datetime.datetime.now() - datetime.timedelta(days=1)
         try:
           entry.id == None
         except:
           entry.id = entry.link
         if story_date > yesterday:
           self.safe_insert(entry, feed, story_date)
       except:
         logging.error("error parsing story" + dir(entry))
         logging.error("".join(traceback.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])))
   except:
     logging.error("error parsing " + feed.url)
     logging.error("".join(traceback.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])))
 def setupConnection(self):
     LOG.info('setupConnection:'+self.sql_url)
     if self._scoped_session:
         self._scoped_session.remove()
     try:
         engine = create_engine(self.sql_url, encoding='utf8', echo=False, pool_recycle=1)
     except:
         exc_type, exc_value, exc_traceback = sys.exc_info()
         lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
         LOG.error(''.join('!! ' + line for line in lines))
         return
     self._insp = reflection.Inspector.from_engine(engine)
     self.d_base = declarative_base(bind=engine)
     a_base = automap_base(bind=engine)
     try:
         a_base.metadata.reflect(views=True)
         self.name = unicode(self.sql_url)
     except:
         LOG.info('Unable to reflect the whole DB!')
         exc_type, exc_value, exc_traceback = sys.exc_info()
         lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
         for line in lines:
             LOG.info(line)
         a_base.metadata.reflect(views=True, only=[self.sql_table])
         self.restricted = True
         self.name = unicode(self.sql_url+'+'+self.sql_table)
     a_base.prepare(a_base.metadata.bind, name_for_collection_relationship=unique_collection)
     self.a_base = a_base
     self._scoped_session = scoped_session(sessionmaker(bind=self.a_base.metadata.bind, extension=ZopeTransactionExtension(keep_session=True), autocommit=True))
Esempio n. 20
0
 def OnPaint(self, event):
     namespace = {'self':self, 'event':event, 'wx':wx}
     if not self.error and self.codes.get('OnPaint', None):
         try:
             code = compile((self.codes['OnPaint'].replace('\r\n', '\n') + '\n'), 'canvastest', 'exec')
             self.error = False
         except:
             self.error = True
             traceback.format_exception(*sys.exc_info())
             def f():
                 d = wx.lib.dialogs.ScrolledMessageDialog(self.parent, (tr("Error compiling script.\n\nTraceback:\n\n") +
                     ''.join(trace)), tr("Error"), wx.DefaultPosition, wx.Size(400,300))
                 d.ShowModal()
                 d.Destroy()
             wx.CallAfter(f)
             return
         
         try:
             exec code in namespace
             self.error = False
         except:
             self.error = True
             trace = traceback.format_exception(*sys.exc_info())
             def f():
                 d = wx.lib.dialogs.ScrolledMessageDialog(self.parent, (tr("Error running script.\n\nTraceback:\n\n") +
                     ''.join(trace)), tr("Error"), wx.DefaultPosition, wx.Size(400,300))
                 d.ShowModal()
                 d.Destroy()
             wx.CallAfter(f)
             return
     else:
         dc = wx.PaintDC(self)
         dc.Clear()
         event.Skip
Esempio n. 21
0
def send_update(log_file_path,
                program,
                email_params):
    try:
        subject = 'Daily ' + program + ' update'
        sender = email_params['sender']
        enc_pwd = email_params['enc_pwd']
        recipient = email_params['recipient']
        f = open(log_file_path, 'rb')
        data = [line for line in f]
        body = str(len(data)) + \
               ' lines of data in log, here are the last 10 lines:<br/>'
        body += '<br/>'.join([line for line in data[-10:]])
        f.close()
    except:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
        body = 'Error getting email body... ' + \
               ''.join('!! ' + line for line in lines)
    try:
        send_mail.mail(sender, enc_pwd, recipient, subject, body)
    except:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
        err = 'Error sending update email!: '  + \
              ''.join('!! ' + line for line in lines)
        log(log_file_path, program, subject, err, True)
Esempio n. 22
0
 def send(self, service_name, method, *args):
     import openerp
     import traceback
     import xmlrpclib
     try:
         result = openerp.netsvc.dispatch_rpc(service_name, method, args)
     except Exception,e:
     # TODO change the except to raise LibException instead of their emulated xmlrpc fault
         if isinstance(e, openerp.osv.osv.except_osv):
             fault = xmlrpclib.Fault('warning -- ' + e.name + '\n\n' + e.value, '')
         elif isinstance(e, openerp.exceptions.Warning):
             fault = xmlrpclib.Fault('warning -- Warning\n\n' + str(e), '')
         elif isinstance(e, openerp.exceptions.AccessError):
             fault = xmlrpclib.Fault('warning -- AccessError\n\n' + str(e), '')
         elif isinstance(e, openerp.exceptions.AccessDenied):
             fault = xmlrpclib.Fault('AccessDenied', str(e))
         elif isinstance(e, openerp.exceptions.DeferredException):
             info = e.traceback
             formatted_info = "".join(traceback.format_exception(*info))
             fault = xmlrpclib.Fault(openerp.tools.ustr(e.message), formatted_info)
         else:
             info = sys.exc_info()
             formatted_info = "".join(traceback.format_exception(*info))
             fault = xmlrpclib.Fault(openerp.tools.exception_to_unicode(e), formatted_info)
         raise fault
Esempio n. 23
0
    def create_authnrequest(self, environ, server_env, start_response, session, acr_value):
        try:
            client = session.getClient()
            session.setAcrValue(client.authorization_endpoint, acr_value)
            request_args = {
                "response_type": self.flow_type,
                "scope": self.extra["scope"],
                "state":  client.state,
            }

            if acr_value is not None:
                request_args["acr_values"] = acr_value

            if self.flow_type == "token":
                request_args["nonce"] = rndstr(16)
                session.setNonce(request_args["nonce"])
            else:
                use_nonce = getattr(self, "use_nonce", None)
                if use_nonce:
                    request_args["nonce"] = rndstr(16)
                    session.setNonce(request_args["nonce"])


            logger.info("client args: %s" % client.__dict__.items(),)
            logger.info("request_args: %s" % (request_args,))
            # User info claims
        except Exception:
            message = traceback.format_exception(*sys.exc_info())
            logger.error(message)
            return self.result(environ, start_response, server_env,(False, "Cannot find the OP! Please view your configuration of pyoidc RP."))


        try:
            cis = client.construct_AuthorizationRequest(
                request_args=request_args)
            logger.debug("request: %s" % cis)

            url, body, ht_args, cis = client.uri_and_body(
                AuthorizationRequest, cis, method="GET",
                request_args=request_args)
            logger.debug("body: %s" % body)
        except Exception:
            message = traceback.format_exception(*sys.exc_info())
            logger.error(message)
            return self.result(environ, start_response, server_env,(False, "Authorization request can not be performed!"))

        logger.info("URL: %s" % url)
        logger.debug("ht_args: %s" % ht_args)

        #session.setAuthn_auth(client.authorization_endpoint)
        #session.setAuthentication("VERIFY")

        #server_env["CACHE"][sid] = session
        session.setClient(client)
        resp_headers = [("Location", str(url))]
        if ht_args:
            resp_headers.extend([(a, b) for a, b in ht_args.items()])
        logger.debug("resp_headers: %s" % resp_headers)
        start_response("302 Found", resp_headers)
        return []
Esempio n. 24
0
File: daemon.py Progetto: ccoss/koji
def log_output(session, path, args, outfile, uploadpath, cwd=None, logerror=0, append=0, chroot=None, env=None):
    """Run command with output redirected.  If chroot is not None, chroot to the directory specified
    before running the command."""
    pid = os.fork()
    fd = None
    if not pid:
        session._forget()
        try:
            if chroot:
                os.chroot(chroot)
            if cwd:
                os.chdir(cwd)
            flags = os.O_CREAT | os.O_WRONLY
            if append:
                flags |= os.O_APPEND
            fd = os.open(outfile, flags, 0666)
            os.dup2(fd, 1)
            if logerror:
                os.dup2(fd, 2)
            # echo the command we're running into the logfile
            os.write(fd, '$ %s\n' % ' '.join(args))
            environ = os.environ.copy()
            if env:
                environ.update(env)
            os.execvpe(path, args, environ)
        except:
            msg = ''.join(traceback.format_exception(*sys.exc_info()))
            if fd:
                try:
                    os.write(fd, msg)
                    os.close(fd)
                except:
                    pass
            print msg
            os._exit(1)
    else:
        if chroot:
            outfile = os.path.normpath(chroot + outfile)
        outfd = None
        remotename = os.path.basename(outfile)
        while True:
            status = os.waitpid(pid, os.WNOHANG)
            time.sleep(1)

            if not outfd:
                try:
                    outfd = file(outfile, 'r')
                except IOError:
                    # will happen if the forked process has not created the logfile yet
                    continue
                except:
                    print 'Error reading log file: %s' % outfile
                    print ''.join(traceback.format_exception(*sys.exc_info()))

            incremental_upload(session, remotename, outfd, uploadpath)

            if status[0] != 0:
                if outfd:
                    outfd.close()
                return status[1]
Esempio n. 25
0
def rateAnalysis(request):
	if request.method == 'POST':
		print request.POST
		try:
			user = User.objects.get(id=request.POST['user_id'])
			teacher = TeacherProfile.objects.get(user=user)
			sa = StandardAnalysis.objects.get(id = request.POST['id'])
			sar, created = StandardAnalysisRating.objects.get_or_create(standard_analysis=sa, rater=teacher, rating_type='All')
		except:
			print traceback.format_exception(*sys.exc_info())
			return HttpResponseRedirect('/standard/?standard_id='+str(sa.id))
		new_rating =  int(request.POST['rating'])
		try:
			if created:
				sar.rating = new_rating
				sar.save()
				sa.cumulative_rating = (sa.cumulative_rating*sa.number_raters + sar.rating)/(sa.number_raters+1)
				sa.number_raters+=1
				sa.save()
			elif (sar.rating != new_rating):
				sa.cumulative_rating = (sa.cumulative_rating*sa.number_raters - sar.rating + new_rating)/sa.number_raters
				sar.rating = new_rating
				sar.save()
				sa.save()
		except:
			print traceback.format_exception(*sys.exc_info())
			
		return HttpResponse(str(sa.cumulative_rating))
Esempio n. 26
0
 def record_results(self, resid, uutid):
     import os, commands
     import string
     import traceback
     #if environment variable IDTYPE == UUID, then use UUID for database entry id, else implicit auto-increment integer is used.
     tmp = self.dbRes[uutid]
     self.info("%s" % (tmp))
     if (("IDTYPE" in os.environ.keys()) and (os.environ["IDTYPE"]=="UUID")):
         try:
             database.VssdVg1a1Sweep(
                 id = (commands.getoutput('uuidgen -t')).strip(),
                 TestResultsID = resid,
                 **tmp
             )
         except:
             self.info("An error was thrown: %s"
                     % string.join(traceback.format_exception(*sys.exc_info()),
                                    ''))
     else:
         try:
             database.VssdVg1a1Sweep(
                 TestResultsID = resid,
                 **tmp
             )
         except:
             self.info("An error was thrown: %s"
                     % string.join(traceback.format_exception(*sys.exc_info()),
                                    ''))
Esempio n. 27
0
def import_function(import_str):
    """
    Attempts to import the specified class method or regular function,
    and returns a callable.

    :raises ImportError if the specified import_str cannot be found.
    :raises TypeError if the specified import_str is found but is
            not a callable.
    """
    mod_str, _sep, class_str = import_str.rpartition('.')
    try:
        __import__(mod_str)
        fn = getattr(sys.modules[mod_str], class_str)
        if not callable(fn):
            msg = '{0} is not callable'
            LOG.error(msg)
            raise TypeError(msg)
    except (ValueError, AttributeError):
        msg = 'Method or function {0} cannot be found.'.format(import_str)
        err_details = traceback.format_exception(*sys.exc_info())
        LOG.error(msg + ' Details: (%s)'.format(err_details))
        raise ImportError(msg)
    except ImportError:
        msg = 'Module {0} cannot be found.'.format(import_str)
        err_details = traceback.format_exception(*sys.exc_info())
        LOG.error(msg + ' Details: (%s)'.format(err_details))
        raise
    return fn
Esempio n. 28
0
def _format_multiple_exceptions(e, debug=False):
    valid_excs = []
    excs = list(e.args)
    while excs:
        (etype, value, tb) = excs.pop(0)
        if (etype == fixtures.MultipleExceptions):
            excs.extend(value.args)
        elif (etype == fixtures.SetupError):
            continue
        else:
            valid_excs.append((etype, value, tb))

    if len(valid_excs) == 1:
        (etype, value, tb) = valid_excs[0]
        if debug:
            LOG.error("".join(traceback.format_exception(etype, value, tb)))
        else:
            raise value
    else:
        LOG.error("MultipleExceptions raised:")
        for n, (etype, value, tb) in enumerate(valid_excs):
            if debug:
                LOG.error("- exception %d:" % n)
                LOG.error("".join(
                    traceback.format_exception(etype, value, tb)))
            else:
                LOG.error(value)
Esempio n. 29
0
    def __init__(self, device=None, config_path=None, user_path=".", cmd_line=""):
        """
        Create an option object and check that parameters are valid.

        :param device: The device to use
        :type device: str
        :param config_path: The openzwave config directory. If None, try to configure automatically.
        :type config_path: str
        :param user_path: The user directory
        :type user_path: str
        :param cmd_line: The "command line" options of the openzwave library
        :type cmd_line: str

        """
        try:
            if os.path.exists(device):
                if os.access(device, os.R_OK) and os.access(device, os.W_OK):
                    self._device = device
                else:
                    import sys, traceback
                    raise ZWaveException("Can't write to device %s : %s" % (device, traceback.format_exception(*sys.exc_info())))
            else:
                import sys, traceback
                raise ZWaveException("Can't find device %s : %s" % (device, traceback.format_exception(*sys.exc_info())))
        except:
            import sys, traceback
            raise ZWaveException("Error when retrieving device %s : %s" % (device, traceback.format_exception(*sys.exc_info())))
        libopenzwave.PyOptions.__init__(self, config_path=config_path, user_path=user_path, cmd_line=cmd_line)
        self._user_path = user_path
        self._config_path = config_path
Esempio n. 30
0
def makeVideoThumb(fullPath, thumbPath):
    print "\n", 80*"-", "\ncreating video thumbnail with command: "
    # must create two frames because of mplayer bug
    createCmd = MPLAYER_DIR+" -vo jpeg -quiet -frames 2 -ss 5 "+ fullPath
    print createCmd
    try:
        sp.check_call(createCmd.split())
    except:
        print "".join(tb.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]))
        
    # delete one of them
    try:
        os.remove("00000001.jpg")
    except:
        print "".join(tb.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])) 

    # resize it to 300x300
    try:
        im = wx.Image("00000002.jpg")  # read the original image
        if im.Ok():  #the image may be corrupted...
            im.Rescale(300, 300)        # resize it
            im.SaveFile("00000002.jpg", wx.BITMAP_TYPE_JPEG)    # save it back to a file
    except: 
        print "".join(tb.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]))
        
    # rename the right one
    try:
        shutil.move("00000002.jpg", thumbPath)
    except:
        print "".join(tb.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])) 
Esempio n. 31
0
def fmt_last_exception():
    exc_info = traceback.format_exception(*sys.exc_info())
    return ''.join(exc_info)
Esempio n. 32
0
    def handleException(self, dump_info):
        """
        Our own handleException method doing some additional stuff before
        calling the original python-meh's one.

        :type dump_info: an instance of the meh.DumpInfo class
        :see: python-meh's ExceptionHandler.handleException

        """

        log.debug("running handleException")
        exception_lines = traceback.format_exception(*dump_info.exc_info)
        log.critical("\n".join(exception_lines))

        ty = dump_info.exc_info.type
        value = dump_info.exc_info.value

        try:
            gi.require_version("Gtk", "3.0")

            from gi.repository import Gtk

            # XXX: Gtk stopped raising RuntimeError if it fails to
            # initialize. Horay! But will it stay like this? Let's be
            # cautious and raise the exception on our own to work in both
            # cases
            initialized = Gtk.init_check(None)[0]
            if not initialized:
                raise RuntimeError()

            # Attempt to grab the GUI initializing lock, do not block
            if not self._gui_lock.acquire(False):
                # the graphical interface is running, don't crash it by
                # running another one potentially from a different thread
                log.debug("Gtk running, queuing exception handler to the "
                         "main loop")
                GLib.idle_add(self._main_loop_handleException, dump_info)
            else:
                log.debug("Gtk not running, starting Gtk and running "
                         "exception handler in it")
                self._main_loop_handleException(dump_info)

        except (RuntimeError, ImportError, ValueError):
            log.debug("Gtk cannot be initialized")
            # X not running (Gtk cannot be initialized)
            if threadMgr.in_main_thread():
                log.debug("In the main thread, running exception handler")
                if issubclass(ty, CmdlineError) or not self._interactive:
                    if issubclass(ty, CmdlineError):
                        cmdline_error_msg = _("\nThe installation was stopped due to "
                                              "incomplete spokes detected while running "
                                              "in non-interactive cmdline mode. Since there "
                                              "cannot be any questions in cmdline mode, "
                                              "edit your kickstart file and retry "
                                              "installation.\nThe exact error message is: "
                                              "\n\n%s.\n\nThe installer will now terminate.") % str(value)
                    else:
                        cmdline_error_msg = _("\nRunning in cmdline mode, no interactive debugging "
                                              "allowed.\nThe exact error message is: "
                                              "\n\n%s.\n\nThe installer will now terminate.") % str(value)

                    # since there is no UI in cmdline mode and it is completely
                    # non-interactive, we can't show a message window asking the user
                    # to acknowledge the error; instead, print the error out and sleep
                    # for a few seconds before exiting the installer
                    print(cmdline_error_msg)
                    time.sleep(10)
                    sys.exit(1)
                else:
                    print("\nAn unknown error has occured, look at the "
                           "/tmp/anaconda-tb* file(s) for more details")
                    # in the main thread, run exception handler
                    self._main_loop_handleException(dump_info)
            else:
                log.debug("In a non-main thread, sending a message with "
                         "exception data")
                # not in the main thread, just send message with exception
                # data and let message handler run the exception handler in
                # the main thread
                exc_info = dump_info.exc_info
                hubQ.send_exception((exc_info.type,
                                     exc_info.value,
                                     exc_info.stack))
Esempio n. 33
0
                            else:
                                FP += 1
            FPR[key].append(FP / (FP + TN))
            TPR[key].append(TP / (TP + FN))
        fnameout = os.path.join(
            outdir,
            (key + os.path.splitext(os.path.basename(csvfile))[0] + 'roc.dat'))
        with open(fnameout, 'w') as fout:
            for n in range(len(FPR[key])):
                fout.write(str(FPR[key][n]) + ' ' + str(TPR[key][n]))

    endmsg = pcl.ok(starttime, command=__script__)
    logger.info(endmsg)

    return


if __name__ == "__main__":
    import sys
    import traceback

    try:
        main()
        logger.info(pcl.ok())
        sys.exit(0)
    except Exception as e:
        if not isinstance(e, SystemExit):
            msg = "".join(traceback.format_exception(*sys.exc_info()))
            logger.critical(msg)
        sys.exit(1)
Esempio n. 34
0
 def format_exc():
     """ replace missing format_exc() """
     return ''.join(traceback.format_exception(*list(sys.exc_info())))
Esempio n. 35
0
import traceback

db_last_modified = datetime(2000, 1, 1, 0, 0, 0)

try:
    app = Flask(__name__)
    app.config['DEBUG'] = True
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
    app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
        'DATABASE_URL'
    ) or "postgresql://*****:*****@localhost:5432/holiday"
    db = SQLAlchemy(app)
    CORS(app)
except Exception as e:
    t, v, tb = sys.exc_info()
    print(traceback.format_exception(t, v, tb))
    print(traceback.format_tb(e.__traceback__))


@app.route('/')
def index():
    print('index()')

    @after_this_request
    def d_header(response):
        response.headers['Last-Modified'] = format_date_time(
            mktime(db_last_modified.timetuple()))
        return response

    return jsonify(ResultSet=read_holidays())
Esempio n. 36
0
                return -2

    except:
        if url.startswith("rtmp"):
            error = downloadfileRTMP(url, nombrefichero, silent)
            if error and not silent:
                from platformcode import platformtools
            platformtools.dialog_ok("No puedes descargar ese vídeo",
                                    "Las descargas en RTMP aún no",
                                    "están soportadas")
        else:
            import traceback
            from pprint import pprint
            exc_type, exc_value, exc_tb = sys.exc_info()
            lines = traceback.format_exception(exc_type, exc_value, exc_tb)
            for line in lines:
                line_splits = line.split("\n")
                for line_split in line_splits:
                    logger.error(line_split)

    try:
        f.close()
    except:
        pass

    if not silent:
        try:
            progreso.close()
        except:
            pass
Esempio n. 37
0
    def handler(self, event, context):
        """
        An AWS Lambda function which parses specific API Gateway input into a
        WSGI request, feeds it to our WSGI app, procceses the response, and returns
        that back to the API Gateway.

        """
        settings = self.settings

        # If in DEBUG mode, log all raw incoming events.
        if settings.DEBUG:
            logger.debug('Zappa Event: {}'.format(event))

        # Set any API Gateway defined Stage Variables
        # as env vars
        if event.get('stageVariables'):
            for key in event['stageVariables'].keys():
                os.environ[str(key)] = event['stageVariables'][key]

        # This is the result of a keep alive, recertify
        # or scheduled event.
        if event.get('detail-type') == u'Scheduled Event':

            whole_function = event['resources'][0].split('/')[-1].split(
                '-')[-1]

            # This is a scheduled function.
            if '.' in whole_function:
                app_function = self.import_module_and_get_function(
                    whole_function)

                # Execute the function!
                return self.run_function(app_function, event, context)

            # Else, let this execute as it were.

        # This is a direct command invocation.
        elif event.get('command', None):

            whole_function = event['command']
            app_function = self.import_module_and_get_function(whole_function)
            result = self.run_function(app_function, event, context)
            print("Result of %s:" % whole_function)
            print(result)
            return result

        # This is a direct, raw python invocation.
        # It's _extremely_ important we don't allow this event source
        # to be overriden by unsanitized, non-admin user input.
        elif event.get('raw_command', None):

            raw_command = event['raw_command']
            exec(raw_command)
            return

        # This is a Django management command invocation.
        elif event.get('manage', None):

            from django.core import management

            try:  # Support both for tests
                from zappa.ext.django_zappa import get_django_wsgi
            except ImportError as e:  # pragma: no cover
                from django_zappa_app import get_django_wsgi

            # Get the Django WSGI app from our extension
            # We don't actually need the function,
            # but we do need to do all of the required setup for it.
            app_function = get_django_wsgi(self.settings.DJANGO_SETTINGS)

            # Couldn't figure out how to get the value into stdout with StringIO..
            # Read the log for now. :[]
            management.call_command(*event['manage'].split(' '))
            return {}

        # This is an AWS-event triggered invokation.
        elif event.get('Records', None):

            records = event.get('Records')
            result = None
            whole_function = self.get_function_for_aws_event(records[0])
            if whole_function:
                app_function = self.import_module_and_get_function(
                    whole_function)
                result = self.run_function(app_function, event, context)
                logger.debug(result)
            else:
                logger.error(
                    "Cannot find a function to process the triggered event.")
            return result

        # This is an API Gateway authorizer event
        elif event.get('type') == u'TOKEN':
            whole_function = self.settings.AUTHORIZER_FUNCTION
            if whole_function:
                app_function = self.import_module_and_get_function(
                    whole_function)
                policy = self.run_function(app_function, event, context)
                return policy
            else:
                logger.error(
                    "Cannot find a function to process the authorization request."
                )
                raise Exception('Unauthorized')

        # Normal web app flow
        try:
            # Timing
            time_start = datetime.datetime.now()

            # This is a normal HTTP request
            if event.get('httpMethod', None):

                script_name = ''
                headers = event.get('headers')
                if headers:
                    host = headers.get('Host')
                else:
                    host = None

                if host:
                    if 'amazonaws.com' in host:
                        # The path provided in th event doesn't include the
                        # stage, so we must tell Flask to include the API
                        # stage in the url it calculates. See https://github.com/Miserlou/Zappa/issues/1014
                        script_name = '/' + settings.API_STAGE
                else:
                    # This is a test request sent from the AWS console
                    if settings.DOMAIN:
                        # Assume the requests received will be on the specified
                        # domain. No special handling is required
                        pass
                    else:
                        # Assume the requests received will be to the
                        # amazonaws.com endpoint, so tell Flask to include the
                        # API stage
                        script_name = '/' + settings.API_STAGE

                # Create the environment for WSGI and handle the request
                environ = create_wsgi_request(
                    event,
                    script_name=script_name,
                    trailing_slash=self.trailing_slash,
                    binary_support=settings.BINARY_SUPPORT,
                    context_header_mappings=settings.CONTEXT_HEADER_MAPPINGS)

                # We are always on https on Lambda, so tell our wsgi app that.
                environ['HTTPS'] = 'on'
                environ['wsgi.url_scheme'] = 'https'
                environ['lambda.context'] = context

                # Execute the application
                response = Response.from_app(self.wsgi_app, environ)

                # This is the object we're going to return.
                # Pack the WSGI response into our special dictionary.
                zappa_returndict = dict()

                if response.data:
                    if settings.BINARY_SUPPORT:
                        if not response.mimetype.startswith("text/") \
                            or response.mimetype != "application/json":
                            zappa_returndict['body'] = base64.b64encode(
                                response.data).decode('utf-8')
                            zappa_returndict["isBase64Encoded"] = "true"
                        else:
                            zappa_returndict['body'] = response.data
                    else:
                        zappa_returndict['body'] = response.get_data(
                            as_text=True)

                zappa_returndict['statusCode'] = response.status_code
                zappa_returndict['headers'] = {}
                for key, value in response.headers:
                    zappa_returndict['headers'][key] = value

                # Calculate the total response time,
                # and log it in the Common Log format.
                time_end = datetime.datetime.now()
                delta = time_end - time_start
                response_time_ms = delta.total_seconds() * 1000
                response.content = response.data
                common_log(environ, response, response_time=response_time_ms)

                return zappa_returndict
        except Exception as e:  # pragma: no cover

            # Print statements are visible in the logs either way
            print(e)
            exc_info = sys.exc_info()
            message = (
                'An uncaught exception happened while servicing this request. '
                'You can investigate this with the `zappa tail` command.')

            # If we didn't even build an app_module, just raise.
            if not settings.DJANGO_SETTINGS:
                try:
                    self.app_module
                except NameError as ne:
                    message = 'Failed to import module: {}'.format(ne.message)

            # Return this unspecified exception as a 500, using template that API Gateway expects.
            content = collections.OrderedDict()
            content['statusCode'] = 500
            body = {'message': message}
            if settings.DEBUG:  # only include traceback if debug is on.
                body['traceback'] = traceback.format_exception(
                    *exc_info)  # traceback as a list for readability.
            content['body'] = json.dumps(str(body), sort_keys=True, indent=4)
            return content
Esempio n. 38
0
def ephemeris_passes(opt, st0, et0):
    """
    DESCRIPTION:
        Finds passes from the start time to the end time given the options. Will
        implement a bash script or execute on the command line.
    USAGE:
        ephemeris_passes(opt, st0, et0)
    INPUTS:
        opt             command line arguments
        st0             unix time start time
        et0             unix time end time

    RETURNS:
        None
    AFFECTS:
        Prints all the passes
    EXCEPTIONS:
        None
    DEPENDENCIES:
        ephem
    """

    passes = {}

    objects = __read_config__(opt.config)

    site = __read_config__(opt.site)

    if opt.verbose:
        print("# got objects ", objects)
        print("# got radio site ", site)
        print("\n")

    ctime = st0
    etime = et0

    last_sat_rise = ctime

    while ctime < etime:

        obj = get_next_object(opt, site, objects, ctime)

        obj_id = obj
        obj_info = objects[obj]

        if opt.debug:
            print("# object ", obj_id, " @ ", ctime)
            print("# obj_info", obj_info)

        site_name = site["site"]["name"]
        site_tag = site["site"]["tag"]
        obs_lat = site["site"]["latitude"]
        obs_long = site["site"]["longitude"]
        obs_elev = float(site["site"]["elevation"])
        obj_name = obj_info["name"]
        obj_tle1 = obj_info["tle1"][1:-1]
        obj_tle2 = obj_info["tle2"][1:-1]
        obj_freqs = np.array(string.split(obj_info["frequencies"], ","),
                             np.float32)
        c_dtime = datetime.datetime.utcfromtimestamp(ctime)
        c_ephem_time = ephem.Date(c_dtime)

        try:
            (sat_rise, sat_transit, sat_set) = satellite_rise_and_set(
                opt,
                obs_lat,
                obs_long,
                obs_elev,
                obj_name,
                obj_tle1,
                obj_tle2,
                c_ephem_time,
            )

            if sat_set <= sat_rise or sat_transit <= sat_rise or sat_set <= sat_transit:
                continue

            if not last_sat_rise == sat_rise:
                (
                    sub_lat,
                    sub_long,
                    sat_range,
                    sat_velocity,
                    az,
                    el,
                    ra,
                    dec,
                    alt,
                ) = satellite_values_at_time(
                    opt,
                    obs_lat,
                    obs_long,
                    obs_elev,
                    obj_name,
                    obj_tle1,
                    obj_tle2,
                    sat_transit,
                )
                (obj_bandwidth, obj_doppler) = satellite_bandwidth(
                    opt,
                    obs_lat,
                    obs_long,
                    obs_elev,
                    obj_name,
                    obj_tle1,
                    obj_tle2,
                    sat_rise,
                    sat_set,
                    op.interval,
                    obj_freqs,
                )
                last_sat_rise = sat_rise
                if opt.debug:
                    print(
                        "time : ",
                        c_ephem_time,
                        sat_set,
                        (sat_set - c_ephem_time) * 60 * 60 * 24,
                    )
                ctime = ctime + (sat_set - c_ephem_time) * 60 * 60 * 24

                if opt.el_mask:
                    el_val = np.rad2deg(el)
                    el_mask = np.float(opt.el_mask)

                    if opt.debug:
                        print("# el_val ", el_val, " el_mask ", el_mask)

                    if el_val < el_mask:  # check mask here!
                        continue

                # This should really go out as digital metadata into the recording location

                print("# Site : %s " % (site_name))
                print("# Site tag : %s " % (site_tag))
                print("# Object Name: %s" % (obj_name))
                print(
                    "# observer @ latitude : %s, longitude : %s, elevation : %s m"
                    % (obs_lat, obs_long, obs_elev))

                print(
                    "# GMT -- Rise Time: %s, Transit Time: %s, Set Time: %s" %
                    (sat_rise, sat_transit, sat_set))
                print("# Azimuth: %f deg, Elevation: %f deg, Altitude: %g km" %
                      (np.rad2deg(az), np.rad2deg(el), alt / 1000.0))
                print("# Frequencies: %s MHz, Bandwidth: %s kHz" % (
                    obj_freqs / 1.0e6,
                    obj_bandwidth[np.argmax(obj_bandwidth)] / 1.0e3,
                ))

                pass_md = {
                    "obj_id": obj_id,
                    "rise_time": sat_rise,
                    "transit_time": sat_transit,
                    "set_time": sat_set,
                    "azimuth": np.rad2deg(az),
                    "elevation": np.rad2deg(el),
                    "altitude": alt,
                    "doppler_frequency": obj_doppler,
                    "doppler_bandwidth": obj_bandwidth,
                }

                if opt.schedule:
                    d = sat_rise.tuple()
                    rise_time = "%04d%02d%02d_%02d%02d" % (d[0], d[1], d[2],
                                                           d[3], d[4])

                    offset_rise = ephem.date(sat_rise - ephem.minute)
                    d = offset_rise.tuple()
                    offset_rise_time = "%04d-%02d-%02dT%02d:%02d:%02dZ" % (
                        d[0],
                        d[1],
                        d[2],
                        d[3],
                        d[4],
                        int(d[5]),
                    )

                    offset_set = ephem.date(sat_set + ephem.minute)
                    d = offset_set.tuple()
                    offset_set_time = "%04d-%02d-%02dT%02d:%02d:%02dZ" % (
                        d[0],
                        d[1],
                        d[2],
                        d[3],
                        d[4],
                        int(d[5]),
                    )

                    cmd_lines = []
                    radio_channel = string.split(
                        site["radio"]["channel"][1:-1], ",")
                    radio_gain = string.split(site["radio"]["gain"][1:-1], ",")
                    radio_address = string.split(
                        site["radio"]["address"][1:-1], ",")
                    recorder_channels = string.split(
                        site["recorder"]["channels"][1:-1], ",")
                    radio_sample_rate = site["radio"]["sample_rate"]

                    cmd_line0 = "%s " % (site["recorder"]["command"])

                    if site["radio"]["type"] == "b210":

                        # just record a fixed frequency, needs a dual radio Thor3 script. This can be done!
                        idx = 0
                        freq = obj_freqs[1]

                        cmd_line1 = '-r %s -d "%s" -s %s -e %s -c %s -f %4.3f ' % (
                            radio_sample_rate,
                            radio_channel[idx],
                            offset_rise_time,
                            offset_set_time,
                            recorder_channels[idx],
                            freq,
                        )

                        log_file_name = "%s_%s_%s_%dMHz.log" % (
                            site_tag,
                            obj_id,
                            offset_rise_time,
                            int(freq / 1.0e6),
                        )
                        cmd_fname = "%s_%s_%s_%dMHz" % (
                            site_tag,
                            obj_id,
                            rise_time,
                            int(freq / 1.0e6),
                        )

                        cmd_line2 = " -g %s -m %s --devargs num_recv_frames=1024 --devargs master_clock_rate=24.0e6 -o %s/%s" % (
                            radio_gain[idx],
                            radio_address[idx],
                            site["recorder"]["data_path"],
                            cmd_fname,
                        )
                        cmd_line2 += " {0}".format(site["radio"].get(
                            "extra_args", "")).rstrip()

                        if not opt.foreground:
                            cmd_line0 = "nohup " + cmd_line0
                            cmd_line2 = cmd_line2 + " 2>&1 &"
                        else:
                            cmd_line2 = cmd_line2

                        if opt.debug:
                            print(cmd_line0, cmd_line1, cmd_line2, cmd_fname)

                        cmd_lines.append((
                            cmd_line0 + cmd_line1 + cmd_line2,
                            cmd_fname,
                            pass_md,
                            obj_info,
                        ))

                        print("\n")

                    elif site["radio"]["type"] == "n200_tvrx2":

                        cmd_line1 = (
                            ' -r %s -d "%s %s" -s %s -e %s -c %s,%s -f %4.3f,%4.3f '
                            % (
                                radio_sample_rate,
                                radio_channel[0],
                                radio_channel[1],
                                offset_rise_time,
                                offset_set_time,
                                recorder_channels[0],
                                recorder_channels[1],
                                obj_freqs[0],
                                obj_freqs[1],
                            ))

                        log_file_name = "%s_%s_%s_combined.log" % (
                            site_tag,
                            obj_id,
                            offset_rise_time,
                        )
                        cmd_fname = "%s_%s_%s_combined" % (site_tag, obj_id,
                                                           rise_time)

                        cmd_line2 = " -g %s,%s -m %s -o %s/%s" % (
                            radio_gain[0],
                            radio_gain[1],
                            radio_address[0],
                            site["recorder"]["data_path"],
                            cmd_fname,
                        )
                        cmd_line2 += " {0}".format(site["radio"].get(
                            "extra_args", "")).rstrip()

                        if not opt.foreground:
                            cmd_line0 = "nohup " + cmd_line0
                            cmd_line2 = cmd_line2 + " 2>&1 &"
                        else:
                            cmd_line2 = cmd_line2

                        if opt.debug:
                            print(cmd_line0, cmd_line1, cmd_line2, cmd_fname)

                        cmd_lines.append((
                            cmd_line0 + cmd_line1 + cmd_line2,
                            cmd_fname,
                            pass_md,
                            obj_info,
                        ))

                print("\n")

                if opt.foreground:
                    dtstart0 = dateutil.parser.parse(offset_rise_time)
                    dtstop0 = dateutil.parser.parse(offset_set_time)
                    start0 = int((dtstart0 - datetime.datetime(
                        1970, 1, 1, tzinfo=pytz.utc)).total_seconds())
                    stop0 = int((dtstop0 - datetime.datetime(
                        1970, 1, 1, tzinfo=pytz.utc)).total_seconds())

                    if opt.verbose:
                        print("# waiting for %s @ %s " %
                              (obj_id, offset_rise_time))

                    while time.time() < start0 - 30:
                        time.sleep(op.interval)
                        if opt.verbose:
                            print("#    %d sec" % (start0 - time.time()))

                    for cmd_tuple in cmd_lines:

                        cmd, cmd_fname, pass_md, info_md = cmd_tuple

                        print("# Executing command %s " % (cmd))

                        # write the digital metadata
                        start_idx = int(start0)
                        mdata_dir = (site["recorder"]["metadata_path"] + "/" +
                                     cmd_fname + "/metadata")

                        # site metadata
                        # note we use directory structure for the dictionary here
                        # eventually we will add this feature to digital metadata

                        for k in site:

                            try:
                                os.makedirs(mdata_dir + "/config/%s" % (k))
                            except:
                                pass

                            md_site_obj = DigitalMetadataWriter(
                                mdata_dir + "/config/%s" % (k), 3600, 60, 1, 1,
                                k)

                            if opt.debug:
                                print(site[k])

                            if opt.verbose:
                                print("# writing metadata config / %s " % (k))

                            md_site_obj.write(start_idx, site[k])

                        # info metadata
                        try:
                            os.makedirs(mdata_dir + "/info")
                        except:
                            pass

                        md_info_obj = DigitalMetadataWriter(
                            mdata_dir + "/info", 3600, 60, 1, 1, "info")

                        if opt.verbose:
                            print("# writing metadata info")

                        if opt.debug:
                            print(info_md)

                        md_info_obj.write(start_idx, info_md)

                        # pass metadata
                        try:
                            os.makedirs(mdata_dir + "/pass")
                        except:
                            pass

                        md_pass_obj = DigitalMetadataWriter(
                            mdata_dir + "/pass", 3600, 60, 1, 1, "pass")

                        if opt.verbose:
                            print("# writing metadata pass")

                        if opt.debug:
                            print(pass_md)

                        md_pass_obj.write(start_idx, pass_md)

                        # sys.exit(1)

                        # call the command
                        try:
                            subprocess.call(cmd, shell=True)
                        except Exception as eobj:
                            exp_str = str(ExceptionString(eobj))
                            print("exception: %s." % (exp_str))
                            exc_type, exc_value, exc_traceback = sys.exc_info()
                            lines = traceback.format_exception(
                                exc_type, exc_value, exc_traceback)
                            print(lines)

                    print("# wait...")
                    while time.time() < stop0 + 1:
                        time.sleep(op.interval)
                        if opt.verbose:
                            print("# complete in %d sec" %
                                  (stop0 - time.time()))

        except Exception as eobj:
            exp_str = str(ExceptionString(eobj))
            print("exception: %s." % (exp_str))
            exc_type, exc_value, exc_traceback = sys.exc_info()
            lines = traceback.format_exception(exc_type, exc_value,
                                               exc_traceback)
            print(lines)
            # sys.exit(1)
            # advance 10 minutes
            ctime = ctime + 60 * op.interval

            continue
Esempio n. 39
0
 def error_msg(t=None, v=None, tb=None):
     if not t:
         t, v, tb = sys.exc_info()
     text = "".join(traceback.format_exception(t, v, tb))
     master.ding(text)
Esempio n. 40
0
    def run_engine(self):
        """Run the test function many times, on database input and generated
        input, using the Conjecture engine.
        """
        # Tell pytest to omit the body of this function from tracebacks
        __tracebackhide__ = True
        try:
            database_key = self.wrapped_test._hypothesis_internal_database_key
        except AttributeError:
            if global_force_seed is None:
                database_key = function_digest(self.test)
            else:
                database_key = None

        runner = ConjectureRunner(
            self._execute_once_for_engine,
            settings=self.settings,
            random=self.random,
            database_key=database_key,
        )
        # Use the Conjecture engine to run the test function many times
        # on different inputs.
        runner.run()
        note_engine_for_statistics(runner)

        if runner.call_count == 0:
            return
        if runner.interesting_examples:
            self.falsifying_examples = sorted(
                runner.interesting_examples.values(),
                key=lambda d: sort_key(d.buffer),
                reverse=True,
            )
        else:
            if runner.valid_examples == 0:
                raise Unsatisfiable(
                    "Unable to satisfy assumptions of hypothesis %s." %
                    (get_pretty_function_description(self.test), ))

        if not self.falsifying_examples:
            return
        elif not self.settings.report_multiple_bugs:
            # Pretend that we only found one failure, by discarding the others.
            del self.falsifying_examples[:-1]

        # The engine found one or more failures, so we need to reproduce and
        # report them.

        self.failed_normally = True

        flaky = 0

        for falsifying_example in self.falsifying_examples:
            info = falsifying_example.extra_information

            ran_example = ConjectureData.for_buffer(falsifying_example.buffer)
            self.__was_flaky = False
            assert info.__expected_exception is not None
            try:
                self.execute_once(
                    ran_example,
                    print_example=not self.is_find,
                    is_final=True,
                    expected_failure=(
                        info.__expected_exception,
                        info.__expected_traceback,
                    ),
                )
            except (UnsatisfiedAssumption, StopTest):
                report(traceback.format_exc())
                self.__flaky(
                    "Unreliable assumption: An example which satisfied "
                    "assumptions on the first run now fails it.")
            except BaseException as e:
                if len(self.falsifying_examples) <= 1:
                    # There is only one failure, so we can report it by raising
                    # it directly.
                    raise

                # We are reporting multiple failures, so we need to manually
                # print each exception's stack trace and information.
                tb = get_trimmed_traceback()
                report("".join(traceback.format_exception(type(e), e, tb)))

            finally:  # pragma: no cover
                # Mostly useful for ``find`` and ensuring that objects that
                # hold on to a reference to ``data`` know that it's now been
                # finished and they shouldn't attempt to draw more data from
                # it.
                ran_example.freeze()

                # This section is in fact entirely covered by the tests in
                # test_reproduce_failure, but it seems to trigger a lovely set
                # of coverage bugs: The branches show up as uncovered (despite
                # definitely being covered - you can add an assert False else
                # branch to verify this and see it fail - and additionally the
                # second branch still complains about lack of coverage even if
                # you add a pragma: no cover to it!
                # See https://bitbucket.org/ned/coveragepy/issues/623/
                if self.settings.print_blob:
                    report(("\nYou can reproduce this example by temporarily "
                            "adding @reproduce_failure(%r, %r) as a decorator "
                            "on your test case") %
                           (__version__,
                            encode_failure(falsifying_example.buffer)))
            if self.__was_flaky:
                flaky += 1

        # If we only have one example then we should have raised an error or
        # flaky prior to this point.
        assert len(self.falsifying_examples) > 1

        if flaky > 0:
            raise Flaky(
                ("Hypothesis found %d distinct failures, but %d of them "
                 "exhibited some sort of flaky behaviour.") %
                (len(self.falsifying_examples), flaky))
        else:
            raise MultipleFailures(("Hypothesis found %d distinct failures.") %
                                   (len(self.falsifying_examples)))
Esempio n. 41
0
def eval_macro(name, args, story, state, module_finder=None):
  """
  Evaluates the macro with the given name in the context of the given story,
  feeding in the given arguments and using the given state. A return-value,
  updated-state pair is returned.

  The given module_finder function should accept a module name and return a
  Story object for that module, or None if the module can't be found.

  Examples:
    ```?
    eval_macro(
      "if",
      ["True", "1", "else", "0"],
      eval( # Fake object with .nodes and .title (without importing story):
        "[exec('class T: pass\\\\nt = T()\\\\nt.nodes = []"
      + "\\\\nt.title=\\\"_\\\"'), "
      + "eval('t')][1]"
      ),
      {}
    )
    ```=
    ( 1, {} )
    ```?
    eval_macro(
      "if",
      ["1 - 1", "`nope`", "2 * 0", 'nope', "`a` or False", "`yes`", "else","0"],
      eval( # Fake object with .nodes and .title (without importing story):
        "[exec('class T: pass\\\\nt = T()\\\\nt.nodes = []"
      + "\\\\nt.title=\\\"_\\\"'), "
      + "eval('t')][1]"
      ),
      {}
    )
    ```=
    ( "yes", {} )
    ```
  """
  state = copy.deepcopy(state)

  if name in story.nodes: # node-as-macro call
    node = story.nodes[name]

    return eval_text(node.content, story, state, args, module_finder)

  # Must be built-in or from a module:
  # Try to resolve as a module:
  if name.count('.') == 1: # From a module
    module_name, inner_name = name.split('.')

    if module_name not in story.modules:
      return error(
        "Module '{}' for macro '{}' is not included by story '{}'.".format(
          module_name,
          name,
          story.title
        ),
        state
      )

    if not module_finder:
      return error(
        "Attempt to use module '{}' without a module finder.".format(
          module_name
        ),
        state
      )

    module = module_finder(module_name)

    if not module:
      return error("Module '{}' not found.".format(module_name), state)

    if inner_name not in module.nodes:
      return error(
        "Module '{}' doesn't define macro '{}'.".format(
          module_name,
          inner_name
        ),
        state
      )

    node = module.nodes[inner_name]
    # TODO: Some way to return a non-string here?
    return eval_text(
      node.content,
      story,
      state,
      args,
      module_finder
    )

  # if it's not a module reference, it might be a builtin?
  elif name in BUILTINS: # A built-in macro
    try:
      return BUILTINS[name](module_finder, story, state, *args)
    except Exception as e:
      return error(
        "Error calling built-in '{}' with arguments:\n{}\nDetails:\n{}"
        .format(
          name,
          '\n'.join(str(a) for a in args),
          ''.join(
            traceback.format_exception(
              type(e),
              e,
              e.__traceback__
            )
          )
        ),
        state
      )

  # otherwise we don't know what this macro is...
  else:
    # Unrecognized macro: expands to error text
    # TODO: Better error text
    return error("Unrecognized macro '{}'.".format(name), state)
Esempio n. 42
0
def satellite_bandwidth(
    opt,
    obsLat,
    obsLong,
    obsElev,
    objName,
    tle1,
    tle2,
    satRise,
    satSet,
    interval,
    beaconFreq,
):
    """
    DESCRIPTION:
        The function finds the bandwidth of a satellite pass
    INPUTS:
        obsLat (string)                  = Latitude of Observer in degrees represented as strings
        obsLong (string)                 = Longitude of Observer in degrees represented as strings
        obsElev (float)                  = Elevation of Observer in meters
        objName (string)                 = Name of the satellite
        tle1 (string)                    = First line of TLE
        tle2 (string)                    = Second line of TLE
        satRise (string or ephem.date)  = The time at which the satellite rises above horizon
        satSet (string or ephem.date)   = The time at which the satellite sets
        interval (float)                = The rate at which to sample during one rise/set cycle in seconds
        beaconFreq (float)               = The frequency of the beacon

    RETURNS:
        Param1 (float)                   = The bandwidth of the satellite during the rise/set cycle
        Param2 (list)                    = All the frequencies during the rise/set cycle sampled
                                           by given interval
    AFFECTS:
        None
    EXCEPTIONS:
        None
    DEPENDENCIES:
        ephem.date(...), ephem.hour, ephem.minute, ephem.second
    """
    currTime = satRise
    dopplerFrequencies = []
    dopplerBandwidth = []

    if opt.debug:
        print("satellite_bandwidth ", currTime, satSet, interval)

    while (currTime.triple())[2] < (satSet.triple(
    ))[2]:  # the 2nd index of the returned tuple has the fraction of the day
        try:
            (
                sublat,
                sublong,
                range_val,
                range_velocity,
                az,
                alt,
                ra,
                dec,
                elevation,
            ) = satellite_values_at_time(opt, obsLat, obsLong, obsElev,
                                         objName, tle1, tle2, currTime)
            (dopplerFreq) = doppler_shift(beaconFreq, range_velocity)
            dopplerFrequencies.append(dopplerFreq)
            dopplerBandwidth.append(dopplerFreq - beaconFreq)
            currTime = currTime + ephem.second * interval
            currTime = ephem.date(currTime)
        except Exception as eobj:
            exp_str = str(ExceptionString(eobj))
            print("exception: %s." % (exp_str))
            exc_type, exc_value, exc_traceback = sys.exc_info()
            lines = traceback.format_exception(exc_type, exc_value,
                                               exc_traceback)
            print(lines)

    if opt.debug:
        print("# DF:", np.array(dopplerFrequencies) / 1e6, " MHz")
        print("# OB:", np.array(dopplerBandwidth) / 1e3, " kHz")

    return (np.array(dopplerBandwidth), np.array(dopplerFrequencies))
    def run(self):
        first_run = True
        while True:
            try:
                if first_run:
                    date_a = datetime.now() - (timedelta(
                        seconds=int(sleep_interval) + 300 +
                        int(preload_logs_interval) * 60 * 60))
                else:
                    date_a = datetime.now() - (timedelta(
                        seconds=int(sleep_interval) + 300))

                first_run = False

                date_b = datetime.now()
                list_files = self.get_files_in_interval_dt(
                    pg_log_dir, date_a, date_b)
                logger.log("Start iteration. Files: " + str(list_files),
                           'Info')
            except Exception as e:
                logger.log("get_files_in_interval_dt error: " + str(e),
                           "Error")

            db_pg_stat = None

            try:
                db_pg_stat = postgresql.open(sys_stat_conn_str)
                self.init_sys_stat(db_pg_stat)
                for file_name in list_files:
                    logger.log("Processing... " + file_name, 'Info')
                    fo = open(file_name, "r")
                    str_val = ""
                    log_lines = []

                    with self.closing_file(fo) as file:
                        for line in file:
                            line_len = len(line)
                            if line_len > int(pg_log_line_max_len):
                                log_lines.append(
                                    str(line)[:int(pg_log_line_max_len)])
                            else:
                                log_lines.append(str(line))

                    for line in log_lines:
                        str_val += str(line)

                    if len(str_val) < 1:
                        continue

                    links = re.finditer(
                        r"(\,(\w+\.\w+)\,\d+\,\".*?duration\:\s)", str_val)
                    plans = re.finditer(
                        r"duration\:\s\d+((.|,)\d+)?\sms\s\splan\:", str_val)
                    queries = re.finditer(
                        r"duration\:\s\d+((.|,)\d+)?\sms\s\s(?!plan\:)",
                        str_val)
                    dates = re.finditer(
                        r"20\d{2}(-|\/)((0[1-9])|(1[0-2]))(-|\/)((0[1-9])|([1-2][0-9])|(3[0-1]))(\s)(([0-1][0-9])|(2[0-3])):([0-5][0-9]):([0-5][0-9])\.([0-9][0-9][0-9])",
                        str_val)

                    map_all = []
                    dates_list = []
                    #======================================
                    for m in links:
                        link_val = str_val[m.span()[0]:m.span(
                        )[1]]  #,597f51d5.7ee4,615,"SELECT",2016-05-04 15:27:30 MSK,55/4139,0,LOG,00000,"duration

                        link_res = re.finditer(r"(\w+\.\w+)",
                                               link_val)  #597f51d5.7ee4
                        link_res_text = ""
                        for v in link_res:
                            link_res_text = link_val[v.span()[0]:v.span()[1]]

                        link_res = re.finditer(r"(\,\d+\/\d+\,\d+\,)",
                                               link_val)  #,55/4139,0,
                        for v in link_res:
                            link_res_text += link_val[v.span()[0]:v.span()[1]]

                        map_all.append(
                            ["l", m.span()[0],
                             m.span()[1], link_res_text])

                    for m in plans:
                        map_all.append([
                            "p",
                            m.span()[0],
                            m.span()[1], str_val[m.span()[0]:m.span()[1]]
                        ])

                    for m in queries:
                        map_all.append([
                            "q",
                            m.span()[0],
                            m.span()[1], str_val[m.span()[0]:m.span()[1]]
                        ])

                    for m in dates:
                        map_all.append([
                            "d",
                            m.span()[0],
                            m.span()[1], str_val[m.span()[0]:m.span()[1]]
                        ])
                        dates_list.append(m.span()[0])
                    #======================================
                    map_all = sorted(map_all, key=itemgetter(1))
                    dates_list = sorted(dates_list)

                    map_stuctured_l1 = []
                    elem = {}

                    def find_gt(a, x):
                        i = bisect.bisect_right(a, x)
                        if i != len(a):
                            return a[i]
                        return len(str_val)

                    for v in map_all:
                        #['d', 15784614, 15784637, '2016-09-30 12:50:54.433']
                        if v[0] == 'd':
                            elem['d'] = [v[1], v[2], v[3]]
                        if v[0] == 'l':
                            elem['l'] = [v[1], v[2], v[3]]
                        if v[0] == 'p':
                            elem['p'] = [
                                v[1], v[2], v[3],
                                find_gt(dates_list, v[2])
                            ]
                        if v[0] == 'q':
                            elem['q'] = [
                                v[1], v[2], v[3],
                                find_gt(dates_list, v[2])
                            ]

                        if 'd' in elem and 'l' in elem and ('p' in elem
                                                            or 'q' in elem):
                            map_stuctured_l1.append(elem.copy())
                            elem.clear()

                    map_stuctured_l2 = {}
                    for v in map_stuctured_l1:
                        #key:		59cf0e58.53d4,95/0,0,
                        #value:		[{'d_q': [77713, 77736, '2016-09-30 07:24:56.193'], 'q': [77869, 77893, 'duration: 30145.346 ms  ', 78813]},
                        #			{'d_p': [78813, 78836, '2016-09-30 07:24:56.217'], 'p': [78969, 78998, 'duration: 30145.336 ms  plan:', 85258]}]
                        if 'q' in v:
                            map_stuctured_l2.setdefault(v['l'][2], []).append({
                                'd_q':
                                v['d'],
                                'q':
                                v['q']
                            })
                        if 'p' in v:
                            map_stuctured_l2.setdefault(v['l'][2], []).append({
                                'd_p':
                                v['d'],
                                'p':
                                v['p']
                            })

                    ps_queries_and_plans = db_pg_stat.prepare("""
							INSERT INTO psc_queries_and_plans(
									 dt, duration, db_id, query, plan, io_read_time, cost_v, shared_hit_v, read_v, dirtied_v, total_blks_size )
								VALUES (
									(($1::text)::timestamp with time zone), $2::double precision, (select psc_get_db($3::text)), $4::text, $5::text, $6::double precision, 
										$7::double precision, $8::bigint, $9::bigint, $10::bigint, (select pg_size_pretty((($8::bigint + $9::bigint + $10::bigint)*8192)::bigint)) 
								);""")

                    ps_queries_and_plans_check = db_pg_stat.prepare("""
							select exists( select 1 from psc_queries_and_plans where dt = (($1::text)::timestamp with time zone) and 
								duration = $2::double precision and query = $3::text )""")

                    for key, value in map_stuctured_l2.items():
                        if sum('d_q' in v for v in value) == 1 and sum(
                                'd_p' in v for v in value) == 1:

                            query_date = next(
                                v['d_q'] for v in value if 'd_q' in
                                v)  #[77713, 77736, '2016-09-30 07:24:56.193']
                            plan_date = next(
                                v['d_p'] for v in value if 'd_p' in
                                v)  #[78813, 78836, '2016-09-30 07:24:56.217']
                            query = next(
                                v['q'] for v in value if 'q' in v
                            )  #[77869, 77893, 'duration: 30145.346 ms  ', 78813]
                            plan = next(
                                v['p'] for v in value if 'p' in v
                            )  #[78969, 78998, 'duration: 30145.336 ms  plan:', 85258]

                            txt_plan = str_val[plan_date[0]:plan[3]]
                            txt_query = str_val[query_date[0]:query[3]]

                            #-----------------------------------------------------------------------------------
                            dt = "2000-01-01 00:00:00"
                            dt_str = re.search(
                                r"20\d{2}(-|\/)((0[1-9])|(1[0-2]))(-|\/)((0[1-9])|([1-2][0-9])|(3[0-1]))(\s)(([0-1][0-9])|(2[0-3])):([0-5][0-9]):([0-5][0-9])\.([0-9][0-9][0-9])",
                                txt_query)
                            if (dt_str is not None):
                                dt = dt_str.group()
                            #-----------------------------------------------------------------------------------
                            dbname = "unknown"
                            pos_first = txt_query.find('","')
                            if pos_first > 0:
                                dbname = txt_query[
                                    pos_first +
                                    3:txt_query.find('",', pos_first +
                                                     3, len(txt_query))]
                            #-----------------------------------------------------------------------------------

                            shared_hit = 0
                            read = 0
                            dirtied = 0
                            io_read_time = 0
                            cost = 0
                            duration = 0

                            duration_str = re.finditer(
                                r"duration\:\s\d+((.|,)\d+)?\sms", txt_plan)
                            cost_str = re.finditer(
                                r"cost\=\d+((.|,)\d+)?\.\.\d+((.|,)\d+)?\s",
                                txt_plan)
                            io_read_time_str = re.finditer(
                                r"I\/O\sTimings\:\sread\=\d+((.|,)\d+)?",
                                txt_plan)
                            shared_hit_str = re.finditer(
                                r"shared\shit\=\d+((.|,)\d+)?", txt_plan)
                            read_str = re.finditer(r"read\=\d+((.|,)\d+)?",
                                                   txt_plan)
                            dirtied_str = re.finditer(
                                r"dirtied\=\d+((.|,)\d+)?", txt_plan)

                            durations = []
                            for m in duration_str:
                                sub_str = txt_plan[m.span()[0]:m.span()[1]]
                                val = re.finditer(r"\d+((.|,)\d+)?", sub_str)
                                for vv in val:
                                    durations.append(
                                        float(sub_str[vv.span()[0]:vv.span(
                                        )[1]]))
                            if len(durations) > 0:
                                duration = max(durations)

                            costs = []
                            for m in cost_str:
                                sub_str = txt_plan[m.span()[0]:m.span()[1]]
                                val = re.finditer(r"\d+((.|,)\d+)?", sub_str)
                                for vv in val:
                                    costs.append(
                                        float(sub_str[vv.span()[0]:vv.span(
                                        )[1]]))
                            if len(costs) > 0:
                                cost = max(costs)

                            shared_hits = []
                            for m in shared_hit_str:
                                sub_str = txt_plan[m.span()[0]:m.span()[1]]
                                val = re.finditer(r"\d+((.|,)\d+)?", sub_str)
                                for vv in val:
                                    shared_hits.append(
                                        float(sub_str[vv.span()[0]:vv.span(
                                        )[1]]))
                            if len(shared_hits) > 0:
                                shared_hit = max(shared_hits)

                            io_read_times = []
                            for m in io_read_time_str:
                                sub_str = txt_plan[m.span()[0]:m.span()[1]]
                                val = re.finditer(r"\d+((.|,)\d+)?", sub_str)
                                for vv in val:
                                    io_read_times.append(
                                        float(sub_str[vv.span()[0]:vv.span(
                                        )[1]]))
                            if len(io_read_times) > 0:
                                io_read_time = max(io_read_times)

                            reads = []
                            for m in read_str:
                                sub_str = txt_plan[m.span()[0]:m.span()[1]]
                                val = re.finditer(r"\d+((.|,)\d+)?", sub_str)
                                for vv in val:
                                    reads.append(
                                        float(sub_str[vv.span()[0]:vv.span(
                                        )[1]]))
                            if len(reads) > 0:
                                if io_read_time in reads:
                                    reads.remove(io_read_time)
                                read = max(reads)

                            dirtieds = []
                            for m in dirtied_str:
                                sub_str = txt_plan[m.span()[0]:m.span()[1]]
                                val = re.finditer(r"\d+((.|,)\d+)?", sub_str)
                                for vv in val:
                                    dirtieds.append(
                                        float(sub_str[vv.span()[0]:vv.span(
                                        )[1]]))
                            if len(dirtieds) > 0:
                                dirtied = max(dirtieds)

                            if float(duration) != 0:
                                if not ps_queries_and_plans_check.first(
                                        str(dt), float(duration),
                                        str(txt_query)):
                                    query_result = ps_queries_and_plans.first(str(dt), float(duration), str(dbname), str(txt_query), \
                                     str(txt_plan), float(io_read_time), float(cost), int(float(shared_hit)), int(float(read)), int(float(dirtied)) )
                                    logger.log("Writed query at " + str(dt),
                                               "Info")

            except Exception as e:
                exc_type, exc_value, exc_traceback = sys.exc_info()
                exc_res = traceback.format_exception(exc_type, exc_value,
                                                     exc_traceback)
                exc_text = ""
                for vv in exc_res:
                    exc_text += '\n' + str(vv)
                logger.log("Connection db_pg_stat error: " + str(e) + exc_text,
                           "Error")
                time.sleep(int(sleep_interval))
            finally:
                if db_pg_stat is not None:
                    if not db_pg_stat.closed:
                        db_pg_stat.close()
                logger.log(
                    'Finish iteration! Sleep on ' + str(sleep_interval) +
                    " seconds...", "Info")
                time.sleep(int(sleep_interval))
Esempio n. 44
0
    def ail_import(self):

        time_start = time.time()
        self._err_log = ''
        invoice = self.env['account.invoice'].browse(
            self._context['active_id'])
        accounts = self.env['account.account'].search([
            ('user_type_id.type', 'not in',
             ['view', 'consolidation', 'closed']),
            ('company_id', '=', invoice.company_id.id)
        ])
        self._accounts_dict = {a.code: a.id for a in accounts}
        self._get_orm_fields()
        lines, header = self._remove_leading_lines(self.lines)
        header_fields = csv.reader(StringIO.StringIO(header),
                                   dialect=self.dialect).next()
        self._header_fields = self._process_header(header_fields)
        reader = csv.DictReader(StringIO.StringIO(lines),
                                fieldnames=self._header_fields,
                                dialect=self.dialect)

        inv_lines = []
        for line in reader:

            ail_vals = {}

            # step 1: handle codepage
            for i, hf in enumerate(self._header_fields):
                try:
                    line[hf] = line[hf].decode(self.codepage).strip()
                except:
                    tb = ''.join(format_exception(*exc_info()))
                    raise UserError(
                        _("Wrong Code Page"),
                        _("Error while processing line '%s' :\n%s") %
                        (line, tb))

            # step 2: process input fields
            for i, hf in enumerate(self._header_fields):
                if i == 0 and line[hf] and line[hf][0] == '#':
                    # lines starting with # are considered as comment lines
                    break
                if hf in self._skip_fields:
                    continue
                if line[hf] == '':
                    continue

                if self._field_methods[hf].get('orm_field'):
                    self._field_methods[hf]['method'](
                        hf,
                        line,
                        invoice,
                        ail_vals,
                        orm_field=self._field_methods[hf]['orm_field'])
                else:
                    self._field_methods[hf]['method'](hf, line, invoice,
                                                      ail_vals)

            if ail_vals:
                self._process_line_vals(line, invoice, ail_vals)
                inv_lines.append(ail_vals)

        vals = [(0, 0, l) for l in inv_lines]
        vals = self._process_vals(invoice, vals)

        if self._err_log:
            self.note = self._err_log
            module = __name__.split('addons.')[1].split('.')[0]
            result_view = self.env.ref('%s.ail_import_view_form_result' %
                                       module)
            return {
                'name': _("Import File result"),
                'res_id': self.id,
                'view_type': 'form',
                'view_mode': 'form',
                'res_model': 'ail.import',
                'view_id': result_view.id,
                'target': 'new',
                'type': 'ir.actions.act_window',
            }
        else:
            invoice.write({'invoice_line_ids': vals})
            import_time = time.time() - time_start
            _logger.warn('account.invoice (id: %s) import time = %.3f seconds',
                         invoice.id, import_time)
            return {'type': 'ir.actions.act_window_close'}
Esempio n. 45
0
def last_exception():
    """ Returns last exception as a string, for use in logging.
    """
    exc_type, exc_value, exc_traceback = sys.exc_info()
    return ''.join(
        traceback.format_exception(exc_type, exc_value, exc_traceback))
		b1 = ToggleRadioButton( bpanel, label='Panel', associated_widget=w1 )
		b2 = ToggleRadioButton( bpanel, label='Button', associated_widget=w2 )
		b3 = ToggleRadioButton( bpanel, label='List', associated_widget=w3 )

		bsizer.Add( b1 )
		bsizer.Add( b2 )
		bsizer.Add( b3 )

		wsizer.Add( w1 )
		wsizer.Add( w2 )
		wsizer.Add( w3 )

		sizer.Add( bpanel, 0, wx.EXPAND | wx.ALL, 5 )
		sizer.Add( wpanel, 1, wx.EXPAND | wx.ALL, 5 )

		self.Show()

if __name__ == '__main__':	
	try:
		app = wx.App()
		TestFrame(None, title="ToggleRadioButton Test")
		app.MainLoop()
	except Exception, e:
		#traceback.print_exc()
		#e = sys.exc_info()[0]
		#print( 'Exception %s', e )
		import sys, traceback
		xc = traceback.format_exception(*sys.exc_info())
		wx.MessageBox(''.join(xc))
Esempio n. 47
0
 def log_exception(self, exception):
     exc_info = sys.exc_info()
     logger.error(" Exception: %s ".center(79, "#") % str(exception))
     logger.error(''.join(traceback.format_exception(*exc_info)))
Esempio n. 48
0
    def _forward(
        self, data: TikTensorBatch, fut: List[Future], device: torch.device, batch_size: int, increase_batch_size: bool
    ) -> Tuple[int, bool]:
        """
        :param data: input data to neural network
        """
        self.logger.debug("this is forward")
        # TODO: Maybe use todevice
        # TODO(novikov): Move model creation to worker
        if device.type == "cuda":
            with torch.cuda.device(device.index):
                model = self.training_model.__class__(**self.config.get("model_init_kwargs", {}))
        else:
            model = self.training_model.__class__(**self.config.get("model_init_kwargs", {}))

        model.load_state_dict(self.training_model.state_dict())
        model.eval()
        model = model.to(device=device)

        keys: List = [d.id for d in data]
        data: List[torch.Tensor] = data.as_torch()

        self.logger.debug("forward with batch_size %d (increasing: %s)", batch_size, increase_batch_size)

        start = 0
        last_batch_size = batch_size

        def create_end_generator(start, end, batch_size):
            for batch_end in range(start + batch_size, end, batch_size):
                yield batch_end

            yield end

        end_generator = create_end_generator(start, len(keys), batch_size)
        while start < len(keys):
            end = next(end_generator)
            try:
                with torch.no_grad():
                    pred = model(torch.stack(data[start:end]).to(dtype=torch.float, device=device)).cpu()
            except Exception as e:
                if batch_size > last_batch_size:
                    self.logger.info(
                        "forward pass with batch size %d threw exception '%s'. Using previous batch size %d again.",
                        batch_size,
                        e,
                        last_batch_size,
                    )
                    batch_size = last_batch_size
                    increase_batch_size = False
                else:
                    last_batch_size = batch_size
                    batch_size //= 2
                    if batch_size == 0:
                        self.logger.error(
                            "Forward pass with batch size %d threw exception '%s'\nwith traceback: %s. Processed %d/%d",
                            last_batch_size,
                            e,
                            traceback.format_exception(type(e), e, e.__traceback__),
                            start,
                            len(keys),
                        )
                        for i in range(start, len(keys)):
                            fut[i].set_exception(e)

                        break

                    increase_batch_size = True
                    self.logger.info(
                        "forward pass with batch size %d threw exception '%s'. Trying again with smaller batch_size %d",
                        last_batch_size,
                        e,
                        batch_size,
                    )
                end_generator = create_end_generator(start, len(keys), batch_size)
            else:
                for i in range(start, end):
                    try:
                        fut[i].set_result(TikTensor(pred[i], id_=keys[i]))
                    except Exception as e:
                        self.logger.error(
                            "start: %s, end: %s, pred: %s, keys: %s, i: %s", start, end, pred.shape, len(keys), i
                        )
                        self.logger.exception(e)
                        raise e
                last_batch_size = batch_size
                if increase_batch_size and end - start >= batch_size:  # do not increase batch size after successfully
                    #                                                    computing an incomplete batch
                    max_cpu_batch_size = self.config.get("inference_max_cpu_batch_size", 100)
                    if batch_size >= max_cpu_batch_size:
                        self.logger.info("Reached 'inference_max_cpu_batch_size' of %d", max_cpu_batch_size)
                        increase_batch_size = False
                    else:
                        batch_size += 1
                        end_generator = create_end_generator(end, len(keys), batch_size)

                start = end

        return batch_size, increase_batch_size
Esempio n. 49
0
def tvm_excepthook(exctype, value, trbk):
    print('\n'.join(traceback.format_exception(exctype, value, trbk)))
    if hasattr(multiprocessing, 'active_children'):
        # pylint: disable=not-callable
        for p in multiprocessing.active_children():
            p.terminate()
Esempio n. 50
0
    def okcmd(self):
        # tixDemo:Status "You have selected the directory" + self.dlist_dir
        self.quitcmd()

    def quitcmd(self):
        self.exit = 0

    def mainloop(self):
        while self.exit < 0:
            self.root.tk.dooneevent(TCL_ALL_EVENTS)

    def destroy(self):
        self.root.destroy()


# This "if" statement makes it possible to run this script file inside or
# outside of the main demo program "tixwidgets.py".
#
if __name__ == '__main__':
    import tkMessageBox, traceback

    try:
        root = Tix.Tk()
        RunSample(root)
    except:
        t, v, tb = sys.exc_info()
        text = "Error running the demo script:\n"
        for line in traceback.format_exception(t, v, tb):
            text = text + line + '\n'
            d = tkMessageBox.showerror('Tix Demo Error', text)
Esempio n. 51
0
    def emit(self, record: logging.LogRecord) -> None:
        report = {}  # type: Dict[str, Any]

        # This parameter determines whether Zulip should attempt to
        # send Zulip messages containing the error report.  If there's
        # syntax that makes the markdown processor throw an exception,
        # we really don't want to send that syntax into a new Zulip
        # message in exception handler (that's the stuff of which
        # recursive exception loops are made).
        #
        # We initialize is_bugdown_rendering_exception to `True` to
        # prevent the infinite loop of zulip messages by ERROR_BOT if
        # the outer try block here throws an exception before we have
        # a chance to check the exception for whether it comes from
        # bugdown.
        is_bugdown_rendering_exception = True

        try:
            report['node'] = platform.node()
            report['host'] = platform.node()

            add_deployment_metadata(report)

            if record.exc_info:
                stack_trace = ''.join(
                    traceback.format_exception(*record.exc_info))
                message = str(record.exc_info[1])
                is_bugdown_rendering_exception = record.msg.startswith(
                    'Exception in Markdown parser')
            else:
                stack_trace = 'No stack trace available'
                message = record.getMessage()
                if '\n' in message:
                    # Some exception code paths in queue processors
                    # seem to result in super-long messages
                    stack_trace = message
                    message = message.split('\n')[0]
                is_bugdown_rendering_exception = False
            report['stack_trace'] = stack_trace
            report['message'] = message

            report['logger_name'] = record.name
            report['log_module'] = find_log_caller_module(record)
            report['log_lineno'] = record.lineno

            if hasattr(record, "request"):
                add_request_metadata(
                    report, record.request
                )  # type: ignore  # record.request is added dynamically

        except Exception:
            report['message'] = "Exception in preparing exception report!"
            logging.warning(report['message'], exc_info=True)
            report['stack_trace'] = "See /var/log/zulip/errors.log"

        if settings.DEBUG_ERROR_REPORTING:  # nocoverage
            logging.warning("Reporting an error to admins...")
            logging.warning(
                "Reporting an error to admins: {} {} {} {} {}".format(
                    record.levelname, report['logger_name'],
                    report['log_module'], report['message'],
                    report['stack_trace']))

        try:
            if settings.STAGING_ERROR_NOTIFICATIONS:
                # On staging, process the report directly so it can happen inside this
                # try/except to prevent looping
                from zerver.lib.error_notify import notify_server_error
                notify_server_error(report, is_bugdown_rendering_exception)
            else:
                queue_json_publish('error_reports',
                                   dict(
                                       type="server",
                                       report=report,
                                   ))
        except Exception:
            # If this breaks, complain loudly but don't pass the traceback up the stream
            # However, we *don't* want to use logging.exception since that could trigger a loop.
            logging.warning("Reporting an exception triggered an exception!",
                            exc_info=True)
Esempio n. 52
0
             msg = " ".join(words)
             if len(msg) > 0: break
         try:
             generateMarkovOgg(msg, g)
             headers = {'User-Agent': USER_AGENT}
             files = {"voice": open("markov.ogg", "rb")}
             bot.sendVoice(
                 _urlopen_hook=lambda u: requests.post(
                     u, headers=headers, files=files).text,
                 chat_id=chat_id)
         except KeyboardInterrupt as e:
             raise e
         except BaseException as e:
             exc_type, exc_value, exc_traceback = sys.exc_info()
             print("\n".join(
                 traceback.format_exception(
                     exc_type, exc_value, exc_traceback)))
             bot.sendMessage(chat_id=chat_id,
                             text="Could not send voice",
                             reply_to_message_id=replyto)
     else:
         bot.sendMessage(chat_id=chat_id,
                         text="[Chain is empty]",
                         reply_to_message_id=replyto)
 if cmd == "/markovttslang":
     if t in LAST_USER.keys():
         if (curtime - LAST_USER[t]) < 1:
             continue
     v = " ".join(message.split(" ")[1:]).strip()
     if v not in LANGS:
         bot.sendMessage(
             chat_id=chat_id,
Esempio n. 53
0
 def _set_exc_info(self, exc_info):
     with self._cond_var:
         just_set = self.__set(exc_info=exc_info)
     if just_set:
         exc_info_str = ''.join(traceback.format_exception(*exc_info))
         LOGGER.debug('%a got exception:\n%s', self, exc_info_str)
Esempio n. 54
0
 def handleException(self, exc_type, exc_param, exc_tb):
     "Exception handler (False to abort)"
     self.writeline(''.join(
         traceback.format_exception(exc_type, exc_param, exc_tb)))
     return True
 def format_exception(cls, exc_info):
     return ''.join(traceback.format_exception(
         *exc_info)) if exc_info else ''
def log_exception():
    "Log a stack trace"
    exc_type, exc_value, exc_traceback = sys.exc_info()
    print(repr(traceback.format_exception(exc_type, exc_value, exc_traceback)))
			fileName = os.path.basename(sys.executable)
			key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Internet Explorer\\Main\\FeatureControl\\FEATURE_BROWSER_EMULATION")
			result = winreg.QueryValueEx(key, fileName)
			print('Key already found with value: {}. Leaving key unchanged.'.format(result))
		except FileNotFoundError:
			try:
				print('Attempting to set browser emulation key in registry')
				key = winreg.CreateKey(winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Internet Explorer\\Main\\FeatureControl\\FEATURE_BROWSER_EMULATION")
				winreg.SetValueEx(key, fileName, 0, winreg.REG_DWORD, 11001)
				print('Registry key set')
			except:
				print('\mFailed to set registry key.  You may need to start the shell with \'Run as Administrator\'.\n')
				stacktrace = traceback.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
				print('Failure in verifyBrowserEmulation: {}'.format(stacktrace))
		except:
			raise

	## end verifyBrowserEmulation
	return


if __name__ == '__main__':
	try:
		osType = platform.system()
		verifyAvailableModules(osType)
		verifyBrowserEmulation(osType)
		main.main()
	except:
		stacktrace = traceback.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
		print('Failure in adminConsole wrapper: {}'.format(stacktrace))
Esempio n. 58
0
    def rescan(self):
        """Rescan all folders for changed/new/removed modules.

        The caller should release all references to removed modules.

        Returns a tuple: (removed, added)
        """

        print_d("Rescanning..")

        info = {}

        # get what is there atm
        for folder in self.__folders:
            for name, path, deps in get_importables(folder):
                # take the basename as module key, later modules win
                info[name] = (path, deps)

        # python can not unload a module, so we can only add new ones
        # or reload if the path is the same and mtime changed,
        # but we can still pretend we removed something

        removed = []
        added = []

        # remove those that are gone and changed ones
        for name, mod in list(self.__modules.items()):
            # not here anymore, remove
            if name not in info:
                del self.__modules[name]
                removed.append(name)
                continue

            # check if any dependency has changed
            path, new_deps = info[name]
            if mod.has_changed(new_deps):
                del self.__modules[name]
                removed.append(name)

        self.__failures.clear()

        # add new ones
        for (name, (path, deps)) in info.items():
            if name in self.__modules:
                continue

            try:
                # add a real module, so that pickle works
                # https://github.com/quodlibet/quodlibet/issues/1093
                parent = "quodlibet.fake"
                if parent not in sys.modules:
                    spec = importlib.machinery.ModuleSpec(parent,
                                                          None,
                                                          is_package=True)
                    sys.modules[parent] = importlib.util.module_from_spec(spec)
                vars(sys.modules["quodlibet"])["fake"] = sys.modules[parent]

                mod = load_module(name, parent + ".plugins", dirname(path))
                if mod is None:
                    continue
            except Exception as err:
                text = format_exception(*sys.exc_info())
                self.__failures[name] = ModuleImportError(name, err, text)
            else:
                added.append(name)
                self.__modules[name] = Module(name, mod, deps, path)

        print_d("Rescanning done: %d added, %d removed, %d error(s)" %
                (len(added), len(removed), len(self.__failures)))

        return removed, added
Esempio n. 59
0
def get_traceback_text(exec_info):
    return "".join(["-"] * 20 + ["\n\n"] +
                   list(traceback.format_exception(*exec_info)) + ["\n"] +
                   ["-"] * 37)
Esempio n. 60
0
    t_i = time.time()
    t_this = t_i
    print "Starting at", current_time()
    error_log.write("Started at: " + current_time() + "\n")
    for f in pdfs_not_done:
        filename = f + ".pdf"
        print "Processing", filename, "..."
        error_log.write("Processing " + filename + " at " + current_time() +
                        "\n")
        try:
            (l_luxParse, l_cleaner, l_tot) = do_evrytin(filename)
            move_to_load(f)
            time_passed_here = int(time.time() - t_this)
            time_total = int(time.time() - t_i)
            error_log.write(current_time() + " - " + filename + " done in " +
                            str(time_passed_here) + "\n")
            error_log.write(" " + str(l_luxParse) + " parser | " +
                            str(l_cleaner) + " cleaner | " + str(l_tot) +
                            " totales\n")
            print "  ", filename, "done in", time_passed_here, "seconds", "| Total time elapsed:", time_total, "[s]"
            t_this = time.time()
        except Exception:
            (type_, value_, tb) = sys.exc_info()
            error_log.write(current_time() + " - " + repr(value_) + "\n")
            for line in traceback.format_exception(type_, value_, tb):
                print line
                error_log.write(" " + line)
            error_log.write("-" * 15 + "\n")
        print "-" * 15