def main(): global trend global total_cost state = 'start' while True: try: log('====', state, '====') now = time.time() lifetime = now - start_time total_cost = INSTANCE_COST * lifetime log("Life Time [sec]: COST", lifetime, total_cost) trend = check_trend() state = eval(state+"()") if check_life(): died_clean(state) notify('DIED', uuid, show_options(), ['text', 'pretext']) log('DIED', uuid, show_options()) break except: if slack_url: notify(uuid, 'ERROR RAISED', str(sys.exc_info()), ['text', 'pretext']) notify('DIED', uuid, show_options(), ['text', 'pretext']) died_clean(state) log('ERROR RAISED' + str(sys.exc_inf())) traceback.print_exc() return 1 sleep(INTERVAL)
def main(args=None): mode = 'text' if (args): mode = args.mode soc = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) soc.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) print('Socket created') try: if (mode == 'bin'): soc.bind(('', 1200)) else: soc.bind(('', 1400)) print('Socket bind complete') except socket.error as msg: import sys print('Bind failed. Error: ' + str(sys.exc_inf())) sys.exit() ##end try t = Process(target=listen, args=(soc, mode)) t.start() try: while 1: cmd = input() if (mode == 'bin'): a = bytearray() for v in cmd.split(): a.append(int(v, base=16)) soc.sendto(a, ('192.168.1.3', 1200)) else: soc.sendto(cmd.encode(), ('127.0.0.1', 1300)) ##end while except (KeyboardInterrupt, SystemExit): t.join()
def cat(fname): try: file = open(fname, "r") for line in file: # 改行せずに出力 sys.stdout.write(line) file.close() except IOError as e: print "IOError: {0}".format(e) except: print "Unexpected error:", sys.exc_inf()[0] raise
def process(self, eventId, UCID): try: self.hub.log("Processing Event: %s Source: %s" % (eventId, UCID)) if eventId == 0xF0000000L: self.updateComponentList() if self.updateCounters == True: print "Received: %d Sent: %d" % (self.hub.received, self.hub.sent) except: traceback.print_exc() self.hub.log(sys.exc_info([0])) if (self.errorHandler <> None): self.errorHandler.raiseException(sys.exc_inf()[0], "Error processing message EventID : %s UCID: %s" % (eventId, UCID), false) else: raise
def import_string(import_name, silent=False): """Imports an object based on a string. This is useful if you want to use import paths as endpoints or something similar. An import path can be specified either in dotted notation (``xml.sax.saxutils.escape``) or with a colon as object delimiter (``xml.sax.saxutils:escape``). If `silent` is True the return value will be `None` if the import fails. For better debugging we recommend the new :func:`import_module` function to be used instead. :param import_name: the dotted name for the object to import. :param silent: if set to `True` import errors are ignored and `None` is returned instead. :return: imported object :copyright: (c) 2011 by the Werkzeug Team """ # force the import name to automatically convert to strings if isinstance(import_name, unicode): import_name = str(import_name) try: if ':' in import_name: module, obj = import_name.split(':', 1) elif '.' in import_name: module, obj = import_name.rsplit('.', 1) else: return __import__(import_name) # __import__ is not able to handle unicode strings in the fromlist # if the module is a package if isinstance(obj, unicode): obj = obj.encode('utf-8') try: return getattr(__import__(module, None, None, [obj]), obj) except (ImportError, AttributeError): # support importing modules not yet set up by the parent module # (or package for that matter) modname = module + '.' + obj __import__(modname) return sys.modules[modname] except ImportError as e: if not silent: six.reraise(ImportStringError, ImportStringError(import_name, e), sys.exc_inf()[2])
def connect(self): try: #self.errorHandler = new AlertExceptionHandler(this); self.server = UDPServer("", 6000) #//server = new TCPServer("", 6000) #//server = new SuperServer() self.server.errorHandler = self.errorHandler self.server.start() self.hub = Hub.MultimodalHub("hub", self.server) self.hub.errorHandler = self.errorHandler #self.hub.textOutput = log self.hub.setProcessor(self.process) self.hub.log("Connect #0") except: #if self.hub <> None: # self.hub.log(sys.exc_inf()[0]) if (self.errorHandler <> None): self.errorHandler.raiseException(sys.exc_inf()[0], "Error creating server", true) else: raise
def lstsq(a, b, rcond=None, sigma_b=None, weight=False, uncertainties=True, covariances=False, digested_output=False, svd=True, last_svd=None): """ Return the least-squares solution to a linear matrix equation. Solves the equation `a x = b` by computing a vector `x` that minimizes the Euclidean 2-norm `|| b - a x ||^2`. The equation may be under-, well-, or over- determined (i.e., the number of linearly independent rows of `a` can be less than, equal to, or greater than its number of linearly independent columns). If `a` is square and of full rank, then `x` (but for round-off error) is the "exact" solution of the equation. Parameters ---------- a : array_like, shape (M, N) "Model" matrix. b : array_like, shape (M,) or (M, K) Ordinate or "dependent variable" values. If `b` is two-dimensional, the least-squares solution is calculated for each of the `K` columns of `b`. sigma_b : uncertainties on the b values or None. If sigma_b has shape (M,) or (M, 1) and b has dimension (M, K), the uncertainty will be the same for all spectra. weight: 0 - No data weighting. Uncertainty of 1 for each data point. 1 - Statistical weight. Weighted fit using the supplied experimental uncertainties or the square root of the b values. svd: If not true, a simple matrix inversion will be used in case of weighting with unequal data weights. Ignored in any other cases. last_svd: Tuple containing U, s, V of the weighted model matrix or None. This is to prevent recalculation on repeated fits. uncertainties: If False, no uncertainties will be calculated unless the covariance matrix is requested. covariances: If True, an array of covariance matrix/matrices will be returned. digested_output: If True, returns a dictionary with explicit keys Returns ------- x : ndarray, shape (N,) or (N, K) Least-squares solution. The shape of `x` depends on the shape of `b`. uncertainties: ndarray, shape (N,) or (N, K) covariances: ndarray, shape (N, N) or (K, N, N) Examples -------- Fit a line, ``y = mx + c``, through some noisy data-points: >>> x = np.array([0, 1, 2, 3]) >>> y = np.array([-1, 0.2, 0.9, 2.1]) By examining the coefficients, we see that the line should have a gradient of roughly 1 and cut the y-axis at, more or less, -1. We can rewrite the line equation as ``y = Ap``, where ``A = [[x 1]]`` and ``p = [[m], [c]]``. Now use `lstsq` to solve for `p`: >>> A = np.vstack([x, np.ones(len(x))]).T >>> A array([[ 0., 1.], [ 1., 1.], [ 2., 1.], [ 3., 1.]]) >>> m, c = np.linalg.lstsq(A, y)[0] >>> print m, c 1.0 -0.95 Plot the data along with the fitted line: >>> import matplotlib.pyplot as plt >>> plt.plot(x, y, 'o', label='Original data', markersize=10) >>> plt.plot(x, m*x + c, 'r', label='Fitted line') >>> plt.legend() >>> plt.show() """ a = numpy.array(a, dtype=numpy.float, copy=False) b = numpy.array(b, dtype=numpy.float, copy=False) a_shape = a.shape b_shape = b.shape original = b_shape if len(a_shape) != 2: raise ValueError("Model matrix must be two dimensional") if len(b_shape) == 1: b.shape = b_shape[0], 1 b_shape = b.shape m = a.shape[0] n = a.shape[1] if m != b.shape[0]: raise ValueError('Incompatible dimensions between A and b matrices') fastest = False if weight: if sigma_b is not None: # experimental uncertainties provided these are the ones to use (if any) w = numpy.abs(numpy.array(sigma_b, dtype=numpy.float, copy=False)) w = w + numpy.equal(w, 0) if w.size == b_shape[0]: # same uncertainty for every spectrum fastest = True w.shape = b.shape[0] else: w.shape = b_shape else: # "statistical" weight # we are asked to somehow weight the data but no uncertainties provided # assume the uncertainties are the square root of the b values ... w = numpy.sqrt(numpy.abs(b)) w = w + numpy.equal(w, 0) else: # we have an unweighted fit with no uncertainties # assume all the uncertainties equal to 1 fastest = True w = numpy.ones(b.shape, numpy.float) if len(w.shape) == 1: w.shape = -1, 1 if covariances: covarianceMatrix = numpy.zeros((b_shape[1], n, n), numpy.float) if not weight: # no weight is applied # get the SVD decomposition of the A matrix # One could avoid calculating U, s, V each time ... if last_svd is not None: U, s, V = last_svd else: U, s, V = numpy.linalg.svd(a, full_matrices=False) if rcond is None: s_cutoff = max(m, n) * numpy.finfo(numpy.float).eps elif rcond == -1: s_cutoff = n * numpy.finfo(numpy.float).eps else: s_cutoff = rcond * s[0] s[s < s_cutoff] = numpy.inf # and get the parameters s.shape = -1 dummy = numpy.dot(V.T, numpy.eye(n) * (1. / s)) parameters = numpy.dot(dummy, numpy.dot(U.T, b)) parameters.shape = n, b.shape[1] if uncertainties or covariances: # get the uncertainties #(in the no-weight case without experimental uncertainties, # the uncertainties on the data points are ignored and the # uncertainty on the fitted parameters are independent of the input data!!!!) if fastest: # This is correct for all weights equal to 1 _covariance = numpy.dot(dummy, dummy.T) sigmapar = numpy.sqrt(numpy.diag(_covariance)) sigmapar = numpy.outer(sigmapar, numpy.ones(b_shape[1])) sigmapar.shape = n, b_shape[1] if covariances: covarianceMatrix[:] = _covariance elif covariances: # loop in order not to use potentially big matrices # but calculates the covariance matrices # It only makes sense if the covariance matrix is requested sigmapar = numpy.zeros((n, b_shape[1]), numpy.float) for k in range(b_shape[1]): pseudoData = numpy.eye(b_shape[0]) * w[:, k] tmpTerm = numpy.dot(dummy, numpy.dot(U.T, pseudoData)) _covariance[:, :] = numpy.dot(tmpTerm, tmpTerm.T) sigmapar[:, k] = numpy.sqrt(numpy.diag(_covariance)) covarianceMatrix[k] = _covariance else: # loop in order not to use potentially big matrices # but not calculating the covariance matrix d = numpy.zeros(b.shape, numpy.float) sigmapar = numpy.zeros((n, b_shape[1])) for k in range(b_shape[0]): d[k] = w[k] sigmapar += (numpy.dot(dummy, numpy.dot(U.T, d)))**2 d[k] = 0.0 sigmapar[:, :] = numpy.sqrt(sigmapar) elif fastest: # same weight for all spectra # it could be made by the calling routine, because it is equivalent to supplying a # different model and different independent values ... # That way one could avoid calculating U, s, V each time A = a / w b = b / w # get the SVD decomposition of the A matrix if last_svd is not None: U, s, V = last_svd else: U, s, V = numpy.linalg.svd(A, full_matrices=False) if rcond is None: s_cutoff = n * numpy.finfo(numpy.float).eps else: s_cutoff = rcond * s[0] s[s < s_cutoff] = numpy.inf # and get the parameters s.shape = -1 dummy = numpy.dot(V.T, numpy.eye(n) * (1. / s)) parameters = numpy.dot(dummy, numpy.dot(U.T, b)) parameters.shape = n, b.shape[1] if uncertainties or covariances: _covariance = numpy.dot(dummy, dummy.T) sigmapar = numpy.sqrt(numpy.diag(_covariance)) sigmapar = numpy.outer(sigmapar, numpy.ones(b_shape[1])) sigmapar.shape = n, b_shape[1] if covariances: covarianceMatrix[:] = _covariance else: parameters = numpy.zeros((n, b_shape[1]), numpy.float) sigmapar = numpy.zeros((n, b_shape[1]), numpy.float) if svd: # SVD - slower by a factor 2 for i in range(b_shape[1]): tmpWeight = w[:, i:i + 1] tmpData = b[:, i:i + 1] / tmpWeight A = a / tmpWeight U, s, V = numpy.linalg.svd(A, full_matrices=False) if rcond is None: s_cutoff = n * numpy.finfo(numpy.float).eps else: s_cutoff = rcond * s[0] s[s < s_cutoff] = numpy.inf s.shape = -1 dummy = numpy.dot(V.T, numpy.eye(n) * (1. / s)) parameters[:, i:i + 1] = numpy.dot(dummy, numpy.dot(U.T, tmpData)) if uncertainties or covariances: # get the uncertainties _covariance = numpy.dot(dummy, dummy.T) sigmapar[:, i] = numpy.sqrt(numpy.diag(_covariance)) if covariances: covarianceMatrix[i] = _covariance elif 1: # Pure matrix inversion (faster than SVD) # I do not seem to gain anything by re-using the storage #alpha = numpy.empty((n, n), numpy.float) #beta = numpy.empty((n, 1), numpy.float) for i in range(b_shape[1]): tmpWeight = w[:, i:i + 1] A = a / tmpWeight tmpData = b[:, i:i + 1] / tmpWeight #numpy.dot(A.T, A, alpha) #numpy.dot(A.T, tmpData, beta) alpha = numpy.dot(A.T, A) beta = numpy.dot(A.T, tmpData) try: _covariance = numpy.linalg.inv(alpha) except: print("Exception") print("Exception", sys.exc_info()[1]) continue parameters[:, i:i + 1] = numpy.dot(_covariance, beta) if uncertainties: sigmapar[:, i] = numpy.sqrt(numpy.diag(_covariance)) if covariances: covarianceMatrix[i] = covariance else: # Matrix inversion with buffers does not improve bufferProduct = numpy.empty((n, n + 1), numpy.float) bufferAB = numpy.empty((b_shape[0], n + 1), numpy.float) alpha = numpy.empty((n, n), numpy.float) for i in range(b_shape[1]): tmpWeight = w[:, i:i + 1] A = a / tmpWeight tmpData = b[:, i:i + 1] / tmpWeight bufferAB[:, :n] = A bufferAB[:, n:n + 1] = tmpData numpy.dot(A.T, bufferAB, bufferProduct) alpha[:, :] = bufferProduct[:n, :n] beta = bufferProduct[:, n] try: _covariance = numpy.linalg.inv(alpha) except: print("Exception") print("Exception", sys.exc_inf()) continue parameters[:, i] = numpy.dot(_covariance, beta) if uncertainties: sigmapar[:, i] = numpy.sqrt(numpy.diag(_covariance)) if covariances: covarianceMatrix[i] = covariance if len(original) == 1: parameters.shape = -1 if covariances: sigmapar.shape = parameters.shape if len(original) == 1: covarianceMatrix.shape = parameters.shape[0], parameters.shape[0] result = [parameters, sigmapar, covarianceMatrix] elif uncertainties: sigmapar.shape = parameters.shape result = [parameters, sigmapar] else: result = [parameters] if digested_output: ddict = {} ddict['parameters'] = result[0] if len(result) > 1: ddict['uncertainties'] = result[1] elif covariances: ddict['covariances'] = result[2] if svd or fastest: ddict['svd'] = (U, s, V) return ddict else: return result