Python log 模块，error() 实例源码

def _connect(self):
        try:
            self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

            if self._broadcast:
                # self._sock.bind((self._broadcast_interface, self._port))
                self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

            return self._sock
        except socket.gaierror:
            error = "Unable to connect to or resolve host: {}".format(
                self._host)
            log.error(error)
            raise IOError(error)

    # Push new data to strand

def update(self, data):
        try:
            self._fixData(data)
            data = self._buf
            s = self._connect()

            count = self.bufByteCount
            packet = self._generateHeader(CMDTYPE.PIXEL_DATA, count)

            packet.extend(data)

            s.sendto(packet, (self._host, self._port))

            s.close()

        except Exception as e:
            log.exception(e)
            error = "Problem communicating with network receiver!"
            log.error(error)
            raise IOError(error)

def update(self, data):
        try:
            s = self._connect()

            count = self.bufByteCount
            packet = self._generateHeader(CMDTYPE.PIXEL_DATA, count)

            packet.extend(data)

            s.sendall(packet)

            resp = ord(s.recv(1))

            if not self.persist:
                s.close()

            if resp != RETURN_CODES.SUCCESS:
                log.warning("Bytecount mismatch! %s", resp)

        except Exception as e:
            log.exception(e)
            error = "Problem communicating with network receiver!"
            log.error(error)
            raise IOError(error)

def getKeys(self):
        bits = 0
        try:
            packet = SerialGamePad._generateHeader(CMDTYPE.GET_BTNS, 0)
            self._com.write(packet)
            resp = self._com.read(1)

            if len(resp) == 0:
                SerialGamePad._comError()
            elif ord(resp) != RETURN_CODES.SUCCESS:
                SerialGamePad._printError(ord(resp))
            resp = self._com.read(2)
            if len(resp) != 2:
                SerialGamePad._comError()

            bits = ord(resp[0]) + (ord(resp[1]) << 8)
        except IOError:
            log.error("IO Error Communicatng With Game Pad!")

        index = 0
        result = {}
        for m in self._map:
            result[m] = (bits & (1 << index) > 0)
            index += 1
        return d(result)

def run_proc(self, body):
        try:
            if body.has_key('client_os_type'):
                pack_id = None
                query_param = ''
                if body.has_key('pack_id'):
                    pack_id = body['pack_id']
                if body.has_key('query_param'):
                    query_param = body['query_param']
                resp = Himalaya().get_recommendation(body['client_os_type'], pack_id, query_param)
                self.finish(resp)
            else:
                tmp_dict = {'code': -1, "error": "need clent os type param"}
                self.finish(json.dumps(tmp_dict))

        except Exception, Argument:
            log.error(Argument)
            self.finish(Argument)

def get_recommendation(self, os_type, pack_id, query_param = ''):
        recommendation = {'code': 0}

        if "luogic_show" in query_param:
            return self.get_sound_by_album_id(os_type, pack_id, 239463, 1)
        else:
            #"""
            res = self.tracks_hot(os_type, pack_id, 18, "???")
            #res = self.tracks_hot(os_type, pack_id, 1, "??")
            if (res is not None) and res.has_key('tracks'):
                recommendation['recommendation'] = []
                tmp_list = res['tracks']
                for track in tmp_list:
                    recommendation['recommendation'].append(self.__set_recommendation(track))
            else:
                recommendation['code'] = -1
                recommendation['error'] = 'no data'
            return json.dumps(recommendation, ensure_ascii = False).encode('utf-8')
            #"""
            #return self.find_track(os_type, pack_id, "?? ??")

def delete_product(product_infos):
    PRODUCT_ID = product_infos["id"]
    try : 
        PRODUCT_NAME = product_infos["name"]
    except KeyError:
        PRODUCT_NAME = "Inconnu"
    log.error("Ref incwo not found for product {} (id {})".format(PRODUCT_NAME, PRODUCT_ID))
    url = "https://www.incwo.com/"+str(ID_USER)+"/customer_products/"+str(PRODUCT_ID)+".xml";
    send_request("delete", url)
    # TODO
    return 0

# Args :
#  product_infos : contient toutes les infos sur le produit picata
#  product_id : id du produit, necessaire pour change_stock_value (fct qui va envoyer la requete ainsi que l'xml correspondant au nouveau stock)
#  cat_id_src : vaux None en cas de creation d'un nouveau produit.
#               pour l'update, contient l'id de la category selon incwo (la ou sont stocke les infos de la precedente synchro)

def _connect(self):
        if self.persist and self._sock:
            return self._sock
        try:
            self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self._sock.connect((self._host, self._port))
            return self._sock
        except socket.gaierror:
            error = "Unable to connect to or resolve host: {}".format(
                self._host)
            log.error(error)
            raise IOError(error)

    # Push new data to strand

def _printError(error):
        msg = "Unknown error occured."
        if error == RETURN_CODES.ERROR_SIZE:
            msg = "Data packet size incorrect."
        elif error == RETURN_CODES.ERROR_UNSUPPORTED:
            msg = "Unsupported configuration attempted."
        elif error == RETURN_CODES.ERROR_BAD_CMD:
            msg = "Unsupported protocol command. Check your device version."

        log.error("%s: %s", error, msg)
        raise SerialPadError(msg)

def _connect(self):
        try:
            if(self.dev == ""):
                SerialGamePad.findSerialDevices(self._hardwareID)

                if len(SerialGamePad.foundDevices) > 0:
                    self.dev = SerialGamePad.foundDevices[0]
                    log.info("Using COM Port: %s", self.dev)

            try:
                self._com = serial.Serial(self.dev, timeout=5)
            except serial.SerialException as e:
                ports = SerialGamePad.findSerialDevices(self._hardwareID)
                error = "Invalid port specified. No COM ports available."
                if len(ports) > 0:
                    error = "Invalid port specified. Try using one of: \n" + \
                        "\n".join(ports)
                log.info(error)
                raise SerialPadError(error)

            packet = SerialGamePad._generateHeader(CMDTYPE.INIT, 0)
            self._com.write(packet)

            resp = self._com.read(1)
            if len(resp) == 0:
                SerialGamePad._comError()

            return ord(resp)

        except serial.SerialException as e:
            error = "Unable to connect to the device. Please check that it is connected and the correct port is selected."
            log.exception(e)
            log.error(error)
            raise e

def broadcast(self, input_, norm, classifier=None, aif_scale=1):
        """
        Used for high level broadcast, in which the input is processed in bulk instead of per-component, i.e., per byte.
        input_ of len 1-256 (for proper CM1K emulation, otherwise unlimited)
        norm: A DistNorm enum
        classifier: A Classifier enum
        aif_scale: Modify the aif when determining whether the fire. The aif can also be permanently scaled via
        CM1KEmulator.scale_all_aifs(), but this parameter enables the same behavior without altering the neuron.
        """
        # Called from CM1KEmulator.broadcast()
        log.trace("Neuron.broadcast()")

        # This shouldn't be necessary. This function should only be called on committed and the rtl neurons.
        if self.state == NeuronState.idle:
            log.error("Neuron.broadcast() called on idle neuron")
            return

        self.dist = 0  # NOTE: Not sure this is necessary. Also, undecided whether this should simply call reset_dist().
        if norm == cm1k.CM1KDistNorm.l1:
            for i, comp in enumerate(input_):
                self.dist += abs(comp - self.pattern[i])
        elif norm == cm1k.CM1KDistNorm.lsup:
            for i, comp in enumerate(input_):
                self.dist = max(abs(comp - self.pattern[i]), self.dist)
        elif norm == cm1k.CM1KDistNorm.euc:
            for i, comp in enumerate(input_):
                self.dist += (comp - self.pattern[i]) * (comp - self.pattern[i])
            self.dist = int(round(math.sqrt(self.dist)))
        log.log("Single neuron cat{} dist: {:>5} < {:>5} ?".format(self.cat, self.dist, self.aif))

        # TODO: Use the minimum and maximum AIFs of each neuron (i.e., of each context)
        aif = self.aif if aif_scale == 1 else min(max(int(round(self.aif * aif_scale)), 0), 0xFFFF)

        if (classifier == cm1k.CM1KClassifier.rbf and self.dist < aif) or classifier == cm1k.CM1KClassifier.knn:
            # The neuron has fired
            log.log("Fire with dist{} aif{} cat{}".format(self.dist, aif, self.cat))
            self.chip.store_firing_neuron(self)

def shrink_if_necessary(self, cat, new_aif, minif):
        """
        Shrink if the AIF if categories don't match and error-compensating AIF < currently held AIF.
        """
        log.trace("Neuron.shrink_if_necessary()")

        # TODO: create unit test where misfiring neuron has exactly the same distance as the best neuron.
        if cat != self.cat and new_aif < self.aif:
            self.shrink_aif(new_aif, minif)

def on_error(self, event, irc):
        log.error(" ".join(event.arguments))
        if " ".join(event.arguments).startswith("Closing Link"):
            self.bot.web.stop()
            self.userdb.flush()
            self.bot.db_job.stop()
            sys.exit(1)

    # Numeric events

def on_unavailresource(self, event, irc):
        log.error("Nick unavailable, trying alternative")
        irc.nick(self.config['nickname'] + "_")
        self.config['nickname'] = self.config['nickname'] + "_"

def on_nicknameinuse(self, event, irc):
        log.error("Nick already in use, trying alternative")
        irc.nick(self.config['nickname'] + "_")
        self.config['nickname'] = self.config['nickname'] + "_"

def get(self):
        try:
            webData = self.request.body
            #print "Handle Get webdata is ", webData
            log.debug("Handle Get webdata is %s" % (webData))

            signature = self.get_argument('signature', '')
            timestamp = self.get_argument('timestamp', '')
            nonce = self.get_argument('nonce', '')
            echostr = self.get_argument('echostr', '')
            token = test_weixin_token

            if len(signature) == 0 or len(timestamp) == 0 or \
                    len(nonce) == 0 or len(echostr) == 0:
                        self.write('')

            list = [token, timestamp, nonce]
            list.sort()
            sha1 = hashlib.sha1()
            map(sha1.update, list)
            hashcode = sha1.hexdigest()
            #print "handle/GET func: hashcode, signature: ", hashcode, signature
            log.debug("handle/GET func: hashcode, signature: %s, %s"%(hashcode, signature))
            if hashcode == signature:
                self.write(echostr)
            else:
                self.write('')
        except Exception, Argument:
            log.error(Argument)
            self.write(Argument)

def post(self):
        body = json.loads(self.request.body)
        response = {'code': 0}
        if body.has_key('songId'):
            search_result = BaiduMusicSearch().search_song_byid(body['songId'])
            response['searchResult'] = search_result
        else:
            response['code'] = -1
            response['error'] = "not found song id."
        json_data = json.dumps(response, ensure_ascii=False)
        log.info(json_data)
        self.write(json_data)

def http_post(self, url, data, header_type):
        header = {'Content-Type': header_type}
        try:
            request = urllib2.Request(url=url, headers=header, data=data)
            resp = urllib2.urlopen(request, timeout=self.__timeout).read()
            return json.loads(resp)
        except Exception, Argument:
            log.error(Argument)
            return None

def get_sound_by_album_id(self, os_type, pack_id, id, count = 20, sort = "asc", page = 1):
        recommendation = {'code': 0}
        res = self.album_browse(os_type, pack_id, id, count, sort, page)
        if (res is not None) and res.has_key('tracks'):
            recommendation['recommendation'] = []
            track_list = res['tracks']
            for track in track_list:
                recommendation['recommendation'].append(self.__set_recommendation(track))
        else:
            recommendation = {'code': -1}
            recommendation['error'] = 'no data'
        #log.debug(json.dumps(recommendation, ensure_ascii = False).encode('utf-8'))
        print json.dumps(recommendation, ensure_ascii = False).encode('utf-8')
        return json.dumps(recommendation, ensure_ascii = False).encode('utf-8')

def find_track(self, os_type, pack_id, param):
        recommendation = {'code': 0}
        res = self.search_tracks(os_type, pack_id, param)
        if (res is not None) and res.has_key('tracks'):
            recommendation['recommendation'] = []
            for track in res['tracks']:
                recommendation['recommendation'].append(self.__set_recommendation(track))
        else:
            recommendation = {'code': -1}
            recommendation['error'] = 'no data'
        return json.dumps(recommendation, ensure_ascii = False).encode('utf-8')

def update_product(fournisseur_product_infos, incwo_product_infos):
    update_infos = {}
    try:
        PRODUCT_ID = incwo_product_infos["id"]
        PRODUCT_REF = fournisseur_product_infos["reference"]
    except KeyError:
        log.error("Incwo product with no ID or ref associated")
        raise ValueError()
    try:
        # Si produit considere comme vitrine : on annule la comparaison prix et category en mettant les champs aux memes valeurs
        if not compareValues(incwo_product_infos["product_category_id"],VITRINE_CATEGORY_ID):
            log.warning("Pas de mise a jour du prix du produit {} (Produit categorisé comme en vitrine)".format(PRODUCT_REF))
            incwo_product_infos["product_category_id"] = fournisseur_product_infos["product_category_id"]
            fournisseur_product_infos["price"] = incwo_product_infos["price"]
    except KeyError:
        log.error("Incwo product with no category_ID associated")
        raise ValueError()

    for key in INCWO_PARAMS:
        if not key in fournisseur_product_infos:
            log.error("Product "+fournisseur_product_infos["name"]+" : fournisseur info incomplete! Missing "+key)
            raise ValueError()
        elif not key in incwo_product_infos:
            if key != 'barcode':
                log.debug("incwo info incomplete, updating "+key)
                update_infos[key]=fournisseur_product_infos[key]
        elif (compareValues(fournisseur_product_infos[key],incwo_product_infos[key])):
            log.debug("incwo info outdated, updating {}".format(key))
            log.debug("Picata {} ; incwo_product_infos {}".format(fournisseur_product_infos[key], incwo_product_infos[key]))
            update_infos[key]=fournisseur_product_infos[key]

    if len(update_infos) > 0 :
        log.debug("Update needed for product "+str(PRODUCT_ID))
        xml = prepare_xml_product(update_infos)
        url = "https://www.incwo.com/"+str(ID_USER)+"/customer_products/"+str(PRODUCT_ID)+".xml";
        send_request('put', url, xml)
    # else :
    #     log.debug("Product {} (id {}) infos up to date".format(fournisseur_product_infos["name"],PRODUCT_ID))

    manage_stock_movement(fournisseur_product_infos, PRODUCT_ID, incwo_product_infos["product_category_id"])

def get(self):
        '''
        the import handle
        '''
        try:
            webData = self.request.body
            #print "WxShowHandler Get webdata is ", webData
            log.info("WxShowHandler Get webdata is %s" % (webData))

            id = self.get_argument('id', '')
            showidstr = self.get_argument('showid', '')
            if len(id) == 0 or len(showidstr) == 0:
                self.write('parameter error!')

            # get sign ticket for weixin jsapisdk
            ticket = DataCenter().get_jsapi_ticket()
            urlall = self.request.uri
            #print self.request.path        /wx/show
            #print self.request.uri         /wx/show?id=oLN9QxI-YpdNJkSIXQkppJDHuvZM&showid=15
            sign = Sign(ticket, test_urlhead + urlall)
            sign_data = sign.sign()
            #print 'weixin_JSAPI_ticket: '
            #print sign_data
            log.info('weixin_JSAPI_ticket: %s'%(sign_data))
            timestamp = sign_data['timestamp']
            nonceStr = sign_data['nonceStr']
            signature = sign_data['signature']

            # get_param id
            showid = long(showidstr)
            userdata = DataCenter().get_data_by_id(showid)
            if len(userdata) == 0:
                self.write("no data")
                return
            data_dict = userdata[0]
            #print data_dict
            log.debug(data_dict)

            title_info = data_dict['title']
            sub_info = data_dict['aidata'].split(test_split_str)
            all_info = data_dict['originaldata'].split(test_split_str)
            createtime = data_dict['createtime'].strftime('%Y-%m-%d %H:%M:%S')

            author = ''
            authorinfo = data_dict['author']
            datasource = data_dict['datasource']
            _userid = data_dict['userid']
            if authorinfo == '':
                author = datasource
            elif datasource == '':
                author = authorinfo
            else :
                author = authorinfo + ' | ' + datasource

            self.render("index.html", title=title_info, allinfo=all_info, subjects=sub_info, author=author, \
                    createtime=createtime, appid=test_weixin_appid, timestamp=timestamp, nonceStr=nonceStr, \
                    userid=_userid, signature=signature)
        except Exception, Argument:
            log.error(Argument)
            self.write(Argument)

def run_sql_proc(self, body, funcname):
        try:
            content = {'code': 0}
            if funcname == 'notread':
                if(body.has_key('userid')):
                    userid = body['userid']
                    res_list = DataCenter().get_not_read_id_from_xdata(userid)
                    list_dict = []
                    for i in range(len(res_list)):
                        tmp = {}
                        tmp['id'] = res_list[i]['id']
                        list_dict.append(tmp)
                    content['collections'] = list_dict
                else:
                    content['code'] = -1
                    content['error'] = 'userid is needed.'
            elif funcname == 'content':
                if (body.has_key('userid') and body.has_key('id')):
                    userid = body['userid']
                    id = body['id']
                    res_list = DataCenter().get_content_from_xdata(userid, id)
                    content['id'] = res_list[0]['id']
                    content['title'] = res_list[0]['title']
                    content['author'] = res_list[0]['author']
                    content['source'] = res_list[0]['datasource']
                    content['subject'] = res_list[0]['aidata'].split(lingx_split_str)
                    content['original'] = res_list[0]['originaldata'].split(lingx_split_str)

                    #??accesstime
                    #DataCenter().update_xdata(id, 'accesstime', datetime.now().strftime('%Y-%m-%d %H:%M:%S'))

                else:
                    content['code'] = -1
                    content['error'] = 'userid and id are needed.'
            elif funcname == 'status':
                if (body.has_key('article_list')):
                    for item in body['article_list']:
                        #??accesstime
                        DataCenter().update_xdata(item['id'], 'accesstime', datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
                else:
                    content['code'] = -1
                    content['error'] = 'article_list is empty.'
            else:
                pass
            #print content
            log.debug(content)
            self.write(tornado.escape.json_encode(content))
            self.finish()
        except Exception, Argument:
            log.error(Argument)
            self.finish(Argument)

def get_recommendation_tmp(self, os_type, pack_id):
        recommendation = {'code': 0}
        #??????
        res = self.categories_human_recommend(os_type, pack_id)
        for item in res:
            #print "===>> category:", item['category_name'].encode("utf-8"), item['id']
            if item['id'] != 8:
                continue
            category_id = item['id']
            category_name = item['category_name']
            print "====>>>> categor name, id:", category_name, category_id
            #log.info("category_name:%s, category_id:%d"%(category_name, category_id))

            #????tag
            res = self.tags_list(os_type, pack_id, 0, category_id)
            tag_names = []
            for item in res:
                tag_names.append(item['tag_name'])

            # category + tag ????
            recommendation['recommendation'] = []
            recommendation['code'] = 0
            cnt = 0
            for item in tag_names:
                """
                if cmp(item, u"????"):
                    #print "===>>> tag_name:", item.encode('utf-8')
                    print "===>>> tag_name:", item
                    continue
                """
                print "===>>> tag_name:", item
                res = self.albums_list(os_type, pack_id, category_id, item, 3)
                if res.has_key('albums'):
                    tmp_list = res['albums']
                    for track in tmp_list:
                        print "==>>>album: ", track['album_title']
                else:
                    pass
        else:
            recommendation = {'code': 0}
            recommendation['error'] = 'no data'

        return json.dumps(recommendation, ensure_ascii = False).encode('utf-8')