0:\\n wi += np.dot(X[i].T, np.dot(X[j], w[j]))\\n norm_wi = np.linalg.norm(wi)\\n if norm_wi > consts.TOLERANCE:\\n wi /= norm_wi\\n w[i] = wi\\n\\n func_val.append(self.f(X, w))\\n\\n if it >= 1:\\n err = func_val[-1] - func_val[-2]\\n else:\\n err = func_val[-1]\\n\\n self.num_iter = it + 1\\n\\n if abs(err) < consts.TOLERANCE:\\n break\\n\\n # Find all model vectors\\n t = [0] * n\\n p = [0] * n\\n for i in range(n):\\n t[i] = np.dot(X[i], w[i])\\n p[i] = np.dot(X[i].T, t[i])\\n titi = np.linalg.norm(t[i])**2.0\\n if titi > consts.TOLERANCE:\\n p[i] = p[i] / titi\\n else:\\n self.warn(\\\"Too small joint component for matrix %d! \\\"\\n \\\"Trying to continue!\\\" % (i,))\\n\\n # Normalise P? It matters whether we update with W or with P!\\n # TODO: Option?\\n# normp = norm(P{i});\\n# P{i} = P{i} / normp;\\n# T{i} = T{i} * normp;\\n\\n return w, t, p, func_val\",\n \"def fit(self,X,y):\\n\\n d = X.shape[1]\\n # 1. sketch the data\\n self.B,a = self._sketch(X,method=self.fd_mode)\\n #H = B.T@B + (self.alpha+a)*np.eye(d)\\n #self.H = H\\n self.H_inv = self._get_inv() #np.linalg.pinv(H)\\n self.coef_ = self.H_inv@(X.T@y) #np.linalg.solve(H, X.T@y)\\n self.is_fitted = True\",\n \"def optimize_cjp_displacements(self, method='lm', init_coeffs=None):\\n if init_coeffs is None:\\n init_coeffs = np.random.rand(5)\\n else:\\n init_coeffs += np.random.rand(5)\\n # optimize least squares\\n return optimize.least_squares(fun=self.residuals_cjp_displacements,\\n x0=init_coeffs,\\n method=method)\",\n \"def fit(self, X, y, **params):\\n\\n assert isinstance(X, pd.DataFrame)\\n assert isinstance(y, pd.DataFrame)\\n assert X.shape[0] == y.shape[0]\\n\\n # Fit the linear regressor (feature = f(covariates))\\n self.regressors = {c: LinearRegression(**params).fit(y.values, X[c].values) for c in X.columns}\\n\\n # Store the covariates\\n self.covariates = y\\n\\n return self\",\n \"def test_coefficients(self):\\n\\n coefs = self.cs.coefficients\\n\\n self.assertEqual(coefs, (1, 0, 1, 0, 0, -1))\",\n \"def CreateCoefficientPolyfitTables(self):\\n for currentRe in self.polars:\\n for currentPolar in currentRe[1]:\\n # Combine (Re, AOA) as a point\\n self.points.append([currentRe[0], currentPolar[0]])\\n\\n # Corresponding to CL, CDp and Cm value\\n self.valuesCL.append(currentPolar[1])\\n self.valuesCDp.append(currentPolar[2])\\n self.valuesCm.append(currentPolar[3])\\n\\n for Re in self.Res:\\n self.AOAs_Re.append([point[1] for point in self.points if point[0] == Re])\\n self.CLs_Re.append([self.valuesCL[i] for i in range(len(self.points)) if self.points[i][0] == Re])\\n self.CDps_Re.append([self.valuesCDp[i] for i in range(len(self.points)) if self.points[i][0] == Re])\\n self.Cms_Re.append([self.valuesCm[i] for i in range(len(self.points)) if self.points[i][0] == Re])\\n\\n # Fit coefficients to AOAs\\n if self.weightedFit:\\n w = np.array([np.cos((a - 2.5) / 5 * np.pi / 4) for a in self.AOAs_Re[-1]])\\n # Fit coefficients with weight\\n self.CLfit_Re.append(np.polyfit(self.AOAs_Re[-1], self.CLs_Re[-1],\\n self.CLfitOrder, w=w))\\n self.CDpfit_Re.append(np.polyfit(self.AOAs_Re[-1], self.CDps_Re[-1],\\n self.CDpfitOrder, w=w))\\n self.Cmfit_Re.append(np.polyfit(self.AOAs_Re[-1], self.Cms_Re[-1],\\n self.CmfitOrder, w=w))\\n\\n else:\\n self.CLfit_Re.append(np.polyfit(self.AOAs_Re[-1], self.CLs_Re[-1], self.CLfitOrder))\\n self.CDpfit_Re.append(np.polyfit(self.AOAs_Re[-1], self.CDps_Re[-1], self.CDpfitOrder))\\n self.Cmfit_Re.append(np.polyfit(self.AOAs_Re[-1], self.Cms_Re[-1], self.CmfitOrder))\",\n \"def _update_parallel_coef_constraints(self, x):\\n n_features = x.shape[1]\\n xi_final = np.zeros((n_features, n_features))\\n\\n # Todo: parallelize this for loop with Multiprocessing/joblib\\n if self.model_subset is None:\\n self.model_subset = range(n_features)\\n elif np.max(np.abs(self.model_subset)) >= n_features:\\n raise ValueError(\\n \\\"A value in model_subset is larger than the number \\\"\\n \\\"of features in the candidate library\\\"\\n )\\n for i in self.model_subset:\\n print(\\\"Model \\\", i)\\n xi = cp.Variable(n_features)\\n # Note that norm choice below must be convex,\\n # so thresholder must be L1 or L2\\n if (self.thresholder).lower() in (\\\"l1\\\", \\\"weighted_l1\\\"):\\n if self.thresholds is None:\\n cost = cp.sum_squares(x[:, i] - x @ xi) + self.threshold * cp.norm1(\\n xi\\n )\\n else:\\n cost = cp.sum_squares(x[:, i] - x @ xi) + cp.norm1(\\n self.thresholds[i, :] @ xi\\n )\\n if (self.thresholder).lower() in (\\\"l2\\\", \\\"weighted_l2\\\"):\\n if self.thresholds is None:\\n cost = (\\n cp.sum_squares(x[:, i] - x @ xi)\\n + self.threshold * cp.norm2(xi) ** 2\\n )\\n else:\\n cost = (\\n cp.sum_squares(x[:, i] - x @ xi)\\n + cp.norm2(self.thresholds[i, :] @ xi) ** 2\\n )\\n prob = cp.Problem(\\n cp.Minimize(cost),\\n [xi[i] == 0.0],\\n )\\n try:\\n prob.solve(\\n max_iter=self.max_iter,\\n eps_abs=self.tol,\\n eps_rel=self.tol,\\n verbose=self.verbose_cvxpy,\\n )\\n if xi.value is None:\\n warnings.warn(\\n \\\"Infeasible solve on iteration \\\"\\n + str(i)\\n + \\\", try changing your library\\\",\\n ConvergenceWarning,\\n )\\n xi_final[:, i] = xi.value\\n # Annoying error coming from L2 norm switching to use the ECOS\\n # solver, which uses \\\"max_iters\\\" instead of \\\"max_iter\\\", and\\n # similar semantic changes for the other variables.\\n except TypeError:\\n prob.solve(\\n max_iters=self.max_iter,\\n abstol=self.tol,\\n reltol=self.tol,\\n verbose=self.verbose_cvxpy,\\n )\\n if xi.value is None:\\n warnings.warn(\\n \\\"Infeasible solve on iteration \\\"\\n + str(i)\\n + \\\", try changing your library\\\",\\n ConvergenceWarning,\\n )\\n xi_final[:, i] = xi.value\\n except cp.error.SolverError:\\n print(\\\"Solver failed on model \\\", str(i), \\\", setting coefs to zeros\\\")\\n xi_final[:, i] = np.zeros(n_features)\\n return xi_final\",\n \"def jacobian(theta, event, parameters_to_fit):\\n for (key, val) in enumerate(parameters_to_fit):\\n setattr(event.model.parameters, val, theta[key])\\n return event.chi2_gradient(parameters_to_fit)\",\n \"def coefC(x0,y0,x1,y1):\\n return (x1*y0-x0*y1)/(x1-x0)\",\n \"def fit(zs, ys, L, lam_1, lam_2, rho=10, maxiter=100, verbose=True, warm_start=None,\\n eps_abs = 1e-5, eps_rel = 1e-5):\\n K = int(zs.max() + 1)\\n N, n = ys.shape\\n Ys, cts = [], []\\n for i in range(K):\\n idx = zs == i\\n cts.append(idx.sum()) #N_i, number of samples per z\\n ys_i = ys[idx]\\n Ys.append(ys_i.T @ ys_i)\\n \\n if verbose:\\n print (\\\"Fitting covariance stratified model.\\\")\\n print (\\\"%d stratification values, %d data points, %d dimensions\\\" % (K, N, n))\\n print (\\\"%d\\\" % (K * n * n), \\\"optimization variables\\\")\\n print (\\\"lam_1 = %3.3e, lam_2 = %3.3e, rho = %3.3e, maxiter=%d\\\" % (lam_1, lam_2, rho, maxiter))\\n print (\\\"count per stratification value:\\\", cts)\\n print (Ys[0].shape)\\n\\n shape = (K, n, n)\\n if warm_start is None:\\n warm_start = []\\n for _ in range(5):\\n warm_start.append(np.zeros(shape))\\n inv_covs_loss, inv_covs_reg, inv_covs_lapl, U_1, U_2 = warm_start\\n \\n solve = factorized(L.tocsc() + rho * sparse.eye(K, format='csc'))\\n \\n for _ in range(maxiter):\\n # inv_covs_loss\\n for i in range(K):\\n if cts[i] == 0:\\n inv_covs_loss[i] = (inv_covs_lapl[i] - U_1[i])\\n continue\\n w, v = np.linalg.eigh((rho/cts[i]) * (inv_covs_lapl[i] - U_1[i]) - Ys[i]/cts[i])\\n w_new = (w*cts[i]/rho + np.sqrt((w*cts[i]/rho)**2 + 4*cts[i]/rho))/2\\n inv_covs_loss[i] = v @ np.diag(w_new) @ v.T \\n \\n # inv_covs_reg\\n for i in range(K):\\n inv_covs_reg[i][np.arange(n), np.arange(n)] = np.diag(inv_covs_lapl[i] - U_2[i] - lam_1/rho) #diagonal elements\\n \\n st2 = soft_threshold(inv_covs_lapl[i] - U_2[i], lam_2 / rho)\\n od_idx = np.where(~np.eye(n,dtype=bool)) #gets off_diags\\n inv_covs_reg[i][od_idx] = st2[od_idx] \\n \\n # inv_covs_lapl\\n rhs = (inv_covs_loss + inv_covs_reg) / 2 + (U_1 + U_2) / 2\\n rhs *= rho\\n inv_covs_lapl_new = solve(rhs.reshape(K, n*n)).reshape(shape)\\n S = rho * np.repeat(inv_covs_lapl_new - inv_covs_lapl, 2, axis=0)\\n inv_covs_lapl = inv_covs_lapl_new.copy()\\n\\n # U_1\\n R_1 = inv_covs_loss - inv_covs_lapl\\n U_1 += R_1\\n \\n # U_2\\n R_2 = inv_covs_reg - inv_covs_lapl\\n U_2 += R_2\\n \\n R = np.concatenate([R_1, R_2], axis=0)\\n \\n # stopping criterion\\n eps_pri = np.sqrt(2 * K * n * n) * eps_abs + eps_rel * max(np.linalg.norm(np.concatenate([inv_covs_loss, inv_covs_reg], axis=0)),\\n np.linalg.norm(np.repeat(inv_covs_lapl, 2, axis=0)))\\n eps_dual = np.sqrt(K * n * n) * eps_abs + eps_rel * np.linalg.norm(np.concatenate([U_1, U_2], axis=0))\\n if verbose:\\n print (np.linalg.norm(R), np.linalg.norm(S), eps_pri, eps_dual)\\n \\n return inv_covs_loss, inv_covs_reg, inv_covs_lapl\",\n \"def calculateElementCoefficients(self):\\n #\\n #get u,grad(u), and grad(u)Xgrad(w) at the quadrature points\\n #\\n for cj in range(self.nc):\\n self.u[cj].getValues(self.q[('v',cj)],\\n self.q[('u',cj)])\\n if self.q.has_key(('grad(u)',cj)):\\n self.u[cj].getGradientValues(self.q[('grad(v)',cj)],\\n self.q[('grad(u)',cj)])\\n #\\n #get functions of (t,x,u) at the quadrature points\\n #\\n self.coefficients.evaluate(self.timeIntegration.t,self.q)\\n log(\\\"Coefficients on element\\\",level=10,data=self.q)\\n #\\n # time integration is handled directly in ELLAM weak approximation, don't have a hook for\\n # doing that via a time integration object (could if it were a direct Lagrange Galerkin formulation I believe)\\n # however, need to set time integration's m_tmp if use that anywhere\\n #if self.timeTerm:\\n # self.timeIntegration.calculateElementCoefficients(self.q)\\n\\n #todo eventually can add nonlinear potential here\\n\\n #cek and mwf need to go through this section to clean up, some of next two blocks could go to calcQuad\\n #\\n #todo need non-diagonal dependence?\\n for ci in range(self.nc):\\n cfemIntegrals.calculateCFLADR(self.elementEffectiveDiametersArray,\\n self.q[('dm',ci,ci)],\\n self.q[('df',ci,ci)],#could just be velocity\\n self.q[('cfl',ci)])\",\n \"def solve(self):\\n \\n # Check if cost is available for both estimators\\n if not self.est0.cost_avail or not self.est1.cost_avail:\\n self.comp_cost = False\\n \\n # Initial estimate from the input node\\n if self.comp_cost:\\n z0, zvar0, cost0 = self.est0.est_init(return_cost=True)\\n else:\\n z0, zvar0 = self.est0.est_init(return_cost=False)\\n cost0 = 0\\n self.z0 = z0\\n self.zvar0 = zvar0\\n self.cost0 = cost0\\n \\n # Initialize other variables\\n self.var_cost0 = 0\\n self.var_cost1 = 0\\n self.cost = 0\\n self.s = np.zeros(self.shape1)\\n \\n for it in range(self.nit):\\n \\n # Forward transform to est1\\n t0 = time.time()\\n rvar1_new = self.A.var_dot(self.zvar0)\\n rvar1_rep = common.repeat_axes(rvar1_new,self.shape1,\\\\\\n self.var_axes1,rep=False)\\n z1_mult = self.A.dot(self.z0)\\n r1_new = z1_mult - rvar1_rep*self.s\\n \\n # Damping\\n if it > 0: \\n self.r1 = (1-self.step)*self.r1 + self.step*r1_new\\n self.rvar1 = (1-self.step)*self.rvar1 + self.step*rvar1_new\\n else:\\n self.r1 = r1_new\\n self.rvar1 = rvar1_new\\n\\n # Estimator 1 \\n if self.comp_cost: \\n z1, zvar1, cost1 = self.est1.est(self.r1, self.rvar1, return_cost=True) \\n if not self.map_est:\\n cost1 -= self.cost_adjust(self.r1,z1,self.rvar1,zvar1,\\\\\\n self.shape1,self.var_axes1)\\n else:\\n z1, zvar1 = self.est1.est(self.r1, self.rvar1, return_cost=False) \\n cost1 = 0\\n self.z1 = z1\\n self.zvar1 = zvar1\\n self.cost1 = cost1 \\n con_new = np.mean(np.abs(z1-z1_mult)**2) \\n \\n # Reverse nonlinear transform to est 0\\n self.s = (self.z1-self.r1)/rvar1_rep\\n self.sprec = 1/self.rvar1*(1-self.zvar1/self.rvar1)\\n t1 = time.time()\\n self.time_est1 = t1-t0\\n \\n # Reverse linear transform to est 0 \\n rvar0_new = 1/self.A.var_dotH(self.sprec)\\n rvar0_rep = common.repeat_axes(rvar0_new,self.shape0,\\\\\\n self.var_axes0,rep=False)\\n r0_new = self.z0 + rvar0_rep*self.A.dotH(self.s)\\n \\n # Damping\\n if it > 0:\\n self.r0 = (1-self.step)*self.r0 + self.step*r0_new\\n self.rvar0 = (1-self.step)*self.rvar0 + self.step*rvar0_new\\n else:\\n self.r0 = r0_new\\n self.rvar0 = rvar0_new\\n \\n \\n # Estimator 0\\n if self.comp_cost:\\n z0, zvar0, cost0 = self.est0.est(self.r0, self.rvar0, return_cost=True)\\n if not self.map_est:\\n cost0 -= self.cost_adjust(self.r0,z0,self.rvar0,zvar0,\\\\\\n self.shape0,self.var_axes0)\\n \\n else:\\n z0, zvar0 = self.est0.est(self.r0, self.rvar0, return_cost=False)\\n cost0 = 0\\n self.z0 = z0\\n self.zvar0 = zvar0\\n self.cost0 = cost0 \\n\\n \\n # Compute total cost and constraint \\n cost_new = self.cost0 + self.cost1 \\n if not self.map_est:\\n cost_new += self.cost_gauss()\\n \\n # Step size adaptation\\n if (self.step_adapt) and (it > 0):\\n if (con_new < self.con):\\n self.step = np.minimum(1,self.step_inc*self.step)\\n else:\\n self.step = np.maximum(self.step_min, self.step_dec*self.step)\\n self.cost=cost_new\\n self.con=con_new\\n \\n t2 = time.time()\\n self.time_est0 = t2-t1\\n self.time_iter = t2-t0\\n \\n # Print progress\\n if self.prt_period > 0:\\n if (it % self.prt_period == 0):\\n if self.comp_cost:\\n print(\\\"it={0:4d} cost={1:12.4e} con={2:12.4e} step={3:12.4e}\\\".format(\\\\\\n it, self.cost, self.con, self.step))\\n else:\\n print(\\\"it={0:4d} con={1:12.4e}\\\".format(\\\\\\n it, self.con))\\n \\n # Save history\\n self.save_hist()\",\n \"def cvxpy_solver(self, verbose=False):\\n self.gamma = self._gamma_from_drawdown_control()\\n\\n objective = 0\\n constr = []\\n\\n # weights variable depends on whether there is a risk-free asset in data\\n if self.rf_included is True:\\n # variable with shape h+1 predictions so first row\\n # can be the known (non-variable) portfolio weight at time t\\n weights = cp.Variable(shape=(self.n_preds + 1, self.n_assets))\\n else:\\n # Set rf to zero in all preds and cov\\n self.rets = np.insert(self.rets, self.n_assets, 0, axis=1)\\n self.cov = np.insert(self.cov, self.n_assets, 0, axis=-2)\\n self.cov = np.insert(self.cov, self.n_assets, 0, axis=-1) # Has to be done in two steps for cov due to dims\\n self.start_weights = np.append(self.start_weights, 0)\\n\\n weights = cp.Variable(shape=(self.n_preds + 1, self.n_assets+1))\\n rf_zero_weights = np.zeros(shape=self.n_preds)\\n constr += [weights[1:, -1] == 0] # Keep rf pos at zero since it non-present in this case\\n\\n\\n # Loop through each row in the weights variable and construct the optimization problem\\n # Note this loop is very cpu-light since no actual computations takes place inside it\\n for t in range(1, weights.shape[0]):\\n # sum problem objectives. Weights are shifted 1 period forward compared to self.rets\\n # Concatenates objective and constraints in lists\\n objective += self.single_period_objective_func(weights[t], weights[t-1], self.rets[t-1], self.cov[t-1])\\n constr += self.single_period_constraints(weights[t]) # Concatenate constraints\\n\\n constr += [weights[0] == self.start_weights] # first weights are fixed at known current portfolio\\n\\n prob = cp.Problem(cp.Maximize(objective), constr) # Construct maximization problem\\n prob.solve(solver=cp.ECOS, verbose=verbose)\\n\\n if self.rf_included is True:\\n opt_var = weights.value\\n else:\\n opt_var = weights.value[:, :-1]\\n\\n if verbose is True:\\n print(\\\"Shape of var: \\\", opt_var.shape)\\n temp_df = pd.DataFrame(opt_var).round(3)\\n temp_df['sum_weights'] = np.sum(opt_var, axis=1)\\n print(temp_df)\\n\\n return opt_var[1:] # Discard first row which is not a variable.\",\n \"def iterateRegression(self, plot=True, estimate=False, init_params=None):\\r\\n # Create empty arrays to store values\\r\\n F = np.zeros(len(self.y))\\r\\n a_b = np.zeros((2,len(self.y))) # alphas and betas\\r\\n v = np.zeros(len(self.y))\\r\\n P = np.zeros((len(self.y),2,2))\\r\\n # Initialize at the initial values parsed to the class\\r\\n if estimate == True:\\r\\n self.T = np.array([[init_params[0],0],[0,1]])\\r\\n self.c = np.vstack(([init_params[1],0]))\\r\\n self.R = np.vstack(([init_params[2]],[0]))\\r\\n self.a_start = np.vstack(([self.alpha_mean], [init_params[3]]))\\r\\n P[0,:,:] = self.P_start\\r\\n a_b[:,0:1] = self.a_start\\r\\n # Iterate\\r\\n for t in range(0, len(self.y) - 1):\\r\\n # Slightly different updating equations for KF since we now have regression coefficient\\r\\n v[t] = self.y[t] - np.dot(self.Z[:,t:t+1].T,a_b[:,t]) - self.d\\r\\n F[t] = np.dot(np.dot(self.Z[:,t:t+1].T, P[t]),self.Z[:,t:t+1]) + self.H\\r\\n a_t = a_b[:,t:t+1] + np.dot(P[t],self.Z[:,t:t+1] / F[t]) * v[t]\\r\\n a_b[:,t + 1:t+2] = np.dot(self.T, a_t) + self.c\\r\\n P_t = P[t] - np.dot((np.dot(P[t],self.Z[:,t:t+1]) / F[t]),np.dot(self.Z[:,t:t+1].T, P[t]))\\r\\n P[t + 1,:,:] = np.dot(np.dot(self.T, P_t),self.T.transpose()) + np.dot(self.R * self.Q,self.R.transpose())\\r\\n F[-1] = np.dot(np.dot(self.Z[:,-1:].T, P[-1]),self.Z[:,-1:]) + self.H\\r\\n v[-1] = self.y[-1] - a_b[0,-1:]\\r\\n # Obtain std error of prediction form variance\\r\\n std = np.sqrt((P[:,0,0] * self.H) / (P[:,0,0] + self.H))\\r\\n return a_b, std, P, v, F\",\n \"def update_model_params(self, new_params):\\n new_params = np.array(new_params)\\n self.cmodel.coef_ = new_params\\n\\n # Save model as pkl\\n self._save_model()\",\n \"def compare_coefficients1():\\n directory = \\\"C:\\\\\\\\Users\\\\\\\\Casper\\\\\\\\Projects\\\\\\\\MasterScriptie\\\\\\\\custom_projects\\\\\\\\editing\\\\\\\\PHT_Preprocessing\\\\\\\\out\\\\\\\\{}\\\\\\\\data.csv\\\".format(dataset)\\n\\n X = pd.read_csv(directory)[var_list].to_numpy()[:datapoints_amount]\\n y = np.squeeze(pd.read_csv(directory)[target_list].to_numpy())[:datapoints_amount]\\n \\n X_mean = np.mean(X, axis=0)\\n X_std = np.std(X, axis=0)\\n \\n X_standardized = standardize(X, X_mean, X_std)\\n \\n model = LogisticRegression().fit(X, y) \\n model_standardized = LogisticRegression().fit(X_standardized, y) \\n \\n print(\\\"coefficients \\\", model.coef_)\\n print(\\\"beta coefficients \\\", model_standardized.coef_)\\n \\n for tuple_ in zip(model.coef_[0], X_std):\\n standardized_coef = unstd_to_std_coef2_log(*tuple_)\\n print(standardized_coef)\\n \\n for tuple_ in zip(model_standardized.coef_[0], X_std):\\n unstd_coef = std_to_unstd_coef_log(*tuple_)\\n print(unstd_coef)\\n \\n print(\\\"\\\\nintercept \\\", model.intercept_)\\n print(\\\"coef \\\", unstd_coef)\\n print(\\\"xmean \\\", X_mean)\",\n \"def _getCovMat(self, cov_expr):\\n # store the expression\\n self.expr = cov_expr\\n # create a PETSC matrix for cov_mat\\n cov_mat = PETSc.Mat().create()\\n cov_mat.setType('aij')\\n cov_mat.setSizes(self.domain.getNodes(), self.domain.getNodes())\\n cov_mat.setUp()\\n\\n # scalar valued function is evaluated in this variable\\n cov_ij = np.empty((1), dtype=float)\\n # the points to evalute the expression\\n xycor = np.empty((4), dtype=float)\\n\\n print '---------------------------'\\n print '---------------------------'\\n print ' Building Covariance Matrix'\\n print '---------------------------'\\n print '---------------------------'\\n # Loop through global nodes and build the matrix for i < j because of\\n # symmetric nature.\\n for node_i in range(0, self.domain.getNodes()):\\n # global node node_i\\n for node_j in range(node_i, self.domain.getNodes()):\\n # global node node_j\\n temp_cov_ij = 0\\n for elem_i in self.node_to_elem[node_i]:\\n # elem_i : element attached to node_i\\n # x1 : x co-ordinate of the centroid of element elem_i\\n x1 = self.c_centroid_array[elem_i].x()\\n # y1 : x co-ordinate of the centroid of element elem_i\\n y1 = self.c_centroid_array[elem_i].y()\\n for elem_j in self.node_to_elem[node_j]:\\n # elem_j : element attached to node_j\\n # x2 : x co-ordinate for the centroid of element elem_j\\n x2 = self.c_centroid_array[elem_j].x()\\n # y2 : y co-ordinate for the centroid of element elem_j\\n y2 = self.c_centroid_array[elem_j].y()\\n xycor[0] = x1\\n xycor[1] = x2\\n xycor[2] = y1\\n xycor[3] = y2\\n # evaluate the expression\\n cov_expr.eval(cov_ij, xycor)\\n if cov_ij[0] > 0:\\n temp_cov_ij += (1.0 / 3) * (1.0 / 3) * \\\\\\n cov_ij[0] * \\\\\\n self.c_volume_array[elem_i] * \\\\\\n self.c_volume_array[elem_j]\\n\\n cov_mat.setValue(node_i, node_j, temp_cov_ij)\\n cov_mat.setValue(node_j, node_i, temp_cov_ij)\\n cov_mat.assemblyBegin()\\n cov_mat.assemblyEnd()\\n print '---------------------------'\\n print '---------------------------'\\n print ' Finished Covariance Matrix'\\n print '---------------------------'\\n print '---------------------------'\\n\\n return cov_mat\",\n \"def set_coefficients(cls):\\r\\n \\\"\\\"\\\" EXECUTE THIS FUNCTION IN THE FARM CLASS! \\\"\\\"\\\"\\r\\n\\r\\n # select file names according to airfoil section:\\r\\n if cls.SEC == 1:\\r\\n clfile, cdfile = 'naca0012cl.csv', 'naca0012cd.csv'\\r\\n elif cls.SEC == 2:\\r\\n clfile, cdfile = 'naca0015cl.csv', 'naca0015cd.csv'\\r\\n elif cls.SEC == 3:\\r\\n clfile, cdfile = 'naca0018cl.csv', 'naca0018cd.csv'\\r\\n elif cls.SEC == 4:\\r\\n clfile, cdfile = 'naca0021cl.csv', 'naca0021cd.csv'\\r\\n elif cls.SEC == 5:\\r\\n clfile, cdfile = 'du06w200cl.csv', 'du06w200cd.csv'\\r\\n else:\\r\\n raise Exception('Input error: invalid airfoil section number!')\\r\\n \\r\\n # load arrays of coefficients:\\r\\n CL = np.loadtxt(clfile, delimiter=',')\\r\\n CD = np.loadtxt(cdfile, delimiter=',')\\r\\n\\r\\n # angle of attack and reynolds tables:\\r\\n if cls.SEC != 5:\\r\\n AA = np.loadtxt('nacaaa.csv', unpack=True)\\r\\n RE = np.loadtxt('nacare.csv', unpack=True)\\r\\n else:\\r\\n AA = np.loadtxt('du06w200aa.csv', unpack=True)\\r\\n RE = np.loadtxt('du06w200re.csv', unpack=True) \\r\\n \\r\\n # create functions for lift and drag coefficients:\\r\\n fCL = interp2d(RE, AA, CL, kind='cubic')\\r\\n fCD = interp2d(RE, AA, CD, kind='cubic')\\r\\n \\r\\n # vectorize lift and drag functions:\\r\\n cls.v_fCL, cls.v_fCD = np.vectorize(fCL), np.vectorize(fCD)\",\n \"def __init__(self, coefficients):\\n self.coefficients = coefficients\",\n \"def CreateCoefficientPolyfitTables(self):\\n for currentPr in self.polars:\\n for currentPolar in currentPr[1]:\\n # Combine (Pr, AOA) as a point\\n self.points.append([currentPr[0], currentPolar[0]])\\n\\n # Corresponding to CL, CD and Cm value\\n self.valuesCL.append(currentPolar[1])\\n self.valuesCD.append(currentPolar[2])\\n self.valuesCm.append(currentPolar[3])\\n\\n for Pr in self.Prs:\\n self.AOAs_Pr.append([point[1] for point in self.points if point[0] == Pr])\\n self.CLs_Pr.append([self.valuesCL[i] for i in range(len(self.points)) if self.points[i][0] == Pr])\\n self.CDs_Pr.append([self.valuesCD[i] for i in range(len(self.points)) if self.points[i][0] == Pr])\\n self.Cms_Pr.append([self.valuesCm[i] for i in range(len(self.points)) if self.points[i][0] == Pr])\\n\\n # Fit coefficients to AOAs\\n if self.weightedFit:\\n w = np.array([np.cos((a - 2.5) / 5 * np.pi / 4) for a in self.AOAs_Pr[-1]])\\n # Fit coefficients with weight\\n self.CLfit_Pr.append(np.polyfit(self.AOAs_Pr[-1], self.CLs_Pr[-1],\\n self.CLfitOrder, w=w))\\n self.CDfit_Pr.append(np.polyfit(self.AOAs_Pr[-1], self.CDs_Pr[-1],\\n self.CDfitOrder, w=w))\\n self.Cmfit_Pr.append(np.polyfit(self.AOAs_Pr[-1], self.Cms_Pr[-1],\\n self.CmfitOrder, w=w))\\n\\n else:\\n self.CLfit_Pr.append(np.polyfit(self.AOAs_Pr[-1], self.CLs_Pr[-1], self.CLfitOrder))\\n self.CDfit_Pr.append(np.polyfit(self.AOAs_Pr[-1], self.CDs_Pr[-1], self.CDfitOrder))\\n self.Cmfit_Pr.append(np.polyfit(self.AOAs_Pr[-1], self.Cms_Pr[-1], self.CmfitOrder))\",\n \"def cofiCostFunc(self,params, *args):\\n\\t\\tY, R, num_users, num_products, num_features,l = args[0], args[1],args[2], args[3],args[4],args[5]\\n\\n\\t\\taux = params.reshape((num_products + num_users, num_features))\\n\\n\\t\\tX = aux[0:num_products , :]\\n\\n\\t\\tTheta = aux[num_products:, :] \\n\\n\\t\\ttest = np.dot(X,Theta.transpose())\\n\\t\\ttest = test - Y\\n\\t\\ttest = np.multiply(test , R)\\n\\t\\ttest = np.power(test,2)\\n\\t\\ttest = test.sum()\\n\\t\\ttest = 0.5 * test\\n\\n\\t\\tJ = 0;\\n\\t\\tregularization = (l * 0.5) * np.power(X,2).sum() + np.power(Theta,2).sum()\\n\\n\\t\\tJ = test# + regularization\\n\\n\\t\\treturn J\",\n \"def fit(self, X):\\r\\n\\t\\tself.data = check_array(X)\\r\\n\\t\\tn_var = self.data.shape[1]\\r\\n\\r\\n\\t\\tU = np.arange(n_var)\\r\\n\\t\\tK = []\\r\\n\\t\\tX_ = np.copy(X)\\r\\n\\t\\tfor _ in range(0, n_var):\\r\\n\\t\\t\\tcu_i = self._search_exogenous_x(X_, U)\\r\\n\\t\\t\\tfor i in U:\\r\\n\\t\\t\\t\\tif i != cu_i:\\r\\n\\t\\t\\t\\t\\tX_[:, i] = self._residual( X_[:, i], X_[:, cu_i] )\\r\\n\\t\\t\\tK.append(cu_i)\\r\\n\\t\\t\\tU = U[U != cu_i]\\r\\n\\r\\n\\t\\tself._causal_order = K\\r\\n\\t\\tself._estimate_adjacency_matrix(X)\",\n \"def _compute_coef_determination(self, stimulus, refSamples, targets, C):\\n # instantiate predictions array, first column is prevalence, the following are conditional averages\\n infer_targets = np.zeros(targets.shape)\\n # iterate over stimulus strength\\n for j in range(stimulus.size):\\n infer_targets[j, 0] = infer_prevalence(self.pars, stimulus[j], refSamples, C)\\n infer_targets[j, 1:] = infer_mean(self.pars, stimulus[j], refSamples, C)\\n return rsq(targets.ravel(), infer_targets.ravel())\",\n \"def train(self, prob: SvmProblem):\\n # Define variables\\n self.prob = prob\\n x = prob.X\\n y = prob.Y\\n\\n # Define the inputs to CVXOPT - See Appendix G.3\\n P11 = (prob.xi_xj * prob.yi_yj) + prob.gamma * (prob.xstari_xstarj * prob.yi_yj)\\n P12 = prob.gamma * (prob.xstari_xstarj * prob.yi_yj)\\n P1 = np.hstack((P11, P12))\\n P2 = np.hstack((P12, P12))\\n P = np.vstack((P1, P2))\\n q = np.hstack((np.repeat(-1, prob.num), np.zeros(prob.num)))\\n positive_eye = np.eye(prob.num, dtype='d')\\n negative_eye = -np.eye(prob.num, dtype='d')\\n zeros = np.zeros((prob.num, prob.num))\\n g1 = np.hstack((negative_eye, zeros))\\n g2 = np.hstack((positive_eye, positive_eye))\\n g3 = np.hstack((zeros, negative_eye))\\n G = np.vstack((g1, g2))\\n G = np.vstack((G, g3))\\n h1 = np.zeros((prob.num, 1))\\n h2 = np.repeat((prob.delta * prob.C), prob.num).reshape(-1, 1)\\n h3 = np.repeat(prob.C, prob.num).reshape(-1, 1)\\n h = np.vstack((h1, h2))\\n h = np.vstack((h, h3))\\n A1 = np.hstack((prob.Y, np.zeros(prob.num)))\\n A2 = np.hstack((-prob.Y, -prob.Y))\\n A = np.vstack((A1, A2))\\n b = np.zeros(2)\\n b = b.reshape(-1, 1)\\n\\n P = matrix(P, tc='d')\\n q = matrix(q, tc='d')\\n G = matrix(G, tc='d')\\n h = matrix(h, tc='d')\\n A = matrix(A, tc='d')\\n b = matrix(b, tc='d')\\n\\n # Solve optimization problem using CVXOPT\\n solvers.options['show_progress'] = False\\n sol = solvers.qp(P, q, G, h, A, b)\\n alphas_and_deltas = np.array(sol['x'])\\n self.alphas = np.asarray(alphas_and_deltas[:prob.num])\\n self.deltas = alphas_and_deltas[prob.num:]\\n\\n # Populate Classifier object to be returned\\n clf = Classifier()\\n clf.b = self.get_b\\n clf.alphas = self.alphas\\n clf.xs = x\\n clf.ys = y\\n clf.kern = prob.xkernel\\n return clf\",\n \"def calculateCoefficientsTrainExp(np.ndarray[double, ndim=2, mode=\\\"c\\\"] x_logs not None, np.ndarray[double, ndim=2, mode=\\\"c\\\"] derivatives not None, np.ndarray[double, ndim=1] x_log_eigenvals not None, np.ndarray[double, ndim=2, mode=\\\"c\\\"] coefficients not None):\\n cdef int n, dd, d\\n\\n n, dd = x_logs.shape[0], x_logs.shape[1]\\n d = np.sqrt(dd)\\n \\n\\n out = c_calculateCoefficientsTrainExp (&x_logs[0,0], &derivatives[0,0], &x_log_eigenvals[0], &coefficients[0,0], n, dd, d)\\n\\n return out\",\n \"def main():\\n ###################\\n ## Dataset ##\\n ###################\\n # (X, y) m = 100, n = 1\\n _data_x, data_y = make_regression(n_samples=100, n_features=1, noise=10)\\n\\n # show the dataset\\n plt.subplot(2, 2, 1)\\n plt.title(\\\"dataset\\\")\\n plt.scatter(_data_x, data_y)\\n\\n # Transform the dataset into matrices.\\n # That is used for writing the equations in the matrix form.\\n data_x = np.hstack((_data_x, np.ones(_data_x.shape)))\\n data_y = data_y.reshape(data_y.shape[0], 1)\\n\\n #################\\n ## Model ##\\n #################\\n # initial parameters\\n init_params = np.random.randn(2, 1)\\n\\n # initial model\\n init_model = model(data_x, init_params)\\n\\n # plot initial model\\n plt.subplot(2, 2, 2)\\n plt.title(\\\"initial model\\\")\\n plt.scatter(_data_x, data_y)\\n plt.plot(_data_x, init_model, c='g')\\n\\n #########################\\n ## cost function ##\\n #########################\\n # show cost function for initial parameters\\n print(cost_function(data_x, data_y, init_params))\\n\\n ####################\\n ## training ##\\n ####################\\n # learning rate\\n learn_rate = 0.005\\n # number of iterations\\n number_iterations = 1_000\\n\\n # final parameters for our model\\n final_params, cost_tracking = gradient_descent(\\n data_x, data_y, init_params, learn_rate, number_iterations)\\n\\n # final model\\n final_model = model(data_x, final_params)\\n\\n # show cost function for final parameters\\n print(cost_function(data_x, data_y, final_params))\\n\\n # plot final model\\n plt.subplot(2, 2, 3)\\n plt.title(\\\"final model\\\")\\n plt.scatter(_data_x, data_y)\\n plt.plot(_data_x, final_model, c='r')\\n\\n ##########################\\n ## learning curve ##\\n ##########################\\n # plot Cost history\\n plt.subplot(2, 2, 4)\\n plt.title(\\\"cost tracking\\\")\\n plt.plot(range(number_iterations), cost_tracking)\\n\\n ########################################\\n ## Coefficient of determination ##\\n ########################################\\n print(coefficient_determination(data_y, final_model))\\n\\n plt.show()\",\n \"def BestFit(self,initialParameterValues = None, method = None, fixedParams=None):\\n\\n if fixedParams:\\n if not isinstance(fixedParams, list):\\n fixedParams=[fixedParams]\\n #Check now if the name is correct\\n l_index=[]\\n for index, par in enumerate(fixedParams):\\n pName, pValue = par\\n if pName not in self.theory.parameterNameList0:\\n print \\\"%s is not a valid name. Ignored\\\" %pName\\n l_index.append(index)\\n if l_index:\\n for i in l_index:\\n fixedParams.pop(i)\\n\\n self.theory.SetFixedParams(fixedParams)\\n\\n if initialParameterValues is None:\\n initialParameterValues = self.theory.initialParameterValues\\n #d = numpy.ones(len(initialParamaeterValues))\\n start_time = time.time()\\n if method is None or method == 'lm':\\n out = scipy.optimize.minpack.leastsq(self.Residual,initialParameterValues,full_output=1, ftol=1.e-16)\\n elif method == 'boldAccel':\\n initialParameterValues=numpy.array(initialParameterValues)\\n out = BoldAccel.leastsq(self.Residual,None,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,ibold=0,verbose=True)\\n elif method == 'bold':\\n initialParameterValues = numpy.array(initialParameterValues)\\n out = Bold.leastsq(self.Residual,None,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,ibold=0,verbose=True)\\n #out = minpack.leastsq(self.Residual,self.AnalyJac,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,Cgoal=4.e04)\\n elif method == 'lm_accel':\\n initialParameterValues=numpy.array(initialParameterValues)\\n out = numrec.leastsq(self.Residual,self.AnalyJac,initialParameterValues,full_output=1,verbose=True, flags=[],maxfev=500)\\n else:\\n print \\\"fitting method is not included\\\"\\n out = None\\n end_time = time.time()\\n print \\\"fitting took (mins)\\\", (end_time-start_time)/60.\\n print \\\"number of function evals:\\\", f_counter\\n \\n if fixedParams:\\n outputParameterValues = self.MergeFixedAndVariableParams(fixedParams,out[0])\\n self.theory.SetFixedParams()\\n else:\\n outputParameterValues = out[0]\\n\\n\\n return outputParameterValues, out\",\n \"def solve(self, regparam):\\n self.regparam = regparam\\n \\n #Some counters for bookkeeping\\n self.stepcounter = 0\\n self.flipcounter = 0\\n self.nochangecounter = 0\\n \\n #Cached results\\n self.evals = np.multiply(self.svals, self.svals)\\n self.newevals = 1. / (self.evals + self.regparam)\\n newevalslamtilde = np.multiply(self.evals, self.newevals)\\n self.D = np.sqrt(newevalslamtilde)\\n #self.D = -newevalslamtilde\\n \\n self.VTY = self.svecs.T * self.Y\\n DVTY = np.multiply(self.D.T, self.svecs.T * self.Y)\\n \\n #Using lists in order to avoid unnecessary matrix slicings\\n self.DVTY_list = []\\n self.YTVDDVTY_list = []\\n self.classFitnessList = []\\n for i in range(self.labelcount):\\n DVTY_i = DVTY[:,i]\\n self.DVTY_list.append(DVTY_i)\\n YTVDDVTY_i = DVTY_i.T * DVTY_i\\n self.YTVDDVTY_list.append(YTVDDVTY_i)\\n fitness_i = self.size - DVTY_i.T * DVTY_i\\n self.classFitnessList.append(fitness_i)\\n \\n self.Dsvecs_list = []\\n self.svecsDDsvecs_list = []\\n for i in range(self.size):\\n Dsvec = np.multiply(self.D.T, self.svecs[i].T)\\n self.Dsvecs_list.append(Dsvec)\\n self.svecsDDsvecs_list.append(Dsvec.T*Dsvec)\\n \\n self.updateA()\\n \\n \\n converged = False\\n print(self.classcounts.T)\\n if self.callbackfun is not None:\\n self.callbackfun.callback(self)\\n while True:\\n \\n converged = self.roundRobin()\\n print(self.classcounts.T)\\n if self.callbackfun is not None:\\n self.callbackfun.callback(self)\\n if converged: break\\n \\n if self.oneclass:\\n self.Y = self.Y[:, 0]\\n self.A = self.A[:, 0]\\n self.results['predicted_clusters_for_training_data'] = self.Y\\n self.predictor = self.svdad.createModel(self)\",\n \"def _fit_coefficients(\\n self, cadence_mask=None, prior_mu=None, prior_sigma=None, propagate_errors=False\\n ):\\n\\n # If prior_mu is specified, prior_sigma must be specified\\n if not ((prior_mu is None) & (prior_sigma is None)) | (\\n (prior_mu is not None) & (prior_sigma is not None)\\n ):\\n raise ValueError(\\\"Please specify both `prior_mu` and `prior_sigma`\\\")\\n\\n # Default cadence mask\\n if cadence_mask is None:\\n cadence_mask = np.ones(len(self.lc.flux.value), bool)\\n\\n # If flux errors are not all finite numbers, then default to array of ones\\n if np.all(~np.isfinite(self.lc.flux_err.value)):\\n flux_err = np.ones(cadence_mask.sum())\\n else:\\n flux_err = self.lc.flux_err.value[cadence_mask]\\n\\n # Retrieve the design matrix (X) as a numpy array\\n X = self.dmc.X[cadence_mask]\\n if isinstance(X, np.ndarray):\\n # Compute `X^T cov^-1 X + 1/prior_sigma^2`\\n sigma_w_inv = X.T.dot(X / flux_err[:, None] ** 2)\\n # Compute `X^T cov^-1 y + prior_mu/prior_sigma^2`\\n B = np.dot(X.T, self.lc.flux.value[cadence_mask] / flux_err ** 2)\\n\\n elif issparse(X):\\n sigma_f_inv = csr_matrix(1 / flux_err[:, None] ** 2)\\n # Compute `X^T cov^-1 X + 1/prior_sigma^2`\\n sigma_w_inv = X.T.dot(X.multiply(sigma_f_inv))\\n # Compute `X^T cov^-1 y + prior_mu/prior_sigma^2`\\n B = X.T.dot((self.lc.flux[cadence_mask] / flux_err ** 2))\\n sigma_w_inv = sigma_w_inv.toarray()\\n\\n if prior_sigma is not None:\\n sigma_w_inv = sigma_w_inv + np.diag(1.0 / prior_sigma ** 2)\\n if prior_sigma is not None:\\n B = B + (prior_mu / prior_sigma ** 2)\\n\\n # Solve for weights w\\n w = np.linalg.solve(sigma_w_inv, B).T\\n if propagate_errors:\\n w_err = np.linalg.inv(sigma_w_inv)\\n else:\\n w_err = np.zeros(len(w)) * np.nan\\n\\n return w, w_err\",\n \"def BestFit(self,initialParameterValues=None, method=None , fixedParams=None):\\n\\n if fixedParams:\\n if not isinstance(fixedParams, list):\\n fixedParams=[fixedParams]\\n #Check now if the name is correct\\n l_index=[]\\n for index, par in enumerate(fixedParams):\\n pName, pValue = par\\n if pName not in self.theory.parameterNameList0:\\n print \\\"%s is not a valid name. Ignored\\\" %pName\\n l_index.append(index)\\n if l_index:\\n for i in l_index:\\n fixedParams.pop(i)\\n self.SetFixedParams(fixedParams)\\n\\n if initialParameterValues is None:\\n initialParameterValues = self.theory.initialParameterValues\\n #d = numpy.ones(len(initialParameterValues))\\n start_time = time.time()\\n if method is None or method == 'lm':\\n out = minpack.leastsq(self.Residual,initialParameterValues,full_output=1, ftol=1.e-16)\\n elif method == 'boldAccel':\\n initialParameterValues=numpy.array(initialParameterValues)\\n out = BoldAccel.leastsq(self.Residual,None,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,ibold=0,verbose=True)\\n elif method == 'bold':\\n initialParameterValues = numpy.array(initialParameterValues)\\n out = Bold.leastsq(self.Residual,None,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,ibold=0,verbose=True)\\n #out = minpack.leastsq(self.Residual,self.AnalyJac,initialParameterValues,gtol=1e-8,xtol=1.49e-8,ftol=1e-16,full_output=1,Cgoal=4.e04)\\n elif method == 'lm_accel':\\n initialParameterValues=numpy.array(initialParameterValues)\\n out = numrec.leastsq(self.Residual,self.AnalyJac,initialParameterValues,full_output=1,verbose=True, flags=[],maxfev=500)\\n else:\\n print \\\"fitting method is not included\\\"\\n end_time = time.time()\\n print \\\"fitting took time (mins): \\\", (end_time-start_time)/60.\\n print \\\"number of function_calls:\\\", f_counter\\n \\n if fixedParams:\\n outputParameterValues = self.MergeFixedAndVariableParams(fixedParams,out[0])\\n else:\\n outputParameterValues = out[0]\\n\\n return outputParameterValues, out\",\n \"def _like4(init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoef, i):\\r\\n\\t\\r\\n\\tplx_mod, v, sigma_v = init_par[i], init_par[-4:-1], init_par[-1] \\r\\n\\tp, q, r = normalTriad(alpha, delta)\\r\\n\\tmualpha_mod = np.dot(np.transpose(p),v)*plx_mod/_A ### [mas/yr]\\r\\n\\tmudelta_mod = np.dot(np.transpose(q),v)*plx_mod/_A ### [mas/yr]\\r\\n\\t### Add the model vector for the radial velocities:\\r\\n\\tvrad_mod = np.dot(np.transpose(r),v) ### [km/s]\\r\\n \\t\\r\\n\\tsigma_plx, sigma_mualpha, sigma_mudelta = np.transpose(sigma_obs)\\r\\n\\tC = np.zeros((4,4),dtype=np.float64) ### This is a 4x4 matrix \\r\\n\\t### Diagonal terms:\\r\\n\\tC[0,0],C[1,1],C[2,2] = sigma_plx**2.,sigma_mualpha**2., sigma_mudelta**2.\\r\\n\\tC[3,3] = sigma_vrad**2.\\r\\n\\t\\r\\n\\tr_plx_muRa, r_plx_muDec, r_muRa_muDec = ccoef[0], ccoef[1], ccoef[2] \\r\\n \\r\\n\\t### Correlation terms:\\r\\n\\tC[0,1], C[0,2] = r_plx_muRa*sigma_plx*sigma_mualpha, r_plx_muDec*sigma_plx*sigma_mudelta\\r\\n\\tC[1,0], C[1,2] = r_plx_muRa*sigma_plx*sigma_mualpha, r_muRa_muDec*sigma_mualpha*sigma_mudelta\\r\\n\\tC[2,0], C[2,1] = r_plx_muDec*sigma_plx*sigma_mudelta, r_muRa_muDec*sigma_mualpha*sigma_mudelta\\r\\n\\r\\n\\tE = np.zeros((4,4),dtype=np.float64) ### 4x4 matrix \\r\\n\\tE[1,1],E[2,2] = (sigma_v**2.)*(plx_mod/_A)**2., (sigma_v**2.)*(plx_mod/_A)**2. ### [mas/yr]\\r\\n\\tE[3,3] = sigma_v**2.\\t\\t\\t\\t\\t\\t\\t\\t ### [km/s]\\r\\n\\r\\n\\t\\r\\n\\tD = np.add(E,C)\\r\\n\\tdetD = det(D) \\r\\n\\tinvD = inv(D)\\r\\n\\t\\t\\r\\n\\ta_c = np.array([plx_obs - plx_mod, mualpha_obs - mualpha_mod, mudelta_obs-mudelta_mod, vrad_obs - vrad_mod])\\r\\n\\tg_func = row_matrix_col_4d(a_c, a_c, invD) \\r\\n\\t\\r\\n\\t\\r\\n\\treturn detD, g_func\",\n \"def setCoefficient(self, *args):\\n return _libsbml.FluxObjective_setCoefficient(self, *args)\",\n \"def train(prob: SvmProblem):\\n # Define variables\\n x = prob.X\\n y = prob.Y\\n C = prob.C\\n C2 = prob.gamma\\n\\n # Swap params, so SVM solves X* with correct params\\n xk = prob.xkernel\\n xsk = prob.xskernel\\n\\n prob.C = C2\\n prob.xkernel = xsk\\n\\n svm = SVM()\\n xstar_clf = svm.train(prob.Xstar, prob)\\n\\n # Get distance to decision boundary\\n xi_star = np.zeros(prob.num)\\n for i in range(prob.num):\\n output = (1 - prob.Y[i] * (xstar_clf.f(prob.Xstar[i])))\\n xi_star[i] = max(0, output)\\n\\n # Replace swapped out params so modified SVM solves X with correct params\\n prob.C = C\\n prob.xkernel = xk\\n\\n # Define the inputs to CVXOPT - See Appendix G.4\\n P = prob.yi_yj * prob.xi_xj\\n q = -np.ones((prob.num, 1))\\n G1 = -np.eye(prob.num)\\n G2 = np.eye(prob.num)\\n G3 = xi_star.reshape(1, -1)\\n G = np.vstack((G1, G2))\\n G = np.vstack((G, G3))\\n h1 = np.zeros(prob.num).reshape(-1, 1)\\n h2 = np.repeat((1 + prob.delta) * C, prob.num).reshape(-1, 1)\\n h3 = sum(xi_star) * C\\n h = np.vstack((h1, h2))\\n h = np.vstack((h, h3))\\n A = y.reshape(1, -1)\\n b = np.zeros(1)\\n\\n P = matrix(P, tc='d')\\n q = matrix(q, tc='d')\\n G = matrix(G, tc='d')\\n h = matrix(h, tc='d')\\n A = matrix(A, tc='d')\\n b = matrix(b, tc='d')\\n\\n # Solve optimization problem using CVXOPT\\n solvers.options['show_progress'] = False\\n sol = solvers.qp(P, q, G, h, A, b)\\n alphas = np.array(sol['x'])\\n\\n # Get the bias\\n bacond1 = (alphas > 1e-8)\\n bacond2 = (alphas <= (1 + prob.delta) * C)\\n bcond = np.array([a and b for a, b in zip(bacond1, bacond2)]).flatten()\\n\\n yS = y[bcond]\\n xS = x[bcond]\\n aS = alphas[bcond]\\n\\n sum_total = 0\\n for s in range(len(yS)):\\n inner_total = 0\\n for m in range(len(yS)):\\n am = aS[m]\\n ym = yS[m]\\n xm_xs = prob.xkernel(xS[m], xS[s])\\n inner_total += am * ym * xm_xs\\n sum_total += yS[s] - inner_total\\n\\n bias = sum_total / len(yS)\\n\\n # Populate Classifier object to be returned\\n clf = Classifier()\\n clf.b = bias\\n clf.alphas = alphas\\n clf.xs = x\\n clf.ys = y\\n clf.kern = prob.xkernel\\n return clf\",\n \"def cost(self, X, y) :\\n ### ========== TODO : START ========== ###\\n # part d: compute J(theta)\\n #we know for linear/polynomial regression, the cost is the square of the errors\\n X = self.generate_polynomial_features(X)\\n y_pred_vector = np.dot(X, self.coef_)\\n cost = np.dot((y-y_pred_vector).transpose(),(y-y_pred_vector))#write in the matrix form\\n ### ========== TODO : END ========== ###\\n return cost\",\n \"def optimizer() -> pd.DataFrame:\\n global iteration, coefs_all\\n\\n X_train, X_test, y_train, y_test = train_test()\\n\\n # Number of observations in train & test set\\n n_train = len(X_train)\\n n_test = len(X_test)\\n n_coefs = X_train.shape[1]\\n\\n # Initialize coefficients\\n coefs_init = np.random.normal(\\n loc=conf.coef_mu, \\n scale=conf.coef_sigma, \\n size=n_coefs\\n )\\n coefs_all = coefs_init.copy()\\n\\n # Coefficients shall be bounded\\n bounds = [conf.coef_bounds] * n_coefs\\n iteration = 0\\n\\n # Run optimization\\n result = minimize( \\n fun=lambda x: loss_func(x, X_train, y_train, n_train),\\n callback=lambda x: callback_func(x, X_train, y_train, n_train),\\n x0=coefs_init,\\n bounds=bounds\\n )\\n # Collect optimal coefficients\\n coefs = pd.Series(data=result.x, index=X_train.columns, name=\\\"coefs\\\")\\n coefs_df = pd.DataFrame(data=coefs_all, columns=X_train.columns).T\\n coefs_df.index.name = \\\"area\\\"\\n\\n rmse_train = result.fun\\n rmse_test = loss_func(\\n coefs=coefs, \\n X=X_test, \\n y=y_test, \\n n=n_test, \\n )\\n print(\\\"\\\\n\\\")\\n print (f\\\"Train RMSE: {rmse_train:.4f}\\\")\\n print (f\\\"Test RMSE: {rmse_test:.4f}\\\")\\n\\n return coefs_df\",\n \"def set_fit_params(self):\\n\\n self.p0 = np.array([self.A_arr, self.T_a])\\n # initial guess at A_arr and T_a\\n\\n self.popt, self.pcov = curve_fit(\\n self.get_eta_fit, self.T_exp, self.eta_exp, p0=self.p0\\n )\\n\\n self.A_arr = self.popt[0]\\n self.T_a = self.popt[1]\\n\\n self.T_array = self.T_model\",\n \"def _reform_poly_coefficients(fit_poly_x, fit_poly_y):\\n # Extract values for CD matrix and recombining\\n c11 = fit_poly_x.c1_0.value\\n c12 = fit_poly_x.c0_1.value\\n c21 = fit_poly_y.c1_0.value\\n c22 = fit_poly_y.c0_1.value\\n sip_poly_x = fit_poly_x.copy()\\n sip_poly_y = fit_poly_y.copy()\\n # Force low order coefficients to be 0 as defined in SIP\\n sip_poly_x.c0_0 = 0\\n sip_poly_y.c0_0 = 0\\n sip_poly_x.c1_0 = 0\\n sip_poly_x.c0_1 = 0\\n sip_poly_y.c1_0 = 0\\n sip_poly_y.c0_1 = 0\\n\\n cdmat = ((c11, c12), (c21, c22))\\n invcdmat = npla.inv(np.array(cdmat))\\n degree = fit_poly_x.degree\\n # Now loop through all remaining coefficients\\n for i in range(0, degree + 1):\\n for j in range(0, degree + 1):\\n if (i + j > 1) and (i + j < degree + 1):\\n old_x = getattr(fit_poly_x, f'c{i}_{j}').value\\n old_y = getattr(fit_poly_y, f'c{i}_{j}').value\\n newcoeff = np.dot(invcdmat, np.array([[old_x], [old_y]]))\\n setattr(sip_poly_x, f'c{i}_{j}', newcoeff[0, 0])\\n setattr(sip_poly_y, f'c{i}_{j}', newcoeff[1, 0])\\n\\n return cdmat, sip_poly_x, sip_poly_y\",\n \"def coef_(self):\\n assert self.sess is not None, \\\"Model has not been fitted yet!\\\"\\n return self.sess.run(self.W_lst)[0]\",\n \"def equation(self):\\n mat = np.empty((self.nunknowns, self.model.neq))\\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\\n for icp in range(self.ncp):\\n istart = icp * self.nlayers\\n ieq = 0\\n for e in self.model.elementlist:\\n if e.nunknowns > 0:\\n qx, qy = e.disvecinflayers(self.xc[icp], self.yc[icp], self.layers)\\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\\\\n qx * self.cosnorm[icp] + qy * self.sinnorm[icp] - self.resfac[:, np.newaxis] * \\\\\\n (e.potinflayers(self.xcin[icp], self.ycin[icp], self.layers, aq=self.aq) / self.aq.Tcol[\\n self.layers] - \\\\\\n e.potinflayers(self.xcout[icp], self.ycout[icp], self.layers, aq=self.aq) / self.aq.Tcol[\\n self.layers])\\n ieq += e.nunknowns\\n else:\\n qx, qy = e.disveclayers(self.xc[icp], self.yc[icp], self.layers)\\n rhs[istart:istart + self.nlayers] -= qx * self.cosnorm[icp] + qy * self.sinnorm[icp] + self.resfac * \\\\\\n (e.potentiallayers(self.xcin[icp], self.ycin[icp], self.layers,\\n aq=self.aq) / self.aq.T[self.layers] -\\n e.potentiallayers(self.xcout[icp], self.ycout[icp],\\n self.layers, aq=self.aq) / self.aq.T[\\n self.layers])\\n return mat, rhs\",\n \"def update_cov_chol(self):\\n log_precision_target = self.downscale.parameter_log_precision_target\\n gp_target = self.downscale.parameter_gp_target\\n # update the covariance matrix for each parameter\\n for i in range(self.n_parameter):\\n # calculate the cholesky of the gram matrix (sometimes referred to\\n # as the kernel matrix)\\n cov_chol = -self.downscale.square_error.copy()\\n gp_scale = gp_target.scale_gp_state[i]\\n cov_chol /= 2 * math.pow(gp_scale, 2)\\n cov_chol = np.exp(cov_chol)\\n cov_chol += np.identity(self.area_unmask) * self.small_covariance\\n cov_chol = linalg.cholesky(cov_chol, True)\\n # scale the cholesky matrix by a precision\\n cov_chol *= math.exp(\\n -0.5*log_precision_target.log_precision_state[i])\\n self.cov_chol_array[i] = cov_chol\",\n \"def __call__(self): \\n m = np.zeros((len(self.observation),))\\n k = np.zeros((len(self.observation), len(self.prior)))\\n \\n sv = self.stateVector\\n m = sv[0] * np.exp(-(self.independentVariable/sv[1])) + sv[2]\\n \\n k[:, 0] = np.exp(-(self.independentVariable/sv[1]))\\n k[:, 1] = (sv[0] * self.independentVariable * \\n np.exp(-(self.independentVariable/sv[1]))/(sv[1])**2)\\n k[:, 2] = np.ones((len(self.observation),))\\n \\n self.modelCalculation, self.Jacobian = m, k\\n \\n return m, k\",\n \"def coefficients(self):\\r\\n return self.coef_['x']\",\n \"def fit(self, kernel=GaussianKernel(sigma=1.0), regularizer=1.0, sparsifiers=None):\\n\\n self.q = np.array((regularizer + kernel(self.x[0], self.x[0])) ** (-1))\\n self.coefficients = np.array([self.q * self.y[0]])\\n self.coefficient_history = [self.coefficients]\\n\\n self._estimate = np.zeros(self.y.shape)\\n self.support_vectors = np.array([self.x[0]]).reshape(-1, 1)\\n self.error_history = [0]\\n\\n self.kernel = kernel\\n\\n for i in range(1, self.n):\\n self.regressor = self.x[i]\\n\\n self.h = kernel(self.support_vectors, self.regressor).T\\n self.z = np.dot(self.q, self.h)\\n self.r = regularizer + kernel(self.x[i], self.x[i]) - np.dot(self.z, self.h)\\n\\n self.estimate[i] = np.dot(self.h.T, self.coefficients)\\n self.error = self.y[i] - self.estimate[i]\\n self.error_history.append(self.error)\\n\\n self.coefficients -= self.z * self.r ** (-1) * self.error\\n self.coefficient_history.append(self.coefficients)\\n\\n if sparsifiers:\\n for sparsifier in sparsifiers:\\n sparsifier.apply(self)\\n\\n else:\\n self.q = self.q * self.r + np.outer(self.z, self.z.T)\\n q_row = np.asarray(-self.z).reshape(-1, 1).T\\n q_col = np.asarray(-self.z).reshape(-1, 1)\\n q_end = np.array([1]).reshape(-1, 1)\\n\\n self.q = np.append(self.q, q_row, axis=0)\\n self.q = np.append(self.q, np.concatenate((q_col, q_end), axis=0), axis=1)\\n self.q = self.r ** (-1) * self.q\\n\\n self.support_vectors = np.vstack((self.support_vectors, self.regressor.reshape(1, -1)))\\n self.coefficients = np.append(self.coefficients, self.r ** (-1) * self.error)\",\n \"def adjust_cost(self) -> None:\\n\\n n_iterations = self.array.shape[-1]\\n n_year = len(self.array.year.values)\\n\\n # If uncertainty is not considered, the cost factor equals 1.\\n # Otherwise, a variability of +/-30% is added.\\n\\n if n_iterations == 1:\\n cost_factor = 1\\n else:\\n if \\\"reference\\\" in self.array.value.values.tolist():\\n cost_factor = np.ones((n_iterations, 1))\\n else:\\n cost_factor = np.random.triangular(0.7, 1, 1.3, (n_iterations, 1))\\n\\n # Correction of hydrogen tank cost, per kg\\n # Correction of fuel cell stack cost, per kW\\n if \\\"FCEV\\\" in self.array.powertrain:\\n self.array.loc[\\n dict(powertrain=\\\"FCEV\\\", parameter=\\\"fuel tank cost per kg\\\")\\n ] = np.reshape(\\n (1.078e58 * np.exp(-6.32e-2 * self.array.year.values) + 3.43e2)\\n * cost_factor,\\n (1, n_year, n_iterations),\\n )\\n\\n self.array.loc[\\n dict(powertrain=\\\"FCEV\\\", parameter=\\\"fuel tank cost per kg\\\")\\n ] = np.reshape(\\n (3.15e66 * np.exp(-7.35e-2 * self.array.year.values) + 2.39e1)\\n * cost_factor,\\n (1, n_year, n_iterations),\\n )\\n\\n # Correction of energy battery system cost, per kWh\\n list_batt = [\\n i\\n for i in [\\\"BEV\\\", \\\"PHEV-e\\\", \\\"PHEV-c-p\\\", \\\"PHEV-c-d\\\"]\\n if i in self.array.powertrain\\n ]\\n if len(list_batt) > 0:\\n self.array.loc[\\n dict(powertrain=list_batt, parameter=\\\"energy battery cost per kWh\\\")\\n ] = np.reshape(\\n (2.75e86 * np.exp(-9.61e-2 * self.array.year.values) + 5.059e1)\\n * cost_factor,\\n (1, 1, n_year, n_iterations),\\n )\\n\\n # Correction of power battery system cost, per kW\\n list_pwt = [\\n i\\n for i in [\\n \\\"ICEV-p\\\",\\n \\\"ICEV-d\\\",\\n \\\"ICEV-g\\\",\\n \\\"PHEV-c-p\\\",\\n \\\"PHEV-c-d\\\",\\n \\\"FCEV\\\",\\n \\\"HEV-p\\\",\\n \\\"HEV-d\\\",\\n ]\\n if i in self.array.powertrain\\n ]\\n\\n if len(list_pwt) > 0:\\n self.array.loc[\\n dict(powertrain=list_pwt, parameter=\\\"power battery cost per kW\\\")\\n ] = np.reshape(\\n (8.337e40 * np.exp(-4.49e-2 * self.array.year.values) + 11.17)\\n * cost_factor,\\n (1, 1, n_year, n_iterations),\\n )\\n\\n # Correction of combustion powertrain cost for ICEV-g\\n if \\\"ICEV-g\\\" in self.array.powertrain:\\n self.array.loc[\\n dict(powertrain=\\\"ICEV-g\\\", parameter=\\\"combustion powertrain cost per kW\\\")\\n ] = np.clip(\\n np.reshape(\\n (5.92e160 * np.exp(-0.1819 * self.array.year.values) + 26.76)\\n * cost_factor,\\n (1, n_year, n_iterations),\\n ),\\n None,\\n 100,\\n )\",\n \"def train(self):\\n\\n for i in range(self.c):\\n mu_i = self.estimate_mu(i).T\\n cov_i = self.estimate_sigma(i, mu_i)\\n inv_sigma_i = np.linalg.inv(cov_i)\\n P_i = self.estimate_P(i)\\n Wi = -1 / 2 * inv_sigma_i\\n wi = inv_sigma_i @ mu_i\\n wi0 = -1 / 2 * mu_i.T @ inv_sigma_i @ mu_i - 1 / 2 * np.log(np.linalg.det(cov_i)) + np.log(P_i)\\n self.weights.append([Wi, wi, wi0])\\n return self.weights\",\n \"def claret_linear(mu, coeff):\\n return 1.0 - coeff * (1.0 - mu)\",\n \"def fit(self, X):\\n if self.precomputedW is None:\\n self.output(\\\"Creating combined loadings ...\\\")\\n self.precomputedW = self.computeGloballyJointW(X)\\n self.output(\\\"Combined loadings created!\\\")\\n\\n ok = True\\n okPred = True\\n\\n self.output(\\\"Filtering matrices ...\\\")\\n n = len(X)\\n Wo = [None] * n\\n To = [None] * n\\n Po = [None] * n\\n ssX = [0] * n\\n for i in range(n):\\n Xi = X[i]\\n gjWi = self.precomputedW[i]\\n ssX[i] = utils.sumOfSquares(Xi)\\n\\n # If we have no vectors here, we have no predictive model for\\n # this matrix, and thus no overlapping variation either:\\n if gjWi.shape[1] < 1:\\n continue\\n\\n for c in range(self.orth_comp[i]):\\n Ti = np.dot(Xi, gjWi) # Recall that Wi'*Wi = I\\n # Any row vector in E represents a possible wortho vector\\n Ei = Xi - np.dot(Ti, gjWi.T)\\n Wortho = np.dot(Ti.T, Ei)\\n\\n if utils.sumOfSquares(Wortho) / ssX[i] < consts.TOLERANCE:\\n self.warn(\\\"No more orthogonal components appear to \\\"\\n \\\"exist for matrix %d! Trying anyway!\\\" % (i,))\\n\\n pca = PCA(1, eps=self.eps, max_iter=self.max_iter)\\n pca.fit(Wortho)\\n wortho = pca.P\\n # We can also use Ei here. Doesn't matter.\\n tortho = np.dot(Xi, wortho)\\n portho = np.dot(Xi.T, tortho)\\n toto = np.dot(tortho.T, tortho)[0, 0]\\n # Avoid division by zero by defining 0 / 0 = 0\\n if toto > consts.TOLERANCE:\\n portho = portho / toto\\n else:\\n self.warn(\\\"Too small orthogonal component for matrix %d! \\\"\\n \\\"Not included!\\\" % (i,))\\n break\\n\\n # It has been discussed whether or not to normalise portho\\n# normpo = np.linalg.norm(portho)\\n# tortho = tortho * normpo\\n# portho = portho / normpo\\n\\n if utils.sumOfSquares(\\n np.dot(tortho, portho.T)) / ssX[i] < consts.LIMIT_R2:\\n self.warn(\\\"Too small orthogonal component for matrix %d! \\\"\\n \\\"Not included!\\\" % (i,))\\n ok = False\\n break\\n\\n if self.verbose == 3:\\n self.output(\\\"Matrix %d, orthogonal component %d, \\\"\\n \\\"T'*to overlap: %f, norm po: %f, \\\"\\n \\\"R2(to*po'): %f\\\"\\n % (i, c, np.dot(tortho.T,\\n np.dot(np.dot(Ti, Ti.T),\\n tortho)),\\n np.linalg.norm(portho),\\n utils.sumOfSquares(\\n np.dot(tortho, portho.T) / ssX[i])))\\n\\n # Filter matrix by removing orthogonal variation:\\n Xi = Xi - np.dot(tortho, portho.T)\\n\\n # Save results\\n if Wo[i] is None:\\n Wo[i] = wortho\\n else:\\n Wo[i] = np.hstack((Wo[i], wortho))\\n if To[i] is None:\\n To[i] = tortho\\n else:\\n To[i] = np.hstack((To[i], tortho))\\n if Po[i] is None:\\n Po[i] = portho\\n else:\\n Po[i] = np.hstack((Po[i], portho))\\n\\n X[i] = Xi\\n self.output(\\\"Matrices filtered!\\\")\\n\\n self.output(\\\"Building globally joint OnPLS model ...\\\")\\n W = [None] * n\\n T = [None] * n\\n P = [None] * n\\n ftot = 0.0\\n numGlobalPredComp = utils.leastNonZero(self.pred_comp)\\n for comp in range(numGlobalPredComp):\\n self.output(\\\"Calculating component %d ...\\\" % (comp + 1,))\\n\\n # Select the best of self.numReps models\\n fMax = -np.inf\\n for i in range(self.numReps):\\n # Find filtered nPLS component:\\n # TODO: Precompute A!\\n npls = nPLS(self.pred_comp)\\n npls.fit(X)\\n _Wx = npls.W\\n _Tx = npls.T\\n _Px = npls.P\\n its = npls.num_iter\\n func_val = npls.func_val\\n # TODO: Use nPLS.f(...) instead:\\n s = np.sum(utils.sumOfCovariances(_Tx, self.pred_comp))\\n if i == 0 or s > fMax:\\n fMax = s\\n Wx = _Wx\\n Tx = _Tx\\n Px = _Px\\n\\n # Obtain \\\"convergence error\\\" (difference between two last its)\\n if len(func_val) > 1:\\n maxerr = func_val[-1] - func_val[-2]\\n else:\\n maxerr = 0.0\\n\\n # Compute this component for each block\\n f = 0.0\\n for i in range(n):\\n\\n # Too many iterations, or not converged?\\n if its >= consts.MAX_ITER or maxerr >= consts.TOLERANCE:\\n okPred = False\\n\\n self.warn(\\\"Component %d may not be correct or is \\\"\\n \\\"non-significant, the number of iterations \\\"\\n \\\"was: %d (maxiter=%d), error is: %.3g \\\"\\n \\\"(noiselevel=%.3g).\\\"\\n % (comp, its, consts.MAX_ITER, maxerr,\\n consts.TOLERANCE))\\n\\n # Can also update with W but that gives non-orthogonal scores!\\n # TODO: Option?\\n temp = np.dot(Tx[i], Px[i].T)\\n\\n # Compute SS of this component for this block. Large enough?\\n ssTemp = utils.sumOfSquares(temp)\\n if ssTemp / ssX[i] < consts.LIMIT_R2:\\n okPred = False\\n\\n if comp >= 1:\\n\\n # Remove already saved results\\n for j in range(i):\\n try:\\n W[j] = W[j][:, :comp]\\n except:\\n pass\\n try:\\n T[j] = T[j][:, :comp]\\n except:\\n pass\\n try:\\n P[j] = P[j][:, :comp]\\n except:\\n pass\\n\\n self.warn(\\\"Component is not significant! Contribution \\\"\\n \\\"of component %d in matrix %d is \\\"\\n \\\"%.2f %% < 1 %%. Not included!\\\"\\n % (comp, i, 100 * ssTemp / ssX[i]))\\n break\\n else:\\n self.warn(\\\"Component is not significant! Contribution \\\"\\n \\\"of component %d in matrix %d is \\\"\\n \\\"%.2f %% < 1 %%. Warning, was included!\\\"\\n % (comp, i, 100 * ssTemp / ssX[i]))\\n\\n # Save results\\n if W[i] is None:\\n W[i] = Wx[i]\\n else:\\n W[i] = np.hstack((W[i], Wx[i]))\\n if T[i] is None:\\n T[i] = Tx[i]\\n else:\\n T[i] = np.hstack((T[i], Tx[i]))\\n if P[i] is None:\\n P[i] = Px[i]\\n else:\\n P[i] = np.hstack((P[i], Px[i]))\\n\\n # Deflate joint variation from matrix\\n X[i] = X[i] - temp\\n\\n # TODO: Create method for objective function\\n for j in range(n):\\n if self.pred_comp[i][j] > 0:\\n f = f + np.dot(Tx[i].T, Tx[j])\\n\\n # If we have at least one component already, we can stop here\\n if comp > 0 and (not okPred):\\n break\\n\\n ftot = ftot + f\\n self.output(\\\"DONE! f = %.8f\\\" % (f,))\\n\\n # Save model\\n self.Wo = Wo\\n self.To = To\\n self.Po = Po\\n self.W = W\\n self.T = T\\n self.P = P\\n\\n numGlobalPredComp = self.T[0].shape[1]\\n self.output(\\\"OnPLS model created with %d components! ftot = %f\\\"\\n % (numGlobalPredComp, ftot))\\n\\n return self\",\n \"def acoeff(self):\\n return np.dot(self.mmi,np.dot(self.mmatrix.T,self.bvec))\",\n \"def __update(self):\\n\\n # Make sure loads have been assigned to group\\n if type(self.appliedLoad) == Load:\\n self.appliedLoad = LoadSet(self.appliedLoad)\\n elif type(self.appliedLoad) != LoadSet:\\n raise TypeError(\\\"Applied load must be a Load or LoadSet\\\")\\n\\n # Begin Calculations\\n _cg = self.cg # calculate the cg once to save computation time\\n _appLoad = self.appliedLoad.totalForce\\n _appMoment = self.appliedLoad.totalMoment\\n\\n coef_mat = np.zeros((len(self) * 3, len(self) * 3)) # coeff matrix\\n soln_mat = np.zeros(len(self) * 3) # solution matrix\\n\\n cSet = [[i, i+1, i+2] for i in range(0, 3 * len(self), 3)]\\n rSet = [[i+6, i+7, i+8] for i in range(0, 3 * (len(self) - 2), 3)]\\n\\n for i, j in enumerate(cSet):\\n # i = column fastener ID\\n # j = column fastener set\\n # Mx = yFz - zFy\\n # My = zFx - xFz\\n # Mz = xFy - yFx\\n\\n Fx = j[0]\\n Fy = j[1]\\n Fz = j[2]\\n\\n # fill in first three rows\\n coef_mat[0][Fx] = 1 # sum of Fx\\n coef_mat[1][Fy] = 1 # sum of Fy\\n coef_mat[2][Fz] = 1 # sum of Fz\\n\\n # fill in fourth row (sum of Mx at CG)\\n coef_mat[3][Fy] = -(F[i].xyz[2] - _cg[2]) # -zFy\\n coef_mat[3][Fz] = +(F[i].xyz[1] - _cg[1]) # +yFz\\n\\n # fill in fifth row (sum of My at CG)\\n coef_mat[4][Fx] = +(F[i].xyz[2] - _cg[2]) # +zFx\\n coef_mat[4][Fz] = -(F[i].xyz[0] - _cg[0]) # -xFz\\n\\n # fill in sixth row (sum of Mz at CG)\\n coef_mat[5][Fx] = -(F[i].xyz[1] - _cg[1]) # -yFx\\n coef_mat[5][Fy] = +(F[i].xyz[0] - _cg[0]) # +xFy\\n\\n for u, w in enumerate(rSet):\\n # u = row fastener ID\\n # w = row fastener set\\n\\n rX = w[0]\\n rY = w[1]\\n rZ = w[2]\\n\\n coef_mat[rX][Fy] = -(F[i].xyz[2] - F[u].xyz[2]) # -zFy\\n coef_mat[rX][Fz] = +(F[i].xyz[1] - F[u].xyz[1]) # +yFz\\n\\n coef_mat[rY][Fx] = +(F[i].xyz[2] - F[u].xyz[2]) # +zFx\\n coef_mat[rY][Fz] = -(F[i].xyz[0] - F[u].xyz[0]) # -xFz\\n\\n coef_mat[rZ][Fx] = -(F[i].xyz[1] - F[u].xyz[1]) # -yFx\\n coef_mat[rZ][Fy] = +(F[i].xyz[0] - F[u].xyz[0]) # +xFy\\n\\n # fill in the solution matrix (soln_mat)\\n for i in range(3):\\n soln_mat[i] = -_netLoad.force[i]\\n soln_mat[i+3] = -_netLoad.moment[i]\\n\\n # fill in the remaining rows\\n for i, j in enumerate(rSet):\\n # i = fastener\\n # j = row\\n\\n rX = j[0]\\n rY = j[1]\\n rZ = j[2]\\n\\n # Mx = (y_cg - y_i)F_znet - (z_cg - z_i)F_ynet + M_xnet\\n soln_mat[rX] = - ((_cg[1] - F[i].xyz[1]) * _netLoad.force[2]\\n - (_cg[2] - F[i].xyz[2]) * _netLoad.force[1]\\n + _netLoad.moment[0])\\n\\n # My = (z_cg - z_i)F_xnet - (x_cg - x_i)F_znet + M_ynet\\n soln_mat[rY] = -((_cg[2] - F[i].xyz[2]) * _netLoad.force[0]\\n - (_cg[0] - F[i].xyz[0]) * _netLoad.force[2]\\n + _netLoad.moment[1])\\n\\n # Mz = (x_cg - x_i)F_ynet - (y_cg - y_i)F_xnet + M_znet\\n soln_mat[rZ] = -((_cg[0] - F[i].xyz[0]) * _netLoad.force[1]\\n - (_cg[1] - F[i].xyz[1]) * _netLoad.force[0]\\n + _netLoad.moment[2])\\n\\n # Solve system of equations\\n matSol = np.linalg.lstsq(coef_mat, soln_mat)[0]\\n\\n # Add resulting fastener loads to fastener objects\\n for i, j in enumerate(cSet):\\n rX = j[0]\\n rY = j[1]\\n rZ = j[2]\\n\\n F[i].force[0] = matSol[rX]\\n F[i].force[1] = matSol[rY]\\n F[i].force[2] = matSol[rZ]\",\n \"def get_cost_updates(self):\\n\\n y = self.get_hidden_values()\\n z = self.get_reconstructed_input(y)\\n\\n L = T.sum((self.x-z)**2, axis=1)\\n\\n cost = T.mean(L)\\n\\n return cost\",\n \"def solver_mtw(Xf, mXf, Ls, y, M, alpha, beta1, beta2, epsilon, gamma, coef1,\\n coef2, R, b1, b2, sigmas, concomitant=False,\\n stable=False, tol=1e-4, max_iter=1000, tol_ot=1e-5,\\n max_iter_ot=20, max_iter_cd=2000,\\n positive=False, n_jobs=1, tol_cd=1e-5, gpu=False,\\n ot_threshold=0):\\n log = {'loss': [], 'dloss': [], 'log_sinkhorn1': [], 'log_sinkhorn2': [],\\n 'stable': stable, \\\"objcd\\\": [], \\\"fot1\\\": [0.], \\\"fot2\\\": [0.],\\n 'reweighting_loss': [], \\\"n_coords\\\": [], \\\"obj\\\": 0.}\\n n_samples, n_features = Xf[0].shape\\n n_tasks = len(Xf)\\n if n_jobs == -1:\\n n_jobs = n_tasks\\n marginals1, marginals2 = np.ones((2, n_tasks, n_features)) / n_features\\n\\n theta1 = coef1.copy()\\n theta2 = coef2.copy()\\n theta = theta1 - theta2\\n\\n thetaold = theta.copy()\\n\\n ot_img = True\\n if len(M) == n_features:\\n ot_img = False\\n\\n update_ot_1 = set_ot_func(stable, ot_img)\\n update_ot_2 = set_ot_func(stable, ot_img)\\n\\n xp = utils.set_module(gpu)\\n M = xp.asarray(- M / epsilon)\\n if b1 is not None:\\n b1 = xp.asarray(b1)\\n if b2 is not None:\\n b2 = xp.asarray(b2)\\n\\n thetabar1 = np.ones_like(coef1).mean(axis=-1)\\n thetabar2 = np.ones_like(coef2).mean(axis=-1)\\n\\n if positive:\\n theta2 *= 0.\\n thetabar2 *= 0.\\n theta = theta1\\n a = n_samples * alpha * gamma\\n beta1 = n_samples * beta1\\n beta2 = n_samples * beta2\\n\\n if concomitant:\\n sigma0 = 0.01 * np.linalg.norm(y, axis=1).min() / (n_samples ** 0.5)\\n else:\\n sigma0 = 0.\\n with Parallel(n_jobs=n_jobs, backend=\\\"threading\\\") as pll:\\n if alpha == 0.:\\n theta, R, sigmas, mx = update_coefs(pll, Xf, y, theta, R,\\n Ls, marginals1,\\n sigmas, a, beta1,\\n sigma0,\\n tol=tol_cd,\\n max_iter=max_iter_cd,\\n positive=positive)\\n obj = 0.5 * (R ** 2).sum(axis=1).dot(1 / sigmas) / n_samples\\n obj += beta1 * abs(theta).sum() + 0.5 * sigmas.sum()\\n theta1, theta2 = utils.get_unsigned(theta)\\n log['loss'].append(obj)\\n else:\\n for i in range(max_iter):\\n obj = 0.\\n if not positive:\\n Y1 = utils.residual(Xf, - theta2, y)\\n else:\\n Y1 = y\\n theta1, R, sigmas, mxp = update_coefs(pll, Xf, Y1, theta1, R,\\n Ls,\\n marginals1,\\n sigmas,\\n a, beta1,\\n sigma0,\\n tol=tol_cd,\\n max_iter=max_iter_cd)\\n if not positive:\\n Y2 = utils.residual(Xf, theta1, y)\\n theta2, R, sigmas, mx = update_coefs(pll, mXf, Y2, theta2,\\n R,\\n Ls,\\n marginals2,\\n sigmas,\\n a, beta2,\\n sigma0,\\n tol=tol_cd,\\n max_iter=max_iter_cd)\\n theta = theta1 - theta2\\n else:\\n theta = theta1\\n\\n dx = abs(theta - thetaold) / max(1, thetaold.max(),\\n theta.max())\\n dx = dx.max()\\n thetaold = theta.copy()\\n if alpha:\\n if (theta1 > ot_threshold).any(0).all():\\n fot1, log_ot1, marginals1, b1, q1 = \\\\\\n update_ot_1(theta1, M, epsilon, gamma,\\n b=b1, tol=tol_ot,\\n max_iter=max_iter_ot,\\n threshold=ot_threshold)\\n if fot1 is None or not theta1.max(0).all():\\n warnings.warn(\\\"Numerical errors. Moving in \\\"\\n \\\"log-domain.\\\")\\n b1 = xp.log(b1 + 1e-100, out=b1)\\n stable = True\\n update_ot_1 = set_ot_func(True, ot_img)\\n fot1, log_ot1, marginals1, b1, q1 = \\\\\\n update_ot_1(theta1, M, epsilon, gamma, b=b1,\\n tol=tol_ot, max_iter=max_iter_ot,\\n threshold=ot_threshold)\\n\\n log[\\\"log_sinkhorn1\\\"].append(log_ot1)\\n thetabar1 = q1\\n log[\\\"fot1\\\"].append(fot1)\\n obj += alpha * fot1\\n if not positive and (theta2 > ot_threshold).any(0).all():\\n fot2, log_ot2, marginals2, b2, q2 = \\\\\\n update_ot_2(theta2, M, epsilon, gamma,\\n b=b2, tol=tol_ot, max_iter=max_iter_ot)\\n\\n if fot2 is None or not theta2.max(0).all():\\n warnings.warn(\\\"Numerical errors. Moving in \\\"\\n \\\"log-domain.\\\")\\n b2 = xp.log(b2 + 1e-100, out=b2)\\n stable = True\\n update_ot_2 = set_ot_func(True, ot_img)\\n fot2, log_ot2, marginals2, b2, q2 = \\\\\\n update_ot_2(theta2, M, epsilon, gamma,\\n b=b2, tol=tol_ot,\\n max_iter=max_iter_ot)\\n\\n log[\\\"log_sinkhorn2\\\"].append(log_ot2)\\n thetabar2 = q2\\n log[\\\"fot2\\\"].append(fot2)\\n obj += alpha * fot2\\n\\n log['loss'].append(obj)\\n log['dloss'].append(dx)\\n\\n if dx < tol:\\n break\\n if i == max_iter - 1:\\n warnings.warn('Objective did not converge.' +\\n ' You might want' +\\n ' to increase the number of iterations.' +\\n ' Fitting data with very small alpha and' +\\n ' beta may cause precision problems.',\\n ConvergenceWarning)\\n log['stable'] = stable\\n\\n if positive:\\n theta2 *= 0.\\n thetabar2 = xp.zeros_like(thetabar1)\\n try:\\n thetabar2 = thetabar2.get()\\n except AttributeError:\\n pass\\n return (theta1, theta2, thetabar1, thetabar2, log, sigmas, b1, b2, R)\",\n \"def get_Objective(self):\\r\\n \\r\\n ans = 0\\r\\n for i in range(len(self.X.shape)):\\r\\n ans += self.parameter['phi'][i] * self.parameter['lambda1'] *norm(tl.unfold(self.Wlist[i], i), 'nuc') + (1 / self.parameter['m']) * norm(tl.unfold(self.X - self.Wlist[i] - self.V, i))\\r\\n\\r\\n # Augmented part is calculated seperately. \\r\\n augment_part1 = 0.5 * self.parameter['rho1'] * norm(self.V - self.T + self.F1)\\r\\n augment_part2 = 0.5 * self.parameter['rho2'] * norm(tl.fold(np.dot(self.Dmatrix, tl.unfold(self.T, 0)), 0, self.T.shape) - self.S + self.F2)\\r\\n\\r\\n # Combine the result for final objective function\\r\\n ans += self.parameter['beta1'] * norm(self.V.reshape(self.totaldim), 1) + self.parameter['beta2'] * norm(self.S.reshape(self.totaldim), 1) + augment_part1 + augment_part2 \\r\\n return ans\",\n \"def estimate_params(self, data, setToZero=None):\\n\\t\\t\\n\\t\\tn = np.sum(data[\\\"len\\\"])\\n\\n\\t\\tX = np.zeros(shape=(n,self.nStateFeatures),dtype=np.float32)\\n\\t\\tA = np.zeros(shape=(n,self.actionDim),dtype=np.float32)\\n\\n\\t\\ti = 0\\n\\t\\tfor ep_n,ep_len in enumerate(data[\\\"len\\\"]):\\n\\t\\t\\tX[i:i+ep_len] = data[\\\"s\\\"][ep_n][0:ep_len]\\n\\t\\t\\tA[i:i+ep_len] = data[\\\"a\\\"][ep_n][0:ep_len]\\n\\t\\t\\ti += ep_len\\n\\n\\t\\tif setToZero is not None:\\n\\t\\t\\tX = np.delete(X,setToZero,1)\\n\\t\\t\\n\\t\\tself.params = np.linalg.lstsq(X, A, rcond=None)[0].T\\n\\t\\t#print(self.params)\\n\\t\\t#print(np.dot(np.dot(np.linalg.inv(np.dot(X.T,X)),X.T),A).T)\\n\\n\\t\\tif setToZero is not None:\\n\\t\\t\\tself.params = np.insert(self.params,setToZero,0,1)\\n\\n\\t\\treturn self.params\",\n \"def update(self, z):\\n\\n Hjac = self._mat_desc[\\\"Hjac\\\"]\\n H = self._mat_desc[\\\"H\\\"];\\n zpred = self._measurement_model(self._state_vec_prev , H)\\n\\n innovation = z - zpred\\n P = self._mat_desc[\\\"P\\\"]\\n Hjac_T = Hjac.T\\n R = self._mat_desc[\\\"R\\\"]\\n M = self._mat_desc[\\\"M\\\"]\\n M_T = M.T\\n S = Hjac * P * Hjac_T + M * R * M_T\\n S_inv = np.linalg.inv(S)\\n self._mat_desc[\\\"K\\\"] = P * Hjac_T * S_inv\\n self._state_vec += self._mat_desc[\\\"K\\\"] * innovation\\n I = np.identity(self._state_vec.shape)\\n\\n # update the covariance matrix\\n P = (I - self._mat_desc[\\\"K\\\"] * Hjac) * P\\n self._mat_desc[\\\"P\\\"] = P\",\n \"def costFunction(self):\\n priorDiff = np.matrix(self.model.stateVector - self.model.prior).T\\n measurementDiff = np.matrix(self.model.observation\\n - self.model.modelCalculation).T\\n chisq = measurementDiff.T * self.errSinv * measurementDiff\\n chisq += priorDiff.T * self.priorSinv * priorDiff\\n \\n return chisq[0,0]\",\n \"def _like3(init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, sigma_obs, ccoef, i):\\r\\n\\r\\n\\tplx_mod, v, sigma_v = init_par[i], init_par[-4:-1], init_par[-1] \\r\\n\\tp, q, r = normalTriad(alpha, delta)\\r\\n\\tmualpha_mod = np.dot(np.transpose(p),v)*plx_mod/_A\\r\\n\\tmudelta_mod = np.dot(np.transpose(q),v)*plx_mod/_A\\r\\n \\t\\r\\n\\tsigma_plx, sigma_mualpha, sigma_mudelta = sigma_obs\\r\\n\\tr_plx_muRa, r_plx_muDec, r_muRa_muDec = ccoef[0], ccoef[1], ccoef[2] \\r\\n\\t\\r\\n\\tC = np.zeros((3,3),dtype=np.float64)\\r\\n\\tC[0,0],C[1,1],C[2,2] = sigma_plx**2.,sigma_mualpha**2., sigma_mudelta**2.\\r\\n\\tC[0,1], C[0,2] = r_plx_muRa*sigma_plx*sigma_mualpha, r_plx_muDec*sigma_plx*sigma_mudelta\\r\\n\\tC[1,0], C[1,2] = r_plx_muRa*sigma_plx*sigma_mualpha, r_muRa_muDec*sigma_mualpha*sigma_mudelta\\r\\n\\tC[2,0], C[2,1] = r_plx_muDec*sigma_plx*sigma_mudelta, r_muRa_muDec*sigma_mualpha*sigma_mudelta\\r\\n\\r\\n\\tE = np.zeros((3,3),dtype=np.float64)\\r\\n\\tE[1,1],E[2,2] = (sigma_v**2.)*(plx_mod/_A)**2., (sigma_v**2.)*(plx_mod/_A)**2.\\r\\n\\t\\r\\n\\tD = np.add(E,C)\\r\\n\\tdetD = det(D) \\r\\n\\tinvD = inv(D)\\r\\n\\t\\t\\r\\n\\ta_c = np.array([plx_obs - plx_mod, mualpha_obs - mualpha_mod, mudelta_obs-mudelta_mod])\\r\\n\\tg_func = row_matrix_col(a_c, a_c, invD)\\r\\n\\t\\r\\n\\t\\r\\n\\treturn detD, g_func\",\n \"def _update_Y_C_Mz(self, hyperparam):\\n\\n if numpy.isscalar(hyperparam):\\n hyperparam_ = numpy.array([hyperparam], dtype=float)\\n else:\\n hyperparam_ = hyperparam\\n\\n # Check if likelihood is already computed for an identical hyperparam\\n if (self.Y is None) or \\\\\\n (self.Cinv is None) or \\\\\\n (self.C is None) or \\\\\\n (self.Mz is None) or \\\\\\n (self.Y_C_Mz_hyperparam is None) or \\\\\\n (hyperparam_.size != self.Y_C_Mz_hyperparam.size) or \\\\\\n (not numpy.allclose(hyperparam_, self.Y_C_Mz_hyperparam,\\n atol=self.hyperparam_tol)):\\n\\n # hyperparameters\\n eta = self._hyperparam_to_eta(hyperparam_)\\n\\n # Include derivative w.r.t scale\\n if (not numpy.isscalar(hyperparam_)) and \\\\\\n (hyperparam_.size > self.scale_index):\\n\\n # Set scale of the covariance object\\n scale = self._hyperparam_to_scale(\\n hyperparam_[self.scale_index:])\\n self.mixed_cor.set_scale(scale)\\n\\n # Variables to compute/update. Note that in all variables, sigma\\n # is factored out. For example, self.B is indeed B1 = B/(sigma**2),\\n # and self.C here is C1 = C/(sigma**2). That is, B and C denoted in\\n # this code are B1 and C1 of the notations used in the paper.\\n self.Y = self.mixed_cor.solve(self.X, eta=eta)\\n self.Cinv = numpy.matmul(self.X.T, self.Y) + self.Binv\\n self.C = numpy.linalg.inv(self.Cinv)\\n self.Mz = self.M_dot(self.C, self.Y, eta, self.z)\\n\\n # Update the current hyperparam\\n self.Y_C_Mz_hyperparam = hyperparam_\",\n \"def fit(self, X, Y):\\n\\n def one_vs_all(house): return [1 if y == house else 0 for y in Y]\\n\\n self.theta = []\\n X = np.insert(X, 0, 1, axis=1)\\n m = Courses.m\\n theta_nb = len(X[0])\\n\\n for house in range(4):\\n y_ova = one_vs_all(house)\\n theta = np.zeros(theta_nb)\\n for _ in range(self.iterations):\\n theta -= self.gradient_descent(X, theta, y_ova, m)\\n self.theta.append(theta)\",\n \"def buildObjective(self):\\r\\n\\r\\n # self.z_prior might be the modified version\\r\\n self.L_elbo = T.mean(self.reconst + self.conditional_prior + self.w_prior + self.z_prior)\\r\\n\\r\\n self.L_elbo_modif = T.mean(self.reconst + self.conditional_prior + self.w_prior_modif + self.z_prior_modif)\\r\\n\\r\\n #---Getting model parameter---#\\r\\n cg = ComputationGraph(self.L_elbo)\\r\\n #self.phi_theta is the list of all the parameters in q and p.\\r\\n self.params = VariableFilter(roles=[PARAMETER])(cg.variables)\",\n \"def yfit(self):\\n return np.dot(self.amatrix,self.acoeff)\",\n \"def _create_coefficients(self) -> npt.NDArray[np.complex_ | np.float_]:\\n _logger.info(\\n f\\\"Slepian eigenvalue {self.rank}: \\\"\\n f\\\"{self.mesh_slepian.slepian_eigenvalues[self.rank]:e}\\\",\\n )\\n s_p_i = self.mesh_slepian.slepian_functions[self.rank]\\n return sleplet.slepian_methods.slepian_mesh_forward(\\n self.mesh_slepian,\\n u_i=s_p_i,\\n )\",\n \"def fit(self, X, y):\\n self.x_values = X\\n self.y_values = y\\n self.gradient_descent(self.coefficients, X, y)\",\n \"def update(self, z):\\n y = z - np.dot(self.measurement_matrix, self.x)\\n\\n innovation_covariance = np.dot(\\n self.measurement_matrix, np.dot(self.prediction_covariance, self.measurement_matrix.T)\\n ) + self.measurement_covariance\\n\\n optimal_kalman_gain = np.dot(\\n np.dot(self.prediction_covariance, self.measurement_matrix.T),\\n np.linalg.inv(innovation_covariance)\\n )\\n\\n self.x = self.x + np.dot(optimal_kalman_gain, y)\\n eye = np.eye(self.state_size)\\n _t1 = eye - np.dot(optimal_kalman_gain, self.measurement_matrix)\\n t1 = np.dot(np.dot(_t1, self.prediction_covariance), _t1.T)\\n t2 = np.dot(np.dot(optimal_kalman_gain, self.measurement_covariance), optimal_kalman_gain.T)\\n self.prediction_covariance = t1 + t2\",\n \"def LeastSquareParametersFit(self,params0,inclination_data=None):\\n\\t\\tnpl = self.Observations.nplanets\\n\\t\\tif len(params0.reshape(-1)) == npl * 5:\\n\\t\\t\\tcoplanar = True\\n\\t\\telif len(params0.reshape(-1)) == npl * 7:\\n\\t\\t\\tcoplanar = False\\n\\t\\telse:\\n\\t\\t\\tprint(\\\"Shape of initial parameter does not match what is required for the number of planets!\\\")\\n\\t\\t\\traise\\n\\t\\t\\t\\n\\t\\ttarget_data = np.array([])\\n\\t\\terrors = np.array([])\\n\\t\\t\\n\\t\\tfor time,err in zip(self.Observations.transit_times,self.Observations.transit_uncertainties):\\n\\t\\t\\ttarget_data = np.append(target_data,time)\\n\\t\\t\\terrors = np.append(errors,err)\\n\\t\\t\\n\\t\\ttFinal = self.Observations.tFinal() + np.max(self.Observations.PeriodEstimates)\\n\\t\\t\\n\\t\\tdef objectivefn(x):\\n\\t\\t\\t\\n\\t\\t\\tif coplanar:\\n\\t\\t\\t\\ttransits,success = self.MCMC_CoplanarParam_TransitTimes(x,tFinal)\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttransits,success = self.MCMC_Param_TransitTimes(x,tFinal)\\n\\t\\t\\tif\\tinclination_data:\\n\\t\\t\\t\\t\\tassert not coplanar, \\\"Inclination data should not be include for coplanar fits\\\"\\n\\t\\t\\t\\t\\tcosi = np.abs( np.cos( x.reshape(-1,7)[:,4] ) )\\n\\t\\t\\t\\t\\tcosi0 = inclination_data[0]\\n\\t\\t\\t\\t\\tcosi_err = inclination_data[0]\\n\\t\\t\\t\\t\\tinc_chi2 = (cosi - cosi0) / cosi_err\\n\\t\\t\\t\\n\\t\\t\\tanswer = np.array([],dtype=float)\\n\\t\\t\\tfor i,t in enumerate(transits):\\n\\t\\t\\t\\ttnums = self.Observations.transit_numbers[i]\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tanswer = np.append( answer,np.array(t[tnums]) )\\n\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\treturn -np.inf * np.ones(len(target_data))\\n\\t\\t\\t#\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tttvchi2 = (answer - target_data)/errors\\n\\t\\t\\texcept:\\n\\t\\t\\t\\treturn -np.inf * np.ones(len(target_data))\\n\\t\\t\\t\\n\\t\\t\\tif inclination_data:\\n\\t\\t\\t\\treturn np.append(ttvchi2,inc_chi2)\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn ttvchi2\\n\\t\\t\\n\\t\\treturn leastsq(objectivefn, params0,full_output=1)\",\n \"def train(x, prob: SvmProblem):\\n\\n # Define the inputs to CVXOPT - See Appendix G.1\\n P = np.zeros((prob.num, prob.num))\\n for i in range(prob.num):\\n for j in range(prob.num):\\n P[i][j] = prob.Y[i] * prob.Y[j] * prob.xkernel(x[i], x[j])\\n q = -np.ones((prob.num, 1))\\n G1 = -np.eye(prob.num)\\n G2 = np.eye(prob.num)\\n G = np.vstack((G1, G2))\\n h1 = np.zeros(prob.num).reshape(-1, 1)\\n h2 = np.repeat(prob.C, prob.num).reshape(-1, 1)\\n h = np.vstack((h1, h2))\\n a = prob.Y.reshape(1, -1)\\n b = np.zeros(1)\\n\\n P = matrix(P, tc='d')\\n q = matrix(q, tc='d')\\n G = matrix(G, tc='d')\\n h = matrix(h, tc='d')\\n A = matrix(a, tc='d')\\n b = matrix(b, tc='d')\\n\\n # Solve optimization problem using CVXOPT\\n solvers.options['show_progress'] = False\\n sol = solvers.qp(P, q, G, h, A, b)\\n alphas = np.array(sol['x'])\\n\\n # Get the bias\\n bacond1 = (alphas > 1e-8)\\n bacond2 = (alphas <= prob.C)\\n bcond = np.array([a and b for a, b in zip(bacond1, bacond2)]).flatten()\\n yS = prob.Y[bcond]\\n xS = x[bcond]\\n aS = alphas[bcond]\\n sum_total = 0\\n for s in range(len(yS)):\\n inner_total = 0\\n for m in range(len(yS)):\\n am = aS[m]\\n ym = yS[m]\\n xm_xs = prob.xkernel(xS[m], xS[s])\\n inner_total += am * ym * xm_xs\\n sum_total += yS[s] - inner_total\\n bias = sum_total / len(yS) if len(yS) > 0 else [0]\\n\\n # Populate Classifier object to be returned\\n clf = Classifier()\\n clf.b = bias[0]\\n clf.alphas = alphas\\n clf.xs = x\\n clf.ys = prob.Y\\n clf.kern = prob.xkernel\\n clf.support_vectors = x[bacond1.flatten()]\\n return clf\",\n \"def calibrate(self, master):\\n if master.polyorder == 'linear':\\n self.fitfunction = \\\"A0 + A1 * D\\\"\\n self.fit_fkt = self.calc_lin\\n elif master.polyorder == 'quadratic':\\n self.fit_fkt = self.calc_quad\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2\\\"\\n elif master.polyorder == \\\"cubic\\\":\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2 + A3 * D**3\\\"\\n self.fit_fkt = self.calc_cubic\\n else:\\n print(\\\"Polynomgrad nicht definiert\\\")\\n \\n self.mw = np.asarray(self.mw)\\n if master.sensortype == \\\"Druck\\\":\\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\\n else:\\n print(\\\"Sensortyp noch nicht Hinterlegt\\\")\",\n \"def update_coeff(self, **kwargs: float) -> None:\\n for rule_name, coeff in kwargs.items():\\n if rule_name not in self.rules:\\n raise ValueError(f\\\"Behavioral rule {rule_name} does not exist\\\")\\n else:\\n self.rules[getattr(self, rule_name)] = coeff\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68213785","0.6568729","0.650561","0.63846326","0.6240839","0.60767925","0.60576737","0.6055638","0.5992137","0.5891918","0.5859752","0.58514315","0.58382076","0.5834185","0.58303267","0.5815064","0.58032453","0.5801474","0.5786988","0.57689154","0.5750727","0.5748894","0.5735946","0.57114196","0.5701099","0.56886363","0.56867296","0.5681767","0.5677477","0.56534487","0.56388414","0.56355214","0.5633109","0.56314045","0.5616408","0.5610408","0.56070733","0.5604736","0.5602756","0.5601693","0.5596225","0.5594635","0.55891436","0.5582251","0.5576138","0.5568768","0.55611336","0.5560937","0.5557131","0.5552895","0.5545569","0.55304927","0.5523926","0.552271","0.5510181","0.5506158","0.5499075","0.54892486","0.5483363","0.54814756","0.5480293","0.5469719","0.54688007","0.54601556","0.54560286","0.54500324","0.5446629","0.544332","0.5438156","0.5434424","0.54323584","0.5432136","0.54282254","0.5428145","0.5425244","0.54173464","0.5415329","0.54120094","0.5410716","0.53928125","0.53916574","0.5388077","0.5385425","0.53831434","0.53809106","0.5380546","0.53798336","0.5377336","0.53756434","0.5369362","0.5369139","0.53629977","0.536101","0.5359996","0.5357928","0.53524375","0.53492063","0.53490895","0.5344537","0.5344122"],"string":"[\n \"0.68213785\",\n \"0.6568729\",\n \"0.650561\",\n \"0.63846326\",\n \"0.6240839\",\n \"0.60767925\",\n \"0.60576737\",\n \"0.6055638\",\n \"0.5992137\",\n \"0.5891918\",\n \"0.5859752\",\n \"0.58514315\",\n \"0.58382076\",\n \"0.5834185\",\n \"0.58303267\",\n \"0.5815064\",\n \"0.58032453\",\n \"0.5801474\",\n \"0.5786988\",\n \"0.57689154\",\n \"0.5750727\",\n \"0.5748894\",\n \"0.5735946\",\n \"0.57114196\",\n \"0.5701099\",\n \"0.56886363\",\n \"0.56867296\",\n \"0.5681767\",\n \"0.5677477\",\n \"0.56534487\",\n \"0.56388414\",\n \"0.56355214\",\n \"0.5633109\",\n \"0.56314045\",\n \"0.5616408\",\n \"0.5610408\",\n \"0.56070733\",\n \"0.5604736\",\n \"0.5602756\",\n \"0.5601693\",\n \"0.5596225\",\n \"0.5594635\",\n \"0.55891436\",\n \"0.5582251\",\n \"0.5576138\",\n \"0.5568768\",\n \"0.55611336\",\n \"0.5560937\",\n \"0.5557131\",\n \"0.5552895\",\n \"0.5545569\",\n \"0.55304927\",\n \"0.5523926\",\n \"0.552271\",\n \"0.5510181\",\n \"0.5506158\",\n \"0.5499075\",\n \"0.54892486\",\n \"0.5483363\",\n \"0.54814756\",\n \"0.5480293\",\n \"0.5469719\",\n \"0.54688007\",\n \"0.54601556\",\n \"0.54560286\",\n \"0.54500324\",\n \"0.5446629\",\n \"0.544332\",\n \"0.5438156\",\n \"0.5434424\",\n \"0.54323584\",\n \"0.5432136\",\n \"0.54282254\",\n \"0.5428145\",\n \"0.5425244\",\n \"0.54173464\",\n \"0.5415329\",\n \"0.54120094\",\n \"0.5410716\",\n \"0.53928125\",\n \"0.53916574\",\n \"0.5388077\",\n \"0.5385425\",\n \"0.53831434\",\n \"0.53809106\",\n \"0.5380546\",\n \"0.53798336\",\n \"0.5377336\",\n \"0.53756434\",\n \"0.5369362\",\n \"0.5369139\",\n \"0.53629977\",\n \"0.536101\",\n \"0.5359996\",\n \"0.5357928\",\n \"0.53524375\",\n \"0.53492063\",\n \"0.53490895\",\n \"0.5344537\",\n \"0.5344122\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65043694"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":83687,"cells":{"query":{"kind":"string","value":"This node matches the predicted matrix with the observed data, but \"masks\" predicted matrix so that we are only using entries that were actually observed from the matrix. Weights the resulting matrix by 1/sigma^2."},"document":{"kind":"string","value":"def __init__(self, mask, data, sigma):\n assert isinstance(sigma, int)\n assert sigma > 0.0\n assert isinstance(mask, utils.Mask)\n assert isinstance(data, np.ndarray)\n assert mask.size == data.size\n self.mask = mask\n self.data = data\n self.sigma = sigma\n self.shape = self.mask.shape\n\n self.weight_mat = self.mask.inv(np.repeat(1.0/sigma**2, self.mask.size))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def predict(self, masked_data, masked_binary_data):\n # Use the loaded model to perform missing value prediction.\n # concatenate multiple students' knowledge state into a matrix of shape (num_students, num_concepts)\n predicted_states = []\n for u in range(len(self.model.mrfs)):\n predicted_states.append(self.model.mrfs[u].correct_probs.numpy())\n predicted_states = np.array(predicted_states)\n\n predictions = self.model.predict(torch.from_numpy(predicted_states).to(device))\n\n return predictions","def filter_predict(filtered_state_mean, filtered_state_covariance,\n transition_matrix, transition_covariance):\n predicted_state_mean = np.dot(transition_matrix, filtered_state_mean)\n predicted_state_covariance = (np.dot(transition_matrix,\n np.dot(filtered_state_covariance,\n transition_matrix.T))\n + transition_covariance)\n\n return (predicted_state_mean, predicted_state_covariance)","def postprocessing(self, prediction, prob_thresh=0.5):\n prob_map = self._np_sigmoid(prediction)\n prob_map = self._np_merge_prediction(prob_map)\n if self.resize :\n prob_map = self._np_resize_image(prob_map,\n self.orig_size,\n dtype='float')\n mask = self._np_get_mask(prob_map, prob_thresh=prob_thresh)\n return mask","def _apply_correction(self):\n np.copyto(self.network.weights, self.correction_matrix)","def predict(self, x, reset=True, verbose=False):\n Nu = self.manifold.log_map(x0_mat=self.manifold_mu0, X_mat=x)\n return super().predict(x=Nu, reset=reset, verbose=verbose)","def predict_mask(logit, EMPTY_THRESHOLD, MASK_THRESHOLD):\n #pred mask 0-1 pixel-wise\n #n = logit.shape[0]\n IMG_SIZE = logit.shape[-1] #256\n #EMPTY_THRESHOLD = 100.0*(IMG_SIZE/128.0)**2 #count of predicted mask pixles<threshold, predict as empty mask image\n #MASK_THRESHOLD = 0.22\n #logit = torch.sigmoid(torch.from_numpy(logit)).view(n, -1)\n #pred = (logit>MASK_THRESHOLD).long()\n #pred[pred.sum(dim=1) < EMPTY_THRESHOLD, ] = 0 #bug here, found it, the bug is input shape is (256, 256) not (16,256,256)\n logit = sigmoid(logit)#.reshape(n, -1)\n pred = (logit>MASK_THRESHOLD).astype(np.int)\n if pred.sum() < EMPTY_THRESHOLD:\n return np.zeros(pred.shape).astype(np.int)\n else:\n return pred","def set_redundant_linker_to_avergae(self, modified_matrix):\n modified_matrix[:, 0:self.selex_predict_str_adaptor, :] = 0.25\n modified_matrix[:, self.selex_str_len - self.selex_predict_str_adaptor:self.selex_str_len, :] = 0.25\n return modified_matrix","def get_remat(self) -> ndarray:\n return self.data.weight[:, None]*self.revar.mapping.mat","def apply_mask(mask_matrix_df, original_matrix_df):\n\n print(\"Applying the mask ...\")\n\n original_matrix_columns = list(original_matrix_df)\n original_matrix_rows = list(original_matrix_df.index)\n\n mask_array = mask_matrix_df.to_numpy()\n original_array = original_matrix_df.to_numpy().astype(float)\n\n\n # Note: np.nan cannot be inserted into an array of type int. The array needs to be float.\n np.putmask(original_array, mask_array, np.nan)\n\n\n after_masking_df = pd.DataFrame(original_array, columns=original_matrix_columns, index=original_matrix_rows)\n return after_masking_df","def _predicted(self):\n return np.matmul(self.x, self.solution)","def reconstruct(mask, y_pred, pixels):\n\n # change mask so that cancer prediction is gone (ie prevent cheating)\n for pi in range(256):\n for pj in range(256):\n if int(round(mask[pi, pj])) == 2:\n mask[pi, pj] = 1\n\n # insert the actual prediction\n for p, pixel in enumerate(pixels):\n pixel_x = pixel[0]\n pixel_y = pixel[1]\n # set the new mask pixel to the predicted score, moving 0 -> 1 (prostate, not cancer)\n # and 1 -> 2 (prostate, cancer)\n mask[pixel_x, pixel_y] = y_pred[p] + 1\n\n return mask","def infectedToRecovered(self):\n\n # initialize a random matrix where around recovery_probability % of the values are True\n recover_prob_arr = np.random.rand(self.space.shape[0],self.space.shape[1]) < self.recovery_probability\n # find the overlap between infected and above array and make those people recovered\n self.space[np.logical_and(self.space == 1, recover_prob_arr)] = 2","def warmup_predict(model, imgs, Npred):\n H = augmented_state_matrix(model[:-1], imgs, 0)\n h0 = H[-2]\n y0 = imgs[-1]\n return predict(model, y0, h0, Npred)","def forward(self, node_hidden, edge_hidden, adj_matrix, mask):\n out_scores, in_scores = None, None\n for layer in self.layers:\n node_hidden, edge_hidden = layer(node_hidden, edge_hidden, adj_matrix, mask)\n return self.norm(node_hidden)","def predict_only(self):","def predict(self, x, reset=True, window_result=False, **kwargs):\n Nu = self.manifold.log_map(x0_mat=self.manifold_mu0, X_mat=x)\n return super().predict(x=Nu, reset=reset, window_result=window_result, **kwargs)","def adjusted_matrix(self):\n mat = AlignerExtract().transform_matrix(self.aligned[\"matrix\"],\n self.aligned[\"size\"],\n self.aligned[\"padding\"])\n return mat","def _predict(self):\n \n # Initialization\n x_k = np.random.rand(4,0)\n w_k = np.ones((1,0))\n \n self.reset(phd_only=True)\n \n # Prediction of the targets' positions\n for k in range(1, self.n_time_steps+1):\n\n if k in self.observed_data.keys():\n\n # perform phd filter\n\n x_k1, w_k1, estimated_x_k1, n_targ_pred = self.PHDfilter(x_k, w_k, self.observed_data[k], k)\n\n # save predicted positions and update parameters\n self.phd_filter['n_targets_predicted'][k] = n_targ_pred\n self.phd_filter['particles_positions'][k] = x_k1\n if estimated_x_k1 is not None:\n self.phd_filter['estimated_positions'][k] = estimated_x_k1\n x_k, w_k = np.copy(x_k1), np.copy(w_k1)\n\n else:\n self.phd_filter['n_targets_predicted'][k] = 0","def mask_sensitivy(Y, Y_pred): \n cm = confusion_matrix(Y.reshape(-1), Y_pred.reshape(-1))\n return sensitivity(cm)","def maskByModel(self, model, sigma=3, pixel_start=30, pixel_end=-10):\n\t\tpixel = np.delete(np.arange(len(self.oriWave)),self.mask)[pixel_start: pixel_end]\n\t\tcustom_mask2 = pixel[np.where(np.abs(self.flux-model.flux) > sigma*np.std(self.flux-model.flux))]\n\t\tprint(custom_mask2)\n\t\tcustom_mask2 = np.append(custom_mask2, np.array(self.mask))\n\t\tcustom_mask2.sort()\n\t\tcustom_mask2 = custom_mask2.tolist()\n\t\tself.mask_custom(custom_mask2)","def postprocess_model_outputs(self, predictions, expected):\n\n predictions = {k: t.numpy() for k, t in predictions.items()}\n\n return predictions, expected","def predict(X, W):\n # This is the sigma_i w_i * x_i but using all data in X\n preds = sigmoid_activation(X.dot(W))\n\n preds[preds <= 0.5] = 0\n preds[preds > 0.5] = 1 # this might be >0.5, but I think it is 0 since prev line has set to 0 some positions\n return preds","def loss_mmse(y_true, y_pred, y_mask):\n y_shape = tf.shape(y_true)\n border = 3\n max_pixels_shifts = 2*border\n size_image = HR_SIZE\n size_croped_image = size_image - max_pixels_shifts\n clear_pixels = size_croped_image*size_croped_image\n cropped_predictions = y_pred[:, border:size_image -\n border, border:size_image-border]\n\n X = []\n for i in range(max_pixels_shifts+1): # range(7)\n for j in range(max_pixels_shifts+1): # range(7)\n cropped_labels = y_true[:, i:i+(size_image-max_pixels_shifts),\n j:j+(size_image-max_pixels_shifts)]\n cropped_y_mask = y_mask[:, i:i+(size_image-max_pixels_shifts),\n j:j+(size_image-max_pixels_shifts)]\n\n cropped_y_mask = tf.cast(cropped_y_mask, tf.float32)\n\n cropped_predictions_masked = cropped_predictions*cropped_y_mask\n cropped_labels_masked = cropped_labels*cropped_y_mask\n\n total_pixels_masked = tf.reduce_sum(cropped_y_mask, axis=[1, 2])\n\n # bias brightness\n b = (1.0/total_pixels_masked)*tf.reduce_sum(\n tf.subtract(cropped_labels_masked, cropped_predictions_masked),\n axis=[1, 2])\n\n b = tf.reshape(b, [y_shape[0], 1, 1, 1])\n\n corrected_cropped_predictions = cropped_predictions_masked+b\n corrected_cropped_predictions = corrected_cropped_predictions*cropped_y_mask\n\n corrected_mse = (1.0/total_pixels_masked)*tf.reduce_sum(\n tf.square(\n tf.subtract(cropped_labels_masked,\n corrected_cropped_predictions)\n ), axis=[1, 2])\n X.append(corrected_mse)\n\n X = tf.stack(X)\n minim = tf.reduce_min(X, axis=0)\n return minim","def predict(self, data):\r\n x = []\r\n x.append(data.sampled_matrix())\r\n x = np.array(x)\r\n x = np.reshape(x, (x.shape[0], x.shape[1], 1))\r\n\r\n result = self.model.predict(x)\r\n return result","def predict(self, prediction_matrix: np.ndarray) -> np.ndarray:\n prediction_matrix = np.moveaxis(prediction_matrix, 0, -1)\n softmax_scores = self.model.predict(prediction_matrix)\n\n return np.argmax(softmax_scores, axis=-1)","def HeatmapLoss(pred, gt, masks):\n assert pred.size() == gt.size()\n l = ((pred - gt)**2) * masks[:, None, :, :].expand_as(pred)\n l = l.mean(dim=3).mean(dim=2).mean(dim=1)\n return l","def predict_noiseless(self, Xnew, full_cov=False, kern=None):\n # Predict the latent function values\n mu, var = self._raw_predict(Xnew, full_cov=full_cov, kern=kern)\n\n # Un-apply normalization\n if self.normalizer is not None:\n mu, var = self.normalizer.inverse_mean(mu), self.normalizer.inverse_variance(var)\n\n return mu, var","def _reclassify_accumulation(\n landuse_transition_from_matrix, landuse_transition_to_matrix,\n accumulation_rate_matrix):\n output_matrix = numpy.empty(landuse_transition_from_matrix.shape,\n dtype=numpy.float32)\n output_matrix[:] = NODATA_FLOAT32_MIN\n\n valid_pixels = numpy.ones(landuse_transition_from_matrix.shape,\n dtype=bool)\n if from_nodata is not None:\n valid_pixels &= ~utils.array_equals_nodata(\n landuse_transition_from_matrix, from_nodata)\n\n if to_nodata is not None:\n valid_pixels &= ~utils.array_equals_nodata(\n landuse_transition_to_matrix, to_nodata)\n\n output_matrix[valid_pixels] = accumulation_rate_matrix[\n landuse_transition_from_matrix[valid_pixels],\n landuse_transition_to_matrix[valid_pixels]].toarray().flatten()\n return output_matrix","def mask_out(self, x, lengths):\n params = self.params\n slen, bs = x.size()\n\n # define target words to predict\n if params.sample_alpha == 0:\n pred_mask = np.random.rand(slen, bs) <= params.word_pred\n pred_mask = torch.from_numpy(pred_mask.astype(np.uint8))\n else:\n x_prob = params.mask_scores[x.flatten()]\n n_tgt = math.ceil(params.word_pred * slen * bs)\n tgt_ids = np.random.choice(len(x_prob), n_tgt, replace=False, p=x_prob / x_prob.sum())\n pred_mask = torch.zeros(slen * bs, dtype=torch.uint8)\n pred_mask[tgt_ids] = 1\n pred_mask = pred_mask.view(slen, bs)\n\n # do not predict padding\n pred_mask[x == params.pad_index] = 0\n pred_mask[0] = 0 # TODO: remove\n\n # mask a number of words == 0 [8] (faster with fp16)\n if params.fp16:\n pred_mask = pred_mask.view(-1)\n n1 = pred_mask.sum().item()\n n2 = max(n1 % 8, 8 * (n1 // 8))\n if n2 != n1:\n pred_mask[torch.nonzero(pred_mask).view(-1)[:n1 - n2]] = 0\n pred_mask = pred_mask.view(slen, bs)\n # assert pred_mask.sum().item() % 8 == 0\n\n # generate possible targets / update x input\n pred_mask = pred_mask.bool()\n _x_real = x[pred_mask]\n if len(_x_real) == 0:\n pred_mask[0, 0] = 1\n _x_real = x[pred_mask]\n _x_rand = _x_real.clone().random_(params.n_words)\n _x_mask = _x_real.clone().fill_(params.mask_index)\n probs = torch.multinomial(params.pred_probs, len(_x_real), replacement=True)\n _x = _x_mask * (probs == 0).long() + _x_real * (probs == 1).long() + _x_rand * (probs == 2).long()\n x = x.masked_scatter(pred_mask, _x)\n\n assert 0 <= x.min() <= x.max() < params.n_words\n assert x.size() == (slen, bs)\n assert pred_mask.size() == (slen, bs)\n\n return x, _x_real, pred_mask","def predict_transparent(self, observation, state=None, mask=None, deterministic=False):\n policy_out = self._get_policy_out(observation, state, mask, transparent=True,\n deterministic=deterministic)\n actions, _val, states, _neglogp, data = policy_out\n return actions, states, data","def predict(self, new_data):\r\n trans, rotation = new_data.image_transformation_from(self.last_data) \r\n \r\n R = np.array([[np.cos(self.att2D), -np.sin(self.att2D)],[np.sin(self.att2D), np.cos(self.att2D)]])\r\n if not np.any(np.isnan(trans)):\r\n self.pos2D = self.pos2D + R.dot(trans[0:2] - self.bias[0:2])\r\n self.att2D = self.att2D + rotation.as_euler('zxy')[0] - self.bias[2]\r\n else:\r\n self.pos2D = self.mapdata.attitude.apply(new_data.gps_pos - self.mapdata.gps_pos)[0:2]\r\n self.att2D = rotation_proj(self.mapdata.attitude, new_data.attitude).as_euler(\"zxy\")[0]\r\n \r\n F = np.array([[1, 0, -np.sin(self.att2D)*(trans[0] - self.bias[0])-np.cos(self.att2D)*(trans[1] - self.bias[1])],\r\n [0, 1, np.cos(self.att2D)*(trans[0] - self.bias[0])-np.sin(self.att2D)*(trans[1] - self.bias[1])],\r\n [0, 0, 1]])\r\n M = np.block([[R, np.zeros((2,1))],[np.zeros(2), 1]])\r\n if self.bias_estimation:\r\n F = np.block([[F, np.block([[-R, np.zeros((2,1))],[np.zeros(2), -1]])],[np.zeros((3,3)), np.eye(3)]])\r\n M = np.block([[M], [np.zeros((3,3))]])\r\n self.P = F.dot(self.P).dot(F.T) + M.dot(self.Q).dot(M.T)\r\n else:\r\n self.P = F.dot(self.P).dot(F.T) + M.dot(self.Q).dot(M.T)","def rescale(data_matrix):\n means, stdevs = scale(data_matrix)\n\n def rescaled(i, j):\n if stdevs[j] > 0:\n return (data_matrix[i][j] - means[j]) / stdevs[j]\n else:\n return data_matrix[i][j]\n\n num_rows, num_cols = shape(data_matrix)\n return make_matrix(num_rows, num_cols, rescaled)","def update(self, predicted, target):\n predicted = predicted.detach().cpu().numpy()\n target = target.detach().cpu().numpy()\n\n assert predicted.shape[0] == target.shape[0], \\\n 'number of targets and predicted outputs do not match'\n\n if np.ndim(predicted) != 1:\n assert predicted.shape[1] == self.num_classes, \\\n 'number of predictions does not match size of confusion matrix'\n predicted = np.argmax(predicted, 1)\n else:\n assert (predicted.max() < self.num_classes) and (predicted.min() >= 0), \\\n 'predicted values are not between 1 and k'\n\n onehot_target = np.ndim(target) != 1\n if onehot_target:\n assert target.shape[1] == self.num_classes, \\\n 'Onehot target does not match size of confusion matrix'\n assert (target >= 0).all() and (target <= 1).all(), \\\n 'in one-hot encoding, target values should be 0 or 1'\n assert (target.sum(1) == 1).all(), \\\n 'multi-label setting is not supported'\n target = np.argmax(target, 1)\n else:\n assert (predicted.max() < self.num_classes) and (predicted.min() >= 0), \\\n 'predicted values are not between 0 and k-1'\n\n # hack for bincounting 2 arrays together\n x = predicted + self.num_classes * target\n bincount_2d = np.bincount(x.astype(np.int32),\n minlength=self.num_classes ** 2)\n assert bincount_2d.size == self.num_classes ** 2\n matrix = bincount_2d.reshape((self.num_classes, self.num_classes))\n\n self.matrix += matrix","def predict(self, DataMatrix):\n # Calculamos la funcion de distribucion gaussiana haciendo uso de la libreria\n # de scipy.stats.multivariate_normal.pdf\n aux = [stats.multivariate_normal(self.medias[i], self.covmatrix[i], allow_singular=True) for i in range(len(self.classes))]\n self.data = [[[elem.pdf(subrow) for elem in aux] for subrow in row] for row in DataMatrix]","def heatmap_max_regularizer(y_true, y_pred):\n\n return -1*K.mean(K.flatten(y_true)*K.log(K.flatten(y_pred)))","def predict(self, X):\n # Multiply the weight matrix, W, by the input matrix X\n results = np.dot(self.weights, X)\n\n if self.transfer_function == \"Hard_limit\":\n actualResults = np.where(results < 0, 0, 1)\n else:\n actualResults = results\n return actualResults\n \n #print(actualResults)","def fill_matrix(X: np.ndarray, mixture: GaussianMixture) -> np.ndarray:\n X_pred = X[:]\n mu, var, p = mixture\n\n post, _ = estep(X, mixture)\n\n missing = np.where(X==0)\n\n X_pred[missing] = (post @ mu)[missing]\n\n return X_pred","def parameter_update(self, X, X_mask):\n data_with_mask = np.hstack([X, X_mask])\n X_pred, X_MC_preds = self.predict(data_with_mask)\n X[X_mask] *= self.keep_coeff\n X[X_mask] += self.weight_update_coeff * X_pred[X_mask]\n return X, X_MC_preds","def predicted(self):\n return np.squeeze(self._predicted)","def confusion_matrix(actual: list, predicted: list) -> list:\n return confusion_matrix(actual, predicted)","def compute_prediction(data,W1,W2,b1,b2,sigma,rng=_default_seed):\n #print \"shapes\",W1.shape,W2.shape,b1.shape,b2.shape\n ha = np.dot(W1,data)+b1\n hs = ha*(ha>0)\n oa = np.dot(W2,hs)+b2\n return oa + normal(0,sigma)","def predict(self, x_test, mask=True):\n if np.isscalar(x_test):\n return (self.models[0].predict(np.atleast_2d(np.array(x_test))), \n self.models[1].predict(np.atleast_2d(np.array(x_test))))\n else: \n if mask:\n lab1 = self.labelFunc(x_test)\n lab2 = np.logical_not(lab1) \n return (self.models[0].predict(x_test[lab1,]), \n self.models[1].predict(x_test[lab2,]))\n else:\n return (self.models[0].predict(x_test), \n self.models[1].predict(x_test))","def mask_incoherent(self):\n self.MaskPrefix = 'i' + self.MaskPrefix\n print('Masking pixel values where .msk value is less than {0}...'.format(threshold))\n for ig in self.Set:\n igram = self.load_ma(ig)\n mskFile = ig.Path[:-3] + 'msk'\n coherence = roipy.tools.load_half(ig, 2, mskFile)\n incoherent = ma.masked_less(coherence, self.Cothresh)\n igram[incoherent.mask] = ma.masked\n mskFile = self.MaskPrefix + 'Mask_' + ig.Name[:-4]\n np.save(os.path.join(self.ProcDir, mskFile), igram.mask)\n print(mskFile)\n\n print('Done')","def predict(self, Xnew, full_cov=False, kern=None, **kwargs):\n return self.predict_noiseless(Xnew, full_cov=full_cov, kern=kern)","def build_predictions_matrix(self):\n df = self._build_data_frame()\n\n self._train_model(df)\n\n test_df, smoothed_predictions = self._get_predictions(df)\n\n predictions_dict = {}\n for (row_index, row), prediction in zip(test_df.iterrows(), smoothed_predictions):\n predictions_dict[row_index] = prediction\n\n self.link_probability_matrix = self._convert_to_matrix(predictions_dict)\n print(predictions_dict)\n # print(self.link_probability_matrix.shape)\n # print(self.link_probability_matrix)","def predict_w_noise(self, xs, stochastic=True, **kwargs):\n raise NotImplementedError","def predict_MAP(self,new_times: ndarray) -> ndarray:\n return self._pred_mag(self.map_params,new_times)","def predict(self):\n train_array = np.array(self.labels != 0, dtype=float)\n if not self.ising:\n labels_logit = self.ising_weights['vertices']\n else:\n neigh_num = self.adj.dot(train_array)\n neigh_num = np.where(neigh_num == 0, 1, neigh_num)\n neigh_weights = self.ising_weights['edges'] * self.labels\n labels_logit = (np.multiply(neigh_weights, neigh_num**(-1))\n + self.ising_weights['vertices'])\n self.prediction = np.where(labels_logit > 0, 1, -1)\n return self","def _raw_predict(self, Xnew, full_cov=False, kern=None):\n mu, var = self.posterior._raw_predict(kern=self.kern if kern is None else kern, Xnew=Xnew,\n pred_var=self._predictive_variable, full_cov=full_cov)\n if self.mean_function is not None:\n mu += self.mean_function.f(Xnew)\n return mu, var","def predict_mat(self):\n return self.u.dot(self.v.T)","def filter(self):\n self.filter_means = [self.m_0]\n self.filter_covs = [self.P_0]\n self.marginal_covs = []\n for t in range(self.data.shape[0]):\n m_bar, P_bar = self.one_step_prediction(self.filter_means[-1], self.filter_covs[-1])\n\n # Update step\n y = self.data[t]\n if not np.isnan(y).any():\n v = y[:, None] - self.observation_matrix @ m_bar\n S = self.observation_matrix @ P_bar @ self.observation_matrix.T + self.observation_cov\n K = P_bar @ self.observation_matrix.T @ np.linalg.inv(S)\n\n m_bar = m_bar + K @ v\n P_bar = P_bar - K @ S @ K.T\n\n self.marginal_covs.append(S)\n\n self.filter_means.append(m_bar)\n self.filter_covs.append(P_bar)\n self.filter_means = self.filter_means[1:]\n self.filter_covs = self.filter_covs[1:]","def fill_matrix(X: np.ndarray, mixture: GaussianMixture) -> np.ndarray:\n shaped_X = X.reshape((X.shape[0],1,X.shape[1])).repeat(mixture.mu.shape[0],axis=1)\n shaped_mu = mixture.mu.reshape((1,mixture.mu.shape[0],mixture.mu.shape[1])).repeat(X.shape[0],axis=0)\n shaped_var = mixture.var.reshape((1,mixture.var.shape[0],1)).repeat(X.shape[0],axis=0)\n shaped_p = mixture.p.reshape((1,mixture.var.shape[0],1)).repeat(X.shape[0],axis=0)\n\n shaped_var_extended = shaped_var.repeat(X.shape[1],axis=2)\n log_N_X = -1/2*np.log(2*np.pi*shaped_var_extended)-(shaped_X-shaped_mu)**2*np.reciprocal(2*shaped_var_extended)\n log_N_X_clean = np.where(shaped_X == 0, shaped_X, log_N_X).sum(axis=2,keepdims=True)\n f = np.log(shaped_p) + log_N_X_clean.sum(axis=2,keepdims=True)\n lse = logsumexp(f,axis=1,keepdims=True).repeat(f.shape[1],axis=1)\n log_post = f-lse\n\n post = np.exp(log_post.reshape((log_post.shape[0],log_post.shape[1])))\n\n n, d = X.shape\n K = mixture.mu.shape[0]\n\n nKd_post = post.reshape(n,K,1).repeat(d,axis=2)\n nKd_mu = mixture.mu.reshape((1,K,d)).repeat(n,axis=0)\n\n predictions = (nKd_mu * nKd_post).sum(axis=1)\n\n return np.where(X == 0, predictions, X)","def predict(self, X):\n N, D = X.shape\n y_pred = torch.zeros(N, device=X.device)\n if self.kernel == linear_kernel:\n W = torch.zeros(D, device=X.device)\n for i in range(len(self.alpha)):\n W += self.alpha[i] * self.sv_y[i] * self.sv[i]\n print(\"X\", X.dtype, \"W\", W.dtype)\n y_pred = torch.sign(torch.matmul(X, W) + self.b)\n else:\n for i in range(N):\n s = 0.0\n for alpha, sv_y, sv in zip(self.alpha, self.sv_y, self.sv):\n s += alpha * sv_y * self.kernel(X[i,:], sv)\n y_pred[i] = s\n y_pred = torch.sign(y_pred + self.b)\n return y_pred","def fill_matrix(X: np.ndarray, mixture: GaussianMixture) -> np.ndarray:\n X_pred = X.copy()\n mu, _, _ = mixture\n\n post, _ = estep(X, mixture)\n\n # Missing entries to be filled\n miss_indices = np.where(X == 0)\n X_pred[miss_indices] = (post @ mu)[miss_indices]\n\n return X_pred","def predict_mat(self):\n mat = self.covs_mat.dot(self.alpha)\n return mat.reshape(self.shape)","def getLandmark_Witness_matrix(self):\n return np.copy(self.distmat.take(self.subsetnodes_indices, axis=0))","def oldPredict(self, data):\n\n predictions = []\n\n if len(self.observations) < self.k_neighbors:\n print(f\"Data length ({len(data)}) was too small.\")\n\n for row in data:\n neighbors_info = {}\n\n for row_index in range(len(self.observations)):\n distance = self.calcualteEuclideanDistance(self.observations[row_index], row)\n if len(neighbors_info) > self.k_neighbors - 1:\n largest_distance = max(neighbors_info.keys())\n if distance < largest_distance:\n neighbors_info[distance] = self.labels[row_index]\n del neighbors_info[largest_distance]\n else:\n neighbors_info[distance] = self.labels[row_index]\n\n unique_values = set(neighbors_info.values())\n if len(unique_values) == 1:\n value = unique_values.pop()\n predictions.append(value)\n else:\n best_value = 0\n best_value_weight = 0\n for label in unique_values:\n weight = 0\n for distance in neighbors_info.keys():\n if label == neighbors_info[distance]:\n if 'inverse_distance' == self.weight_type:\n weight += self.calulateWeightedVote(distance)\n elif 'no_weight' == self.weight_type:\n weight += 1\n else:\n print(\"Not a valid_weight_type.\")\n\n if weight > best_value_weight:\n best_value_weight = weight\n best_value = label\n\n predictions.append(best_value)\n # print(f\"Neighbors Info: {neighbors_info}\")\n\n return predictions","def search_intensification(self):\n self.stage = 1\n return np.mean(self.MTM[:,:-1], axis=0, \n keepdims=True).T","def mapd(simulated_array, observed_array, replace_nan=None, replace_inf=None,\n remove_neg=False, remove_zero=False):\n\n # Treats data\n simulated_array, observed_array = treat_values(\n simulated_array,\n observed_array,\n replace_nan=replace_nan,\n replace_inf=replace_inf,\n remove_neg=remove_neg,\n remove_zero=remove_zero\n )\n\n a = np.sum(np.abs(simulated_array - observed_array))\n b = np.sum(np.abs(observed_array))\n return a / b","def predict(self, new_table):\r\n \r\n if self.is_leaf:\r\n if len(self.path) == 1:\r\n self.cur.execute(\"SELECT ROUND(AVG(\" + self.y_name + \")) FROM \" + self.table_name + \" WHERE \" + self.path[0] + \";\")\r\n else:\r\n self.cur.execute(\"SELECT ROUND(AVG(\" + self.y_name + \")) FROM \" + self.table_name + \" WHERE \" + \" AND \".join(self.path) + \";\")\r\n y = self.cur.fetchone()[0]\r\n self.cur.execute(\"UPDATE \" + new_table + \" SET preds = \" + str(y) + \" WHERE \" + \" AND \".join(self.path) + \";\")\r\n \r\n else:\r\n self.lhs.predict(new_table)\r\n self.rhs.predict(new_table)","def _noise_matrix(self):\n\n return self._noise * (np.random.rand(self._rows, self._cols)\n - 0.5)","def predict_entire_mask_downscaled(dataset, model, batch_size=32, tta=False):\n loader = DataLoader(dataset, batch_size=batch_size, shuffle=False, pin_memory=True)\n\n weighting = torch.from_numpy(get_tile_weighting(dataset.tile_size))\n weighting_cuda = weighting.clone().cuda().unsqueeze(0)\n weighting = weighting.cuda().half()\n\n global_pred = torch.zeros(\n (dataset.orig_size[0], dataset.orig_size[1]),\n dtype=torch.half, device=\"cuda\"\n )\n global_counter = torch.zeros(\n (dataset.orig_size[0], dataset.orig_size[1]),\n dtype=torch.half, device=\"cuda\"\n )\n\n model.eval()\n with torch.no_grad():\n for img, pos in loader:\n img = img.to(\"cuda\")\n _, _, h, w = img.shape\n\n if model.num_classes == 2:\n pred = model(img)[:, 0].view(-1, h, w).sigmoid().detach()\n else:\n pred = model(img).view(-1, h, w).sigmoid().detach()\n\n if tta:\n for f in FLIPS:\n pred_flip = model(torch.flip(img, f))\n if model.num_classes == 2:\n pred_flip = pred_flip[:, 0]\n pred_flip = torch.flip(pred_flip, f).view(-1, h, w).sigmoid().detach()\n pred += pred_flip\n pred = torch.div(pred, len(FLIPS) + 1)\n\n pred = (pred * weighting_cuda).half()\n\n for tile_idx, (x0, x1, y0, y1) in enumerate(pos):\n global_pred[x0: x1, y0: y1] += pred[tile_idx]\n global_counter[x0: x1, y0: y1] += weighting\n\n for i in range(len(global_pred)):\n global_pred[i] = torch.div(global_pred[i], global_counter[i])\n\n return global_pred","def trace(self):\n self.normalize()\n return (self._mat[0][0] + self._mat[1][1])**2","def _apply_mask_for_mlm(self,\n ds: tf.data.Dataset,\n vocab_size: int):\n\n # Do action only for 15% of tokens (and mask output for others)\n prob_mask_idx = 0.15\n # 10% nothing to do, 10% random word, 80% mask\n # prob_nothing, prob_random_replacement, prob_replace_by_mask \\\n prob_mask_actions = np.array([0.1, 0.1, 0.8])\n prob_mask_actions = prob_mask_actions * prob_mask_idx\n prob_mask_actions = np.append(prob_mask_actions, [1 - sum(prob_mask_actions)]).tolist()\n\n distrib_mask = tfp.distributions.Multinomial(total_count=1,\n probs=prob_mask_actions)\n\n @tf.function\n def apply_mask(x, output):\n inputs, enc_padding_mask = x\n\n input_shape = tf.shape(inputs) # Batch size * Seq Length\n output_shape = tf.shape(output) # Batch size * Seq Length\n\n masks = distrib_mask.sample(input_shape,\n seed=self._seed) # Batch size *Seq Length * Probability for each class (4)\n masks = tf.cast(masks, dtype=tf.int32)\n\n random_tokens = tf.random.uniform(input_shape, minval=len(self._special_tokens), maxval=vocab_size,\n dtype=inputs.dtype, seed=self._seed, name=None)\n\n # Replace with mask\n # One is the mask token id for HuggingFace tokenizers\n inputs_masked = tf.where(tf.math.equal(masks[:, :, 2], 1), inputs, tf.ones(input_shape, dtype=inputs.dtype))\n\n # Replace with random token\n inputs_masked = tf.where(tf.math.equal(masks[:, :, 1], 1), inputs_masked, random_tokens)\n\n output_masked = tf.where(tf.math.equal(masks[:, :, 3], 1),\n tf.zeros(output_shape, dtype=output.dtype),\n output)\n\n return (inputs_masked, enc_padding_mask), output_masked\n\n return ds.map(map_func=apply_mask)","def nmi(ypred, y):\n# print (ypred)\n# print (y)\n return normalized_mutual_info_score(y,ypred)","def predict_entire_mask_downscaled_tta(dataset, model, batch_size=32):\n\n loader = DataLoader(dataset, batch_size=batch_size, shuffle=False, pin_memory=True)\n\n weighting = torch.from_numpy(get_tile_weighting(dataset.tile_size))\n weighting_cuda = weighting.clone().cuda().unsqueeze(0).unsqueeze(0)\n weighting = weighting.cuda().half()\n\n global_pred = torch.zeros(\n (4, dataset.orig_size[0], dataset.orig_size[1]),\n dtype=torch.half, device=\"cuda\"\n )\n global_counter = torch.zeros(\n (1, dataset.orig_size[0], dataset.orig_size[1]),\n dtype=torch.half, device=\"cuda\"\n )\n\n model.eval()\n with torch.no_grad():\n for img, pos in loader:\n img = img.to(\"cuda\")\n _, _, h, w = img.shape\n\n preds = []\n if model.num_classes == 2:\n pred = model(img)[:, 0].view(1, -1, h, w).sigmoid().detach()\n else:\n pred = model(img).view(1, -1, h, w).sigmoid().detach()\n preds.append(pred)\n\n for f in FLIPS:\n pred_flip = model(torch.flip(img, f))\n if model.num_classes == 2:\n pred_flip = pred_flip[:, 0]\n pred_flip = torch.flip(pred_flip, f).view(1, -1, h, w).sigmoid().detach()\n preds.append(pred_flip)\n\n pred = torch.cat(preds, 0)\n pred = (pred * weighting_cuda).half()\n\n for tile_idx, (x0, x1, y0, y1) in enumerate(pos):\n global_pred[:, x0: x1, y0: y1] += pred[:, tile_idx]\n global_counter[:, x0: x1, y0: y1] += weighting\n\n for i in range(global_pred.size(1)):\n global_pred[:, i] = torch.div(global_pred[:, i], global_counter[:, i])\n\n return global_pred","def postprocess_model_outputs(self, predictions, expected):\n\n for key, val in predictions.items():\n predictions[key] = val.numpy()\n\n for key, val in expected.items():\n expected[key] = val.numpy()\n\n return predictions, expected","def predict(self, board):\n pass","def loss_hole(self, mask, y_true, y_pred):\n return self.l1((1-mask) * y_true, (1-mask) * y_pred)","def transform(self, net, data, prediction, truth):\n raw_output = prediction['output']\n # raw_output = tf.constant(np.load('out.npy'))\n batch = util.shape(raw_output)[0]\n prediction = tf.reshape(\n raw_output,\n (batch, self.num_cells, self.num_cells,\n self.num_anchors, 4 + 1 + self.num_classes))\n box_predict, obj_predict, class_predict = tf.split(\n prediction, [4, 1, self.num_classes], axis=-1)\n obj_predict = tf.nn.sigmoid(obj_predict)\n obj_predict_squeeze = tf.squeeze(obj_predict, -1)\n xy_original, wh_original = tf.split(box_predict, [2, 2], axis=-1)\n xy_predict, wh_predict = tf.sigmoid(xy_original), tf.exp(wh_original)\n prediction = {\n 'raw': raw_output,\n 'object': obj_predict_squeeze,\n 'object_mask': obj_predict,\n 'coordinate': [xy_predict, wh_original],\n 'outbox': self._cell_to_global(xy_predict, wh_predict),\n 'class': tf.nn.softmax(class_predict),\n }\n inputs = (\n prediction['object_mask'], prediction['class'],\n prediction['outbox'])\n corner_test, score_test, class_test, count_test = map_fn(\n self._filter, inputs,\n dtype=(tf.float32, tf.float32, tf.int32, tf.int32))\n prediction['test'] = {\n 'corner': corner_test,\n 'class': class_test,\n 'score': score_test,\n 'count': count_test,\n }\n # the original box and label values from the dataset\n image = data['input']\n if truth:\n rawlabel, truebox, count = truth\n rawlabel += self.label_offset\n truebox = util.corners_to_box(truebox)\n obj, box, label = map_fn(\n self._truth_to_cell, (truebox, rawlabel, count),\n dtype=(tf.float32, tf.float32, tf.int32))\n truth = {\n 'object': obj,\n 'object_mask': tf.expand_dims(obj, -1),\n 'box': box,\n 'class': slim.one_hot_encoding(label, self.num_classes),\n 'count': count,\n 'rawbox': truebox,\n 'rawclass': rawlabel,\n }\n return image, prediction, truth","def predict(self, X, copy=True):\n check_is_fitted(self)\n # X = check_array(X, copy=copy, dtype=FLOAT_DTYPES)\n # Normalize\n\n X -= self.x_mean_\n X /= self.x_std_\n\n Ypred = torch.mm(X, self.coef_)\n return Ypred + self.y_mean_","def confusionMatrix(testDataPredictions, testDataOriginal):\n matrix = {\"predicted >50K correctly as >50K\": 0, \"predicted >50K incorrectly as <=50K\": 0,\n \"predicted <=50K correctly as <=50K\": 0, \"predicted <=50K incorrectly as >50K\": 0}\n\n for instance in range(len(testDataPredictions)):\n prediction = testDataPredictions[instance]\n original = testDataOriginal[14].iloc[instance]\n\n #calculating total number of TP,TN,FP and FN\n\n if prediction == 1.0 and original == 1.0:\n matrix[\"predicted >50K correctly as >50K\"] += 1.00\n elif prediction == 0.0 and original == 1.0:\n matrix[\"predicted >50K incorrectly as <=50K\"] += 1.00\n elif prediction == 0.0 and original == 0.0:\n matrix[\"predicted <=50K correctly as <=50K\"] += 1.00\n elif prediction == 1.0 and original == 0.0:\n matrix[\"predicted <=50K incorrectly as >50K\"] += 1.00\n\n #Making the confusion matrix look readable on console printing\n print('----------------')\n print('CONFUSION MATRIX')\n print( 'TP: ', matrix[\"predicted >50K correctly as >50K\"], '||', 'FP: ', matrix[\"predicted >50K incorrectly as <=50K\"])\n print('----------------')\n print('FN: ', matrix[\"predicted <=50K incorrectly as >50K\"], '||', 'TN: ', matrix[\"predicted <=50K correctly as <=50K\"])\n\n # definition of sensitivity, precision and specificity formulas\n sensitivity = matrix[\"predicted >50K correctly as >50K\"] / (\n matrix[\"predicted >50K correctly as >50K\"] + matrix[\"predicted <=50K incorrectly as >50K\"])\n\n precision = matrix[\"predicted >50K correctly as >50K\"]/ (\n matrix[\"predicted >50K correctly as >50K\"] + matrix[\"predicted >50K incorrectly as <=50K\"])\n\n specificity = matrix[\"predicted <=50K correctly as <=50K\"] / (\n matrix[\"predicted <=50K correctly as <=50K\"] + matrix[\"predicted >50K incorrectly as <=50K\"])\n\n print('Precision: ' + str(precision*100) + '%')\n print('Sensitivity: '+ str(sensitivity*100)+ '%')\n print('Specificity: '+ str(specificity*100) +'%')\n\n return matrix, precision, sensitivity, specificity","def predict_entire_mask(dataset, model, batch_size=32, tta=False):\n loader = DataLoader(dataset, batch_size=batch_size, shuffle=False, pin_memory=True)\n\n weighting = torch.from_numpy(get_tile_weighting(dataset.tile_size))\n weighting_cuda = weighting.clone().cuda().unsqueeze(0)\n weighting = weighting.cuda().half()\n\n global_pred = torch.zeros(\n (dataset.orig_size[0], dataset.orig_size[1]),\n dtype=torch.half, device=\"cuda\"\n )\n global_counter = torch.zeros(\n (dataset.orig_size[0], dataset.orig_size[1]),\n dtype=torch.half, device=\"cuda\"\n )\n\n model.eval()\n with torch.no_grad():\n for img, pos in loader:\n img = img.to(\"cuda\")\n _, _, h, w = img.shape\n\n if model.num_classes == 2:\n pred = model(img)[:, 0].view(-1, 1, h, w).sigmoid().detach()\n else:\n pred = model(img).view(-1, 1, h, w).sigmoid().detach()\n\n if tta:\n for f in FLIPS:\n pred_flip = model(torch.flip(img, f))\n if model.num_classes == 2:\n pred_flip = pred_flip[:, 0]\n\n pred_flip = torch.flip(pred_flip, f).view(-1, 1, h, w).sigmoid().detach()\n pred += pred_flip\n pred = torch.div(pred, len(FLIPS) + 1)\n\n pred = torch.nn.functional.interpolate(\n pred, (dataset.tile_size, dataset.tile_size), mode='area'\n ).view(-1, dataset.tile_size, dataset.tile_size)\n\n pred = (pred * weighting_cuda).half()\n\n for tile_idx, (x0, x1, y0, y1) in enumerate(pos):\n global_pred[x0: x1, y0: y1] += pred[tile_idx]\n global_counter[x0: x1, y0: y1] += weighting\n\n for i in range(len(global_pred)):\n global_pred[i] = torch.div(global_pred[i], global_counter[i])\n\n return global_pred","def predict(self):\n for column in self.data_to_predict.columns:\n if column not in list(self.selected_features_):\n self.data_to_predict.drop(column, axis=1, inplace=True)\n for column in list(self.selected_features_):\n if column not in self.data_to_predict.columns:\n self.data_to_predict.loc[:, column] = 0\n self.predictions = self.model.predict(\n self.data_to_predict[self.selected_features_])","def clone_predicted_label_tensor_output(self) -> torch.Tensor:\n pass","def normalize(self,matrix):\n for i in range(self.N):\n matrix[self.N-1][i] = 0\n for i in range(self.n):\n matrix[self.N - 1][self.index(i,i)] = 1\n return matrix","def apply(self, X, ntree_limit=0):\n test_dmatrix = DMatrix(X, missing=self.missing, nthread=self.n_jobs)\n return self.get_booster().predict(test_dmatrix,\n pred_leaf=True,\n ntree_limit=ntree_limit)","def predict(parameters, X):\n A2, cache = forward_propagation(X, parameters)\n\n predictions = (A2 > 0.5)\n \n return predictions","def predict(self, x):\n if self.training:\n self.eval()\n\n with torch.no_grad():\n output = self.forward(x)\n\n if self.classes > 1:\n probs = torch.softmax(output, dim=1)\n else:\n probs = torch.sigmoid(output)\n\n probs = probs.squeeze(0)\n tf = transforms.Compose(\n [\n transforms.ToPILImage(),\n transforms.Resize(x.size[1]),\n transforms.ToTensor()\n ]\n )\n full_mask = tf(probs.cpu()) \n\n return full_mask","def mase(simulated_array, observed_array, m=1, replace_nan=None, replace_inf=None,\n remove_neg=False, remove_zero=False):\n\n # Checking and cleaning the data\n\n simulated_array, observed_array = treat_values(\n simulated_array,\n observed_array,\n replace_nan=replace_nan,\n replace_inf=replace_inf,\n remove_neg=remove_neg,\n remove_zero=remove_zero\n )\n\n start = m\n end = simulated_array.size - m\n a = np.mean(np.abs(simulated_array - observed_array))\n b = np.abs(observed_array[start:observed_array.size] - observed_array[:end])\n return a / (np.sum(b) / end)","def reset_hidden(hidden, mask):\n if len(mask) != 0:\n hidden[:, mask, :] = 0\n \n return hidden","def edit_emission(mat):\n B_1_2 = np.full(mf.K_ADDITION, mf.U_PROPABILITY)\n mat = np.vstack([mat, B_1_2])\n B_end_B_start = np.zeros(mf.K_ADDITION)\n mat = np.vstack([mat, B_end_B_start])\n mat = np.vstack([B_1_2, mat])\n mat = np.vstack([B_end_B_start, mat])\n k = mat.shape[0]\n hat_vector = np.zeros((1, k))\n dollar_vector = np.zeros((1, k))\n hat_vector[0][0], dollar_vector[0][k - 1] = 1, 1\n mat = np.insert(mat, 4, hat_vector, axis=1)\n mat = np.insert(mat, 5, dollar_vector, axis=1)\n return mf.log_marix(mat), k","def forward(self, node_hidden, edge_hidden, adj_matrix, mask):\n # x.shape = (batch, max_length, d_atom)\n node_hidden = self.dropout(self.norm(node_hidden))\n node_hidden_first, edge_hidden_temp = self.self_attn(node_hidden, node_hidden, edge_hidden, adj_matrix, mask)\n # the first residue block\n node_hidden_first = node_hidden + self.dropout(self.norm(node_hidden_first))\n node_hidden_second = self.feed_forward(node_hidden_first)\n # the second residue block\n return node_hidden + node_hidden_first + self.dropout(self.norm(node_hidden_second)), edge_hidden","def predict(self, X_test):\n if self.basis_func is not None:\n X_transformed = self.basis_func(X_test)\n else:\n X_transformed = X_test\n\n # Marginalise predictions over hyperparameters\n mu = np.zeros([len(self.hypers), X_transformed.shape[0]])\n var = np.zeros([len(self.hypers), X_transformed.shape[0]])\n\n for i, h in enumerate(self.hypers):\n mu[i] = np.dot(self.models[i][0].T, X_transformed.T)\n var[i] = 1. / h[1] + np.diag(np.dot(np.dot(X_transformed, self.models[i][1]), X_transformed.T))\n\n m = mu.mean(axis=0)\n v = var.mean(axis=0)\n # Clip negative variances and set them to the smallest\n # positive float value\n if v.shape[0] == 1:\n v = np.clip(v, np.finfo(v.dtype).eps, np.inf)\n else:\n v = np.clip(v, np.finfo(v.dtype).eps, np.inf)\n v[np.where((v < np.finfo(v.dtype).eps) & (v > -np.finfo(v.dtype).eps))] = 0\n\n return m, v","def reset_mocap_welds(self):\n if self.sim.model.nmocap > 0 and self.sim.model.eq_data is not None:\n for i in range(self.sim.model.eq_data.shape[0]):\n if self.sim.model.eq_type[i] == mujoco_py.const.EQ_WELD:\n self.sim.model.eq_data[i, :] = np.array(\n [0., 0., 0., 1., 0., 0., 0.])\n self.sim.forward()","def masked_mse_loss(prediction : Union[T.tensor, np.ndarray],\n groundtruth : Union[T.tensor, np.ndarray],\n masked_proportion : float = 0.1) -> Union[T.tensor, np.ndarray]:\n n_batch, N, n_par = groundtruth.shape\n mask = create_mask(n_batch, N, n_par, masked_proportion)\n if not isinstance(prediction, np.ndarray):\n mask = T.tensor(mask, \n dtype=T.float32, \n requires_grad=False)\n \n loss_matrix = 0.5*(groundtruth - prediction)**2\n return (mask*loss_matrix).mean()","def filter(self, likelihood=False, calculate_backwards_inital=False):\n # Initial values\n ll_hist = []\n T = self.n_observations()\n y_pred_online = np.zeros((self.observations_size, 1, T))\n final_gain_partial = None\n\n # Kalman Filter and update over all observations t in 0..T\n for t in range(T):\n\n # t-1 parameters and state\n (A, B, C, D, Q, R) = self.parameters(t - 1)\n (mu_tm1, V_tm1) = self.state(t - 1)\n (y_t, u_t) = self.data(t)\n\n # Predict\n (y_pred, mu_pred) = self.predict(A, B, C, D, mu_tm1, u_t)\n V_pred = self.predict_covariance(A, V_tm1, Q)\n y_pred_online[:, :, t] = y_pred\n\n (y_t, _) = self.data(t)\n\n ll = self.update(t, mu_pred, V_pred, y_t, y_pred, likelihood)\n\n if likelihood:\n ll_hist.append(ll)\n\n if calculate_backwards_inital and t == T-1:\n # Occurs after update, for V_tm1 given 1..t-1\n (mu_tm1_new, V_tm1_new) = self.state(t-1)\n S = C @ V_pred @ C.T + R\n K = V_pred @ C.T @ pinv(S)\n (A, B, C, D, Q, R) = self.parameters(t - 1)\n final_gain_partial = V_tm1_new - K @ C @ A @ V_tm1_new\n\n return y_pred_online, ll_hist, final_gain_partial","def smape(actual: np.ndarray, predicted: np.ndarray):\n return np.mean(np.divide(np.abs(actual - predicted), (np.abs(actual) + np.abs(predicted) + np.finfo(float).eps) * 0.5))","def getLandmark_Witness_matrix(self):\n return np.copy(self.pointcloud.distmat[self.subsetindices]) # ndarray","def _reclassify_disturbance(\n landuse_transition_from_matrix, landuse_transition_to_matrix):\n output_matrix = numpy.empty(landuse_transition_from_matrix.shape,\n dtype=numpy.float32)\n output_matrix[:] = NODATA_FLOAT32_MIN\n\n valid_pixels = numpy.ones(landuse_transition_from_matrix.shape,\n dtype=bool)\n if from_nodata is not None:\n valid_pixels &= ~utils.array_equals_nodata(\n landuse_transition_from_matrix, from_nodata)\n\n if to_nodata is not None:\n valid_pixels &= ~utils.array_equals_nodata(\n landuse_transition_to_matrix, to_nodata)\n\n disturbance_magnitude = disturbance_magnitude_matrix[\n landuse_transition_from_matrix[valid_pixels],\n landuse_transition_to_matrix[valid_pixels]].toarray().flatten()\n\n output_matrix[valid_pixels] = disturbance_magnitude\n return output_matrix","def _train_pattern(self, matrix, input, current, bmu):\n\n for input_neuron in range(self.input_neuron_count):\n current_weight = matrix[current][input_neuron]\n input_value = input[input_neuron]\n\n new_weight = self._determine_new_weight(current_weight,\n input_value, current, bmu)\n\n self.correction_matrix[current][input_neuron] = new_weight","def _to_bert_self_attention_mask(matrix):\n matrix = tf.squeeze(matrix, axis=[1])\n matrix = tf.tile(matrix, [batch_size, 1, 1])\n return matrix","def create_masked_lm_predictions(self,tokens, masked_lm_prob,\n max_predictions_per_seq, vocab_words, rng):\n\n cand_indexes = []\n for (i, token) in enumerate(tokens):\n if token == \"[CLS]\" or token == \"[SEP]\":\n continue\n # Whole Word Masking means that if we mask all of the wordpieces\n # corresponding to an original word. When a word has been split into\n # WordPieces, the first token does not have any marker and any subsequence\n # tokens are prefixed with ##. So whenever we see the ## token, we\n # append it to the previous set of word indexes.\n #\n # Note that Whole Word Masking does *not* change the training code\n # at all -- we still predict each WordPiece independently, softmaxed\n # over the entire vocabulary.\n if (self.do_whole_word_mask and len(cand_indexes) >= 1 and\n token.startswith(\"##\")):\n cand_indexes[-1].append(i)\n else:\n cand_indexes.append([i])\n\n rng.shuffle(cand_indexes)\n\n output_tokens = list(tokens)\n\n num_to_predict = min(max_predictions_per_seq,\n max(1, int(round(len(tokens) * masked_lm_prob))))\n\n masked_lms = []\n covered_indexes = set()\n for index_set in cand_indexes:\n if len(masked_lms) >= num_to_predict:\n break\n # If adding a whole-word mask would exceed the maximum number of\n # predictions, then just skip this candidate.\n if len(masked_lms) + len(index_set) > num_to_predict:\n continue\n is_any_index_covered = False\n for index in index_set:\n if index in covered_indexes:\n is_any_index_covered = True\n break\n if is_any_index_covered:\n continue\n for index in index_set:\n covered_indexes.add(index)\n\n masked_token = None\n # 80% of the time, replace with [MASK]\n if rng.random() < 0.8:\n masked_token = \"[MASK]\"\n else:\n # 10% of the time, keep original\n if rng.random() < 0.5:\n masked_token = tokens[index]\n # 10% of the time, replace with random word\n else:\n masked_token = vocab_words[rng.randint(0, len(vocab_words) - 1)]\n\n output_tokens[index] = masked_token\n\n masked_lms.append(MaskedLmInstance(index=index, label=tokens[index]))\n assert len(masked_lms) <= num_to_predict\n masked_lms = sorted(masked_lms, key=lambda x: x.index)\n\n masked_lm_positions = []\n masked_lm_labels = []\n for p in masked_lms:\n masked_lm_positions.append(p.index)\n masked_lm_labels.append(p.label)\n\n return (output_tokens, masked_lm_positions, masked_lm_labels)","def process(self, mat):","def mnfb(actual: np.ndarray, predicted: np.ndarray):\n df = pd.DataFrame.from_dict({\n 'actual': actual,\n 'predicted': predicted,\n })\n df['err'] = df['predicted'] - df['actual']\n df['mo'] = df['predicted'] / df['actual']\n df['om'] = df['actual'] / df['predicted']\n\n df_pos = df.loc[df['err'] >= 0, :]\n df_neg = df.loc[df['err'] < 0, :]\n\n # drop inf\n df_pos.replace([np.inf, -np.inf], np.nan, inplace=True)\n df_pos.dropna(inplace=True)\n df_neg.replace([np.inf, -np.inf], np.nan, inplace=True)\n df_neg.dropna(inplace=True)\n\n # df_pos == M >= O -> sum(M/O - 1)\n # df_neg == M < O -> sum(1 - O/M)\n return sum(df_pos['mo'] - 1.0) / len(df_pos['mo']) + \\\n sum(1.0 - df_neg['om']) / len(df_neg['om'])","def test_predict_uncertain_inputs(self):\n X = np.linspace(-5,5, 10)[:, None]\n Y = 2*X + np.random.randn(*X.shape)*1e-3\n m = GPy.models.BayesianGPLVM(Y, 1, X=X, kernel=GPy.kern.Linear(1), num_inducing=1)\n m.Gaussian_noise[:] = 1e-4\n m.X.mean[:] = X[:]\n m.X.variance[:] = 1e-5\n m.X.fix()\n m.optimize()\n X_pred_mu = np.random.randn(5, 1)\n X_pred_var = np.random.rand(5, 1) + 1e-5\n from GPy.core.parameterization.variational import NormalPosterior\n X_pred = NormalPosterior(X_pred_mu, X_pred_var)\n # mu = \\int f(x)q(x|mu,S) dx = \\int 2x.q(x|mu,S) dx = 2.mu\n # S = \\int (f(x) - m)^2q(x|mu,S) dx = \\int f(x)^2 q(x) dx - mu**2 = 4(mu^2 + S) - (2.mu)^2 = 4S\n Y_mu_true = 2*X_pred_mu\n Y_var_true = 4*X_pred_var\n Y_mu_pred, Y_var_pred = m.predict_noiseless(X_pred)\n np.testing.assert_allclose(Y_mu_true, Y_mu_pred, rtol=1e-3)\n np.testing.assert_allclose(Y_var_true, Y_var_pred, rtol=1e-3)","def FitFundamentalMatrix(mss):\n\n\tbatch_size = mss.shape[0]\n\tnum_correspondences = mss.shape[1]\t\n\n\tmss_src, T_src = utils.normalise2dpts(mss[:, :, :2])\n\tmss_target, T_target = utils.normalise2dpts(mss[:, :, 2:])\n\n\tones = torch.tensor([1]).double().cuda().view(1, 1, 1).repeat(batch_size, num_correspondences, 1)\n\tmss_src = torch.cat([mss_src, ones], dim = 2)\n\tmss_target = torch.cat([mss_target, ones], dim = 2)\n\n\trow = torch.cat([\n\t\tmss_src * mss_target[:, :, 0].view(batch_size, num_correspondences, 1), \n\t\tmss_src * mss_target[:, :, 1].view(batch_size, num_correspondences, -1),\n\t\tmss_src \n\t], dim = 2)\n\n\n\touter_product = row.unsqueeze(3) * row.unsqueeze(2)\n\tmat = outer_product.sum(dim = 1)\n\n\n\tU = []\n\tS = []\n\tVT = []\n\n\tfor i in range(batch_size):\n\n\t\t_, V = torch.symeig(mat[i])\n\t\tu, s, v = torch.svd(V[:, 0].view(3, 3))\n\t\tvt = v.permute(1, 0)\n\t\ts[2] = 0\n\n\t\tU.append(u.unsqueeze(0))\n\t\tS.append(torch.diag(s).unsqueeze(0))\n\t\tVT.append(vt.unsqueeze(0))\n\n\tU = torch.cat(U, dim = 0)\n\tS = torch.cat(S, dim = 0)\n\tVT = torch.cat(VT, dim = 0)\n\n\tF = torch.bmm(torch.bmm(U, S), VT)\n\tF = torch.bmm(T_src, torch.bmm(F.permute(0, 2, 1), T_target.permute(0, 2, 1)))\n\tF = F / F[:, 2, 2].view(batch_size, 1, 1)\n\n\tutils.nan_check(F)\n\n\treturn F","def innovation(observation: np.ndarray, observation_predicted: np.ndarray) -> np.ndarray:\n return observation - observation_predicted","def recover(self, reduced):\n return np.dot(reduced, self.w)+self.mu","def rescale_data(self):\n\n # Dividing every array of simulated data vectors by the mean of that array.\n '''# Didnt work\n for key in self.data.keys():\n self.data[key] /= np.mean(self.data[key])\n '''\n\n self.rescaled = True\n\n # Mean normalization\n \"\"\" didnt work\n for key in self.data.keys():\n self.data[key] -= np.mean(self.data[key])\n self.data[key] /= (np.max(self.data[key]) - np.min(self.data[key]))\n \"\"\"\n\n # Median normalization\n \"\"\" didnt work, still dividing by large number \n for key in self.data.keys():\n self.data[key] -= np.median(self.data[key])\n self.data[key] /= (np.max(self.data[key]) - np.min(self.data[key]))\n \"\"\"\n\n # Divide by median\n \"\"\" didnt work\n for key in self.data.keys():\n self.data[key] -= np.median(self.data[key])\n self.data[key] /= (np.median(self.data[key]))\n \"\"\"\n\n # Take logarithm of data\n \"\"\" didnt work\n for key in self.data.keys():\n self.data[key] = np.log10(self.data[key])\n \"\"\"\n\n # Scale by length of vector\n \"\"\"\n for key in self.data.keys():\n self.data[key] /= np.linalg.norm(self.Cl_noiseless)\n \"\"\"\n\n \n # Scale by negative of the natural logarithm \n for key in self.data.keys():\n self.data[key] = -1 * np.log(self.data[key]) \n \n \"\"\"\n # Scale by subtracting the mean and dividing by std\n std = np.nanstd(self.data['data'])\n mean = np.nanmean(self.data['data'])\n for key in self.data.keys():\n # self.data[key] -= np.log(self.Cl_noiseless) # -1* # scale this same way\n # self.data[key] -= self.Cl_noiseless # -1* # scale this same way\n self.data[key] -= mean \n self.data[key] /= std\n \"\"\""],"string":"[\n \"def predict(self, masked_data, masked_binary_data):\\n # Use the loaded model to perform missing value prediction.\\n # concatenate multiple students' knowledge state into a matrix of shape (num_students, num_concepts)\\n predicted_states = []\\n for u in range(len(self.model.mrfs)):\\n predicted_states.append(self.model.mrfs[u].correct_probs.numpy())\\n predicted_states = np.array(predicted_states)\\n\\n predictions = self.model.predict(torch.from_numpy(predicted_states).to(device))\\n\\n return predictions\",\n \"def filter_predict(filtered_state_mean, filtered_state_covariance,\\n transition_matrix, transition_covariance):\\n predicted_state_mean = np.dot(transition_matrix, filtered_state_mean)\\n predicted_state_covariance = (np.dot(transition_matrix,\\n np.dot(filtered_state_covariance,\\n transition_matrix.T))\\n + transition_covariance)\\n\\n return (predicted_state_mean, predicted_state_covariance)\",\n \"def postprocessing(self, prediction, prob_thresh=0.5):\\n prob_map = self._np_sigmoid(prediction)\\n prob_map = self._np_merge_prediction(prob_map)\\n if self.resize :\\n prob_map = self._np_resize_image(prob_map,\\n self.orig_size,\\n dtype='float')\\n mask = self._np_get_mask(prob_map, prob_thresh=prob_thresh)\\n return mask\",\n \"def _apply_correction(self):\\n np.copyto(self.network.weights, self.correction_matrix)\",\n \"def predict(self, x, reset=True, verbose=False):\\n Nu = self.manifold.log_map(x0_mat=self.manifold_mu0, X_mat=x)\\n return super().predict(x=Nu, reset=reset, verbose=verbose)\",\n \"def predict_mask(logit, EMPTY_THRESHOLD, MASK_THRESHOLD):\\n #pred mask 0-1 pixel-wise\\n #n = logit.shape[0]\\n IMG_SIZE = logit.shape[-1] #256\\n #EMPTY_THRESHOLD = 100.0*(IMG_SIZE/128.0)**2 #count of predicted mask pixles<threshold, predict as empty mask image\\n #MASK_THRESHOLD = 0.22\\n #logit = torch.sigmoid(torch.from_numpy(logit)).view(n, -1)\\n #pred = (logit>MASK_THRESHOLD).long()\\n #pred[pred.sum(dim=1) < EMPTY_THRESHOLD, ] = 0 #bug here, found it, the bug is input shape is (256, 256) not (16,256,256)\\n logit = sigmoid(logit)#.reshape(n, -1)\\n pred = (logit>MASK_THRESHOLD).astype(np.int)\\n if pred.sum() < EMPTY_THRESHOLD:\\n return np.zeros(pred.shape).astype(np.int)\\n else:\\n return pred\",\n \"def set_redundant_linker_to_avergae(self, modified_matrix):\\n modified_matrix[:, 0:self.selex_predict_str_adaptor, :] = 0.25\\n modified_matrix[:, self.selex_str_len - self.selex_predict_str_adaptor:self.selex_str_len, :] = 0.25\\n return modified_matrix\",\n \"def get_remat(self) -> ndarray:\\n return self.data.weight[:, None]*self.revar.mapping.mat\",\n \"def apply_mask(mask_matrix_df, original_matrix_df):\\n\\n print(\\\"Applying the mask ...\\\")\\n\\n original_matrix_columns = list(original_matrix_df)\\n original_matrix_rows = list(original_matrix_df.index)\\n\\n mask_array = mask_matrix_df.to_numpy()\\n original_array = original_matrix_df.to_numpy().astype(float)\\n\\n\\n # Note: np.nan cannot be inserted into an array of type int. The array needs to be float.\\n np.putmask(original_array, mask_array, np.nan)\\n\\n\\n after_masking_df = pd.DataFrame(original_array, columns=original_matrix_columns, index=original_matrix_rows)\\n return after_masking_df\",\n \"def _predicted(self):\\n return np.matmul(self.x, self.solution)\",\n \"def reconstruct(mask, y_pred, pixels):\\n\\n # change mask so that cancer prediction is gone (ie prevent cheating)\\n for pi in range(256):\\n for pj in range(256):\\n if int(round(mask[pi, pj])) == 2:\\n mask[pi, pj] = 1\\n\\n # insert the actual prediction\\n for p, pixel in enumerate(pixels):\\n pixel_x = pixel[0]\\n pixel_y = pixel[1]\\n # set the new mask pixel to the predicted score, moving 0 -> 1 (prostate, not cancer)\\n # and 1 -> 2 (prostate, cancer)\\n mask[pixel_x, pixel_y] = y_pred[p] + 1\\n\\n return mask\",\n \"def infectedToRecovered(self):\\n\\n # initialize a random matrix where around recovery_probability % of the values are True\\n recover_prob_arr = np.random.rand(self.space.shape[0],self.space.shape[1]) < self.recovery_probability\\n # find the overlap between infected and above array and make those people recovered\\n self.space[np.logical_and(self.space == 1, recover_prob_arr)] = 2\",\n \"def warmup_predict(model, imgs, Npred):\\n H = augmented_state_matrix(model[:-1], imgs, 0)\\n h0 = H[-2]\\n y0 = imgs[-1]\\n return predict(model, y0, h0, Npred)\",\n \"def forward(self, node_hidden, edge_hidden, adj_matrix, mask):\\n out_scores, in_scores = None, None\\n for layer in self.layers:\\n node_hidden, edge_hidden = layer(node_hidden, edge_hidden, adj_matrix, mask)\\n return self.norm(node_hidden)\",\n \"def predict_only(self):\",\n \"def predict(self, x, reset=True, window_result=False, **kwargs):\\n Nu = self.manifold.log_map(x0_mat=self.manifold_mu0, X_mat=x)\\n return super().predict(x=Nu, reset=reset, window_result=window_result, **kwargs)\",\n \"def adjusted_matrix(self):\\n mat = AlignerExtract().transform_matrix(self.aligned[\\\"matrix\\\"],\\n self.aligned[\\\"size\\\"],\\n self.aligned[\\\"padding\\\"])\\n return mat\",\n \"def _predict(self):\\n \\n # Initialization\\n x_k = np.random.rand(4,0)\\n w_k = np.ones((1,0))\\n \\n self.reset(phd_only=True)\\n \\n # Prediction of the targets' positions\\n for k in range(1, self.n_time_steps+1):\\n\\n if k in self.observed_data.keys():\\n\\n # perform phd filter\\n\\n x_k1, w_k1, estimated_x_k1, n_targ_pred = self.PHDfilter(x_k, w_k, self.observed_data[k], k)\\n\\n # save predicted positions and update parameters\\n self.phd_filter['n_targets_predicted'][k] = n_targ_pred\\n self.phd_filter['particles_positions'][k] = x_k1\\n if estimated_x_k1 is not None:\\n self.phd_filter['estimated_positions'][k] = estimated_x_k1\\n x_k, w_k = np.copy(x_k1), np.copy(w_k1)\\n\\n else:\\n self.phd_filter['n_targets_predicted'][k] = 0\",\n \"def mask_sensitivy(Y, Y_pred): \\n cm = confusion_matrix(Y.reshape(-1), Y_pred.reshape(-1))\\n return sensitivity(cm)\",\n \"def maskByModel(self, model, sigma=3, pixel_start=30, pixel_end=-10):\\n\\t\\tpixel = np.delete(np.arange(len(self.oriWave)),self.mask)[pixel_start: pixel_end]\\n\\t\\tcustom_mask2 = pixel[np.where(np.abs(self.flux-model.flux) > sigma*np.std(self.flux-model.flux))]\\n\\t\\tprint(custom_mask2)\\n\\t\\tcustom_mask2 = np.append(custom_mask2, np.array(self.mask))\\n\\t\\tcustom_mask2.sort()\\n\\t\\tcustom_mask2 = custom_mask2.tolist()\\n\\t\\tself.mask_custom(custom_mask2)\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n predictions = {k: t.numpy() for k, t in predictions.items()}\\n\\n return predictions, expected\",\n \"def predict(X, W):\\n # This is the sigma_i w_i * x_i but using all data in X\\n preds = sigmoid_activation(X.dot(W))\\n\\n preds[preds <= 0.5] = 0\\n preds[preds > 0.5] = 1 # this might be >0.5, but I think it is 0 since prev line has set to 0 some positions\\n return preds\",\n \"def loss_mmse(y_true, y_pred, y_mask):\\n y_shape = tf.shape(y_true)\\n border = 3\\n max_pixels_shifts = 2*border\\n size_image = HR_SIZE\\n size_croped_image = size_image - max_pixels_shifts\\n clear_pixels = size_croped_image*size_croped_image\\n cropped_predictions = y_pred[:, border:size_image -\\n border, border:size_image-border]\\n\\n X = []\\n for i in range(max_pixels_shifts+1): # range(7)\\n for j in range(max_pixels_shifts+1): # range(7)\\n cropped_labels = y_true[:, i:i+(size_image-max_pixels_shifts),\\n j:j+(size_image-max_pixels_shifts)]\\n cropped_y_mask = y_mask[:, i:i+(size_image-max_pixels_shifts),\\n j:j+(size_image-max_pixels_shifts)]\\n\\n cropped_y_mask = tf.cast(cropped_y_mask, tf.float32)\\n\\n cropped_predictions_masked = cropped_predictions*cropped_y_mask\\n cropped_labels_masked = cropped_labels*cropped_y_mask\\n\\n total_pixels_masked = tf.reduce_sum(cropped_y_mask, axis=[1, 2])\\n\\n # bias brightness\\n b = (1.0/total_pixels_masked)*tf.reduce_sum(\\n tf.subtract(cropped_labels_masked, cropped_predictions_masked),\\n axis=[1, 2])\\n\\n b = tf.reshape(b, [y_shape[0], 1, 1, 1])\\n\\n corrected_cropped_predictions = cropped_predictions_masked+b\\n corrected_cropped_predictions = corrected_cropped_predictions*cropped_y_mask\\n\\n corrected_mse = (1.0/total_pixels_masked)*tf.reduce_sum(\\n tf.square(\\n tf.subtract(cropped_labels_masked,\\n corrected_cropped_predictions)\\n ), axis=[1, 2])\\n X.append(corrected_mse)\\n\\n X = tf.stack(X)\\n minim = tf.reduce_min(X, axis=0)\\n return minim\",\n \"def predict(self, data):\\r\\n x = []\\r\\n x.append(data.sampled_matrix())\\r\\n x = np.array(x)\\r\\n x = np.reshape(x, (x.shape[0], x.shape[1], 1))\\r\\n\\r\\n result = self.model.predict(x)\\r\\n return result\",\n \"def predict(self, prediction_matrix: np.ndarray) -> np.ndarray:\\n prediction_matrix = np.moveaxis(prediction_matrix, 0, -1)\\n softmax_scores = self.model.predict(prediction_matrix)\\n\\n return np.argmax(softmax_scores, axis=-1)\",\n \"def HeatmapLoss(pred, gt, masks):\\n assert pred.size() == gt.size()\\n l = ((pred - gt)**2) * masks[:, None, :, :].expand_as(pred)\\n l = l.mean(dim=3).mean(dim=2).mean(dim=1)\\n return l\",\n \"def predict_noiseless(self, Xnew, full_cov=False, kern=None):\\n # Predict the latent function values\\n mu, var = self._raw_predict(Xnew, full_cov=full_cov, kern=kern)\\n\\n # Un-apply normalization\\n if self.normalizer is not None:\\n mu, var = self.normalizer.inverse_mean(mu), self.normalizer.inverse_variance(var)\\n\\n return mu, var\",\n \"def _reclassify_accumulation(\\n landuse_transition_from_matrix, landuse_transition_to_matrix,\\n accumulation_rate_matrix):\\n output_matrix = numpy.empty(landuse_transition_from_matrix.shape,\\n dtype=numpy.float32)\\n output_matrix[:] = NODATA_FLOAT32_MIN\\n\\n valid_pixels = numpy.ones(landuse_transition_from_matrix.shape,\\n dtype=bool)\\n if from_nodata is not None:\\n valid_pixels &= ~utils.array_equals_nodata(\\n landuse_transition_from_matrix, from_nodata)\\n\\n if to_nodata is not None:\\n valid_pixels &= ~utils.array_equals_nodata(\\n landuse_transition_to_matrix, to_nodata)\\n\\n output_matrix[valid_pixels] = accumulation_rate_matrix[\\n landuse_transition_from_matrix[valid_pixels],\\n landuse_transition_to_matrix[valid_pixels]].toarray().flatten()\\n return output_matrix\",\n \"def mask_out(self, x, lengths):\\n params = self.params\\n slen, bs = x.size()\\n\\n # define target words to predict\\n if params.sample_alpha == 0:\\n pred_mask = np.random.rand(slen, bs) <= params.word_pred\\n pred_mask = torch.from_numpy(pred_mask.astype(np.uint8))\\n else:\\n x_prob = params.mask_scores[x.flatten()]\\n n_tgt = math.ceil(params.word_pred * slen * bs)\\n tgt_ids = np.random.choice(len(x_prob), n_tgt, replace=False, p=x_prob / x_prob.sum())\\n pred_mask = torch.zeros(slen * bs, dtype=torch.uint8)\\n pred_mask[tgt_ids] = 1\\n pred_mask = pred_mask.view(slen, bs)\\n\\n # do not predict padding\\n pred_mask[x == params.pad_index] = 0\\n pred_mask[0] = 0 # TODO: remove\\n\\n # mask a number of words == 0 [8] (faster with fp16)\\n if params.fp16:\\n pred_mask = pred_mask.view(-1)\\n n1 = pred_mask.sum().item()\\n n2 = max(n1 % 8, 8 * (n1 // 8))\\n if n2 != n1:\\n pred_mask[torch.nonzero(pred_mask).view(-1)[:n1 - n2]] = 0\\n pred_mask = pred_mask.view(slen, bs)\\n # assert pred_mask.sum().item() % 8 == 0\\n\\n # generate possible targets / update x input\\n pred_mask = pred_mask.bool()\\n _x_real = x[pred_mask]\\n if len(_x_real) == 0:\\n pred_mask[0, 0] = 1\\n _x_real = x[pred_mask]\\n _x_rand = _x_real.clone().random_(params.n_words)\\n _x_mask = _x_real.clone().fill_(params.mask_index)\\n probs = torch.multinomial(params.pred_probs, len(_x_real), replacement=True)\\n _x = _x_mask * (probs == 0).long() + _x_real * (probs == 1).long() + _x_rand * (probs == 2).long()\\n x = x.masked_scatter(pred_mask, _x)\\n\\n assert 0 <= x.min() <= x.max() < params.n_words\\n assert x.size() == (slen, bs)\\n assert pred_mask.size() == (slen, bs)\\n\\n return x, _x_real, pred_mask\",\n \"def predict_transparent(self, observation, state=None, mask=None, deterministic=False):\\n policy_out = self._get_policy_out(observation, state, mask, transparent=True,\\n deterministic=deterministic)\\n actions, _val, states, _neglogp, data = policy_out\\n return actions, states, data\",\n \"def predict(self, new_data):\\r\\n trans, rotation = new_data.image_transformation_from(self.last_data) \\r\\n \\r\\n R = np.array([[np.cos(self.att2D), -np.sin(self.att2D)],[np.sin(self.att2D), np.cos(self.att2D)]])\\r\\n if not np.any(np.isnan(trans)):\\r\\n self.pos2D = self.pos2D + R.dot(trans[0:2] - self.bias[0:2])\\r\\n self.att2D = self.att2D + rotation.as_euler('zxy')[0] - self.bias[2]\\r\\n else:\\r\\n self.pos2D = self.mapdata.attitude.apply(new_data.gps_pos - self.mapdata.gps_pos)[0:2]\\r\\n self.att2D = rotation_proj(self.mapdata.attitude, new_data.attitude).as_euler(\\\"zxy\\\")[0]\\r\\n \\r\\n F = np.array([[1, 0, -np.sin(self.att2D)*(trans[0] - self.bias[0])-np.cos(self.att2D)*(trans[1] - self.bias[1])],\\r\\n [0, 1, np.cos(self.att2D)*(trans[0] - self.bias[0])-np.sin(self.att2D)*(trans[1] - self.bias[1])],\\r\\n [0, 0, 1]])\\r\\n M = np.block([[R, np.zeros((2,1))],[np.zeros(2), 1]])\\r\\n if self.bias_estimation:\\r\\n F = np.block([[F, np.block([[-R, np.zeros((2,1))],[np.zeros(2), -1]])],[np.zeros((3,3)), np.eye(3)]])\\r\\n M = np.block([[M], [np.zeros((3,3))]])\\r\\n self.P = F.dot(self.P).dot(F.T) + M.dot(self.Q).dot(M.T)\\r\\n else:\\r\\n self.P = F.dot(self.P).dot(F.T) + M.dot(self.Q).dot(M.T)\",\n \"def rescale(data_matrix):\\n means, stdevs = scale(data_matrix)\\n\\n def rescaled(i, j):\\n if stdevs[j] > 0:\\n return (data_matrix[i][j] - means[j]) / stdevs[j]\\n else:\\n return data_matrix[i][j]\\n\\n num_rows, num_cols = shape(data_matrix)\\n return make_matrix(num_rows, num_cols, rescaled)\",\n \"def update(self, predicted, target):\\n predicted = predicted.detach().cpu().numpy()\\n target = target.detach().cpu().numpy()\\n\\n assert predicted.shape[0] == target.shape[0], \\\\\\n 'number of targets and predicted outputs do not match'\\n\\n if np.ndim(predicted) != 1:\\n assert predicted.shape[1] == self.num_classes, \\\\\\n 'number of predictions does not match size of confusion matrix'\\n predicted = np.argmax(predicted, 1)\\n else:\\n assert (predicted.max() < self.num_classes) and (predicted.min() >= 0), \\\\\\n 'predicted values are not between 1 and k'\\n\\n onehot_target = np.ndim(target) != 1\\n if onehot_target:\\n assert target.shape[1] == self.num_classes, \\\\\\n 'Onehot target does not match size of confusion matrix'\\n assert (target >= 0).all() and (target <= 1).all(), \\\\\\n 'in one-hot encoding, target values should be 0 or 1'\\n assert (target.sum(1) == 1).all(), \\\\\\n 'multi-label setting is not supported'\\n target = np.argmax(target, 1)\\n else:\\n assert (predicted.max() < self.num_classes) and (predicted.min() >= 0), \\\\\\n 'predicted values are not between 0 and k-1'\\n\\n # hack for bincounting 2 arrays together\\n x = predicted + self.num_classes * target\\n bincount_2d = np.bincount(x.astype(np.int32),\\n minlength=self.num_classes ** 2)\\n assert bincount_2d.size == self.num_classes ** 2\\n matrix = bincount_2d.reshape((self.num_classes, self.num_classes))\\n\\n self.matrix += matrix\",\n \"def predict(self, DataMatrix):\\n # Calculamos la funcion de distribucion gaussiana haciendo uso de la libreria\\n # de scipy.stats.multivariate_normal.pdf\\n aux = [stats.multivariate_normal(self.medias[i], self.covmatrix[i], allow_singular=True) for i in range(len(self.classes))]\\n self.data = [[[elem.pdf(subrow) for elem in aux] for subrow in row] for row in DataMatrix]\",\n \"def heatmap_max_regularizer(y_true, y_pred):\\n\\n return -1*K.mean(K.flatten(y_true)*K.log(K.flatten(y_pred)))\",\n \"def predict(self, X):\\n # Multiply the weight matrix, W, by the input matrix X\\n results = np.dot(self.weights, X)\\n\\n if self.transfer_function == \\\"Hard_limit\\\":\\n actualResults = np.where(results < 0, 0, 1)\\n else:\\n actualResults = results\\n return actualResults\\n \\n #print(actualResults)\",\n \"def fill_matrix(X: np.ndarray, mixture: GaussianMixture) -> np.ndarray:\\n X_pred = X[:]\\n mu, var, p = mixture\\n\\n post, _ = estep(X, mixture)\\n\\n missing = np.where(X==0)\\n\\n X_pred[missing] = (post @ mu)[missing]\\n\\n return X_pred\",\n \"def parameter_update(self, X, X_mask):\\n data_with_mask = np.hstack([X, X_mask])\\n X_pred, X_MC_preds = self.predict(data_with_mask)\\n X[X_mask] *= self.keep_coeff\\n X[X_mask] += self.weight_update_coeff * X_pred[X_mask]\\n return X, X_MC_preds\",\n \"def predicted(self):\\n return np.squeeze(self._predicted)\",\n \"def confusion_matrix(actual: list, predicted: list) -> list:\\n return confusion_matrix(actual, predicted)\",\n \"def compute_prediction(data,W1,W2,b1,b2,sigma,rng=_default_seed):\\n #print \\\"shapes\\\",W1.shape,W2.shape,b1.shape,b2.shape\\n ha = np.dot(W1,data)+b1\\n hs = ha*(ha>0)\\n oa = np.dot(W2,hs)+b2\\n return oa + normal(0,sigma)\",\n \"def predict(self, x_test, mask=True):\\n if np.isscalar(x_test):\\n return (self.models[0].predict(np.atleast_2d(np.array(x_test))), \\n self.models[1].predict(np.atleast_2d(np.array(x_test))))\\n else: \\n if mask:\\n lab1 = self.labelFunc(x_test)\\n lab2 = np.logical_not(lab1) \\n return (self.models[0].predict(x_test[lab1,]), \\n self.models[1].predict(x_test[lab2,]))\\n else:\\n return (self.models[0].predict(x_test), \\n self.models[1].predict(x_test))\",\n \"def mask_incoherent(self):\\n self.MaskPrefix = 'i' + self.MaskPrefix\\n print('Masking pixel values where .msk value is less than {0}...'.format(threshold))\\n for ig in self.Set:\\n igram = self.load_ma(ig)\\n mskFile = ig.Path[:-3] + 'msk'\\n coherence = roipy.tools.load_half(ig, 2, mskFile)\\n incoherent = ma.masked_less(coherence, self.Cothresh)\\n igram[incoherent.mask] = ma.masked\\n mskFile = self.MaskPrefix + 'Mask_' + ig.Name[:-4]\\n np.save(os.path.join(self.ProcDir, mskFile), igram.mask)\\n print(mskFile)\\n\\n print('Done')\",\n \"def predict(self, Xnew, full_cov=False, kern=None, **kwargs):\\n return self.predict_noiseless(Xnew, full_cov=full_cov, kern=kern)\",\n \"def build_predictions_matrix(self):\\n df = self._build_data_frame()\\n\\n self._train_model(df)\\n\\n test_df, smoothed_predictions = self._get_predictions(df)\\n\\n predictions_dict = {}\\n for (row_index, row), prediction in zip(test_df.iterrows(), smoothed_predictions):\\n predictions_dict[row_index] = prediction\\n\\n self.link_probability_matrix = self._convert_to_matrix(predictions_dict)\\n print(predictions_dict)\\n # print(self.link_probability_matrix.shape)\\n # print(self.link_probability_matrix)\",\n \"def predict_w_noise(self, xs, stochastic=True, **kwargs):\\n raise NotImplementedError\",\n \"def predict_MAP(self,new_times: ndarray) -> ndarray:\\n return self._pred_mag(self.map_params,new_times)\",\n \"def predict(self):\\n train_array = np.array(self.labels != 0, dtype=float)\\n if not self.ising:\\n labels_logit = self.ising_weights['vertices']\\n else:\\n neigh_num = self.adj.dot(train_array)\\n neigh_num = np.where(neigh_num == 0, 1, neigh_num)\\n neigh_weights = self.ising_weights['edges'] * self.labels\\n labels_logit = (np.multiply(neigh_weights, neigh_num**(-1))\\n + self.ising_weights['vertices'])\\n self.prediction = np.where(labels_logit > 0, 1, -1)\\n return self\",\n \"def _raw_predict(self, Xnew, full_cov=False, kern=None):\\n mu, var = self.posterior._raw_predict(kern=self.kern if kern is None else kern, Xnew=Xnew,\\n pred_var=self._predictive_variable, full_cov=full_cov)\\n if self.mean_function is not None:\\n mu += self.mean_function.f(Xnew)\\n return mu, var\",\n \"def predict_mat(self):\\n return self.u.dot(self.v.T)\",\n \"def filter(self):\\n self.filter_means = [self.m_0]\\n self.filter_covs = [self.P_0]\\n self.marginal_covs = []\\n for t in range(self.data.shape[0]):\\n m_bar, P_bar = self.one_step_prediction(self.filter_means[-1], self.filter_covs[-1])\\n\\n # Update step\\n y = self.data[t]\\n if not np.isnan(y).any():\\n v = y[:, None] - self.observation_matrix @ m_bar\\n S = self.observation_matrix @ P_bar @ self.observation_matrix.T + self.observation_cov\\n K = P_bar @ self.observation_matrix.T @ np.linalg.inv(S)\\n\\n m_bar = m_bar + K @ v\\n P_bar = P_bar - K @ S @ K.T\\n\\n self.marginal_covs.append(S)\\n\\n self.filter_means.append(m_bar)\\n self.filter_covs.append(P_bar)\\n self.filter_means = self.filter_means[1:]\\n self.filter_covs = self.filter_covs[1:]\",\n \"def fill_matrix(X: np.ndarray, mixture: GaussianMixture) -> np.ndarray:\\n shaped_X = X.reshape((X.shape[0],1,X.shape[1])).repeat(mixture.mu.shape[0],axis=1)\\n shaped_mu = mixture.mu.reshape((1,mixture.mu.shape[0],mixture.mu.shape[1])).repeat(X.shape[0],axis=0)\\n shaped_var = mixture.var.reshape((1,mixture.var.shape[0],1)).repeat(X.shape[0],axis=0)\\n shaped_p = mixture.p.reshape((1,mixture.var.shape[0],1)).repeat(X.shape[0],axis=0)\\n\\n shaped_var_extended = shaped_var.repeat(X.shape[1],axis=2)\\n log_N_X = -1/2*np.log(2*np.pi*shaped_var_extended)-(shaped_X-shaped_mu)**2*np.reciprocal(2*shaped_var_extended)\\n log_N_X_clean = np.where(shaped_X == 0, shaped_X, log_N_X).sum(axis=2,keepdims=True)\\n f = np.log(shaped_p) + log_N_X_clean.sum(axis=2,keepdims=True)\\n lse = logsumexp(f,axis=1,keepdims=True).repeat(f.shape[1],axis=1)\\n log_post = f-lse\\n\\n post = np.exp(log_post.reshape((log_post.shape[0],log_post.shape[1])))\\n\\n n, d = X.shape\\n K = mixture.mu.shape[0]\\n\\n nKd_post = post.reshape(n,K,1).repeat(d,axis=2)\\n nKd_mu = mixture.mu.reshape((1,K,d)).repeat(n,axis=0)\\n\\n predictions = (nKd_mu * nKd_post).sum(axis=1)\\n\\n return np.where(X == 0, predictions, X)\",\n \"def predict(self, X):\\n N, D = X.shape\\n y_pred = torch.zeros(N, device=X.device)\\n if self.kernel == linear_kernel:\\n W = torch.zeros(D, device=X.device)\\n for i in range(len(self.alpha)):\\n W += self.alpha[i] * self.sv_y[i] * self.sv[i]\\n print(\\\"X\\\", X.dtype, \\\"W\\\", W.dtype)\\n y_pred = torch.sign(torch.matmul(X, W) + self.b)\\n else:\\n for i in range(N):\\n s = 0.0\\n for alpha, sv_y, sv in zip(self.alpha, self.sv_y, self.sv):\\n s += alpha * sv_y * self.kernel(X[i,:], sv)\\n y_pred[i] = s\\n y_pred = torch.sign(y_pred + self.b)\\n return y_pred\",\n \"def fill_matrix(X: np.ndarray, mixture: GaussianMixture) -> np.ndarray:\\n X_pred = X.copy()\\n mu, _, _ = mixture\\n\\n post, _ = estep(X, mixture)\\n\\n # Missing entries to be filled\\n miss_indices = np.where(X == 0)\\n X_pred[miss_indices] = (post @ mu)[miss_indices]\\n\\n return X_pred\",\n \"def predict_mat(self):\\n mat = self.covs_mat.dot(self.alpha)\\n return mat.reshape(self.shape)\",\n \"def getLandmark_Witness_matrix(self):\\n return np.copy(self.distmat.take(self.subsetnodes_indices, axis=0))\",\n \"def oldPredict(self, data):\\n\\n predictions = []\\n\\n if len(self.observations) < self.k_neighbors:\\n print(f\\\"Data length ({len(data)}) was too small.\\\")\\n\\n for row in data:\\n neighbors_info = {}\\n\\n for row_index in range(len(self.observations)):\\n distance = self.calcualteEuclideanDistance(self.observations[row_index], row)\\n if len(neighbors_info) > self.k_neighbors - 1:\\n largest_distance = max(neighbors_info.keys())\\n if distance < largest_distance:\\n neighbors_info[distance] = self.labels[row_index]\\n del neighbors_info[largest_distance]\\n else:\\n neighbors_info[distance] = self.labels[row_index]\\n\\n unique_values = set(neighbors_info.values())\\n if len(unique_values) == 1:\\n value = unique_values.pop()\\n predictions.append(value)\\n else:\\n best_value = 0\\n best_value_weight = 0\\n for label in unique_values:\\n weight = 0\\n for distance in neighbors_info.keys():\\n if label == neighbors_info[distance]:\\n if 'inverse_distance' == self.weight_type:\\n weight += self.calulateWeightedVote(distance)\\n elif 'no_weight' == self.weight_type:\\n weight += 1\\n else:\\n print(\\\"Not a valid_weight_type.\\\")\\n\\n if weight > best_value_weight:\\n best_value_weight = weight\\n best_value = label\\n\\n predictions.append(best_value)\\n # print(f\\\"Neighbors Info: {neighbors_info}\\\")\\n\\n return predictions\",\n \"def search_intensification(self):\\n self.stage = 1\\n return np.mean(self.MTM[:,:-1], axis=0, \\n keepdims=True).T\",\n \"def mapd(simulated_array, observed_array, replace_nan=None, replace_inf=None,\\n remove_neg=False, remove_zero=False):\\n\\n # Treats data\\n simulated_array, observed_array = treat_values(\\n simulated_array,\\n observed_array,\\n replace_nan=replace_nan,\\n replace_inf=replace_inf,\\n remove_neg=remove_neg,\\n remove_zero=remove_zero\\n )\\n\\n a = np.sum(np.abs(simulated_array - observed_array))\\n b = np.sum(np.abs(observed_array))\\n return a / b\",\n \"def predict(self, new_table):\\r\\n \\r\\n if self.is_leaf:\\r\\n if len(self.path) == 1:\\r\\n self.cur.execute(\\\"SELECT ROUND(AVG(\\\" + self.y_name + \\\")) FROM \\\" + self.table_name + \\\" WHERE \\\" + self.path[0] + \\\";\\\")\\r\\n else:\\r\\n self.cur.execute(\\\"SELECT ROUND(AVG(\\\" + self.y_name + \\\")) FROM \\\" + self.table_name + \\\" WHERE \\\" + \\\" AND \\\".join(self.path) + \\\";\\\")\\r\\n y = self.cur.fetchone()[0]\\r\\n self.cur.execute(\\\"UPDATE \\\" + new_table + \\\" SET preds = \\\" + str(y) + \\\" WHERE \\\" + \\\" AND \\\".join(self.path) + \\\";\\\")\\r\\n \\r\\n else:\\r\\n self.lhs.predict(new_table)\\r\\n self.rhs.predict(new_table)\",\n \"def _noise_matrix(self):\\n\\n return self._noise * (np.random.rand(self._rows, self._cols)\\n - 0.5)\",\n \"def predict_entire_mask_downscaled(dataset, model, batch_size=32, tta=False):\\n loader = DataLoader(dataset, batch_size=batch_size, shuffle=False, pin_memory=True)\\n\\n weighting = torch.from_numpy(get_tile_weighting(dataset.tile_size))\\n weighting_cuda = weighting.clone().cuda().unsqueeze(0)\\n weighting = weighting.cuda().half()\\n\\n global_pred = torch.zeros(\\n (dataset.orig_size[0], dataset.orig_size[1]),\\n dtype=torch.half, device=\\\"cuda\\\"\\n )\\n global_counter = torch.zeros(\\n (dataset.orig_size[0], dataset.orig_size[1]),\\n dtype=torch.half, device=\\\"cuda\\\"\\n )\\n\\n model.eval()\\n with torch.no_grad():\\n for img, pos in loader:\\n img = img.to(\\\"cuda\\\")\\n _, _, h, w = img.shape\\n\\n if model.num_classes == 2:\\n pred = model(img)[:, 0].view(-1, h, w).sigmoid().detach()\\n else:\\n pred = model(img).view(-1, h, w).sigmoid().detach()\\n\\n if tta:\\n for f in FLIPS:\\n pred_flip = model(torch.flip(img, f))\\n if model.num_classes == 2:\\n pred_flip = pred_flip[:, 0]\\n pred_flip = torch.flip(pred_flip, f).view(-1, h, w).sigmoid().detach()\\n pred += pred_flip\\n pred = torch.div(pred, len(FLIPS) + 1)\\n\\n pred = (pred * weighting_cuda).half()\\n\\n for tile_idx, (x0, x1, y0, y1) in enumerate(pos):\\n global_pred[x0: x1, y0: y1] += pred[tile_idx]\\n global_counter[x0: x1, y0: y1] += weighting\\n\\n for i in range(len(global_pred)):\\n global_pred[i] = torch.div(global_pred[i], global_counter[i])\\n\\n return global_pred\",\n \"def trace(self):\\n self.normalize()\\n return (self._mat[0][0] + self._mat[1][1])**2\",\n \"def _apply_mask_for_mlm(self,\\n ds: tf.data.Dataset,\\n vocab_size: int):\\n\\n # Do action only for 15% of tokens (and mask output for others)\\n prob_mask_idx = 0.15\\n # 10% nothing to do, 10% random word, 80% mask\\n # prob_nothing, prob_random_replacement, prob_replace_by_mask \\\\\\n prob_mask_actions = np.array([0.1, 0.1, 0.8])\\n prob_mask_actions = prob_mask_actions * prob_mask_idx\\n prob_mask_actions = np.append(prob_mask_actions, [1 - sum(prob_mask_actions)]).tolist()\\n\\n distrib_mask = tfp.distributions.Multinomial(total_count=1,\\n probs=prob_mask_actions)\\n\\n @tf.function\\n def apply_mask(x, output):\\n inputs, enc_padding_mask = x\\n\\n input_shape = tf.shape(inputs) # Batch size * Seq Length\\n output_shape = tf.shape(output) # Batch size * Seq Length\\n\\n masks = distrib_mask.sample(input_shape,\\n seed=self._seed) # Batch size *Seq Length * Probability for each class (4)\\n masks = tf.cast(masks, dtype=tf.int32)\\n\\n random_tokens = tf.random.uniform(input_shape, minval=len(self._special_tokens), maxval=vocab_size,\\n dtype=inputs.dtype, seed=self._seed, name=None)\\n\\n # Replace with mask\\n # One is the mask token id for HuggingFace tokenizers\\n inputs_masked = tf.where(tf.math.equal(masks[:, :, 2], 1), inputs, tf.ones(input_shape, dtype=inputs.dtype))\\n\\n # Replace with random token\\n inputs_masked = tf.where(tf.math.equal(masks[:, :, 1], 1), inputs_masked, random_tokens)\\n\\n output_masked = tf.where(tf.math.equal(masks[:, :, 3], 1),\\n tf.zeros(output_shape, dtype=output.dtype),\\n output)\\n\\n return (inputs_masked, enc_padding_mask), output_masked\\n\\n return ds.map(map_func=apply_mask)\",\n \"def nmi(ypred, y):\\n# print (ypred)\\n# print (y)\\n return normalized_mutual_info_score(y,ypred)\",\n \"def predict_entire_mask_downscaled_tta(dataset, model, batch_size=32):\\n\\n loader = DataLoader(dataset, batch_size=batch_size, shuffle=False, pin_memory=True)\\n\\n weighting = torch.from_numpy(get_tile_weighting(dataset.tile_size))\\n weighting_cuda = weighting.clone().cuda().unsqueeze(0).unsqueeze(0)\\n weighting = weighting.cuda().half()\\n\\n global_pred = torch.zeros(\\n (4, dataset.orig_size[0], dataset.orig_size[1]),\\n dtype=torch.half, device=\\\"cuda\\\"\\n )\\n global_counter = torch.zeros(\\n (1, dataset.orig_size[0], dataset.orig_size[1]),\\n dtype=torch.half, device=\\\"cuda\\\"\\n )\\n\\n model.eval()\\n with torch.no_grad():\\n for img, pos in loader:\\n img = img.to(\\\"cuda\\\")\\n _, _, h, w = img.shape\\n\\n preds = []\\n if model.num_classes == 2:\\n pred = model(img)[:, 0].view(1, -1, h, w).sigmoid().detach()\\n else:\\n pred = model(img).view(1, -1, h, w).sigmoid().detach()\\n preds.append(pred)\\n\\n for f in FLIPS:\\n pred_flip = model(torch.flip(img, f))\\n if model.num_classes == 2:\\n pred_flip = pred_flip[:, 0]\\n pred_flip = torch.flip(pred_flip, f).view(1, -1, h, w).sigmoid().detach()\\n preds.append(pred_flip)\\n\\n pred = torch.cat(preds, 0)\\n pred = (pred * weighting_cuda).half()\\n\\n for tile_idx, (x0, x1, y0, y1) in enumerate(pos):\\n global_pred[:, x0: x1, y0: y1] += pred[:, tile_idx]\\n global_counter[:, x0: x1, y0: y1] += weighting\\n\\n for i in range(global_pred.size(1)):\\n global_pred[:, i] = torch.div(global_pred[:, i], global_counter[:, i])\\n\\n return global_pred\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n for key, val in predictions.items():\\n predictions[key] = val.numpy()\\n\\n for key, val in expected.items():\\n expected[key] = val.numpy()\\n\\n return predictions, expected\",\n \"def predict(self, board):\\n pass\",\n \"def loss_hole(self, mask, y_true, y_pred):\\n return self.l1((1-mask) * y_true, (1-mask) * y_pred)\",\n \"def transform(self, net, data, prediction, truth):\\n raw_output = prediction['output']\\n # raw_output = tf.constant(np.load('out.npy'))\\n batch = util.shape(raw_output)[0]\\n prediction = tf.reshape(\\n raw_output,\\n (batch, self.num_cells, self.num_cells,\\n self.num_anchors, 4 + 1 + self.num_classes))\\n box_predict, obj_predict, class_predict = tf.split(\\n prediction, [4, 1, self.num_classes], axis=-1)\\n obj_predict = tf.nn.sigmoid(obj_predict)\\n obj_predict_squeeze = tf.squeeze(obj_predict, -1)\\n xy_original, wh_original = tf.split(box_predict, [2, 2], axis=-1)\\n xy_predict, wh_predict = tf.sigmoid(xy_original), tf.exp(wh_original)\\n prediction = {\\n 'raw': raw_output,\\n 'object': obj_predict_squeeze,\\n 'object_mask': obj_predict,\\n 'coordinate': [xy_predict, wh_original],\\n 'outbox': self._cell_to_global(xy_predict, wh_predict),\\n 'class': tf.nn.softmax(class_predict),\\n }\\n inputs = (\\n prediction['object_mask'], prediction['class'],\\n prediction['outbox'])\\n corner_test, score_test, class_test, count_test = map_fn(\\n self._filter, inputs,\\n dtype=(tf.float32, tf.float32, tf.int32, tf.int32))\\n prediction['test'] = {\\n 'corner': corner_test,\\n 'class': class_test,\\n 'score': score_test,\\n 'count': count_test,\\n }\\n # the original box and label values from the dataset\\n image = data['input']\\n if truth:\\n rawlabel, truebox, count = truth\\n rawlabel += self.label_offset\\n truebox = util.corners_to_box(truebox)\\n obj, box, label = map_fn(\\n self._truth_to_cell, (truebox, rawlabel, count),\\n dtype=(tf.float32, tf.float32, tf.int32))\\n truth = {\\n 'object': obj,\\n 'object_mask': tf.expand_dims(obj, -1),\\n 'box': box,\\n 'class': slim.one_hot_encoding(label, self.num_classes),\\n 'count': count,\\n 'rawbox': truebox,\\n 'rawclass': rawlabel,\\n }\\n return image, prediction, truth\",\n \"def predict(self, X, copy=True):\\n check_is_fitted(self)\\n # X = check_array(X, copy=copy, dtype=FLOAT_DTYPES)\\n # Normalize\\n\\n X -= self.x_mean_\\n X /= self.x_std_\\n\\n Ypred = torch.mm(X, self.coef_)\\n return Ypred + self.y_mean_\",\n \"def confusionMatrix(testDataPredictions, testDataOriginal):\\n matrix = {\\\"predicted >50K correctly as >50K\\\": 0, \\\"predicted >50K incorrectly as <=50K\\\": 0,\\n \\\"predicted <=50K correctly as <=50K\\\": 0, \\\"predicted <=50K incorrectly as >50K\\\": 0}\\n\\n for instance in range(len(testDataPredictions)):\\n prediction = testDataPredictions[instance]\\n original = testDataOriginal[14].iloc[instance]\\n\\n #calculating total number of TP,TN,FP and FN\\n\\n if prediction == 1.0 and original == 1.0:\\n matrix[\\\"predicted >50K correctly as >50K\\\"] += 1.00\\n elif prediction == 0.0 and original == 1.0:\\n matrix[\\\"predicted >50K incorrectly as <=50K\\\"] += 1.00\\n elif prediction == 0.0 and original == 0.0:\\n matrix[\\\"predicted <=50K correctly as <=50K\\\"] += 1.00\\n elif prediction == 1.0 and original == 0.0:\\n matrix[\\\"predicted <=50K incorrectly as >50K\\\"] += 1.00\\n\\n #Making the confusion matrix look readable on console printing\\n print('----------------')\\n print('CONFUSION MATRIX')\\n print( 'TP: ', matrix[\\\"predicted >50K correctly as >50K\\\"], '||', 'FP: ', matrix[\\\"predicted >50K incorrectly as <=50K\\\"])\\n print('----------------')\\n print('FN: ', matrix[\\\"predicted <=50K incorrectly as >50K\\\"], '||', 'TN: ', matrix[\\\"predicted <=50K correctly as <=50K\\\"])\\n\\n # definition of sensitivity, precision and specificity formulas\\n sensitivity = matrix[\\\"predicted >50K correctly as >50K\\\"] / (\\n matrix[\\\"predicted >50K correctly as >50K\\\"] + matrix[\\\"predicted <=50K incorrectly as >50K\\\"])\\n\\n precision = matrix[\\\"predicted >50K correctly as >50K\\\"]/ (\\n matrix[\\\"predicted >50K correctly as >50K\\\"] + matrix[\\\"predicted >50K incorrectly as <=50K\\\"])\\n\\n specificity = matrix[\\\"predicted <=50K correctly as <=50K\\\"] / (\\n matrix[\\\"predicted <=50K correctly as <=50K\\\"] + matrix[\\\"predicted >50K incorrectly as <=50K\\\"])\\n\\n print('Precision: ' + str(precision*100) + '%')\\n print('Sensitivity: '+ str(sensitivity*100)+ '%')\\n print('Specificity: '+ str(specificity*100) +'%')\\n\\n return matrix, precision, sensitivity, specificity\",\n \"def predict_entire_mask(dataset, model, batch_size=32, tta=False):\\n loader = DataLoader(dataset, batch_size=batch_size, shuffle=False, pin_memory=True)\\n\\n weighting = torch.from_numpy(get_tile_weighting(dataset.tile_size))\\n weighting_cuda = weighting.clone().cuda().unsqueeze(0)\\n weighting = weighting.cuda().half()\\n\\n global_pred = torch.zeros(\\n (dataset.orig_size[0], dataset.orig_size[1]),\\n dtype=torch.half, device=\\\"cuda\\\"\\n )\\n global_counter = torch.zeros(\\n (dataset.orig_size[0], dataset.orig_size[1]),\\n dtype=torch.half, device=\\\"cuda\\\"\\n )\\n\\n model.eval()\\n with torch.no_grad():\\n for img, pos in loader:\\n img = img.to(\\\"cuda\\\")\\n _, _, h, w = img.shape\\n\\n if model.num_classes == 2:\\n pred = model(img)[:, 0].view(-1, 1, h, w).sigmoid().detach()\\n else:\\n pred = model(img).view(-1, 1, h, w).sigmoid().detach()\\n\\n if tta:\\n for f in FLIPS:\\n pred_flip = model(torch.flip(img, f))\\n if model.num_classes == 2:\\n pred_flip = pred_flip[:, 0]\\n\\n pred_flip = torch.flip(pred_flip, f).view(-1, 1, h, w).sigmoid().detach()\\n pred += pred_flip\\n pred = torch.div(pred, len(FLIPS) + 1)\\n\\n pred = torch.nn.functional.interpolate(\\n pred, (dataset.tile_size, dataset.tile_size), mode='area'\\n ).view(-1, dataset.tile_size, dataset.tile_size)\\n\\n pred = (pred * weighting_cuda).half()\\n\\n for tile_idx, (x0, x1, y0, y1) in enumerate(pos):\\n global_pred[x0: x1, y0: y1] += pred[tile_idx]\\n global_counter[x0: x1, y0: y1] += weighting\\n\\n for i in range(len(global_pred)):\\n global_pred[i] = torch.div(global_pred[i], global_counter[i])\\n\\n return global_pred\",\n \"def predict(self):\\n for column in self.data_to_predict.columns:\\n if column not in list(self.selected_features_):\\n self.data_to_predict.drop(column, axis=1, inplace=True)\\n for column in list(self.selected_features_):\\n if column not in self.data_to_predict.columns:\\n self.data_to_predict.loc[:, column] = 0\\n self.predictions = self.model.predict(\\n self.data_to_predict[self.selected_features_])\",\n \"def clone_predicted_label_tensor_output(self) -> torch.Tensor:\\n pass\",\n \"def normalize(self,matrix):\\n for i in range(self.N):\\n matrix[self.N-1][i] = 0\\n for i in range(self.n):\\n matrix[self.N - 1][self.index(i,i)] = 1\\n return matrix\",\n \"def apply(self, X, ntree_limit=0):\\n test_dmatrix = DMatrix(X, missing=self.missing, nthread=self.n_jobs)\\n return self.get_booster().predict(test_dmatrix,\\n pred_leaf=True,\\n ntree_limit=ntree_limit)\",\n \"def predict(parameters, X):\\n A2, cache = forward_propagation(X, parameters)\\n\\n predictions = (A2 > 0.5)\\n \\n return predictions\",\n \"def predict(self, x):\\n if self.training:\\n self.eval()\\n\\n with torch.no_grad():\\n output = self.forward(x)\\n\\n if self.classes > 1:\\n probs = torch.softmax(output, dim=1)\\n else:\\n probs = torch.sigmoid(output)\\n\\n probs = probs.squeeze(0)\\n tf = transforms.Compose(\\n [\\n transforms.ToPILImage(),\\n transforms.Resize(x.size[1]),\\n transforms.ToTensor()\\n ]\\n )\\n full_mask = tf(probs.cpu()) \\n\\n return full_mask\",\n \"def mase(simulated_array, observed_array, m=1, replace_nan=None, replace_inf=None,\\n remove_neg=False, remove_zero=False):\\n\\n # Checking and cleaning the data\\n\\n simulated_array, observed_array = treat_values(\\n simulated_array,\\n observed_array,\\n replace_nan=replace_nan,\\n replace_inf=replace_inf,\\n remove_neg=remove_neg,\\n remove_zero=remove_zero\\n )\\n\\n start = m\\n end = simulated_array.size - m\\n a = np.mean(np.abs(simulated_array - observed_array))\\n b = np.abs(observed_array[start:observed_array.size] - observed_array[:end])\\n return a / (np.sum(b) / end)\",\n \"def reset_hidden(hidden, mask):\\n if len(mask) != 0:\\n hidden[:, mask, :] = 0\\n \\n return hidden\",\n \"def edit_emission(mat):\\n B_1_2 = np.full(mf.K_ADDITION, mf.U_PROPABILITY)\\n mat = np.vstack([mat, B_1_2])\\n B_end_B_start = np.zeros(mf.K_ADDITION)\\n mat = np.vstack([mat, B_end_B_start])\\n mat = np.vstack([B_1_2, mat])\\n mat = np.vstack([B_end_B_start, mat])\\n k = mat.shape[0]\\n hat_vector = np.zeros((1, k))\\n dollar_vector = np.zeros((1, k))\\n hat_vector[0][0], dollar_vector[0][k - 1] = 1, 1\\n mat = np.insert(mat, 4, hat_vector, axis=1)\\n mat = np.insert(mat, 5, dollar_vector, axis=1)\\n return mf.log_marix(mat), k\",\n \"def forward(self, node_hidden, edge_hidden, adj_matrix, mask):\\n # x.shape = (batch, max_length, d_atom)\\n node_hidden = self.dropout(self.norm(node_hidden))\\n node_hidden_first, edge_hidden_temp = self.self_attn(node_hidden, node_hidden, edge_hidden, adj_matrix, mask)\\n # the first residue block\\n node_hidden_first = node_hidden + self.dropout(self.norm(node_hidden_first))\\n node_hidden_second = self.feed_forward(node_hidden_first)\\n # the second residue block\\n return node_hidden + node_hidden_first + self.dropout(self.norm(node_hidden_second)), edge_hidden\",\n \"def predict(self, X_test):\\n if self.basis_func is not None:\\n X_transformed = self.basis_func(X_test)\\n else:\\n X_transformed = X_test\\n\\n # Marginalise predictions over hyperparameters\\n mu = np.zeros([len(self.hypers), X_transformed.shape[0]])\\n var = np.zeros([len(self.hypers), X_transformed.shape[0]])\\n\\n for i, h in enumerate(self.hypers):\\n mu[i] = np.dot(self.models[i][0].T, X_transformed.T)\\n var[i] = 1. / h[1] + np.diag(np.dot(np.dot(X_transformed, self.models[i][1]), X_transformed.T))\\n\\n m = mu.mean(axis=0)\\n v = var.mean(axis=0)\\n # Clip negative variances and set them to the smallest\\n # positive float value\\n if v.shape[0] == 1:\\n v = np.clip(v, np.finfo(v.dtype).eps, np.inf)\\n else:\\n v = np.clip(v, np.finfo(v.dtype).eps, np.inf)\\n v[np.where((v < np.finfo(v.dtype).eps) & (v > -np.finfo(v.dtype).eps))] = 0\\n\\n return m, v\",\n \"def reset_mocap_welds(self):\\n if self.sim.model.nmocap > 0 and self.sim.model.eq_data is not None:\\n for i in range(self.sim.model.eq_data.shape[0]):\\n if self.sim.model.eq_type[i] == mujoco_py.const.EQ_WELD:\\n self.sim.model.eq_data[i, :] = np.array(\\n [0., 0., 0., 1., 0., 0., 0.])\\n self.sim.forward()\",\n \"def masked_mse_loss(prediction : Union[T.tensor, np.ndarray],\\n groundtruth : Union[T.tensor, np.ndarray],\\n masked_proportion : float = 0.1) -> Union[T.tensor, np.ndarray]:\\n n_batch, N, n_par = groundtruth.shape\\n mask = create_mask(n_batch, N, n_par, masked_proportion)\\n if not isinstance(prediction, np.ndarray):\\n mask = T.tensor(mask, \\n dtype=T.float32, \\n requires_grad=False)\\n \\n loss_matrix = 0.5*(groundtruth - prediction)**2\\n return (mask*loss_matrix).mean()\",\n \"def filter(self, likelihood=False, calculate_backwards_inital=False):\\n # Initial values\\n ll_hist = []\\n T = self.n_observations()\\n y_pred_online = np.zeros((self.observations_size, 1, T))\\n final_gain_partial = None\\n\\n # Kalman Filter and update over all observations t in 0..T\\n for t in range(T):\\n\\n # t-1 parameters and state\\n (A, B, C, D, Q, R) = self.parameters(t - 1)\\n (mu_tm1, V_tm1) = self.state(t - 1)\\n (y_t, u_t) = self.data(t)\\n\\n # Predict\\n (y_pred, mu_pred) = self.predict(A, B, C, D, mu_tm1, u_t)\\n V_pred = self.predict_covariance(A, V_tm1, Q)\\n y_pred_online[:, :, t] = y_pred\\n\\n (y_t, _) = self.data(t)\\n\\n ll = self.update(t, mu_pred, V_pred, y_t, y_pred, likelihood)\\n\\n if likelihood:\\n ll_hist.append(ll)\\n\\n if calculate_backwards_inital and t == T-1:\\n # Occurs after update, for V_tm1 given 1..t-1\\n (mu_tm1_new, V_tm1_new) = self.state(t-1)\\n S = C @ V_pred @ C.T + R\\n K = V_pred @ C.T @ pinv(S)\\n (A, B, C, D, Q, R) = self.parameters(t - 1)\\n final_gain_partial = V_tm1_new - K @ C @ A @ V_tm1_new\\n\\n return y_pred_online, ll_hist, final_gain_partial\",\n \"def smape(actual: np.ndarray, predicted: np.ndarray):\\n return np.mean(np.divide(np.abs(actual - predicted), (np.abs(actual) + np.abs(predicted) + np.finfo(float).eps) * 0.5))\",\n \"def getLandmark_Witness_matrix(self):\\n return np.copy(self.pointcloud.distmat[self.subsetindices]) # ndarray\",\n \"def _reclassify_disturbance(\\n landuse_transition_from_matrix, landuse_transition_to_matrix):\\n output_matrix = numpy.empty(landuse_transition_from_matrix.shape,\\n dtype=numpy.float32)\\n output_matrix[:] = NODATA_FLOAT32_MIN\\n\\n valid_pixels = numpy.ones(landuse_transition_from_matrix.shape,\\n dtype=bool)\\n if from_nodata is not None:\\n valid_pixels &= ~utils.array_equals_nodata(\\n landuse_transition_from_matrix, from_nodata)\\n\\n if to_nodata is not None:\\n valid_pixels &= ~utils.array_equals_nodata(\\n landuse_transition_to_matrix, to_nodata)\\n\\n disturbance_magnitude = disturbance_magnitude_matrix[\\n landuse_transition_from_matrix[valid_pixels],\\n landuse_transition_to_matrix[valid_pixels]].toarray().flatten()\\n\\n output_matrix[valid_pixels] = disturbance_magnitude\\n return output_matrix\",\n \"def _train_pattern(self, matrix, input, current, bmu):\\n\\n for input_neuron in range(self.input_neuron_count):\\n current_weight = matrix[current][input_neuron]\\n input_value = input[input_neuron]\\n\\n new_weight = self._determine_new_weight(current_weight,\\n input_value, current, bmu)\\n\\n self.correction_matrix[current][input_neuron] = new_weight\",\n \"def _to_bert_self_attention_mask(matrix):\\n matrix = tf.squeeze(matrix, axis=[1])\\n matrix = tf.tile(matrix, [batch_size, 1, 1])\\n return matrix\",\n \"def create_masked_lm_predictions(self,tokens, masked_lm_prob,\\n max_predictions_per_seq, vocab_words, rng):\\n\\n cand_indexes = []\\n for (i, token) in enumerate(tokens):\\n if token == \\\"[CLS]\\\" or token == \\\"[SEP]\\\":\\n continue\\n # Whole Word Masking means that if we mask all of the wordpieces\\n # corresponding to an original word. When a word has been split into\\n # WordPieces, the first token does not have any marker and any subsequence\\n # tokens are prefixed with ##. So whenever we see the ## token, we\\n # append it to the previous set of word indexes.\\n #\\n # Note that Whole Word Masking does *not* change the training code\\n # at all -- we still predict each WordPiece independently, softmaxed\\n # over the entire vocabulary.\\n if (self.do_whole_word_mask and len(cand_indexes) >= 1 and\\n token.startswith(\\\"##\\\")):\\n cand_indexes[-1].append(i)\\n else:\\n cand_indexes.append([i])\\n\\n rng.shuffle(cand_indexes)\\n\\n output_tokens = list(tokens)\\n\\n num_to_predict = min(max_predictions_per_seq,\\n max(1, int(round(len(tokens) * masked_lm_prob))))\\n\\n masked_lms = []\\n covered_indexes = set()\\n for index_set in cand_indexes:\\n if len(masked_lms) >= num_to_predict:\\n break\\n # If adding a whole-word mask would exceed the maximum number of\\n # predictions, then just skip this candidate.\\n if len(masked_lms) + len(index_set) > num_to_predict:\\n continue\\n is_any_index_covered = False\\n for index in index_set:\\n if index in covered_indexes:\\n is_any_index_covered = True\\n break\\n if is_any_index_covered:\\n continue\\n for index in index_set:\\n covered_indexes.add(index)\\n\\n masked_token = None\\n # 80% of the time, replace with [MASK]\\n if rng.random() < 0.8:\\n masked_token = \\\"[MASK]\\\"\\n else:\\n # 10% of the time, keep original\\n if rng.random() < 0.5:\\n masked_token = tokens[index]\\n # 10% of the time, replace with random word\\n else:\\n masked_token = vocab_words[rng.randint(0, len(vocab_words) - 1)]\\n\\n output_tokens[index] = masked_token\\n\\n masked_lms.append(MaskedLmInstance(index=index, label=tokens[index]))\\n assert len(masked_lms) <= num_to_predict\\n masked_lms = sorted(masked_lms, key=lambda x: x.index)\\n\\n masked_lm_positions = []\\n masked_lm_labels = []\\n for p in masked_lms:\\n masked_lm_positions.append(p.index)\\n masked_lm_labels.append(p.label)\\n\\n return (output_tokens, masked_lm_positions, masked_lm_labels)\",\n \"def process(self, mat):\",\n \"def mnfb(actual: np.ndarray, predicted: np.ndarray):\\n df = pd.DataFrame.from_dict({\\n 'actual': actual,\\n 'predicted': predicted,\\n })\\n df['err'] = df['predicted'] - df['actual']\\n df['mo'] = df['predicted'] / df['actual']\\n df['om'] = df['actual'] / df['predicted']\\n\\n df_pos = df.loc[df['err'] >= 0, :]\\n df_neg = df.loc[df['err'] < 0, :]\\n\\n # drop inf\\n df_pos.replace([np.inf, -np.inf], np.nan, inplace=True)\\n df_pos.dropna(inplace=True)\\n df_neg.replace([np.inf, -np.inf], np.nan, inplace=True)\\n df_neg.dropna(inplace=True)\\n\\n # df_pos == M >= O -> sum(M/O - 1)\\n # df_neg == M < O -> sum(1 - O/M)\\n return sum(df_pos['mo'] - 1.0) / len(df_pos['mo']) + \\\\\\n sum(1.0 - df_neg['om']) / len(df_neg['om'])\",\n \"def test_predict_uncertain_inputs(self):\\n X = np.linspace(-5,5, 10)[:, None]\\n Y = 2*X + np.random.randn(*X.shape)*1e-3\\n m = GPy.models.BayesianGPLVM(Y, 1, X=X, kernel=GPy.kern.Linear(1), num_inducing=1)\\n m.Gaussian_noise[:] = 1e-4\\n m.X.mean[:] = X[:]\\n m.X.variance[:] = 1e-5\\n m.X.fix()\\n m.optimize()\\n X_pred_mu = np.random.randn(5, 1)\\n X_pred_var = np.random.rand(5, 1) + 1e-5\\n from GPy.core.parameterization.variational import NormalPosterior\\n X_pred = NormalPosterior(X_pred_mu, X_pred_var)\\n # mu = \\\\int f(x)q(x|mu,S) dx = \\\\int 2x.q(x|mu,S) dx = 2.mu\\n # S = \\\\int (f(x) - m)^2q(x|mu,S) dx = \\\\int f(x)^2 q(x) dx - mu**2 = 4(mu^2 + S) - (2.mu)^2 = 4S\\n Y_mu_true = 2*X_pred_mu\\n Y_var_true = 4*X_pred_var\\n Y_mu_pred, Y_var_pred = m.predict_noiseless(X_pred)\\n np.testing.assert_allclose(Y_mu_true, Y_mu_pred, rtol=1e-3)\\n np.testing.assert_allclose(Y_var_true, Y_var_pred, rtol=1e-3)\",\n \"def FitFundamentalMatrix(mss):\\n\\n\\tbatch_size = mss.shape[0]\\n\\tnum_correspondences = mss.shape[1]\\t\\n\\n\\tmss_src, T_src = utils.normalise2dpts(mss[:, :, :2])\\n\\tmss_target, T_target = utils.normalise2dpts(mss[:, :, 2:])\\n\\n\\tones = torch.tensor([1]).double().cuda().view(1, 1, 1).repeat(batch_size, num_correspondences, 1)\\n\\tmss_src = torch.cat([mss_src, ones], dim = 2)\\n\\tmss_target = torch.cat([mss_target, ones], dim = 2)\\n\\n\\trow = torch.cat([\\n\\t\\tmss_src * mss_target[:, :, 0].view(batch_size, num_correspondences, 1), \\n\\t\\tmss_src * mss_target[:, :, 1].view(batch_size, num_correspondences, -1),\\n\\t\\tmss_src \\n\\t], dim = 2)\\n\\n\\n\\touter_product = row.unsqueeze(3) * row.unsqueeze(2)\\n\\tmat = outer_product.sum(dim = 1)\\n\\n\\n\\tU = []\\n\\tS = []\\n\\tVT = []\\n\\n\\tfor i in range(batch_size):\\n\\n\\t\\t_, V = torch.symeig(mat[i])\\n\\t\\tu, s, v = torch.svd(V[:, 0].view(3, 3))\\n\\t\\tvt = v.permute(1, 0)\\n\\t\\ts[2] = 0\\n\\n\\t\\tU.append(u.unsqueeze(0))\\n\\t\\tS.append(torch.diag(s).unsqueeze(0))\\n\\t\\tVT.append(vt.unsqueeze(0))\\n\\n\\tU = torch.cat(U, dim = 0)\\n\\tS = torch.cat(S, dim = 0)\\n\\tVT = torch.cat(VT, dim = 0)\\n\\n\\tF = torch.bmm(torch.bmm(U, S), VT)\\n\\tF = torch.bmm(T_src, torch.bmm(F.permute(0, 2, 1), T_target.permute(0, 2, 1)))\\n\\tF = F / F[:, 2, 2].view(batch_size, 1, 1)\\n\\n\\tutils.nan_check(F)\\n\\n\\treturn F\",\n \"def innovation(observation: np.ndarray, observation_predicted: np.ndarray) -> np.ndarray:\\n return observation - observation_predicted\",\n \"def recover(self, reduced):\\n return np.dot(reduced, self.w)+self.mu\",\n \"def rescale_data(self):\\n\\n # Dividing every array of simulated data vectors by the mean of that array.\\n '''# Didnt work\\n for key in self.data.keys():\\n self.data[key] /= np.mean(self.data[key])\\n '''\\n\\n self.rescaled = True\\n\\n # Mean normalization\\n \\\"\\\"\\\" didnt work\\n for key in self.data.keys():\\n self.data[key] -= np.mean(self.data[key])\\n self.data[key] /= (np.max(self.data[key]) - np.min(self.data[key]))\\n \\\"\\\"\\\"\\n\\n # Median normalization\\n \\\"\\\"\\\" didnt work, still dividing by large number \\n for key in self.data.keys():\\n self.data[key] -= np.median(self.data[key])\\n self.data[key] /= (np.max(self.data[key]) - np.min(self.data[key]))\\n \\\"\\\"\\\"\\n\\n # Divide by median\\n \\\"\\\"\\\" didnt work\\n for key in self.data.keys():\\n self.data[key] -= np.median(self.data[key])\\n self.data[key] /= (np.median(self.data[key]))\\n \\\"\\\"\\\"\\n\\n # Take logarithm of data\\n \\\"\\\"\\\" didnt work\\n for key in self.data.keys():\\n self.data[key] = np.log10(self.data[key])\\n \\\"\\\"\\\"\\n\\n # Scale by length of vector\\n \\\"\\\"\\\"\\n for key in self.data.keys():\\n self.data[key] /= np.linalg.norm(self.Cl_noiseless)\\n \\\"\\\"\\\"\\n\\n \\n # Scale by negative of the natural logarithm \\n for key in self.data.keys():\\n self.data[key] = -1 * np.log(self.data[key]) \\n \\n \\\"\\\"\\\"\\n # Scale by subtracting the mean and dividing by std\\n std = np.nanstd(self.data['data'])\\n mean = np.nanmean(self.data['data'])\\n for key in self.data.keys():\\n # self.data[key] -= np.log(self.Cl_noiseless) # -1* # scale this same way\\n # self.data[key] -= self.Cl_noiseless # -1* # scale this same way\\n self.data[key] -= mean \\n self.data[key] /= std\\n \\\"\\\"\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.56636155","0.5445435","0.53317714","0.5287088","0.5251721","0.52371836","0.52243984","0.51921326","0.518488","0.51842225","0.51705045","0.51641315","0.51526016","0.50631","0.5036301","0.50272423","0.50238395","0.5009977","0.4998374","0.49955526","0.49938983","0.49904048","0.49897113","0.49886805","0.49885273","0.49863496","0.49634007","0.49631697","0.49425358","0.49400094","0.49303693","0.49077156","0.49076185","0.49051788","0.49011853","0.4893192","0.4890937","0.48888278","0.4887554","0.48867154","0.48812398","0.4869466","0.48678523","0.48499566","0.48482865","0.48473722","0.4845837","0.4843017","0.4837835","0.48312446","0.4827849","0.4820989","0.48207378","0.48186332","0.4817468","0.48129848","0.48121777","0.48045167","0.480426","0.47983813","0.47919568","0.47837698","0.47747052","0.47737736","0.47670937","0.4766169","0.47648677","0.47589362","0.4752713","0.47520792","0.47500697","0.47485998","0.47424513","0.4740992","0.47385752","0.47383195","0.47315425","0.47309044","0.47298118","0.47280437","0.47252968","0.47238472","0.47206452","0.47198445","0.47089958","0.47089818","0.47063157","0.47055978","0.4705128","0.46926907","0.4685901","0.46762487","0.46732098","0.46710014","0.4670792","0.46682307","0.4666859","0.46650648","0.46643108","0.46639797"],"string":"[\n \"0.56636155\",\n \"0.5445435\",\n \"0.53317714\",\n \"0.5287088\",\n \"0.5251721\",\n \"0.52371836\",\n \"0.52243984\",\n \"0.51921326\",\n \"0.518488\",\n \"0.51842225\",\n \"0.51705045\",\n \"0.51641315\",\n \"0.51526016\",\n \"0.50631\",\n \"0.5036301\",\n \"0.50272423\",\n \"0.50238395\",\n \"0.5009977\",\n \"0.4998374\",\n \"0.49955526\",\n \"0.49938983\",\n \"0.49904048\",\n \"0.49897113\",\n \"0.49886805\",\n \"0.49885273\",\n \"0.49863496\",\n \"0.49634007\",\n \"0.49631697\",\n \"0.49425358\",\n \"0.49400094\",\n \"0.49303693\",\n \"0.49077156\",\n \"0.49076185\",\n \"0.49051788\",\n \"0.49011853\",\n \"0.4893192\",\n \"0.4890937\",\n \"0.48888278\",\n \"0.4887554\",\n \"0.48867154\",\n \"0.48812398\",\n \"0.4869466\",\n \"0.48678523\",\n \"0.48499566\",\n \"0.48482865\",\n \"0.48473722\",\n \"0.4845837\",\n \"0.4843017\",\n \"0.4837835\",\n \"0.48312446\",\n \"0.4827849\",\n \"0.4820989\",\n \"0.48207378\",\n \"0.48186332\",\n \"0.4817468\",\n \"0.48129848\",\n \"0.48121777\",\n \"0.48045167\",\n \"0.480426\",\n \"0.47983813\",\n \"0.47919568\",\n \"0.47837698\",\n \"0.47747052\",\n \"0.47737736\",\n \"0.47670937\",\n \"0.4766169\",\n \"0.47648677\",\n \"0.47589362\",\n \"0.4752713\",\n \"0.47520792\",\n \"0.47500697\",\n \"0.47485998\",\n \"0.47424513\",\n \"0.4740992\",\n \"0.47385752\",\n \"0.47383195\",\n \"0.47315425\",\n \"0.47309044\",\n \"0.47298118\",\n \"0.47280437\",\n \"0.47252968\",\n \"0.47238472\",\n \"0.47206452\",\n \"0.47198445\",\n \"0.47089958\",\n \"0.47089818\",\n \"0.47063157\",\n \"0.47055978\",\n \"0.4705128\",\n \"0.46926907\",\n \"0.4685901\",\n \"0.46762487\",\n \"0.46732098\",\n \"0.46710014\",\n \"0.4670792\",\n \"0.46682307\",\n \"0.4666859\",\n \"0.46650648\",\n \"0.46643108\",\n \"0.46639797\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.47924504"},"document_rank":{"kind":"string","value":"60"}}},{"rowIdx":83688,"cells":{"query":{"kind":"string","value":"This node specifies a lowrank structure with rank `rank` for the predicted matrix. Weights the resulting matrix by 1/sigma^2."},"document":{"kind":"string","value":"def __init__(self, shape, rank, sigma):\n assert isinstance(sigma, int)\n assert sigma > 0.0\n assert isinstance(shape, tuple)\n assert isinstance(rank, int)\n assert rank > 0\n assert rank <= min(*shape)\n self.shape = shape\n self.rank = rank\n self.sigma = sigma\n\n self.weight_mat = np.empty(self.shape)\n self.weight_mat.fill(1.0/sigma**2)\n\n self.u = np.zeros((self.shape[0], self.rank))\n self.v = np.zeros((self.shape[1], self.rank))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def find_optimal_low_rank_matrix( self, orig_similarity_matrix, orig_rank, u, s, v, singular_reduction ):\n '''rank_list = list()\n sum_singular_values = list()\n for rank in range( 0, orig_rank ):\n compute_result = self.compute_low_rank_matrix( u, s, v, rank + 1 )\n rank_list.append( ( rank + 1 ) / float( orig_rank ) )\n sum_singular_values.append( compute_result[ 1 ] )\n utils._plot_singular_values_rank( rank_list, sum_singular_values )'''\n return self.compute_low_rank_matrix( u, s, v, int( singular_reduction * orig_rank ) )","def set_rank(self,rank):\n self._rank = rank","def rank(self, rank):\n self._rank = rank","def sample_low_rank(self, n_samples, mu, logvar, F):\n #F = torch.unsqueeze(F, dim=1).repeat(1, n_samples, 1, 1) # [self.batch_size, n_samples, self.Y_dim, self.rank]\n F = F.repeat(n_samples, 1, 1) # [self.batch_size*n_samples, self.Y_dim, self.rank]\n mu = mu.repeat(n_samples, 1) # [self.batch_size*n_samples, self.Y_dim]\n logvar = logvar.repeat(n_samples, 1) # [self.batch_size*n_samples, self.Y_dim]\n eps_low_rank = torch.randn(self.batch_size*n_samples, self.rank, 1)\n eps_diag = torch.randn(self.batch_size*n_samples, self.Y_dim)\n half_var = torch.exp(0.5*logvar) # [self.batch_size*n_samples, self.Y_dim]\n samples = torch.bmm(F, eps_low_rank).squeeze() + mu + half_var*eps_diag\n samples = samples.reshape(n_samples, self.batch_size, self.Y_dim)\n samples = samples.transpose(0, 1)\n samples = self.unwhiten_back(samples)\n samples = samples.data.cpu().numpy()\n return samples","def rank():\n return 0","def update(self, rank):\n # calculate MR and MRR\n self.mr += rank\n self.mrr += 1 / rank\n # calculate Hits@k\n if rank <= 1:\n self.hits1 += 1\n self.hits3 += 1\n self.hits5 += 1\n self.hits10 += 1\n elif rank <= 3:\n self.hits3 += 1\n self.hits5 += 1\n self.hits10 += 1\n elif rank <= 5:\n self.hits5 += 1\n self.hits10 += 1\n elif rank <= 10:\n self.hits10 += 1","def classify_rank(rank):\n return np.where(rank>0, 1, 0)","def getRank(self):\r\n return self.rank","def process_assumed_rank(self, node):\n # fortran_generic must already be empty\n options = node.options\n params = node.ast.declarator.params\n\n for rank in range(options.F_assumed_rank_min,\n options.F_assumed_rank_max+1):\n newdecls = copy.deepcopy(params)\n for decl in newdecls:\n attrs = decl.declarator.attrs\n meta = decl.declarator.metaattrs\n if meta[\"assumed-rank\"]:\n # Replace dimension(..) with rank(n).\n attrs[\"dimension\"] = None\n attrs[\"rank\"] = rank\n meta[\"assumed-rank\"] = None\n generic = ast.FortranGeneric(\n \"\", function_suffix=\"_{}d\".format(rank),\n decls=newdecls)\n node.fortran_generic.append(generic)\n\n # Remove assumed-rank from C function.\n for decl in params:\n attrs = decl.declarator.attrs\n meta = decl.declarator.metaattrs\n if meta[\"assumed-rank\"]:\n attrs[\"dimension\"] = None\n meta[\"assumed-rank\"] = None\n node.declgen = node.ast.gen_decl()","def __rank__(self) -> int:","def get_rank(self):\r\n return self.rank","def getRank(self):\n return self.rank","def get_rank(self) -> int:\r\n return self.rank","def determine_rank(self, X, err):\n singularValues,_,_,_ = self.compute_svd(X,k=-1)\n ratio = np.array([np.linalg.norm(singularValues[k:]) / np.linalg.norm(singularValues) for k in\n range(len(singularValues) - 1, 0, -1)])\n find_idx = numpy.nonzero(ratio <= err)\n rank = find_idx[0]\n if self.global_rank==0: print('Estimated rank=',rank)\n return rank","def compute_low_rank_matrix( self, u, s, v, rank ):\n u_approx = u[ :, :rank ]\n s_approx = s[ :rank ]\n sum_taken_percent = np.sum( s_approx ) / float( np.sum( s ) )\n s_approx = np.diag( np.array( s_approx ) )\n v_approx = v[ :rank, : ]\n return [ u_approx.dot( s_approx ).dot( v_approx ), sum_taken_percent ]","def __init__(self, rank):\n self.rank = rank\n self.face = 'down'","def getRank(self):\n return self._rank","def optim_initialize(self, rank=0):\n self.rank = rank\n try:\n # We're probably dealing with DDP\n self.model = self.agent.model.module\n except:\n self.model = self.agent.model\n\n # Split into (optionally) three groups for separate LRs.\n conv_params, dynamics_model_params, q_l1_params, other_params = self.model.list_params()\n self.optimizer = self.OptimCls([\n {'params': conv_params, 'lr': self.encoder_lr},\n {'params': q_l1_params, 'lr': self.q_l1_lr},\n {'params': dynamics_model_params, 'lr': self.dynamics_model_lr},\n {'params': other_params, 'lr': self.learning_rate}\n ],\n **self.optim_kwargs)\n\n if self.initial_optim_state_dict is not None:\n self.optimizer.load_state_dict(self.initial_optim_state_dict)\n if self.prioritized_replay:\n self.pri_beta_itr = max(1, self.pri_beta_steps // self.sampler_bs)","def learning_to_rank(self):\n self.error_throw('rank')\n\n instance = Instance(self.table_name)\n instance.addTable(Table_LTR(instance,False,'',''))\n if self.import_method == 'mysql': instance = self.mysql_handle(instance)\n elif self.import_method == 'csv': instance = self.csv_handle(instance)\n\n self.rank_learning(instance)\n\n self.rank_method = methods_of_ranking[1] # = 'learn_to_rank'","def rank_local(model, number_of_core_samples, step_size, name, threshold, output_path, top_k_to_plot):\n feature_vectors = pd.DataFrame(np.load('{}/feature_vectors_{}_{}_{}.npy'.format(output_path, number_of_core_samples, step_size, name)), index = np.arange(number_of_core_samples), columns=pd.MultiIndex.from_product([model.perturbation_status_columns, model.feature_names], names=['perturbation_status','features']))\n core_feature_vectors = feature_vectors.loc[:, 'core'].copy()\n core_feature_vectors = normalize_inputs(model, core_feature_vectors)\n raw_outputs = pd.DataFrame(np.load('{}/outputs_{}_{}_{}.npy'.format(output_path, number_of_core_samples, step_size, name)), index = np.arange(number_of_core_samples), columns=pd.MultiIndex.from_product([model.output_names, model.perturbation_status_columns_output], names=['outputs','perturbation_status']))\n outputs = normalize_outputs(model, pd.DataFrame(raw_outputs))\n hessian = calculate_hessian(model, outputs, step_size)\n hessian = denoise_hessian(hessian)\n np.save('{}/hessian_{}_{}_{}'.format(output_path,number_of_core_samples, step_size, name), hessian)\n \n ranking = []\n for output_name in model.output_names:\n interaction_maps = list(futures.map(functools.partial(create_interaction_map, model, hessian, core_feature_vectors, output_name, 'linear'), model.feature_pairs))\n for ind in range(len(model.feature_pairs)):\n first_variable, second_variable = model.feature_pairs[ind].split(' and ')\n if ind < top_k_to_plot:\n model.set_ground_truth(number_of_core_samples, step_size, name, output_path)\n most_nonlinear_sample = hessian[output_name][model.feature_pairs[ind]].abs().idxmax()\n y_coord = 100 * (feature_vectors.loc[most_nonlinear_sample, 'core'][first_variable] - model.feature_limits[first_variable][0]) / (model.feature_limits[first_variable][1] - model.feature_limits[first_variable][0])\n x_coord = 100 * (feature_vectors.loc[most_nonlinear_sample, 'core'][second_variable] - model.feature_limits[second_variable][0]) / (model.feature_limits[second_variable][1] - model.feature_limits[second_variable][0])\n plot_interaction_map(model, name, interaction_maps[ind], output_name, first_variable, second_variable, x_coord, y_coord, output_path)\n features = []\n features.append(feature_vectors.loc[most_nonlinear_sample, 'core'])\n features.append(feature_vectors.loc[most_nonlinear_sample, first_variable])\n features.append(feature_vectors.loc[most_nonlinear_sample, second_variable])\n features.append(feature_vectors.loc[most_nonlinear_sample, model.feature_pairs[ind]])\n features = np.array(features)\n # local_ranking = list(futures.map(functools.partial(get_max_filters), interaction_maps))\n # ranking_indices = np.argsort(local_ranking)[::-1]\n # ranking.append((output_name, list(np.array(model.feature_pairs)[np.array(ranking_indices)]), np.array(local_ranking)[ranking_indices]))\n pickle.dump(obj = ranking, file = open('{}/local_ranking_{}_{}_{}.pickle'.format(output_path,number_of_core_samples, step_size, name),'wb'))\n return ranking","def get_rank(self):\n return self.rank","def mpi_rank(self, new_value):","def get_rank(score):\n if score in range(0, 500):\n return RANKTYPES[0]\n elif score in range(500, 1500):\n return RANKTYPES[1]\n elif score in range(1500, 2000):\n return RANKTYPES[2]\n elif score in range(2000, 2500):\n return RANKTYPES[3]\n elif score in range(2500, 3000):\n return RANKTYPES[4]\n elif score in range(3000, 4000):\n return RANKTYPES[5]\n elif score in range(4000, 5500):\n return RANKTYPES[6]\n elif score > 5500:\n return RANKTYPES[7]","def update_rank(self):\n self.__rank += 1","def rank(self):\n return self._rank","def rank(self):\n return self._rank","def rank(self):\n return self._rank","def rank(self):\n return self._rank","def rank(self):\n return self._rank","def __init__(self, nrows: int, ncols: int, rank: int):\n try:\n nrows = int(nrows)\n except ValueError:\n print(\"Invalid value of nrows. Must be an int.\")\n self.nrows = nrows\n try:\n ncols = int(ncols)\n except ValueError:\n print(\"Invalid value of ncols. Must be an int.\")\n self.ncols = ncols\n if rank is None:\n rank = np.minimum(nrows, ncols)\n try:\n rank = int(rank)\n except ValueError:\n print(\"Invalid value of rank. Must be an int.\")\n self.rank = rank\n super(GaussianRandomSampling, self).__init__(mat=self.build_sampling_matrix())","def workout_rank(a, rank):\r\n # Check if workout score is empty\r\n if pd.isnull(a):\r\n return np.nan\r\n else:\r\n return int(rank)","def get_rank(self):\n return self.__rank","def mrr(self, ranking):\n return np.mean(ranking)","def _validate_rank(self, rank: int) -> None:\n if not isinstance(rank, int):\n raise TypeError(\"rank should be an integer\")\n if rank < 0:\n raise ValueError(\"rank cannot be negative\")\n if rank >= self.L**2:\n raise ValueError(f\"rank should be less than {self.L**2}\")","def _apply_rank(U, S, VT, r, verbose=False):\n if r is None:\n r = len(S)\n S_r = S[:r]\n U_r = U[:, :r]\n VT_r = VT[:r]\n if verbose:\n print(\"Rank:\", r, \"SVD shape:\", U_r.shape, S_r.shape, VT_r.shape)\n return U_r, S_r, VT_r","def weyl_vector(rank):\n return np.ones(rank, dtype=utils.itype)","def rank(self):\n del self._rank","def rank(self) -> int:\n return self._rank","def ranking_loss(self, sim, margin=1.0):\n # sim = 1.0 - distance\n pos_sim, neg_sim = tf.slice(sim, [0, 0], [-1, 1]), tf.slice(sim, [0, 1], [-1, -1])\n pos_dis, neg_dis = 1.0 - pos_sim, 1.0 - neg_sim\n hinge_loss = tf.nn.relu(margin - neg_dis)\n ranking_loss = tf.reduce_mean(\n pos_dis) + tf.reduce_mean(tf.reduce_sum(hinge_loss, axis=-1))\n\n return ranking_loss","def rank(self):\n return self.matrix().rank()","def individual_weights(self, labels, ranks):\n del ranks\n return labels","def rank(self, value: int) -> None:\n self._rank = value","def GetColumnIndexOfRank(\n self: \"HereditaryStratumOrderedStoreList\",\n rank: int,\n ) -> typing.Optional[int]:\n if self.GetNumStrataRetained() == 0:\n return None\n else:\n res_idx = binary_search(\n lambda idx: self.GetRankAtColumnIndex(idx) >= rank,\n 0,\n self.GetNumStrataRetained() - 1,\n )\n if res_idx is None:\n return None\n elif self.GetRankAtColumnIndex(res_idx) == rank:\n return res_idx\n else:\n return None","def rank() -> int:\n return dist.get_rank() if dist.is_initialized() else 0","def rank(self):\n if self._rank is None:\n self._rank = self.prufer_rank()\n return self._rank","def predict(self):\n\n # get current level and problem description\n L = self.level\n P = L.prob\n\n # evaluate RHS at left point\n L.f[0] = P.eval_f(L.u[0], L.time)\n\n for m in range(1, self.coll.num_nodes + 1):\n # copy u[0] to all collocation nodes, evaluate RHS\n if self.params.initial_guess == 'spread':\n L.u[m] = P.dtype_u(L.u[0])\n L.f[m] = P.eval_f(L.u[m], L.time + L.dt * self.coll.nodes[m - 1])\n # start with zero everywhere\n elif self.params.initial_guess == 'zero':\n L.u[m] = P.dtype_u(init=P.init, val=0.0)\n L.f[m] = P.dtype_f(init=P.init, val=0.0)\n # start with random initial guess\n elif self.params.initial_guess == 'random':\n L.u[m] = P.dtype_u(init=P.init, val=self.rng.rand(1)[0])\n L.f[m] = P.dtype_f(init=P.init, val=self.rng.rand(1)[0])\n else:\n raise ParameterError(f'initial_guess option {self.params.initial_guess} not implemented')\n\n # indicate that this level is now ready for sweeps\n L.status.unlocked = True\n L.status.updated = True","def get_rank(self):\n return int(self._rank)","def predict(self, X, from_idx=False, get_ranks=False):\n return super().predict(X, from_idx=from_idx, get_ranks=get_ranks)","def predict(self, X, from_idx=False, get_ranks=False):\n return super().predict(X, from_idx=from_idx, get_ranks=get_ranks)","def predict(self, X, from_idx=False, get_ranks=False):\n return super().predict(X, from_idx=from_idx, get_ranks=get_ranks)","def predict(self, X, from_idx=False, get_ranks=False):\n return super().predict(X, from_idx=from_idx, get_ranks=get_ranks)","def addRankToLine(self,cols,rank):\n line = \"\"\n ann = \";RankScore=\" + str(self.family_id) + \":\" + str(rank)\n for c in cols:\n line = line + c\n if cols.index(c) == 7: # 0-based index\n line = line + ann\n if cols.index(c) < len(cols):\n line = line + \"\\t\"\n print(line)","def rank(self):\n\n if self._rank >= 0:\n return self._rank\n\n reduced, operations = self.to_row_echelon()\n non_leading_rows = 0\n for i in range(self.rows, 0, -1):\n if not reduce(lambda x,y: x or y, reduced.row(i)):\n non_leading_rows += 1\n else:\n break\n\n self._rank = self.rows - non_leading_rows\n return self._rank","def select_top_predictions(self, prediction, img_w, img_h):\n scores = prediction.get_field(\"scores\")\n boxes = prediction.bbox\n weighted_scores = []\n for idx, (box, score) in enumerate(zip(boxes, scores)):\n box = box.to(torch.int64)\n x1, y1, x3, y3 = box[:4].tolist()\n if (y3 - y1 > self.min_bbox_h * img_h) and (x3 - x1 > self.min_bbox_w * img_w) and ((x3 - x1) * (y3 - y1) > self.min_bbox_area * img_h * img_w):\n weighted_score = self.score_weight * score.item() + self.pos_weight * math.exp(-5*(math.pow(0.5*(x1+x3)/img_w-0.5, 2)+math.pow(0.5*(y1+y3)/img_h-0.5, 2))) + self.area_weight * (x3 - x1) * (y3 - y1) / (img_h * img_w)\n # print('weihted_score={}={}*{}(score)+{}*{}(position)+{}*{}(area)'.format(weighted_score, self.score_weight, score.item(), self.pos_weight, math.exp(-5*(math.pow(0.5*(x1+x3)/img_w-0.5, 2)+math.pow(0.5*(y1+y3)/img_h-0.5, 2))), self.area_weight, (x3 - x1) * (y3 - y1) / (img_h * img_w * 1.0)))\n else:\n weighted_score = 0.0\n weighted_scores.append(weighted_score)\n rank_idxs = np.argsort(-1*np.array(weighted_scores))\n top_predictions = []\n for rank_idx in rank_idxs[:self.topn]:\n if weighted_scores[rank_idx] <= 0:\n continue\n top_prediction = dict()\n scores_all = prediction[[rank_idx]].get_field(\"scores_all\")\n scores_all[:, -1] = max(scores_all[:, -1], self.score_thresh_high) # other category\n boxes = prediction[[rank_idx]].bbox\n box = boxes[0].to(torch.int64)\n top_prediction['bbox'] = box[:4].tolist()\n if scores_all.shape[1] < len(self.CATEGORIES):\n scores, labels = scores_all[0][0:].sort(0, descending=True)\n else:\n scores, labels = scores_all[0][1:].sort(0, descending=True)\n top_prediction['category'] = [self.CATEGORIES[label+1] for label in labels]\n top_prediction['score'] = [score.item() for score in scores]\n top_predictions.append(top_prediction)\n if len(top_predictions) == 0 and self.data_source == 0: # use whole image if no bbox\n top_prediction = dict()\n top_prediction['bbox'] = [0, 0, img_w-1, img_h-1]\n top_prediction['category'] = [self.CATEGORIES[-1]]\n top_prediction['score'] = [0.0]\n top_predictions.append(top_prediction)\n return top_predictions","def rank_pre_extract(self, mention_data, predictions):\n mdata = pd.DataFrame(mention_data)\n\n\n\n\n pass","def mrr_at(prediction, target, k=10):\n rank_target = (prediction.t() > prediction[range(prediction.shape[0]), target]).sum(0) + 1.0\n rr = 1.0 / rank_target.to(torch.float32)\n rr[rank_target > k] = 0.0\n mrr = rr.mean()\n return mrr","def rank_and_assign(self, cutoff_matrix_element):\r\n\r\n L0 = (qt.liouvillian(self.rotating_frame_hamiltonian, self.jump_ops))\r\n \r\n relevance_table = [[self.calculate_first_order_correction(cutoff_matrix_element,L0,ket_index=n,bra_index=m) for m in range(self.dim)] for n in range(self.dim)]\r\n relevance_table = np.asarray(relevance_table)\r\n \r\n number_of_transitions = int(self.dim*(self.dim-1)/2)\r\n transition_rank = [None for i in range(number_of_transitions)]\r\n # This loop ranks drive terms according to relevance \r\n for rank in range(number_of_transitions):\r\n max_ranked_indices = np.where(relevance_table == relevance_table.max())\r\n indices = [max_ranked_indices[0][0], max_ranked_indices[1][0]]\r\n transition_rank[rank] = [relevance_table.max(), indices]\r\n relevance_table[indices[0]][indices[1]] = relevance_table[indices[1]][indices[0]] = 0\r\n \r\n # This graphical algorithm assigns an integer to each eigenstate of the Hamiltonian based on the ranking from above\r\n integer_list = [None for i in range(self.dim)]\r\n # START ALGORITHM\r\n # initialize first term into a graph\r\n first_index = transition_rank[0][1]\r\n graph_list = [[first_index[0],first_index[1]]]\r\n integer_list[max(first_index)] = 1\r\n integer_list[min(first_index)] = 0\r\n # assign subsequent terms\r\n for i in range(1,number_of_transitions):\r\n # if no more non-zero relevance parameters, then break \r\n if transition_rank[i][0] == 0.0:\r\n break\r\n else:\r\n index = transition_rank[i][1]\r\n # scenario (i) neither states have been incorporated into the graph \r\n if integer_list[index[0]]==integer_list[index[1]]==None: \r\n integer_list[max(index)] = 1\r\n integer_list[min(index)] = 0\r\n # place them in a new graph\r\n graph_list.append([index[0],index[1]])\r\n # scenario (ii) one of the states has been incorporated, but not the other\r\n elif integer_list[index[0]]==None:\r\n if index[0] > index[1]:\r\n integer_list[index[0]] = integer_list[index[1]] + 1\r\n else:\r\n integer_list[index[0]] = integer_list[index[1]] - 1\r\n # find which graph component to put the state in (the component the other state is in)\r\n for k,graph in enumerate(graph_list):\r\n if index[1] in graph:\r\n # place that state in that graph component\r\n graph_list[k].append(index[0]) \r\n break\r\n elif integer_list[index[1]]==None:\r\n if index[0] > index[1]:\r\n integer_list[index[1]] = integer_list[index[0]] - 1\r\n else:\r\n integer_list[index[1]] = integer_list[index[0]] + 1\r\n for k,graph in enumerate(graph_list):\r\n if index[0] in graph:\r\n graph_list[k].append(index[1])\r\n break\r\n # scenario (iii) both states have already been incorporated in the graph\r\n else:\r\n # find the graph components where these states have been placed\r\n for k,graph in enumerate(graph_list):\r\n overlap = list(set(index) & set(graph))\r\n # subscenario: the states are in the same graph component, hence a cycle, so nothing can do\r\n if (len(overlap) == 2):\r\n break\r\n # subscenario: the states are in two disjoint graph components\r\n elif (len(overlap) == 1):\r\n fixed_index = overlap[0]\r\n shift_index = list(set(index) - set(graph))[0]\r\n old_integer = integer_list[shift_index]\r\n if shift_index > fixed_index:\r\n new_integer = integer_list[fixed_index] + 1\r\n else:\r\n new_integer = integer_list[fixed_index] - 1\r\n shift_amount = new_integer - old_integer\r\n # merge one graph component into the other\r\n for j,graph2 in enumerate(graph_list):\r\n if shift_index in graph2:\r\n for m,index2 in enumerate(graph2):\r\n integer_list[index2] = integer_list[index2] + shift_amount\r\n graph_list[k] = graph_list[k] + graph2\r\n graph_list.pop(j)\r\n break\r\n break\r\n else:\r\n continue\r\n continue\r\n # Just in case, if a state was not assigned an integer due to not participating in dynamics, set its integer to 0\r\n for i,integer in enumerate(integer_list):\r\n if integer == None:\r\n integer_list[i] = 0\r\n ## END algorithm\r\n return transition_rank, integer_list","def get_ranks(d): \n raise NotImplementedError(\"Problem 3 Incomplete\")","def validate_average_rank(self) -> float:\n logger.info('Average rank validation ...')\n\n args = self.args\n self.biencoder.eval()\n distributed_factor = self.distributed_factor\n\n if args.use_dict_input:\n data_iterator = self.get_dict_data_iterator(args.dev_psgs_file, args.dev_queries_file,\n args.dev_qrels_file, args.dev_trec_file,\n args.dev_batch_size,\n shuffle=False, split=False)\n else:\n data_iterator = self.get_data_iterator(args.dev_file, args.dev_batch_size, shuffle=False)\n\n sub_batch_size = args.val_av_rank_bsz\n sim_score_f = ClusterNllLoss.get_similarity_function()\n q_represenations = []\n ctx_represenations = []\n positive_idx_per_question = []\n\n num_hard_negatives = args.val_av_rank_hard_neg\n num_other_negatives = args.val_av_rank_other_neg\n\n log_result_step = args.log_batch_step\n\n for i, samples_batch in enumerate(data_iterator.iterate_data()):\n # samples += 1\n if len(q_represenations) > args.val_av_rank_max_qs / distributed_factor:\n break\n\n biencoder_input = ClusterBertEncoder.create_biencoder_input(samples_batch, self.tensorizer,\n True,\n max_query_length=args.query_sequence_length,\n max_doc_length=args.sequence_length,\n num_hard_negatives=num_hard_negatives,\n num_other_negatives=num_other_negatives,\n shuffle=False)\n total_ctxs = len(ctx_represenations)\n ctxs_ids = biencoder_input.context_ids\n ctxs_segments = biencoder_input.ctx_segments\n bsz = ctxs_ids.size(0)\n\n # split contexts batch into sub batches since it is supposed to be too large to be processed in one batch\n for j, batch_start in enumerate(range(0, bsz, sub_batch_size)):\n\n q_ids, q_segments = (biencoder_input.question_ids, biencoder_input.question_segments) if j == 0 \\\n else (None, None)\n\n if j == 0 and args.n_gpu > 1 and q_ids.size(0) == 1:\n # if we are in DP (but not in DDP) mode, all model input tensors should have batch size >1 or 0,\n # otherwise the other input tensors will be split but only the first split will be called\n continue\n\n ctx_ids_batch = ctxs_ids[batch_start:batch_start + sub_batch_size]\n ctx_seg_batch = ctxs_segments[batch_start:batch_start + sub_batch_size]\n\n q_attn_mask = self.tensorizer.get_attn_mask(q_ids)\n ctx_attn_mask = self.tensorizer.get_attn_mask(ctx_ids_batch)\n with torch.no_grad():\n q_dense, ctx_dense = self.biencoder(q_ids, q_segments, q_attn_mask, ctx_ids_batch, ctx_seg_batch,\n ctx_attn_mask)\n\n if q_dense is not None:\n q_represenations.extend(q_dense.cpu().split(1, dim=0))\n\n ctx_represenations.extend(ctx_dense.cpu().split(1, dim=0))\n\n batch_positive_idxs = biencoder_input.is_positive\n positive_idx_per_question.extend([total_ctxs + v for v in batch_positive_idxs])\n\n if (i + 1) % log_result_step == 0:\n logger.info('Av.rank validation: step %d, computed ctx_vectors %d, q_vectors %d', i,\n len(ctx_represenations), len(q_represenations))\n\n ctx_represenations = torch.cat(ctx_represenations, dim=0)\n q_represenations = torch.cat(q_represenations, dim=0)\n\n logger.info('Av.rank validation: total q_vectors size=%s', q_represenations.size())\n logger.info('Av.rank validation: total ctx_vectors size=%s', ctx_represenations.size())\n\n q_num = q_represenations.size(0)\n assert q_num == len(positive_idx_per_question)\n\n scores = sim_score_f(q_represenations, ctx_represenations)\n values, indices = torch.sort(scores, dim=1, descending=True)\n\n rank = 0\n for i, idx in enumerate(positive_idx_per_question):\n # aggregate the rank of the known gold passage in the sorted results for each question\n gold_idx = (indices[i] == idx).nonzero()\n rank += gold_idx.item()\n\n if distributed_factor > 1:\n # each node calcuated its own rank, exchange the information between node and calculate the \"global\" average rank\n # NOTE: the set of passages is still unique for every node\n eval_stats = all_gather_list([rank, q_num], max_size=1000)\n for i, item in enumerate(eval_stats):\n remote_rank, remote_q_num = item\n if i != args.local_rank:\n rank += remote_rank\n q_num += remote_q_num\n\n av_rank = float(rank / q_num)\n logger.info('Av.rank validation: average rank %s, total questions=%d', av_rank, q_num)\n return av_rank","def rank(self) -> tskit.Rank:\n return combinatorics.RankTree.from_tsk_tree(self).rank()","def assignRanks(self):\r\n\t\trank = 0\r\n\t\tscores = list(self._playerScores)\r\n\t\tscores.reverse()\r\n\t\tfor playerScore in scores:\r\n\t\t\tif not playerScore.has(NOT_MET) or not playerScore.value(NOT_MET):\r\n\t\t\t\trank += 1\r\n\t\t\t\tplayerScore.set(RANK, smallText(BugUtil.colorText(u\"%d\" % rank, ScoreOpt.getRankColor())))\r\n\t\tif rank > 0:\r\n\t\t\tself._anyHas[RANK] = True","def get_hs_rank(self, points):\n p = points\n rank = self.RANKS\n while p > 0 and rank > 0:\n p = p - self.BASE * math.pow(self.FACTOR, (self.RANKS - rank))\n rank = rank - 1\n\n if rank > 0:\n return str(rank)\n else:\n return str(self.get_rank(points)) + \" Legend\"","def get_prev_rank(self) -> int:\n assert not self.is_first_stage(), \"Cannot get previous rank in the first stage.\"\n return self.prev_rank","def lrprInit(Y, A, rank=None): \n \n # initializing\n m = Y.shape[0]\n q = Y.shape[1]\n n = A.shape[0]\n\n Y_init = np.zeros((n, n), dtype=np.complex)\n \n # looping through each frame\n for k in range(q):\n y_k = Y[:, k]\n A_k = A[:, :, k]\n y_k_mean = y_k.mean()\n\n trunc_y_k = np.where(np.abs(y_k)<=9*y_k_mean, y_k, 0)\n Y_init += (A_k @ np.diag(trunc_y_k) @ A_k.conj().T)\n \n Y_init = (1/(m*q))*Y_init\n \n eig_val, eig_vec = np.linalg.eig(Y_init)\n \n # choosing rank if not given\n if rank is None:\n rank = chooseRank(eig_val)\n \n # fixing the chosen rank if needed\n max_rank = min(n, q)\n if rank > max_rank:\n rank = max_rank\n \n U = eig_vec[:, :rank]\n else:\n U = eig_vec[:, :rank]\n \n B = np.zeros((q, rank), dtype=np.complex)\n \n for k in range(q):\n y_k = Y[:, k]\n A_k = A[:, :, k]\n mean_y_k = y_k.mean()\n \n avg_Y = (1/m)*(A_k @ np.diag(y_k) @ A_k.conj().T)\n B_init_mat = U.conj().T @ avg_Y @ U\n \n b_val, b_vec = np.linalg.eig(B_init_mat)\n b_k = np.sqrt(mean_y_k) * b_vec[:, 0]\n \n B[k] = b_k\n \n print('Chosen rank:', rank)\n print('Spectral Initialization Complete.')\n \n return U, B","def _rank_2_n(my_type: LieType, lie_rank: Nat) -> Nat:\n if my_type is LieType.A:\n # A lie_rank corresponds to SL(lie_rank+1)\n n_val = lie_rank+1\n if lie_rank < 1:\n raise ValueError(\"Rank is too small\")\n elif my_type is LieType.B:\n # B lie_rank corresponds to SO(2*lie_rank+1)\n n_val = 2*lie_rank+1\n if lie_rank < 2:\n raise ValueError(\"Rank is too small\")\n elif my_type is LieType.C:\n # C lie_rank corresponds to Sp(2*lie_rank)\n n_val = 2*lie_rank\n if lie_rank < 2:\n raise ValueError(\"Rank is too small\")\n elif my_type is LieType.D:\n # D lie_rank corresponds to SO(2*lie_rank)\n n_val = 2*lie_rank\n if lie_rank < 3:\n raise ValueError(\"Rank is too small\")\n else:\n raise ValueError(\n \"Lie type must be one of the 4 classical families\")\n return n_val","def add_roi_2mlp_head(model, blob_in, dim_in, spatial_scale):\n hidden_dim = cfg.FAST_RCNN.MLP_HEAD_DIM\n roi_size = cfg.FAST_RCNN.ROI_XFORM_RESOLUTION\n roi_feat = model.RoIFeatureTransform(\n blob_in,\n 'roi_feat',\n blob_rois='rois',\n method=cfg.FAST_RCNN.ROI_XFORM_METHOD,\n resolution=roi_size,\n sampling_ratio=cfg.FAST_RCNN.ROI_XFORM_SAMPLING_RATIO,\n spatial_scale=spatial_scale\n )\n model.FC(roi_feat, 'fc6', dim_in * roi_size * roi_size, hidden_dim)\n model.Relu('fc6', 'fc6')\n model.FC('fc6', 'fc7', hidden_dim, hidden_dim)\n model.Relu('fc7', 'fc7')\n return 'fc7', hidden_dim","def get_rank(self):\n \n if self.rank == None:\n self.rank = self.main_ranker(self.string)\n \n return self.rank","def rank(self):\n return self.lib.calculate_rank()","def pagerank(matrix, bias, d=0.85):\n n = matrix.shape[0]\n rank = 0\n new_rank = np.array([1.0 / n] * n)\n for i in range(0,200):\n print \"iteration: \"+str(i)\n rank = new_rank\n new_rank = np.array([(1.0-d)/n] * n) + d * np.dot(matrix, rank)\n# new_rank = (1.0-d) * bias + d * np.dot(matrix, rank)\n # new_rank = [(((1.0-d) / n) +\n # d * sum((rank[i] * link) for i, link in enumerate(row)))\n # for row in matrix]\n if(has_converged(rank, new_rank)):\n break\n return new_rank","def world_rank(self):\n return self._wrank","def unrank(self, rank, n):\n n, rank = as_int(n), as_int(rank)\n L = defaultdict(int)\n for i in range(n - 3, -1, -1):\n L[i] = rank % n\n rank = (rank - L[i])//n\n return Prufer([L[i] for i in range(len(L))])","def optim_initialize(self, rank=0):\n super().optim_initialize(rank)\n self.optimizer.pytorch_step = self.optimizer.step\n self.optimizer.step = self.save_and_step","def select_rank_minka(shape, svals):\n # assert shape[0] > shape[1]\n\n n_samples, n_features = shape\n # assert n_samples > n_features\n assert len(svals) == n_features\n\n cov_evals = svals ** 2 / n_samples\n\n ranks = np.arange(1, n_features) # 1 to n_features - 1\n\n log_liks = np.empty_like(ranks)\n\n for idx, rank in enumerate(ranks):\n log_liks[idx] = get_log_lik(cov_evals=cov_evals,\n rank=rank,\n shape=shape)\n\n log_liks = pd.Series(log_liks, index=ranks)\n log_liks.name = 'log_lik'\n log_liks.index.name = 'rank'\n\n rank_est = log_liks.idxmax()\n\n return rank_est, {'log_liks': log_liks,\n 'cov_evals': cov_evals}","def predict(self, user: torch.tensor, k: int):\n pass","def create_text_rank(self):\n # filtered_tokens = self.filter_pos() #if use, replace 2 self.lemma_tokens below\n vocab = self.create_vocab(self.lemma_tokens)\n token_windows = self.create_token_windows(self.lemma_tokens)\n graph = self.create_matrix(vocab, token_windows)\n text_rank = np.array([1] * len(vocab))\n previous_tr = 0\n d = 0.85\n min_difference = 1e-5\n for epoch in range(10):\n text_rank = (1 - d) + d * np.dot(graph, text_rank)\n if abs(previous_tr - sum(text_rank)) < min_difference:\n break\n else:\n previous_tr = sum(text_rank)\n node_weight = {}\n for word in vocab:\n node_weight[word] = text_rank[vocab[word]]\n return node_weight","def __init__(self, A, rank=0):\r\n _u, _s, _v = np.linalg.svd(A, full_matrices=0)\r\n \r\n self.rank = rank\r\n\r\n self.U = _u[:,:self.rank].copy()\r\n self.S = _s[:self.rank].copy()\r\n self.SI = np.matrix(np.diag(self.S)).getI()\r\n self.VT = _v[:self.rank,:].copy()\r\n \r\n self._var = [ e/(_s**2).sum() for e in (_s**2).cumsum() ][self.rank-1]","def page_rank(self):\n print(\"Generating the matrix...\")\n G = self.graph\n p = FOLLOW\n column_sum = np.sum(G, axis=0, dtype=np.float64)\n \n n = self.graph.shape[0]\n\n D = sps.lil_matrix((n, n))\n D.setdiag(np.divide(1.,column_sum, where=column_sum != 0, out=np.zeros_like(column_sum)).reshape(-1, 1))\n self.diagonal = D\n print(\"created diagonal\")\n e = np.ones((n, 1))\n I = sps.eye(n)\n x = sps.linalg.spsolve((I - p*G*D), e)\n x = x/np.sum(x)\n\n self.page_rank = x\n\n return x","def prufer_rank(self):\n r = 0\n p = 1\n for i in range(self.nodes - 3, -1, -1):\n r += p*self.prufer_repr[i]\n p *= self.nodes\n return r","def __init__(self,\n topn=None,\n gain_fn=lambda label: label,\n rank_discount_fn=lambda rank: 1. / rank,\n normalized=False):\n self._topn = topn\n self._gain_fn = gain_fn\n self._rank_discount_fn = rank_discount_fn\n self._normalized = normalized","def load_ranker(cfg_file, i):\n return metapy.index.OkapiBM25(k1=i, b=0.75, k3=3.35)","def __init__(self, rank, suit):\n self.rank = rank\n self.suit = suit","def update_rank(self, new_rank, match):\n\n self.rank = new_rank\n\n # update cached ranks with rank change\n if self.cached_rank_changes:\n rank_changes = json.loads(self.cached_rank_changes)\n else:\n rank_changes = []\n\n rank_changes.append({\n \"rank\": new_rank,\n \"played_time\": str(match.played_time),\n \"played_timestamp\": get_timestamp(match.played_time)\n })\n self.cached_rank_changes = json.dumps(\n rank_changes[-CACHED_RANK_LIMIT:])\n self.save()","def minimize_neg_lbl(self):\n if self.spatial_only:\n init_index = 0 # anything should work here\n else:\n init_index = np.mean((self.energy_likelihood._min_index,\n self.energy_likelihood._max_index))\n \n init_ns = np.arange(self.fit_input['N']).mean()\n\n m = Minuit(self._neg_lbl,\n n_s = init_ns,\n gamma = init_index)\n\n m.errors = [1, 0.1]\n m.errordef = Minuit.LIKELIHOOD # 0.5\n \n if self.spatial_only:\n m.fixed['gamma'] = True\n m.limits = [(0, self.fit_input['N']-1),\n (None,None)]\n else:\n m.limits = [(0, self.fit_input['N']-1),\n (self.energy_likelihood._min_index,\n self.energy_likelihood._max_index)]\n\n m.migrad()\n self.minuit = m\n self._best_fit_ns = m.values[\"n_s\"]\n self._best_fit_index = m.values[\"gamma\"]\n return m, self._best_fit_ns, self._best_fit_index","def fit_transform(self, X):\n N, K = X.shape\n\n I_data = ~np.isnan(X)\n R_data = X[I_data].astype('int32')\n\n with tf.Session() as sess:\n # Define model in edward\n I = tf.placeholder(tf.float32, [N, K])\n U = Normal(loc=0.0, scale=1.0, sample_shape=[self.rank, N])\n V = Normal(loc=0.0, scale=1.0, sample_shape=[self.rank, K])\n logits = tf.matmul(tf.transpose(U), V)\n\n cutpoints = get_cutpoints(self.response_freq)\n\n R = OrdinalLogit(logits=logits, cutpoints=cutpoints, indicators=I)\n\n # Define variational parameters\n qU = Normal(loc=tf.get_variable(\"qU/loc\", [self.rank, N]),\n scale=tf.nn.softplus(\n tf.get_variable(\"qU/scale\", [self.rank, N])))\n qV = Normal(loc=tf.get_variable(\"qV/loc\", [self.rank, K]),\n scale=tf.nn.softplus(\n tf.get_variable(\"qV/scale\", [self.rank, K])))\n\n # Run variational inference\n inference = ed.KLqp({U: qU, V: qV}, data={R: R_data, I: I_data})\n inference.run()\n\n # Use posterior mean for prediction\n U_pred = qU.mean().eval()\n V_pred = qV.mean().eval()\n R_pred = OrdinalLogit(\n # if we don't use qU.mean() and qV.mean(), edward will draw from qU and qV\n logits=tf.matmul(tf.transpose(qU.mean()), qV.mean()),\n cutpoints=cutpoints,\n indicators=tf.ones(X.shape)\n ).mean().eval().reshape(X.shape)\n\n if self.override_preds:\n R_pred[I_data] = R_data\n\n print(\"Resetting default graph\")\n tf.reset_default_graph()\n\n return CompletionResult(\n X_filled=R_pred,\n U=U_pred.T,\n V=V_pred,\n S=None,\n rank=self.rank\n )","def k_rank_approximate(doc_matrix, k):\n return []","def mpi_rank(self):\n return 0","def afterDDP(self, rank : int):\n pass","def remove_topk_nodes(adj, node_importance_rank, topk):\n for idx in node_importance_rank[:topk]:\n for i in range(adj.shape[0]):\n adj[i, idx] = 0\n adj[idx, i] = 0\n\n return adj","def predict(self):\n train_array = np.array(self.labels != 0, dtype=float)\n if not self.ising:\n labels_logit = self.ising_weights['vertices']\n else:\n neigh_num = self.adj.dot(train_array)\n neigh_num = np.where(neigh_num == 0, 1, neigh_num)\n neigh_weights = self.ising_weights['edges'] * self.labels\n labels_logit = (np.multiply(neigh_weights, neigh_num**(-1))\n + self.ising_weights['vertices'])\n self.prediction = np.where(labels_logit > 0, 1, -1)\n return self","def rerank_candidates(s, pred2sub_rank, all_predictions, rerank_top=20):\n predicted_smiles = []\n model_input = []\n for (predict_smi, label), _ in Counter(all_predictions).most_common(rerank_top):\n if predict_smi == s:\n continue\n features = get_all_features(\n get_all_ranking_info(pred2sub_rank[predict_smi]))\n predicted_smiles.append((predict_smi, label))\n model_input.append(features)\n\n model = RankingModel()\n model.load_state_dict(torch.load('./models/ranker/rank_model.pt', map_location='cpu'))\n model.eval()\n\n test_loader = DataLoader(RankingTestDataset(\n model_input), batch_size=1000, shuffle=False, num_workers=2)\n ranking_scores = []\n for data in test_loader:\n outputs = model(data)[0]\n ranking_scores.extend(outputs.detach().cpu().numpy())\n\n assert len(predicted_smiles) == len(ranking_scores)\n pred_smi2score = {k: v[1]\n for k, v in zip(predicted_smiles, ranking_scores)}\n return pred_smi2score","def __init__(self,suit,rank):\n self.suit = suit\n self.rank = rank\n self.value = values[rank]","def svd_HO(data, rank, max_iter=10):\n svd_iter = 10\n data_shape = np.shape(data) # p0\n\n # Check that number of dimensions match the number of rank numbers\n if len(data_shape) != len(rank):\n print(\"The rank should be the same size as the data shape\")\n return data, [], []\n\n # Check that for each rank, the product of all the rest ranks are larger than this rank\n for k in range(len(rank)):\n prod = 1\n for i in range(len(rank)):\n if i != k:\n prod = prod * rank[i]\n if rank[k] > prod:\n print(\"The rank does not satisfy requirment of HOOI.\")\n return data, [], []\n\n dimensions = len(data_shape) # d\n ordered_indexes = np.argsort(data_shape) # getting the indicies from min len to max, initialization starts from smallest size\n\n ## Initialize U and Y with SVD\n U = [None] * dimensions # Generate an empty array to save all the U matrices with fixed length\n X = data\n for k in ordered_indexes: # calculating initial SVD\n unfolded = unfold_axis(X, k) # unfolding from the axis with minimum size\n [U[k], _ , _] = fast_svd(unfolded,rank[k],n_iter=svd_iter)\n X = ttm(X, np.transpose(U[k]), k) # This needs to be fixed!\n\n ## Update U with HOOI\n iter_count = 0\n while iter_count < max_iter:\n iter_count += 1\n for k in range(0, dimensions):\n Y = data\n minus_k = list(range(0,dimensions))\n minus_k.remove(k) # every value except for k, seems do it in one step will remove all the elements in the list.\n for j in minus_k:\n Y = ttm(Y, np.transpose(U[j]), j)\n MY = unfold_axis(Y, k)\n [U[k], _, _] = fast_svd(MY, rank[k],n_iter=svd_iter)\n\n ## Use the determined U matrices to calculate core tensor and denoised tensor\n X = data\n for k in ordered_indexes:\n X = ttm(X,np.transpose(U[k]), k) # Check this part.\n S = X # core tensor\n for k in range(0,dimensions):\n X = ttm(X,U[k], k)\n\n return X, U, S","def prelu(input, weight):\n return FunctionLib.apply('PRelu', input.device, [input, weight])","def returnLowerBound(self, dimension):\n value = self._distribution.returnLowerBound(dimension)\n return value","def _get_rank(self,fitness):\n # infact you can get the order or rank by only once sort.\n rank=fitness[:,0].argsort().argsort() # [n]\n return rank","def get_ancestor_of_rank(node: PhyloNode, rank: str) -> Optional[int]:\n\n while node:\n if node.rank == rank:\n return node.tax_id\n node = node.parent\n return None","def normalize_rank(self, x, axis=-1):\n\t\tx = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\n\t\treturn x","def rank(self, current_order_by_value: Comparable, current_row_number: int) -> int:","def __init__(self, rank, suit):\n self._rank = rank\n self._suit = suit","def rank(matrix, decayThreshold, zeroThreshold):\n\n _, s, _ = np.linalg.svd(matrix)\n\n if (len(s) != 0) and (s[0] > zeroThreshold):\n rank = 1\n else:\n return 0\n\n for s1, s2 in zip(s, s[1:]):\n if (s2 > zeroThreshold) and (s2/s1 > decayThreshold):\n rank += 1\n else:\n break\n return rank"],"string":"[\n \"def find_optimal_low_rank_matrix( self, orig_similarity_matrix, orig_rank, u, s, v, singular_reduction ):\\n '''rank_list = list()\\n sum_singular_values = list()\\n for rank in range( 0, orig_rank ):\\n compute_result = self.compute_low_rank_matrix( u, s, v, rank + 1 )\\n rank_list.append( ( rank + 1 ) / float( orig_rank ) )\\n sum_singular_values.append( compute_result[ 1 ] )\\n utils._plot_singular_values_rank( rank_list, sum_singular_values )'''\\n return self.compute_low_rank_matrix( u, s, v, int( singular_reduction * orig_rank ) )\",\n \"def set_rank(self,rank):\\n self._rank = rank\",\n \"def rank(self, rank):\\n self._rank = rank\",\n \"def sample_low_rank(self, n_samples, mu, logvar, F):\\n #F = torch.unsqueeze(F, dim=1).repeat(1, n_samples, 1, 1) # [self.batch_size, n_samples, self.Y_dim, self.rank]\\n F = F.repeat(n_samples, 1, 1) # [self.batch_size*n_samples, self.Y_dim, self.rank]\\n mu = mu.repeat(n_samples, 1) # [self.batch_size*n_samples, self.Y_dim]\\n logvar = logvar.repeat(n_samples, 1) # [self.batch_size*n_samples, self.Y_dim]\\n eps_low_rank = torch.randn(self.batch_size*n_samples, self.rank, 1)\\n eps_diag = torch.randn(self.batch_size*n_samples, self.Y_dim)\\n half_var = torch.exp(0.5*logvar) # [self.batch_size*n_samples, self.Y_dim]\\n samples = torch.bmm(F, eps_low_rank).squeeze() + mu + half_var*eps_diag\\n samples = samples.reshape(n_samples, self.batch_size, self.Y_dim)\\n samples = samples.transpose(0, 1)\\n samples = self.unwhiten_back(samples)\\n samples = samples.data.cpu().numpy()\\n return samples\",\n \"def rank():\\n return 0\",\n \"def update(self, rank):\\n # calculate MR and MRR\\n self.mr += rank\\n self.mrr += 1 / rank\\n # calculate Hits@k\\n if rank <= 1:\\n self.hits1 += 1\\n self.hits3 += 1\\n self.hits5 += 1\\n self.hits10 += 1\\n elif rank <= 3:\\n self.hits3 += 1\\n self.hits5 += 1\\n self.hits10 += 1\\n elif rank <= 5:\\n self.hits5 += 1\\n self.hits10 += 1\\n elif rank <= 10:\\n self.hits10 += 1\",\n \"def classify_rank(rank):\\n return np.where(rank>0, 1, 0)\",\n \"def getRank(self):\\r\\n return self.rank\",\n \"def process_assumed_rank(self, node):\\n # fortran_generic must already be empty\\n options = node.options\\n params = node.ast.declarator.params\\n\\n for rank in range(options.F_assumed_rank_min,\\n options.F_assumed_rank_max+1):\\n newdecls = copy.deepcopy(params)\\n for decl in newdecls:\\n attrs = decl.declarator.attrs\\n meta = decl.declarator.metaattrs\\n if meta[\\\"assumed-rank\\\"]:\\n # Replace dimension(..) with rank(n).\\n attrs[\\\"dimension\\\"] = None\\n attrs[\\\"rank\\\"] = rank\\n meta[\\\"assumed-rank\\\"] = None\\n generic = ast.FortranGeneric(\\n \\\"\\\", function_suffix=\\\"_{}d\\\".format(rank),\\n decls=newdecls)\\n node.fortran_generic.append(generic)\\n\\n # Remove assumed-rank from C function.\\n for decl in params:\\n attrs = decl.declarator.attrs\\n meta = decl.declarator.metaattrs\\n if meta[\\\"assumed-rank\\\"]:\\n attrs[\\\"dimension\\\"] = None\\n meta[\\\"assumed-rank\\\"] = None\\n node.declgen = node.ast.gen_decl()\",\n \"def __rank__(self) -> int:\",\n \"def get_rank(self):\\r\\n return self.rank\",\n \"def getRank(self):\\n return self.rank\",\n \"def get_rank(self) -> int:\\r\\n return self.rank\",\n \"def determine_rank(self, X, err):\\n singularValues,_,_,_ = self.compute_svd(X,k=-1)\\n ratio = np.array([np.linalg.norm(singularValues[k:]) / np.linalg.norm(singularValues) for k in\\n range(len(singularValues) - 1, 0, -1)])\\n find_idx = numpy.nonzero(ratio <= err)\\n rank = find_idx[0]\\n if self.global_rank==0: print('Estimated rank=',rank)\\n return rank\",\n \"def compute_low_rank_matrix( self, u, s, v, rank ):\\n u_approx = u[ :, :rank ]\\n s_approx = s[ :rank ]\\n sum_taken_percent = np.sum( s_approx ) / float( np.sum( s ) )\\n s_approx = np.diag( np.array( s_approx ) )\\n v_approx = v[ :rank, : ]\\n return [ u_approx.dot( s_approx ).dot( v_approx ), sum_taken_percent ]\",\n \"def __init__(self, rank):\\n self.rank = rank\\n self.face = 'down'\",\n \"def getRank(self):\\n return self._rank\",\n \"def optim_initialize(self, rank=0):\\n self.rank = rank\\n try:\\n # We're probably dealing with DDP\\n self.model = self.agent.model.module\\n except:\\n self.model = self.agent.model\\n\\n # Split into (optionally) three groups for separate LRs.\\n conv_params, dynamics_model_params, q_l1_params, other_params = self.model.list_params()\\n self.optimizer = self.OptimCls([\\n {'params': conv_params, 'lr': self.encoder_lr},\\n {'params': q_l1_params, 'lr': self.q_l1_lr},\\n {'params': dynamics_model_params, 'lr': self.dynamics_model_lr},\\n {'params': other_params, 'lr': self.learning_rate}\\n ],\\n **self.optim_kwargs)\\n\\n if self.initial_optim_state_dict is not None:\\n self.optimizer.load_state_dict(self.initial_optim_state_dict)\\n if self.prioritized_replay:\\n self.pri_beta_itr = max(1, self.pri_beta_steps // self.sampler_bs)\",\n \"def learning_to_rank(self):\\n self.error_throw('rank')\\n\\n instance = Instance(self.table_name)\\n instance.addTable(Table_LTR(instance,False,'',''))\\n if self.import_method == 'mysql': instance = self.mysql_handle(instance)\\n elif self.import_method == 'csv': instance = self.csv_handle(instance)\\n\\n self.rank_learning(instance)\\n\\n self.rank_method = methods_of_ranking[1] # = 'learn_to_rank'\",\n \"def rank_local(model, number_of_core_samples, step_size, name, threshold, output_path, top_k_to_plot):\\n feature_vectors = pd.DataFrame(np.load('{}/feature_vectors_{}_{}_{}.npy'.format(output_path, number_of_core_samples, step_size, name)), index = np.arange(number_of_core_samples), columns=pd.MultiIndex.from_product([model.perturbation_status_columns, model.feature_names], names=['perturbation_status','features']))\\n core_feature_vectors = feature_vectors.loc[:, 'core'].copy()\\n core_feature_vectors = normalize_inputs(model, core_feature_vectors)\\n raw_outputs = pd.DataFrame(np.load('{}/outputs_{}_{}_{}.npy'.format(output_path, number_of_core_samples, step_size, name)), index = np.arange(number_of_core_samples), columns=pd.MultiIndex.from_product([model.output_names, model.perturbation_status_columns_output], names=['outputs','perturbation_status']))\\n outputs = normalize_outputs(model, pd.DataFrame(raw_outputs))\\n hessian = calculate_hessian(model, outputs, step_size)\\n hessian = denoise_hessian(hessian)\\n np.save('{}/hessian_{}_{}_{}'.format(output_path,number_of_core_samples, step_size, name), hessian)\\n \\n ranking = []\\n for output_name in model.output_names:\\n interaction_maps = list(futures.map(functools.partial(create_interaction_map, model, hessian, core_feature_vectors, output_name, 'linear'), model.feature_pairs))\\n for ind in range(len(model.feature_pairs)):\\n first_variable, second_variable = model.feature_pairs[ind].split(' and ')\\n if ind < top_k_to_plot:\\n model.set_ground_truth(number_of_core_samples, step_size, name, output_path)\\n most_nonlinear_sample = hessian[output_name][model.feature_pairs[ind]].abs().idxmax()\\n y_coord = 100 * (feature_vectors.loc[most_nonlinear_sample, 'core'][first_variable] - model.feature_limits[first_variable][0]) / (model.feature_limits[first_variable][1] - model.feature_limits[first_variable][0])\\n x_coord = 100 * (feature_vectors.loc[most_nonlinear_sample, 'core'][second_variable] - model.feature_limits[second_variable][0]) / (model.feature_limits[second_variable][1] - model.feature_limits[second_variable][0])\\n plot_interaction_map(model, name, interaction_maps[ind], output_name, first_variable, second_variable, x_coord, y_coord, output_path)\\n features = []\\n features.append(feature_vectors.loc[most_nonlinear_sample, 'core'])\\n features.append(feature_vectors.loc[most_nonlinear_sample, first_variable])\\n features.append(feature_vectors.loc[most_nonlinear_sample, second_variable])\\n features.append(feature_vectors.loc[most_nonlinear_sample, model.feature_pairs[ind]])\\n features = np.array(features)\\n # local_ranking = list(futures.map(functools.partial(get_max_filters), interaction_maps))\\n # ranking_indices = np.argsort(local_ranking)[::-1]\\n # ranking.append((output_name, list(np.array(model.feature_pairs)[np.array(ranking_indices)]), np.array(local_ranking)[ranking_indices]))\\n pickle.dump(obj = ranking, file = open('{}/local_ranking_{}_{}_{}.pickle'.format(output_path,number_of_core_samples, step_size, name),'wb'))\\n return ranking\",\n \"def get_rank(self):\\n return self.rank\",\n \"def mpi_rank(self, new_value):\",\n \"def get_rank(score):\\n if score in range(0, 500):\\n return RANKTYPES[0]\\n elif score in range(500, 1500):\\n return RANKTYPES[1]\\n elif score in range(1500, 2000):\\n return RANKTYPES[2]\\n elif score in range(2000, 2500):\\n return RANKTYPES[3]\\n elif score in range(2500, 3000):\\n return RANKTYPES[4]\\n elif score in range(3000, 4000):\\n return RANKTYPES[5]\\n elif score in range(4000, 5500):\\n return RANKTYPES[6]\\n elif score > 5500:\\n return RANKTYPES[7]\",\n \"def update_rank(self):\\n self.__rank += 1\",\n \"def rank(self):\\n return self._rank\",\n \"def rank(self):\\n return self._rank\",\n \"def rank(self):\\n return self._rank\",\n \"def rank(self):\\n return self._rank\",\n \"def rank(self):\\n return self._rank\",\n \"def __init__(self, nrows: int, ncols: int, rank: int):\\n try:\\n nrows = int(nrows)\\n except ValueError:\\n print(\\\"Invalid value of nrows. Must be an int.\\\")\\n self.nrows = nrows\\n try:\\n ncols = int(ncols)\\n except ValueError:\\n print(\\\"Invalid value of ncols. Must be an int.\\\")\\n self.ncols = ncols\\n if rank is None:\\n rank = np.minimum(nrows, ncols)\\n try:\\n rank = int(rank)\\n except ValueError:\\n print(\\\"Invalid value of rank. Must be an int.\\\")\\n self.rank = rank\\n super(GaussianRandomSampling, self).__init__(mat=self.build_sampling_matrix())\",\n \"def workout_rank(a, rank):\\r\\n # Check if workout score is empty\\r\\n if pd.isnull(a):\\r\\n return np.nan\\r\\n else:\\r\\n return int(rank)\",\n \"def get_rank(self):\\n return self.__rank\",\n \"def mrr(self, ranking):\\n return np.mean(ranking)\",\n \"def _validate_rank(self, rank: int) -> None:\\n if not isinstance(rank, int):\\n raise TypeError(\\\"rank should be an integer\\\")\\n if rank < 0:\\n raise ValueError(\\\"rank cannot be negative\\\")\\n if rank >= self.L**2:\\n raise ValueError(f\\\"rank should be less than {self.L**2}\\\")\",\n \"def _apply_rank(U, S, VT, r, verbose=False):\\n if r is None:\\n r = len(S)\\n S_r = S[:r]\\n U_r = U[:, :r]\\n VT_r = VT[:r]\\n if verbose:\\n print(\\\"Rank:\\\", r, \\\"SVD shape:\\\", U_r.shape, S_r.shape, VT_r.shape)\\n return U_r, S_r, VT_r\",\n \"def weyl_vector(rank):\\n return np.ones(rank, dtype=utils.itype)\",\n \"def rank(self):\\n del self._rank\",\n \"def rank(self) -> int:\\n return self._rank\",\n \"def ranking_loss(self, sim, margin=1.0):\\n # sim = 1.0 - distance\\n pos_sim, neg_sim = tf.slice(sim, [0, 0], [-1, 1]), tf.slice(sim, [0, 1], [-1, -1])\\n pos_dis, neg_dis = 1.0 - pos_sim, 1.0 - neg_sim\\n hinge_loss = tf.nn.relu(margin - neg_dis)\\n ranking_loss = tf.reduce_mean(\\n pos_dis) + tf.reduce_mean(tf.reduce_sum(hinge_loss, axis=-1))\\n\\n return ranking_loss\",\n \"def rank(self):\\n return self.matrix().rank()\",\n \"def individual_weights(self, labels, ranks):\\n del ranks\\n return labels\",\n \"def rank(self, value: int) -> None:\\n self._rank = value\",\n \"def GetColumnIndexOfRank(\\n self: \\\"HereditaryStratumOrderedStoreList\\\",\\n rank: int,\\n ) -> typing.Optional[int]:\\n if self.GetNumStrataRetained() == 0:\\n return None\\n else:\\n res_idx = binary_search(\\n lambda idx: self.GetRankAtColumnIndex(idx) >= rank,\\n 0,\\n self.GetNumStrataRetained() - 1,\\n )\\n if res_idx is None:\\n return None\\n elif self.GetRankAtColumnIndex(res_idx) == rank:\\n return res_idx\\n else:\\n return None\",\n \"def rank() -> int:\\n return dist.get_rank() if dist.is_initialized() else 0\",\n \"def rank(self):\\n if self._rank is None:\\n self._rank = self.prufer_rank()\\n return self._rank\",\n \"def predict(self):\\n\\n # get current level and problem description\\n L = self.level\\n P = L.prob\\n\\n # evaluate RHS at left point\\n L.f[0] = P.eval_f(L.u[0], L.time)\\n\\n for m in range(1, self.coll.num_nodes + 1):\\n # copy u[0] to all collocation nodes, evaluate RHS\\n if self.params.initial_guess == 'spread':\\n L.u[m] = P.dtype_u(L.u[0])\\n L.f[m] = P.eval_f(L.u[m], L.time + L.dt * self.coll.nodes[m - 1])\\n # start with zero everywhere\\n elif self.params.initial_guess == 'zero':\\n L.u[m] = P.dtype_u(init=P.init, val=0.0)\\n L.f[m] = P.dtype_f(init=P.init, val=0.0)\\n # start with random initial guess\\n elif self.params.initial_guess == 'random':\\n L.u[m] = P.dtype_u(init=P.init, val=self.rng.rand(1)[0])\\n L.f[m] = P.dtype_f(init=P.init, val=self.rng.rand(1)[0])\\n else:\\n raise ParameterError(f'initial_guess option {self.params.initial_guess} not implemented')\\n\\n # indicate that this level is now ready for sweeps\\n L.status.unlocked = True\\n L.status.updated = True\",\n \"def get_rank(self):\\n return int(self._rank)\",\n \"def predict(self, X, from_idx=False, get_ranks=False):\\n return super().predict(X, from_idx=from_idx, get_ranks=get_ranks)\",\n \"def predict(self, X, from_idx=False, get_ranks=False):\\n return super().predict(X, from_idx=from_idx, get_ranks=get_ranks)\",\n \"def predict(self, X, from_idx=False, get_ranks=False):\\n return super().predict(X, from_idx=from_idx, get_ranks=get_ranks)\",\n \"def predict(self, X, from_idx=False, get_ranks=False):\\n return super().predict(X, from_idx=from_idx, get_ranks=get_ranks)\",\n \"def addRankToLine(self,cols,rank):\\n line = \\\"\\\"\\n ann = \\\";RankScore=\\\" + str(self.family_id) + \\\":\\\" + str(rank)\\n for c in cols:\\n line = line + c\\n if cols.index(c) == 7: # 0-based index\\n line = line + ann\\n if cols.index(c) < len(cols):\\n line = line + \\\"\\\\t\\\"\\n print(line)\",\n \"def rank(self):\\n\\n if self._rank >= 0:\\n return self._rank\\n\\n reduced, operations = self.to_row_echelon()\\n non_leading_rows = 0\\n for i in range(self.rows, 0, -1):\\n if not reduce(lambda x,y: x or y, reduced.row(i)):\\n non_leading_rows += 1\\n else:\\n break\\n\\n self._rank = self.rows - non_leading_rows\\n return self._rank\",\n \"def select_top_predictions(self, prediction, img_w, img_h):\\n scores = prediction.get_field(\\\"scores\\\")\\n boxes = prediction.bbox\\n weighted_scores = []\\n for idx, (box, score) in enumerate(zip(boxes, scores)):\\n box = box.to(torch.int64)\\n x1, y1, x3, y3 = box[:4].tolist()\\n if (y3 - y1 > self.min_bbox_h * img_h) and (x3 - x1 > self.min_bbox_w * img_w) and ((x3 - x1) * (y3 - y1) > self.min_bbox_area * img_h * img_w):\\n weighted_score = self.score_weight * score.item() + self.pos_weight * math.exp(-5*(math.pow(0.5*(x1+x3)/img_w-0.5, 2)+math.pow(0.5*(y1+y3)/img_h-0.5, 2))) + self.area_weight * (x3 - x1) * (y3 - y1) / (img_h * img_w)\\n # print('weihted_score={}={}*{}(score)+{}*{}(position)+{}*{}(area)'.format(weighted_score, self.score_weight, score.item(), self.pos_weight, math.exp(-5*(math.pow(0.5*(x1+x3)/img_w-0.5, 2)+math.pow(0.5*(y1+y3)/img_h-0.5, 2))), self.area_weight, (x3 - x1) * (y3 - y1) / (img_h * img_w * 1.0)))\\n else:\\n weighted_score = 0.0\\n weighted_scores.append(weighted_score)\\n rank_idxs = np.argsort(-1*np.array(weighted_scores))\\n top_predictions = []\\n for rank_idx in rank_idxs[:self.topn]:\\n if weighted_scores[rank_idx] <= 0:\\n continue\\n top_prediction = dict()\\n scores_all = prediction[[rank_idx]].get_field(\\\"scores_all\\\")\\n scores_all[:, -1] = max(scores_all[:, -1], self.score_thresh_high) # other category\\n boxes = prediction[[rank_idx]].bbox\\n box = boxes[0].to(torch.int64)\\n top_prediction['bbox'] = box[:4].tolist()\\n if scores_all.shape[1] < len(self.CATEGORIES):\\n scores, labels = scores_all[0][0:].sort(0, descending=True)\\n else:\\n scores, labels = scores_all[0][1:].sort(0, descending=True)\\n top_prediction['category'] = [self.CATEGORIES[label+1] for label in labels]\\n top_prediction['score'] = [score.item() for score in scores]\\n top_predictions.append(top_prediction)\\n if len(top_predictions) == 0 and self.data_source == 0: # use whole image if no bbox\\n top_prediction = dict()\\n top_prediction['bbox'] = [0, 0, img_w-1, img_h-1]\\n top_prediction['category'] = [self.CATEGORIES[-1]]\\n top_prediction['score'] = [0.0]\\n top_predictions.append(top_prediction)\\n return top_predictions\",\n \"def rank_pre_extract(self, mention_data, predictions):\\n mdata = pd.DataFrame(mention_data)\\n\\n\\n\\n\\n pass\",\n \"def mrr_at(prediction, target, k=10):\\n rank_target = (prediction.t() > prediction[range(prediction.shape[0]), target]).sum(0) + 1.0\\n rr = 1.0 / rank_target.to(torch.float32)\\n rr[rank_target > k] = 0.0\\n mrr = rr.mean()\\n return mrr\",\n \"def rank_and_assign(self, cutoff_matrix_element):\\r\\n\\r\\n L0 = (qt.liouvillian(self.rotating_frame_hamiltonian, self.jump_ops))\\r\\n \\r\\n relevance_table = [[self.calculate_first_order_correction(cutoff_matrix_element,L0,ket_index=n,bra_index=m) for m in range(self.dim)] for n in range(self.dim)]\\r\\n relevance_table = np.asarray(relevance_table)\\r\\n \\r\\n number_of_transitions = int(self.dim*(self.dim-1)/2)\\r\\n transition_rank = [None for i in range(number_of_transitions)]\\r\\n # This loop ranks drive terms according to relevance \\r\\n for rank in range(number_of_transitions):\\r\\n max_ranked_indices = np.where(relevance_table == relevance_table.max())\\r\\n indices = [max_ranked_indices[0][0], max_ranked_indices[1][0]]\\r\\n transition_rank[rank] = [relevance_table.max(), indices]\\r\\n relevance_table[indices[0]][indices[1]] = relevance_table[indices[1]][indices[0]] = 0\\r\\n \\r\\n # This graphical algorithm assigns an integer to each eigenstate of the Hamiltonian based on the ranking from above\\r\\n integer_list = [None for i in range(self.dim)]\\r\\n # START ALGORITHM\\r\\n # initialize first term into a graph\\r\\n first_index = transition_rank[0][1]\\r\\n graph_list = [[first_index[0],first_index[1]]]\\r\\n integer_list[max(first_index)] = 1\\r\\n integer_list[min(first_index)] = 0\\r\\n # assign subsequent terms\\r\\n for i in range(1,number_of_transitions):\\r\\n # if no more non-zero relevance parameters, then break \\r\\n if transition_rank[i][0] == 0.0:\\r\\n break\\r\\n else:\\r\\n index = transition_rank[i][1]\\r\\n # scenario (i) neither states have been incorporated into the graph \\r\\n if integer_list[index[0]]==integer_list[index[1]]==None: \\r\\n integer_list[max(index)] = 1\\r\\n integer_list[min(index)] = 0\\r\\n # place them in a new graph\\r\\n graph_list.append([index[0],index[1]])\\r\\n # scenario (ii) one of the states has been incorporated, but not the other\\r\\n elif integer_list[index[0]]==None:\\r\\n if index[0] > index[1]:\\r\\n integer_list[index[0]] = integer_list[index[1]] + 1\\r\\n else:\\r\\n integer_list[index[0]] = integer_list[index[1]] - 1\\r\\n # find which graph component to put the state in (the component the other state is in)\\r\\n for k,graph in enumerate(graph_list):\\r\\n if index[1] in graph:\\r\\n # place that state in that graph component\\r\\n graph_list[k].append(index[0]) \\r\\n break\\r\\n elif integer_list[index[1]]==None:\\r\\n if index[0] > index[1]:\\r\\n integer_list[index[1]] = integer_list[index[0]] - 1\\r\\n else:\\r\\n integer_list[index[1]] = integer_list[index[0]] + 1\\r\\n for k,graph in enumerate(graph_list):\\r\\n if index[0] in graph:\\r\\n graph_list[k].append(index[1])\\r\\n break\\r\\n # scenario (iii) both states have already been incorporated in the graph\\r\\n else:\\r\\n # find the graph components where these states have been placed\\r\\n for k,graph in enumerate(graph_list):\\r\\n overlap = list(set(index) & set(graph))\\r\\n # subscenario: the states are in the same graph component, hence a cycle, so nothing can do\\r\\n if (len(overlap) == 2):\\r\\n break\\r\\n # subscenario: the states are in two disjoint graph components\\r\\n elif (len(overlap) == 1):\\r\\n fixed_index = overlap[0]\\r\\n shift_index = list(set(index) - set(graph))[0]\\r\\n old_integer = integer_list[shift_index]\\r\\n if shift_index > fixed_index:\\r\\n new_integer = integer_list[fixed_index] + 1\\r\\n else:\\r\\n new_integer = integer_list[fixed_index] - 1\\r\\n shift_amount = new_integer - old_integer\\r\\n # merge one graph component into the other\\r\\n for j,graph2 in enumerate(graph_list):\\r\\n if shift_index in graph2:\\r\\n for m,index2 in enumerate(graph2):\\r\\n integer_list[index2] = integer_list[index2] + shift_amount\\r\\n graph_list[k] = graph_list[k] + graph2\\r\\n graph_list.pop(j)\\r\\n break\\r\\n break\\r\\n else:\\r\\n continue\\r\\n continue\\r\\n # Just in case, if a state was not assigned an integer due to not participating in dynamics, set its integer to 0\\r\\n for i,integer in enumerate(integer_list):\\r\\n if integer == None:\\r\\n integer_list[i] = 0\\r\\n ## END algorithm\\r\\n return transition_rank, integer_list\",\n \"def get_ranks(d): \\n raise NotImplementedError(\\\"Problem 3 Incomplete\\\")\",\n \"def validate_average_rank(self) -> float:\\n logger.info('Average rank validation ...')\\n\\n args = self.args\\n self.biencoder.eval()\\n distributed_factor = self.distributed_factor\\n\\n if args.use_dict_input:\\n data_iterator = self.get_dict_data_iterator(args.dev_psgs_file, args.dev_queries_file,\\n args.dev_qrels_file, args.dev_trec_file,\\n args.dev_batch_size,\\n shuffle=False, split=False)\\n else:\\n data_iterator = self.get_data_iterator(args.dev_file, args.dev_batch_size, shuffle=False)\\n\\n sub_batch_size = args.val_av_rank_bsz\\n sim_score_f = ClusterNllLoss.get_similarity_function()\\n q_represenations = []\\n ctx_represenations = []\\n positive_idx_per_question = []\\n\\n num_hard_negatives = args.val_av_rank_hard_neg\\n num_other_negatives = args.val_av_rank_other_neg\\n\\n log_result_step = args.log_batch_step\\n\\n for i, samples_batch in enumerate(data_iterator.iterate_data()):\\n # samples += 1\\n if len(q_represenations) > args.val_av_rank_max_qs / distributed_factor:\\n break\\n\\n biencoder_input = ClusterBertEncoder.create_biencoder_input(samples_batch, self.tensorizer,\\n True,\\n max_query_length=args.query_sequence_length,\\n max_doc_length=args.sequence_length,\\n num_hard_negatives=num_hard_negatives,\\n num_other_negatives=num_other_negatives,\\n shuffle=False)\\n total_ctxs = len(ctx_represenations)\\n ctxs_ids = biencoder_input.context_ids\\n ctxs_segments = biencoder_input.ctx_segments\\n bsz = ctxs_ids.size(0)\\n\\n # split contexts batch into sub batches since it is supposed to be too large to be processed in one batch\\n for j, batch_start in enumerate(range(0, bsz, sub_batch_size)):\\n\\n q_ids, q_segments = (biencoder_input.question_ids, biencoder_input.question_segments) if j == 0 \\\\\\n else (None, None)\\n\\n if j == 0 and args.n_gpu > 1 and q_ids.size(0) == 1:\\n # if we are in DP (but not in DDP) mode, all model input tensors should have batch size >1 or 0,\\n # otherwise the other input tensors will be split but only the first split will be called\\n continue\\n\\n ctx_ids_batch = ctxs_ids[batch_start:batch_start + sub_batch_size]\\n ctx_seg_batch = ctxs_segments[batch_start:batch_start + sub_batch_size]\\n\\n q_attn_mask = self.tensorizer.get_attn_mask(q_ids)\\n ctx_attn_mask = self.tensorizer.get_attn_mask(ctx_ids_batch)\\n with torch.no_grad():\\n q_dense, ctx_dense = self.biencoder(q_ids, q_segments, q_attn_mask, ctx_ids_batch, ctx_seg_batch,\\n ctx_attn_mask)\\n\\n if q_dense is not None:\\n q_represenations.extend(q_dense.cpu().split(1, dim=0))\\n\\n ctx_represenations.extend(ctx_dense.cpu().split(1, dim=0))\\n\\n batch_positive_idxs = biencoder_input.is_positive\\n positive_idx_per_question.extend([total_ctxs + v for v in batch_positive_idxs])\\n\\n if (i + 1) % log_result_step == 0:\\n logger.info('Av.rank validation: step %d, computed ctx_vectors %d, q_vectors %d', i,\\n len(ctx_represenations), len(q_represenations))\\n\\n ctx_represenations = torch.cat(ctx_represenations, dim=0)\\n q_represenations = torch.cat(q_represenations, dim=0)\\n\\n logger.info('Av.rank validation: total q_vectors size=%s', q_represenations.size())\\n logger.info('Av.rank validation: total ctx_vectors size=%s', ctx_represenations.size())\\n\\n q_num = q_represenations.size(0)\\n assert q_num == len(positive_idx_per_question)\\n\\n scores = sim_score_f(q_represenations, ctx_represenations)\\n values, indices = torch.sort(scores, dim=1, descending=True)\\n\\n rank = 0\\n for i, idx in enumerate(positive_idx_per_question):\\n # aggregate the rank of the known gold passage in the sorted results for each question\\n gold_idx = (indices[i] == idx).nonzero()\\n rank += gold_idx.item()\\n\\n if distributed_factor > 1:\\n # each node calcuated its own rank, exchange the information between node and calculate the \\\"global\\\" average rank\\n # NOTE: the set of passages is still unique for every node\\n eval_stats = all_gather_list([rank, q_num], max_size=1000)\\n for i, item in enumerate(eval_stats):\\n remote_rank, remote_q_num = item\\n if i != args.local_rank:\\n rank += remote_rank\\n q_num += remote_q_num\\n\\n av_rank = float(rank / q_num)\\n logger.info('Av.rank validation: average rank %s, total questions=%d', av_rank, q_num)\\n return av_rank\",\n \"def rank(self) -> tskit.Rank:\\n return combinatorics.RankTree.from_tsk_tree(self).rank()\",\n \"def assignRanks(self):\\r\\n\\t\\trank = 0\\r\\n\\t\\tscores = list(self._playerScores)\\r\\n\\t\\tscores.reverse()\\r\\n\\t\\tfor playerScore in scores:\\r\\n\\t\\t\\tif not playerScore.has(NOT_MET) or not playerScore.value(NOT_MET):\\r\\n\\t\\t\\t\\trank += 1\\r\\n\\t\\t\\t\\tplayerScore.set(RANK, smallText(BugUtil.colorText(u\\\"%d\\\" % rank, ScoreOpt.getRankColor())))\\r\\n\\t\\tif rank > 0:\\r\\n\\t\\t\\tself._anyHas[RANK] = True\",\n \"def get_hs_rank(self, points):\\n p = points\\n rank = self.RANKS\\n while p > 0 and rank > 0:\\n p = p - self.BASE * math.pow(self.FACTOR, (self.RANKS - rank))\\n rank = rank - 1\\n\\n if rank > 0:\\n return str(rank)\\n else:\\n return str(self.get_rank(points)) + \\\" Legend\\\"\",\n \"def get_prev_rank(self) -> int:\\n assert not self.is_first_stage(), \\\"Cannot get previous rank in the first stage.\\\"\\n return self.prev_rank\",\n \"def lrprInit(Y, A, rank=None): \\n \\n # initializing\\n m = Y.shape[0]\\n q = Y.shape[1]\\n n = A.shape[0]\\n\\n Y_init = np.zeros((n, n), dtype=np.complex)\\n \\n # looping through each frame\\n for k in range(q):\\n y_k = Y[:, k]\\n A_k = A[:, :, k]\\n y_k_mean = y_k.mean()\\n\\n trunc_y_k = np.where(np.abs(y_k)<=9*y_k_mean, y_k, 0)\\n Y_init += (A_k @ np.diag(trunc_y_k) @ A_k.conj().T)\\n \\n Y_init = (1/(m*q))*Y_init\\n \\n eig_val, eig_vec = np.linalg.eig(Y_init)\\n \\n # choosing rank if not given\\n if rank is None:\\n rank = chooseRank(eig_val)\\n \\n # fixing the chosen rank if needed\\n max_rank = min(n, q)\\n if rank > max_rank:\\n rank = max_rank\\n \\n U = eig_vec[:, :rank]\\n else:\\n U = eig_vec[:, :rank]\\n \\n B = np.zeros((q, rank), dtype=np.complex)\\n \\n for k in range(q):\\n y_k = Y[:, k]\\n A_k = A[:, :, k]\\n mean_y_k = y_k.mean()\\n \\n avg_Y = (1/m)*(A_k @ np.diag(y_k) @ A_k.conj().T)\\n B_init_mat = U.conj().T @ avg_Y @ U\\n \\n b_val, b_vec = np.linalg.eig(B_init_mat)\\n b_k = np.sqrt(mean_y_k) * b_vec[:, 0]\\n \\n B[k] = b_k\\n \\n print('Chosen rank:', rank)\\n print('Spectral Initialization Complete.')\\n \\n return U, B\",\n \"def _rank_2_n(my_type: LieType, lie_rank: Nat) -> Nat:\\n if my_type is LieType.A:\\n # A lie_rank corresponds to SL(lie_rank+1)\\n n_val = lie_rank+1\\n if lie_rank < 1:\\n raise ValueError(\\\"Rank is too small\\\")\\n elif my_type is LieType.B:\\n # B lie_rank corresponds to SO(2*lie_rank+1)\\n n_val = 2*lie_rank+1\\n if lie_rank < 2:\\n raise ValueError(\\\"Rank is too small\\\")\\n elif my_type is LieType.C:\\n # C lie_rank corresponds to Sp(2*lie_rank)\\n n_val = 2*lie_rank\\n if lie_rank < 2:\\n raise ValueError(\\\"Rank is too small\\\")\\n elif my_type is LieType.D:\\n # D lie_rank corresponds to SO(2*lie_rank)\\n n_val = 2*lie_rank\\n if lie_rank < 3:\\n raise ValueError(\\\"Rank is too small\\\")\\n else:\\n raise ValueError(\\n \\\"Lie type must be one of the 4 classical families\\\")\\n return n_val\",\n \"def add_roi_2mlp_head(model, blob_in, dim_in, spatial_scale):\\n hidden_dim = cfg.FAST_RCNN.MLP_HEAD_DIM\\n roi_size = cfg.FAST_RCNN.ROI_XFORM_RESOLUTION\\n roi_feat = model.RoIFeatureTransform(\\n blob_in,\\n 'roi_feat',\\n blob_rois='rois',\\n method=cfg.FAST_RCNN.ROI_XFORM_METHOD,\\n resolution=roi_size,\\n sampling_ratio=cfg.FAST_RCNN.ROI_XFORM_SAMPLING_RATIO,\\n spatial_scale=spatial_scale\\n )\\n model.FC(roi_feat, 'fc6', dim_in * roi_size * roi_size, hidden_dim)\\n model.Relu('fc6', 'fc6')\\n model.FC('fc6', 'fc7', hidden_dim, hidden_dim)\\n model.Relu('fc7', 'fc7')\\n return 'fc7', hidden_dim\",\n \"def get_rank(self):\\n \\n if self.rank == None:\\n self.rank = self.main_ranker(self.string)\\n \\n return self.rank\",\n \"def rank(self):\\n return self.lib.calculate_rank()\",\n \"def pagerank(matrix, bias, d=0.85):\\n n = matrix.shape[0]\\n rank = 0\\n new_rank = np.array([1.0 / n] * n)\\n for i in range(0,200):\\n print \\\"iteration: \\\"+str(i)\\n rank = new_rank\\n new_rank = np.array([(1.0-d)/n] * n) + d * np.dot(matrix, rank)\\n# new_rank = (1.0-d) * bias + d * np.dot(matrix, rank)\\n # new_rank = [(((1.0-d) / n) +\\n # d * sum((rank[i] * link) for i, link in enumerate(row)))\\n # for row in matrix]\\n if(has_converged(rank, new_rank)):\\n break\\n return new_rank\",\n \"def world_rank(self):\\n return self._wrank\",\n \"def unrank(self, rank, n):\\n n, rank = as_int(n), as_int(rank)\\n L = defaultdict(int)\\n for i in range(n - 3, -1, -1):\\n L[i] = rank % n\\n rank = (rank - L[i])//n\\n return Prufer([L[i] for i in range(len(L))])\",\n \"def optim_initialize(self, rank=0):\\n super().optim_initialize(rank)\\n self.optimizer.pytorch_step = self.optimizer.step\\n self.optimizer.step = self.save_and_step\",\n \"def select_rank_minka(shape, svals):\\n # assert shape[0] > shape[1]\\n\\n n_samples, n_features = shape\\n # assert n_samples > n_features\\n assert len(svals) == n_features\\n\\n cov_evals = svals ** 2 / n_samples\\n\\n ranks = np.arange(1, n_features) # 1 to n_features - 1\\n\\n log_liks = np.empty_like(ranks)\\n\\n for idx, rank in enumerate(ranks):\\n log_liks[idx] = get_log_lik(cov_evals=cov_evals,\\n rank=rank,\\n shape=shape)\\n\\n log_liks = pd.Series(log_liks, index=ranks)\\n log_liks.name = 'log_lik'\\n log_liks.index.name = 'rank'\\n\\n rank_est = log_liks.idxmax()\\n\\n return rank_est, {'log_liks': log_liks,\\n 'cov_evals': cov_evals}\",\n \"def predict(self, user: torch.tensor, k: int):\\n pass\",\n \"def create_text_rank(self):\\n # filtered_tokens = self.filter_pos() #if use, replace 2 self.lemma_tokens below\\n vocab = self.create_vocab(self.lemma_tokens)\\n token_windows = self.create_token_windows(self.lemma_tokens)\\n graph = self.create_matrix(vocab, token_windows)\\n text_rank = np.array([1] * len(vocab))\\n previous_tr = 0\\n d = 0.85\\n min_difference = 1e-5\\n for epoch in range(10):\\n text_rank = (1 - d) + d * np.dot(graph, text_rank)\\n if abs(previous_tr - sum(text_rank)) < min_difference:\\n break\\n else:\\n previous_tr = sum(text_rank)\\n node_weight = {}\\n for word in vocab:\\n node_weight[word] = text_rank[vocab[word]]\\n return node_weight\",\n \"def __init__(self, A, rank=0):\\r\\n _u, _s, _v = np.linalg.svd(A, full_matrices=0)\\r\\n \\r\\n self.rank = rank\\r\\n\\r\\n self.U = _u[:,:self.rank].copy()\\r\\n self.S = _s[:self.rank].copy()\\r\\n self.SI = np.matrix(np.diag(self.S)).getI()\\r\\n self.VT = _v[:self.rank,:].copy()\\r\\n \\r\\n self._var = [ e/(_s**2).sum() for e in (_s**2).cumsum() ][self.rank-1]\",\n \"def page_rank(self):\\n print(\\\"Generating the matrix...\\\")\\n G = self.graph\\n p = FOLLOW\\n column_sum = np.sum(G, axis=0, dtype=np.float64)\\n \\n n = self.graph.shape[0]\\n\\n D = sps.lil_matrix((n, n))\\n D.setdiag(np.divide(1.,column_sum, where=column_sum != 0, out=np.zeros_like(column_sum)).reshape(-1, 1))\\n self.diagonal = D\\n print(\\\"created diagonal\\\")\\n e = np.ones((n, 1))\\n I = sps.eye(n)\\n x = sps.linalg.spsolve((I - p*G*D), e)\\n x = x/np.sum(x)\\n\\n self.page_rank = x\\n\\n return x\",\n \"def prufer_rank(self):\\n r = 0\\n p = 1\\n for i in range(self.nodes - 3, -1, -1):\\n r += p*self.prufer_repr[i]\\n p *= self.nodes\\n return r\",\n \"def __init__(self,\\n topn=None,\\n gain_fn=lambda label: label,\\n rank_discount_fn=lambda rank: 1. / rank,\\n normalized=False):\\n self._topn = topn\\n self._gain_fn = gain_fn\\n self._rank_discount_fn = rank_discount_fn\\n self._normalized = normalized\",\n \"def load_ranker(cfg_file, i):\\n return metapy.index.OkapiBM25(k1=i, b=0.75, k3=3.35)\",\n \"def __init__(self, rank, suit):\\n self.rank = rank\\n self.suit = suit\",\n \"def update_rank(self, new_rank, match):\\n\\n self.rank = new_rank\\n\\n # update cached ranks with rank change\\n if self.cached_rank_changes:\\n rank_changes = json.loads(self.cached_rank_changes)\\n else:\\n rank_changes = []\\n\\n rank_changes.append({\\n \\\"rank\\\": new_rank,\\n \\\"played_time\\\": str(match.played_time),\\n \\\"played_timestamp\\\": get_timestamp(match.played_time)\\n })\\n self.cached_rank_changes = json.dumps(\\n rank_changes[-CACHED_RANK_LIMIT:])\\n self.save()\",\n \"def minimize_neg_lbl(self):\\n if self.spatial_only:\\n init_index = 0 # anything should work here\\n else:\\n init_index = np.mean((self.energy_likelihood._min_index,\\n self.energy_likelihood._max_index))\\n \\n init_ns = np.arange(self.fit_input['N']).mean()\\n\\n m = Minuit(self._neg_lbl,\\n n_s = init_ns,\\n gamma = init_index)\\n\\n m.errors = [1, 0.1]\\n m.errordef = Minuit.LIKELIHOOD # 0.5\\n \\n if self.spatial_only:\\n m.fixed['gamma'] = True\\n m.limits = [(0, self.fit_input['N']-1),\\n (None,None)]\\n else:\\n m.limits = [(0, self.fit_input['N']-1),\\n (self.energy_likelihood._min_index,\\n self.energy_likelihood._max_index)]\\n\\n m.migrad()\\n self.minuit = m\\n self._best_fit_ns = m.values[\\\"n_s\\\"]\\n self._best_fit_index = m.values[\\\"gamma\\\"]\\n return m, self._best_fit_ns, self._best_fit_index\",\n \"def fit_transform(self, X):\\n N, K = X.shape\\n\\n I_data = ~np.isnan(X)\\n R_data = X[I_data].astype('int32')\\n\\n with tf.Session() as sess:\\n # Define model in edward\\n I = tf.placeholder(tf.float32, [N, K])\\n U = Normal(loc=0.0, scale=1.0, sample_shape=[self.rank, N])\\n V = Normal(loc=0.0, scale=1.0, sample_shape=[self.rank, K])\\n logits = tf.matmul(tf.transpose(U), V)\\n\\n cutpoints = get_cutpoints(self.response_freq)\\n\\n R = OrdinalLogit(logits=logits, cutpoints=cutpoints, indicators=I)\\n\\n # Define variational parameters\\n qU = Normal(loc=tf.get_variable(\\\"qU/loc\\\", [self.rank, N]),\\n scale=tf.nn.softplus(\\n tf.get_variable(\\\"qU/scale\\\", [self.rank, N])))\\n qV = Normal(loc=tf.get_variable(\\\"qV/loc\\\", [self.rank, K]),\\n scale=tf.nn.softplus(\\n tf.get_variable(\\\"qV/scale\\\", [self.rank, K])))\\n\\n # Run variational inference\\n inference = ed.KLqp({U: qU, V: qV}, data={R: R_data, I: I_data})\\n inference.run()\\n\\n # Use posterior mean for prediction\\n U_pred = qU.mean().eval()\\n V_pred = qV.mean().eval()\\n R_pred = OrdinalLogit(\\n # if we don't use qU.mean() and qV.mean(), edward will draw from qU and qV\\n logits=tf.matmul(tf.transpose(qU.mean()), qV.mean()),\\n cutpoints=cutpoints,\\n indicators=tf.ones(X.shape)\\n ).mean().eval().reshape(X.shape)\\n\\n if self.override_preds:\\n R_pred[I_data] = R_data\\n\\n print(\\\"Resetting default graph\\\")\\n tf.reset_default_graph()\\n\\n return CompletionResult(\\n X_filled=R_pred,\\n U=U_pred.T,\\n V=V_pred,\\n S=None,\\n rank=self.rank\\n )\",\n \"def k_rank_approximate(doc_matrix, k):\\n return []\",\n \"def mpi_rank(self):\\n return 0\",\n \"def afterDDP(self, rank : int):\\n pass\",\n \"def remove_topk_nodes(adj, node_importance_rank, topk):\\n for idx in node_importance_rank[:topk]:\\n for i in range(adj.shape[0]):\\n adj[i, idx] = 0\\n adj[idx, i] = 0\\n\\n return adj\",\n \"def predict(self):\\n train_array = np.array(self.labels != 0, dtype=float)\\n if not self.ising:\\n labels_logit = self.ising_weights['vertices']\\n else:\\n neigh_num = self.adj.dot(train_array)\\n neigh_num = np.where(neigh_num == 0, 1, neigh_num)\\n neigh_weights = self.ising_weights['edges'] * self.labels\\n labels_logit = (np.multiply(neigh_weights, neigh_num**(-1))\\n + self.ising_weights['vertices'])\\n self.prediction = np.where(labels_logit > 0, 1, -1)\\n return self\",\n \"def rerank_candidates(s, pred2sub_rank, all_predictions, rerank_top=20):\\n predicted_smiles = []\\n model_input = []\\n for (predict_smi, label), _ in Counter(all_predictions).most_common(rerank_top):\\n if predict_smi == s:\\n continue\\n features = get_all_features(\\n get_all_ranking_info(pred2sub_rank[predict_smi]))\\n predicted_smiles.append((predict_smi, label))\\n model_input.append(features)\\n\\n model = RankingModel()\\n model.load_state_dict(torch.load('./models/ranker/rank_model.pt', map_location='cpu'))\\n model.eval()\\n\\n test_loader = DataLoader(RankingTestDataset(\\n model_input), batch_size=1000, shuffle=False, num_workers=2)\\n ranking_scores = []\\n for data in test_loader:\\n outputs = model(data)[0]\\n ranking_scores.extend(outputs.detach().cpu().numpy())\\n\\n assert len(predicted_smiles) == len(ranking_scores)\\n pred_smi2score = {k: v[1]\\n for k, v in zip(predicted_smiles, ranking_scores)}\\n return pred_smi2score\",\n \"def __init__(self,suit,rank):\\n self.suit = suit\\n self.rank = rank\\n self.value = values[rank]\",\n \"def svd_HO(data, rank, max_iter=10):\\n svd_iter = 10\\n data_shape = np.shape(data) # p0\\n\\n # Check that number of dimensions match the number of rank numbers\\n if len(data_shape) != len(rank):\\n print(\\\"The rank should be the same size as the data shape\\\")\\n return data, [], []\\n\\n # Check that for each rank, the product of all the rest ranks are larger than this rank\\n for k in range(len(rank)):\\n prod = 1\\n for i in range(len(rank)):\\n if i != k:\\n prod = prod * rank[i]\\n if rank[k] > prod:\\n print(\\\"The rank does not satisfy requirment of HOOI.\\\")\\n return data, [], []\\n\\n dimensions = len(data_shape) # d\\n ordered_indexes = np.argsort(data_shape) # getting the indicies from min len to max, initialization starts from smallest size\\n\\n ## Initialize U and Y with SVD\\n U = [None] * dimensions # Generate an empty array to save all the U matrices with fixed length\\n X = data\\n for k in ordered_indexes: # calculating initial SVD\\n unfolded = unfold_axis(X, k) # unfolding from the axis with minimum size\\n [U[k], _ , _] = fast_svd(unfolded,rank[k],n_iter=svd_iter)\\n X = ttm(X, np.transpose(U[k]), k) # This needs to be fixed!\\n\\n ## Update U with HOOI\\n iter_count = 0\\n while iter_count < max_iter:\\n iter_count += 1\\n for k in range(0, dimensions):\\n Y = data\\n minus_k = list(range(0,dimensions))\\n minus_k.remove(k) # every value except for k, seems do it in one step will remove all the elements in the list.\\n for j in minus_k:\\n Y = ttm(Y, np.transpose(U[j]), j)\\n MY = unfold_axis(Y, k)\\n [U[k], _, _] = fast_svd(MY, rank[k],n_iter=svd_iter)\\n\\n ## Use the determined U matrices to calculate core tensor and denoised tensor\\n X = data\\n for k in ordered_indexes:\\n X = ttm(X,np.transpose(U[k]), k) # Check this part.\\n S = X # core tensor\\n for k in range(0,dimensions):\\n X = ttm(X,U[k], k)\\n\\n return X, U, S\",\n \"def prelu(input, weight):\\n return FunctionLib.apply('PRelu', input.device, [input, weight])\",\n \"def returnLowerBound(self, dimension):\\n value = self._distribution.returnLowerBound(dimension)\\n return value\",\n \"def _get_rank(self,fitness):\\n # infact you can get the order or rank by only once sort.\\n rank=fitness[:,0].argsort().argsort() # [n]\\n return rank\",\n \"def get_ancestor_of_rank(node: PhyloNode, rank: str) -> Optional[int]:\\n\\n while node:\\n if node.rank == rank:\\n return node.tax_id\\n node = node.parent\\n return None\",\n \"def normalize_rank(self, x, axis=-1):\\n\\t\\tx = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\\n\\t\\treturn x\",\n \"def rank(self, current_order_by_value: Comparable, current_row_number: int) -> int:\",\n \"def __init__(self, rank, suit):\\n self._rank = rank\\n self._suit = suit\",\n \"def rank(matrix, decayThreshold, zeroThreshold):\\n\\n _, s, _ = np.linalg.svd(matrix)\\n\\n if (len(s) != 0) and (s[0] > zeroThreshold):\\n rank = 1\\n else:\\n return 0\\n\\n for s1, s2 in zip(s, s[1:]):\\n if (s2 > zeroThreshold) and (s2/s1 > decayThreshold):\\n rank += 1\\n else:\\n break\\n return rank\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59534043","0.5852097","0.5795221","0.56463134","0.55684614","0.55317307","0.5511257","0.53647435","0.53025186","0.52452224","0.5243477","0.52426994","0.520438","0.51970804","0.5141929","0.5132518","0.51169837","0.51121306","0.5107999","0.50937647","0.508624","0.50805074","0.5045129","0.5038172","0.5029346","0.5029346","0.5029346","0.5029346","0.5029346","0.50067514","0.4998597","0.4957885","0.49556458","0.49433902","0.49348348","0.4909947","0.49079168","0.48970467","0.4893223","0.48912266","0.488678","0.48862585","0.487109","0.48705694","0.48475495","0.48378026","0.48205173","0.4815731","0.4815731","0.4815731","0.4815731","0.47578743","0.4748291","0.47459516","0.47401565","0.47395113","0.47259432","0.47200406","0.47184992","0.4718067","0.47175682","0.47106308","0.47055352","0.46970674","0.46960762","0.4695992","0.4691506","0.46897048","0.46784523","0.4678234","0.46411377","0.46391904","0.46369046","0.46337873","0.46267197","0.4625538","0.46205157","0.46179253","0.46118727","0.4609921","0.46094912","0.46091086","0.46090087","0.4606006","0.46005604","0.4598944","0.4598181","0.45978603","0.45952213","0.45913994","0.45880097","0.45777875","0.45766884","0.45711425","0.45704216","0.45666367","0.45651817","0.45615596","0.45393896","0.45335737"],"string":"[\n \"0.59534043\",\n \"0.5852097\",\n \"0.5795221\",\n \"0.56463134\",\n \"0.55684614\",\n \"0.55317307\",\n \"0.5511257\",\n \"0.53647435\",\n \"0.53025186\",\n \"0.52452224\",\n \"0.5243477\",\n \"0.52426994\",\n \"0.520438\",\n \"0.51970804\",\n \"0.5141929\",\n \"0.5132518\",\n \"0.51169837\",\n \"0.51121306\",\n \"0.5107999\",\n \"0.50937647\",\n \"0.508624\",\n \"0.50805074\",\n \"0.5045129\",\n \"0.5038172\",\n \"0.5029346\",\n \"0.5029346\",\n \"0.5029346\",\n \"0.5029346\",\n \"0.5029346\",\n \"0.50067514\",\n \"0.4998597\",\n \"0.4957885\",\n \"0.49556458\",\n \"0.49433902\",\n \"0.49348348\",\n \"0.4909947\",\n \"0.49079168\",\n \"0.48970467\",\n \"0.4893223\",\n \"0.48912266\",\n \"0.488678\",\n \"0.48862585\",\n \"0.487109\",\n \"0.48705694\",\n \"0.48475495\",\n \"0.48378026\",\n \"0.48205173\",\n \"0.4815731\",\n \"0.4815731\",\n \"0.4815731\",\n \"0.4815731\",\n \"0.47578743\",\n \"0.4748291\",\n \"0.47459516\",\n \"0.47401565\",\n \"0.47395113\",\n \"0.47259432\",\n \"0.47200406\",\n \"0.47184992\",\n \"0.4718067\",\n \"0.47175682\",\n \"0.47106308\",\n \"0.47055352\",\n \"0.46970674\",\n \"0.46960762\",\n \"0.4695992\",\n \"0.4691506\",\n \"0.46897048\",\n \"0.46784523\",\n \"0.4678234\",\n \"0.46411377\",\n \"0.46391904\",\n \"0.46369046\",\n \"0.46337873\",\n \"0.46267197\",\n \"0.4625538\",\n \"0.46205157\",\n \"0.46179253\",\n \"0.46118727\",\n \"0.4609921\",\n \"0.46094912\",\n \"0.46091086\",\n \"0.46090087\",\n \"0.4606006\",\n \"0.46005604\",\n \"0.4598944\",\n \"0.4598181\",\n \"0.45978603\",\n \"0.45952213\",\n \"0.45913994\",\n \"0.45880097\",\n \"0.45777875\",\n \"0.45766884\",\n \"0.45711425\",\n \"0.45704216\",\n \"0.45666367\",\n \"0.45651817\",\n \"0.45615596\",\n \"0.45393896\",\n \"0.45335737\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5629263"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":83689,"cells":{"query":{"kind":"string","value":"Gives the full predicted matrix based on the low rank u and v."},"document":{"kind":"string","value":"def predict_mat(self):\n return self.u.dot(self.v.T)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def compute_low_rank_matrix( self, u, s, v, rank ):\n u_approx = u[ :, :rank ]\n s_approx = s[ :rank ]\n sum_taken_percent = np.sum( s_approx ) / float( np.sum( s ) )\n s_approx = np.diag( np.array( s_approx ) )\n v_approx = v[ :rank, : ]\n return [ u_approx.dot( s_approx ).dot( v_approx ), sum_taken_percent ]","def prediction(self, v, imu_meas):\n # YOUR CODE HERE\n pass","def predict(self, u=0):\n self.x = np.dot(self.transition_matrix, self.x) + np.dot(self.control_matrix, u)\n\n self.prediction_covariance = np.dot(\n np.dot(self.transition_matrix, self.prediction_covariance), self.transition_matrix.T\n ) + self.process_covariance\n\n return self.x","def predict(self, X_test, V = None):\n\t\tif X_test.ndim == 1:\n\t\t\tX_test = X_test[:,np.newaxis]\n\t\tif X_test.shape[1] == self.D:\n\t\t\tX_test = np.concatenate((np.ones((X_test.shape[0],1)), X_test), axis = 1) #adding dummy variable for the bias\n\t\tif V is None:\n\t\t\tV = self.V\n\t\tres = np.matmul(X_test,V) #(N,K)\n\t\tres = np.exp(res) + 1e-5 #(N,K)\n\t\tres = np.divide(res.T, np.sum(res, axis = 1)).T #(N,K) normalizing\n\n\t\treturn res","def predict(self, u):\n\n dtheta_l = self.current_state_estimate[0,0]\n dtheta_r = self.current_state_estimate[1,0]\n v = self.current_state_estimate[2,0]\n w = self.current_state_estimate[3,0]\n x = self.current_state_estimate[4,0]\n y = self.current_state_estimate[5,0]\n theta = self.current_state_estimate[6,0]\n vl = u[0,0]\n vr = u[1,0]\n \n # Vary noise with input voltage\n if abs(self.current_state_estimate[0,0]) < .03:\n self.Q[0,0] = .0000001\n dtheta_l = 0\n\n else:\n self.Q[0,0] = abs(vl)*.03/3000+.03\n\n if abs(self.current_state_estimate[1,0]) < .03:\n self.Q[1,1] = .0000001\n dtheta_r = 0\n else:\n self.Q[1,1] = abs(vr)*.03/3000+.03\n\n ## TRANSITION ESTIMATE\n self.current_state_estimate[0] += self.dt*(self.k2_l*dtheta_l + self.k1_l*vl)\n self.current_state_estimate[1] += self.dt*(self.k2_r*dtheta_r + self.k1_r*vr)\n self.current_state_estimate[2] = self.r/2 * (self.current_state_estimate[0] + self.current_state_estimate[1])\n self.current_state_estimate[3] = self.r/self.l * (self.current_state_estimate[1] - self.current_state_estimate[0])\n self.current_state_estimate[4] += (self.dt)*self.current_state_estimate[2]*math.cos(theta)\n self.current_state_estimate[5] += (self.dt)*self.current_state_estimate[2]*math.sin(theta)\n self.current_state_estimate[6] += (self.dt)*self.current_state_estimate[3]\n \n ## TRANISTION PROBABILITY\n # only propogate the things that can move\n self.A[0:7, 0:7] = np.array([[1+self.dt*self.k2_l, 0, 0, 0, 0, 0, 0],\\\n [0, 1+self.dt*self.k2_r, 0, 0, 0, 0, 0],\\\n [self.r/2, self.r/2, 0, 0, 0, 0, 0],\\\n [-self.r/self.l, self.r/self.l, 0, 0, 0, 0, 0],\\\n [0, 0, math.cos(theta)*self.dt , 0, 1, 0, -v*math.sin(theta)*self.dt],\\\n [0, 0, math.sin(theta)*self.dt , 0, 0, 1, v*math.cos(theta)*self.dt],\\\n [0, 0, 0, self.dt, 0, 0, 1]])\n \n self.current_prob_estimate = np.dot(np.dot(self.A, self.current_prob_estimate), np.transpose(self.A)) + self.Q","def predict(self, u):\n\n A = self._mat_desc[\"A\"]\n B = self._mat_desc[\"B\"]\n\n # update the prediction of the state vector\n self._state_vec = self._motion_model(self._state_vec_prev, A, B, u)\n\n P = self._mat_desc[\"P\"]\n Q = self._mat_desc[\"Q\"]\n L = self._mat_desc[\"L\"]\n L_T = L.T\n F = self._mat_desc[\"F\"]\n F_T = F.T\n P = F * P * F_T + L * Q * L_T\n self._mat_desc[\"P\"] = P","def _estimate_ratings(self, U, V):\n Rhat = np.matmul(U, V.transpose()) # estimate R with UV^T\n Rhat = np.where(self.R_missing, 0, Rhat) # fill in missing values of R with 0s\n return Rhat","def predict(self, u=0):\n\n self.predict_x(u)\n \n W = np.concatenate((dot(self.F, self.U), self.Uq), axis=1)\n D = np.concatenate((self.D, self.Dq))\n self.U, self.D = mwgs(W, D)\n\n # save prior\n self.x_prior = np.copy(self.x)\n self.U_prior = np.copy(self.U)\n self.D_prior = np.copy(self.D)","def matrix_deflation(X_curr, Y_curr, X_orig, Y_orig, u, v):\n Xp = X_curr\n Yp = Y_curr\n #u = u / (np.sqrt(np.sum(u**2)+1e-7))\n #v = v / (np.sqrt(np.sum(v**2)+1e-7))\n\n qx = np.dot(Xp.T,np.dot(X_orig,u))\n qx = qx / (np.sqrt(np.sum(qx**2)+1e-7))\n #qx = qx.astype('float16')\n Xp = Xp - np.dot(Xp,qx).dot(qx.T)\n X = Xp.reshape(1,Xp.shape[0],Xp.shape[1])\n\n qy = np.dot(Yp.T,np.dot(Y_orig,v))\n qy = qy / (np.sqrt(np.sum(qy**2)+1e-7))\n #qy = qy.astype('float16')\n Yp = Yp - np.dot(Yp,qy).dot(qy.T)\n Y = Yp.reshape(1,Yp.shape[0],Yp.shape[1])\n\n return X, Y","def get_prediction(self, u=0):\n raise \"Not implemented yet\"\n\n x = dot(self._F, self._x) + dot(self._B, u)\n P = dot3(self._F, self._P, self._F.T) + self.Q\n return (x, P)","def matrix_deflation(X_curr, Y_curr, X_orig, Y_orig, u, v):\n Xp = X_curr\n Yp = Y_curr\n\n qx = np.dot(Xp.T,np.dot(X_orig,u))\n qx = qx / (np.sqrt(np.sum(qx**2)+1e-7))\n Xp = Xp - np.dot(Xp,qx).dot(qx.T)\n\n qy = np.dot(Yp.T,np.dot(Y_orig,v))\n qy = qy / (np.sqrt(np.sum(qy**2)+1e-7))\n Yp = Yp - np.dot(Yp,qy).dot(qy.T)\n\n Xp = (Xp - np.mean(Xp)) / np.std(Xp)\n Yp = (Yp - np.mean(Yp)) / np.std(Yp)\n\n return Xp, Yp","def predict(self, user: torch.tensor, k: int):\n pass","def _predicted(self):\n return np.matmul(self.x, self.solution)","def predict_x(self, u=0):\n self.x = dot(self.F, self.x) + dot(self.B, u)","def predict(self):\n add = np.ones(len(self.X_test))\n X_add = np.c_[add, self.X_test]\n pred = np.dot(X_add, self.w_result.T)\n\n pred[pred > 0] = 1\n pred[pred < 0] = 0\n return pred","def get_u(m):\n U = m.copy()\n for i in range(1, U.shape[0]):\n U[i, :i] = 0\n return U","def predict(self, x_test_unvec, verbose=True):\n y_test_probas = self.predict_proba(x_test_unvec, verbose=verbose)\n return np.argmax(y_test_probas, axis=1)","def predict(self, x: np.ndarray, u: np.ndarray, t: int = None, noise: np.ndarray = None):","def get_predictions(self, x_train_single):\n\n x_row = x_train_single.toarray()\n x_row = cp.array(x_row.reshape(-1, 1))\n #x_row = cupyx.scipy.sparse.csr_matrix(x_row)\n\t\n #h = cupyx.scipy.sparse.csr_matrix.dot(self.weights, x_row)\n h = cp.matmul(self.weights,x_row)\n h = cp.reshape(h,(self.num_models))\n h = cp.asnumpy(h)\n \n cp.cuda.Stream.null.synchronize()\n return h.tolist()\n #y = []\n #for val in h:\n # y.append(val[0])\n \n #return y","def pred(self,u,i):\r\n if self.user_based:\r\n bias=self.mu[u]\r\n else:\r\n bias=self.mu[i]\r\n pred=self.X[i,:].dot(self.W[:,u])+bias\r\n if pred<0:\r\n return 0\r\n if pred>5:\r\n return 5\r\n return pred","def predict(self, test_set_):\n\n test_set = np.array(test_set_)\n n_samples, n_features = test_set.shape\n\n assert n_features == self.features\n\n single_feature = test_set[:, self.bestn]\n h = np.ones((n_samples))\n h[single_feature*self.bestd < self.bestp*self.bestd] = -1\n return h","def get_batch_predictions_MFE(rnn, X, target):\n\n out = rnn.forward(X, mean_field_inference=True)\n arr_preds = nn.functional.softmax(out, dim=-1).data.cpu().numpy()\n arr_target = target.detach().cpu().numpy()\n\n return arr_preds, arr_target","def _generate_predictions(self, data):\n\n return np.zeros(data.shape[0])","def find_optimal_low_rank_matrix( self, orig_similarity_matrix, orig_rank, u, s, v, singular_reduction ):\n '''rank_list = list()\n sum_singular_values = list()\n for rank in range( 0, orig_rank ):\n compute_result = self.compute_low_rank_matrix( u, s, v, rank + 1 )\n rank_list.append( ( rank + 1 ) / float( orig_rank ) )\n sum_singular_values.append( compute_result[ 1 ] )\n utils._plot_singular_values_rank( rank_list, sum_singular_values )'''\n return self.compute_low_rank_matrix( u, s, v, int( singular_reduction * orig_rank ) )","def predict_all(self):\n # DONE return prediction for all users\n return self._user_factors.dot(self._item_factors.T)","def offset_to_uvd(self, x):\n self.batch_size = x.shape[0]\n self.W = x.shape[2]\n self.H = x.shape[3] \n self.D = 5\n self.grid_size = self.W*self.H*self.D\n \n grid_linear = x.reshape(self.batch_size, 64, -1)\n\n index = torch.from_numpy(np.asarray(np.unravel_index(np.arange(self.grid_size), \n (self.W, self.H, self.D)))).type(torch.FloatTensor)\n u = index[0, :].unsqueeze(0).expand(21, -1)\n v = index[1, :].unsqueeze(0).expand(21, -1)\n z = index[2, :].unsqueeze(0).expand(21, -1)\n\n if self.device != \"cpu\":\n u = u.cuda()\n v = v.cuda()\n z = z.cuda()\n\n pred_uvd_no_offset = grid_linear[:, :63, :].reshape(self.batch_size, 21, 3, self.grid_size)\n pred_conf = grid_linear[:, 63, :].reshape(self.batch_size, self.W, self.H, self.D)\n pred_conf = torch.sigmoid(pred_conf)\n \n # middle finger root is hand root\n pred_uvd_no_offset[:, self.hand_root, :, :] = torch.sigmoid(pred_uvd_no_offset[:, self.hand_root, :, :])\n \n pred_uvd = pred_uvd_no_offset.clone().detach()\n pred_uvd[:, :, 0, :] = (pred_uvd[:, :, 0, :] + u) / self.W\n pred_uvd[:, :, 1, :] = (pred_uvd[:, :, 1, :] + v) / self.H\n pred_uvd[:, :, 2, :] = (pred_uvd[:, :, 2, :] + z) / self.D\n \n pred_uvd_no_offset = pred_uvd_no_offset.reshape(self.batch_size, 21, 3, self.W, self.H, self.D)\n \n return pred_uvd_no_offset, pred_uvd, pred_conf","def get_predictions(self, model, inputs=None):\n if inputs is None:\n inputs = self.inputs\n\n refl_id = BaseModel.get_refl_id(inputs)\n iobs = BaseModel.get_intensities(inputs).flatten()\n sig_iobs = BaseModel.get_uncertainties(inputs).flatten()\n asu_id,H = self.asu_collection.to_asu_id_and_miller_index(refl_id)\n #ipred = model(inputs)\n ipred,sigipred = model.prediction_mean_stddev(inputs)\n\n h,k,l = H.T\n results = ()\n for i,asu in enumerate(self.asu_collection):\n idx = asu_id == i\n idx = idx.flatten()\n output = rs.DataSet({\n 'H' : h[idx],\n 'K' : k[idx],\n 'L' : l[idx],\n 'Iobs' : iobs[idx],\n 'SigIobs' : sig_iobs[idx],\n 'Ipred' : ipred[idx],\n 'SigIpred' : sigipred[idx],\n }, \n cell=asu.cell, \n spacegroup=asu.spacegroup,\n merged=False,\n ).infer_mtz_dtypes().set_index(['H', 'K', 'L'])\n results += (output, )\n return results","def get_batch_predictions(rnn, X, target):\n\n out = rnn.forward(X)\n arr_preds = nn.functional.softmax(out, dim=-1).data.cpu().numpy()\n arr_target = target.detach().cpu().numpy()\n\n return arr_preds, arr_target","def make_predictions(model, x_test, y_test):\r\n preds = model.predict(x_test)\r\n y_hat = np.argmax(preds, axis=-1)\r\n print(type(y_test))\r\n y_test.columns = [0, 1]\r\n y = y_test.idxmax(axis=1)\r\n print(y_hat.shape)\r\n print(y.shape)\r\n return y_hat, y","def prediction(self, v, imu_meas):\n\n omega = -imu_meas[3]\n\n current_time = imu_meas[4]\n theta = self.x[2]\n\n if self.last_time is None:\n dt = 0\n else:\n dt = current_time - self.last_time\n self.last_time = current_time\n\n # jacobian of state transition function\n dfdx = np.eye(3) + dt * np.array([(0, 0, -v * np.sin(theta)),\n (0, 0, v * np.cos(theta)),\n (0, 0, 0)])\n dfdn = dt * np.array(((math.cos(theta), 1),\n (math.sin(theta), 1), (1, 1)))\n xp = self.x + dt * \\\n np.array((v * np.cos(theta), v * np.sin(theta), omega))\n Pp = np.dot(np.dot(dfdx, self.P_t), dfdx.T) + \\\n np.dot(np.dot(dfdn, self.Q_t), dfdn.T)\n\n return xp, Pp","def predict_only(self):","def nnPredict(w1,w2,data): \r\n \r\n labels = np.array([])\r\n #Your code here\r\n #Get bias dimension\r\n bias_dimension = data.shape[0]\r\n\r\n #Fill it all with ones\r\n bias = np.ones((bias_dimension,1))\r\n\r\n #Add bias to weights \r\n data_with_bias = np.concatenate((data,bias),1)\r\n\r\n #Feed Foward Start By Multiplying Training data by weights of w1\r\n z2 = np.dot(data_with_bias,np.transpose(w1))\r\n\r\n #Apply Sigmoid function\r\n a2= sigmoid(z2)\r\n #Apply Another Bias Dimension to the new matrix\r\n\r\n #bias_dimension=a2.shape[0]\r\n #bias = np.ones((bias_dimension,1))\r\n a2_bias= np.concatenate((a2,bias),1)\r\n\r\n #Multiply new matrix by the weights of w2\r\n z3 = np.dot(a2_bias,np.transpose(w2))\r\n \r\n #Apply Sigmoid Function to the new data\r\n y= sigmoid(z3)\r\n\r\n #find max value and add that digit to the labels vector\r\n labels= np.zeros((y.shape[0],1))\r\n count=0\r\n for x in y:\r\n index=0\r\n max=0\r\n inmax=0\r\n for p in x:\r\n if p >= max:\r\n max=p\r\n inmax=index\r\n index+=1\r\n labels[count][0]=inmax\r\n count+=1\r\n \r\n print('results n ', labels)\r\n return labels","def predict(self, input_data):\n assert len(input_data.shape) == 2\n assert input_data.shape[1] == self.training_data[0].shape[1]\n\n l = self.kernel.get_kernel_matrix(self.training_data[0], input_data)\n y = numpy.dot(l.T, self.alpha)\n\n beta = scipy.linalg.solve_triangular(self.u, l, trans='T')\n c = scipy.linalg.solve_triangular(self.u, beta)\n v = self.kernel.get_kernel_diagonal(input_data) - numpy.sum(l * c, axis=0)\n return numpy.asarray(y).flatten(), numpy.asarray(v).reshape((v.size, 1))","def predict_for_customers(self,):\n return self.user_vectors.dot(self.item_vectors.T)","def _multiply_matrix(self, v):\n\n self.inputs.grad.data.zero_()\n\n with torch.no_grad():\n v_features = self.lpips_model.features(self.inputs.detach() +\n self.h * v)\n D_phi_v = (\n normalize_flatten_features(v_features) -\n self.input_features\n ) / self.h\n\n torch.sum(self.input_features * D_phi_v).backward(retain_graph=True)\n\n return self.inputs.grad.data.clone()","def hadamard(u: np.ndarray, v: np.ndarray) -> np.ndarray:\n\n return u * v","def _raw_predict(self,_Xnew,slices=None, full_cov=False):\n Kx = self.kern.K(self.X,_Xnew, slices1=self.Xslices,slices2=slices)\n mu = np.dot(np.dot(Kx.T,self.Ki),self.likelihood.Y)\n KiKx = np.dot(self.Ki,Kx)\n if full_cov:\n Kxx = self.kern.K(_Xnew, slices1=slices,slices2=slices)\n var = Kxx - np.dot(KiKx.T,Kx)\n else:\n Kxx = self.kern.Kdiag(_Xnew, slices=slices)\n var = Kxx - np.sum(np.multiply(KiKx,Kx),0)\n var = var[:,None]\n return mu, var","def gen_U(self, n_dims, n, V):\n cov = np.eye(n_dims)\n\n U = []\n for v in V:\n μ = np.zeros(n_dims)\n U_for_class_v = m_normal(μ, cov, n)\n U_for_class_v -= U_for_class_v.mean(axis=0)\n U_for_class_v += v # Center at v to control test results.\n U.append(U_for_class_v)\n\n # To control the test result, each set of u's sums to its respective v.\n for x in range(len(U)):\n are_same = np.allclose(V[x], U[x].mean(axis=0))\n assert are_same == True\n\n U = np.vstack(U)\n\n return U","def get_confmatrix(self,y_pred,y_test):","def get_preds(training_data: np.mat, mcol_b: np.mat, tau: float) -> np.ndarray:\r\n ypred = local_weight_regression(training_data, mcol_b, tau)\r\n return ypred","def predict_all(self):\n return self.Bi + tf.matmul(self.Gu, self.Gi, transpose_b=True) \\\n + tf.matmul(self.Tu, tf.matmul(self.F, self.E), transpose_b=True) \\\n + tf.squeeze(tf.matmul(self.F, self.Bp))","def oldPredict(self, data):\n\n predictions = []\n\n if len(self.observations) < self.k_neighbors:\n print(f\"Data length ({len(data)}) was too small.\")\n\n for row in data:\n neighbors_info = {}\n\n for row_index in range(len(self.observations)):\n distance = self.calcualteEuclideanDistance(self.observations[row_index], row)\n if len(neighbors_info) > self.k_neighbors - 1:\n largest_distance = max(neighbors_info.keys())\n if distance < largest_distance:\n neighbors_info[distance] = self.labels[row_index]\n del neighbors_info[largest_distance]\n else:\n neighbors_info[distance] = self.labels[row_index]\n\n unique_values = set(neighbors_info.values())\n if len(unique_values) == 1:\n value = unique_values.pop()\n predictions.append(value)\n else:\n best_value = 0\n best_value_weight = 0\n for label in unique_values:\n weight = 0\n for distance in neighbors_info.keys():\n if label == neighbors_info[distance]:\n if 'inverse_distance' == self.weight_type:\n weight += self.calulateWeightedVote(distance)\n elif 'no_weight' == self.weight_type:\n weight += 1\n else:\n print(\"Not a valid_weight_type.\")\n\n if weight > best_value_weight:\n best_value_weight = weight\n best_value = label\n\n predictions.append(best_value)\n # print(f\"Neighbors Info: {neighbors_info}\")\n\n return predictions","def predict(self, predPoints=None):","def cross_matrix(v):\n\treturn np.array([\n\t\t[ 0, -v[2], v[1]],\n\t\t[ v[2], 0, -v[0]],\n\t\t[-v[1], v[0], 0]])","def gen_pred(model, indices, inp):\n preds = model.predict(inp)#, label)\n print(np.argmax(preds))\n for k,v in indices.items():\n print(k)\n if v == np.argmax(preds):\n print(k)\n new_inp = np.roll(inp, -1, 1)\n new_inp[0][-1] = eye[indices[k]]\n return new_inp","def predict_mat(self):\n mat = self.covs_mat.dot(self.alpha)\n return mat.reshape(self.shape)","def nnPredict(w1,w2,data):\n \n labels = np.array([])\n \n # create bias row\n bias_row =np.ones((np.size(data,0),1))\n \n # concatenate bias with data matrix\n data=np.concatenate((data,bias_row),axis=1)\n \n #Calculate input to hidden layer\n intput_hidden_layer= np.dot(data,w1.transpose()) \n \n #Calculate output of hidden layer using sigmoid function\n output_hidden_layer= sigmoid(intput_hidden_layer)\n \n #Calculate input to output nodes\n input_with_bias = np.concatenate((output_hidden_layer,bias_row),axis=1) \n input_output_node= np.dot(input_with_bias,w2.transpose()) \n \n # Calculate output of output layer\n output_layer= sigmoid(input_output_node) \n \n # get index of maximum from all rows in ouput layer matrix\n labels = np.argmax(output_layer,axis=1) \n \n return labels","def s2s_predict(self, gmv_data, model): \r\n\r\n test_X1 = gmv_data[-self.pre_time-self.input_len:\r\n -self.pre_time].reshape(1, -1, self.input_dim)\r\n pre1 = model.predict(test_X1) \r\n\r\n test_X2 = np.concatenate((test_X1[0][14:], pre1[0])).\\\r\n reshape(1, -1, self.input_dim)\r\n pre2 = model.predict(test_X2)\r\n\r\n test_X3 = np.concatenate((test_X2[0][7:], pre1[0][0:7])).\\\r\n reshape(1, -1, self.input_dim)\r\n pre3 = model.predict(test_X3)\r\n\r\n pre = np.concatenate((pre1[0], pre2[0], pre3[0][7:]))\r\n\r\n return pre","def nnPredict(w1,w2,data): \r\n #Similar to the forward pass stage in nnObj\r\n trans_w1=w1.T\r\n trans_w2=w2.T\r\n\r\n x=np.column_stack((data,np.ones(len(data))))\r\n #equation1\r\n eq1=np.dot(x,trans_w1)\r\n \r\n #equation2\r\n z=sigmoid(eq1)\r\n\r\n z=np.column_stack((z,np.ones(len(z))))\r\n\r\n eq3=np.dot(z,trans_w2)\r\n\r\n o=sigmoid(eq3)\r\n\r\n labels = np.argmax(o, 1) #Return the index of the number which has maximum value\r\n return labels","def reflection_matrix(v):\n n = len(v)\n v = np.array(v)[np.newaxis]\n return np.eye(n) - 2 * np.dot(v.T, v)","def predict(self, test):\n\n test_scores = self.score(test)\n user_ids = test[self.col_user].map(self.user2index).values\n\n # create mapping of new items to zeros\n item_ids = test[self.col_item].map(self.item2index).values\n nans = np.isnan(item_ids)\n if any(nans):\n logger.warning(\n \"Items found in test not seen during training, new items will have score of 0\"\n )\n test_scores = np.append(test_scores, np.zeros((self.n_users, 1)), axis=1)\n item_ids[nans] = self.n_items\n item_ids = item_ids.astype(\"int64\")\n\n df = pd.DataFrame(\n {\n self.col_user: test[self.col_user].values,\n self.col_item: test[self.col_item].values,\n self.col_prediction: test_scores[user_ids, item_ids],\n }\n )\n\n return df","def toMatrix(self,v):\n return Matrix([[v.x],[v.y],[v.z]])","def predict_all(self):\n return numpy.dot(self.P, self.Q.T)","def predict(self, X_test):\n \n X_test = np.insert(X_test, 0, 1, axis=1)\n Y_out = self.W.T.dot(X_test.T)\n pred = np.argmax(Y_out, axis=0)\n \n \n return pred","def predict(self, X):\n pred = np.zeros(X.shape[0])\n ### YOUR CODE HERE 1-3 lines\n probabilities = np.array([model.probability(X) for model in self.models])\n pred=np.argmax(probabilities, axis=0)\n ### END CODE\n assert pred.shape == (X.shape[0],)\n return pred","def predict(self):\n for src_p, pair in enumerate(self.pairs):\n dst_p = pair[1].argmax()\n dst_ind = pair[0][dst_p]\n\n self.vector_field.append(np.hstack([self.frame_0[src_p], self.frame_1[dst_ind]]))\n\n self.vector_field = np.vstack(self.vector_field)\n\n return self.vector_field","def predict(self, params, test):\n vect_logit = np.vectorize(logit)\n vect_comp = np.vectorize(complement)\n n_test = np.shape(test)[0]\n prior = self.model_prior\n conditional = self.model_conditional\n K = len(prior)\n p = np.shape(conditional)[1]\n test_p = np.shape(test)[1]\n if p != test_p:\n print \"Error: Number of training and testing features differ\"\n return\n preds = []\n weight = vect_logit(conditional)\n # Stores weight matrix\n condition_comp = vect_comp(conditional)\n intercept = np.log(\n prior) + np.sum(np.apply_along_axis(np.log, 1, condition_comp), axis=1)\n # Stores intercept vector\n weight = weight.transpose()\n classifier = test.dot(weight) + intercept\n preds = np.argmax(classifier, axis=1) + 1\n # Add 1 because the classes have a 1-based index\n preds = preds.reshape(n_test, 1)\n return preds","def predict(self, X):","def predict(self, X):","def predict(self):\n train_array = np.array(self.labels != 0, dtype=float)\n if not self.ising:\n labels_logit = self.ising_weights['vertices']\n else:\n neigh_num = self.adj.dot(train_array)\n neigh_num = np.where(neigh_num == 0, 1, neigh_num)\n neigh_weights = self.ising_weights['edges'] * self.labels\n labels_logit = (np.multiply(neigh_weights, neigh_num**(-1))\n + self.ising_weights['vertices'])\n self.prediction = np.where(labels_logit > 0, 1, -1)\n return self","def predict(self, X:np.ndarray) -> np.ndarray:\n n_obs = X.shape[0]\n n_classes = self.mu.shape[0]\n n_features = self.mu.shape[1]\n\n # initalize the output vector\n y = np.empty(n_obs,dtype=int)\n #d=np.linalg.det()\n c_=np.zeros(n_classes)\n a=np.zeros((n_features,n_features))\n for j,x in enumerate(X):\n for i in range(n_classes):\n diag=self.sigma[i].diagonal()\n np.fill_diagonal(a,diag)\n #print(a,i)\n #sig_inv=np.linalg.inv(self.sigma[i]) #l'nverse de la matrice sigma\n sig_inv=np.linalg.inv(a)\n x_u=x - self.mu[i] \n #c_[i]=-((n_features/2.)*log(2*pi) + 0.5*log(np.linalg.det(self.sigma[i]))) - 0.5*((x_u.T).dot(sig_inv)).dot(x_u)\n c_[i]=-0.5*log(np.linalg.det(self.sigma[i])) - 0.5*((x_u.T).dot(sig_inv)).dot(x_u) + log(self.priors[i])\n y[j]=np.argmax(c_)\n \n #print(y)\n return y","def predict(self, X):\n pred = None\n ### YOUR CODE HERE\n dat = X[:, self.idx]\n n = X.shape[0] \n decision = (dat < self.val).astype(int)\n # values = np.c_[np.ones(n)*self.left, np.ones(n)*self.right]\n pred = decision * self.left + (1-decision) * self.right\n ### END CODE\n return pred","def get_svd(self,new_df):\n\n\t\tnew_matrix = new_df.as_matrix()\n\t\t\n\t\t#get the mean score of users\n\t\tmean_score = np.mean(new_matrix,axis = 1)\n\t\tnew_matrix_dm = new_matrix - mean_score.reshape(-1,1)\n\t\t#decompose interaction matrix into U, Vt, Sigma\n\t\tU, sigma, Vt = svds(new_matrix_dm, k = 5)\n\t\tsigma = np.diag(sigma)\n\t\tall_user_predicted_ratings = np.dot(np.dot(U, sigma), Vt) + mean_score.reshape(-1, 1)\n\t\tpreds_df = pd.DataFrame(all_user_predicted_ratings, columns = new_df.columns)\n\t\tpreds_df = preds_df.round(1)\n\n\t\treturn preds_df","def proba_redefined_predict(model,X,weigh):\n\n y_proba=model.predict_proba(X)\n tuned=renorm(y_proba,weigh)\n y_max_arg=tuned.argmax(axis=1)\n predict=to_class(y_max_arg,model.classes_)\n\n return predict","def getPredictions(self):\n\t\tself.bestLabel = self.testingProbs.apply(lambda x: x.argmax(),1)","def prediction(self, x):\n pred = np.dot(self.fonction_base_polynomiale(x),self.w)\n if pred.shape == (1,):\n return pred[0]\n else:\n return pred","def predict(self, data):\r\n x = []\r\n x.append(data.sampled_matrix())\r\n x = np.array(x)\r\n x = np.reshape(x, (x.shape[0], x.shape[1], 1))\r\n\r\n result = self.model.predict(x)\r\n return result","def predict(self, xs, **kwargs):","def prediction(prediction_file_name, clusters_list, svd_use_flag):\n \n coords = misc_functions.getWindowCoords()\n \n test_users = range(coords[0], coords[2] + 1) \n test_items = range(coords[1], coords[3] + 1)\n \n #print \"len(test_users) = \", len(test_users)\n #print \"len(test_items) = \", len(test_items)\n #print \"test_items = \", test_items\n \n # this matrix to be written as result finally\n #misc_functions.step()\n prediction_matrix = zeros((len(test_users), len(test_items)), dtype = float)\n \n training_matrix = scipy.io.mmio.mmread(\"history.mtx\").tocsr()\n \n item_X_meta_matrix = scipy.io.mmio.mmread(\"../../../well_done/items-metas_global.mtx\").toarray()\n \n # getting meta matrices for corresponding using metas\n meta_ctr = 0\n meta_matrices = []\n for meta in METAS_TO_USE:\n if svd_use_flag:\n meta_matrice_file_name = \"users-\" + METAS_TO_USE[meta] + \".svd.mtx\"\n else:\n meta_matrice_file_name = \"users-\" + METAS_TO_USE[meta] + \".mtx\"\n exec(\"meta_matrices.append(scipy.io.mmio.mmread(\\\"\" + meta_matrice_file_name + \"\\\").toarray())\")\n\n #user_counter = 0\n #for user in test_users:\n for cur_cluster in clusters_list:\n \n #print \"cur_cluster[0] = \", cur_cluster[0]\n user = int (cur_cluster[0].split(\"\\t\")[1])\n #print \"user #\", user\n \n #user_metas = {} - changed to list because of problem with dimension\n user_metas = []\n \n values = zeros((len(METAS_TO_USE), len(test_items)), dtype = float)\n meta_ctr = 0\n for meta in METAS_TO_USE:\n \n #print \" meta_matrices = \", meta_matrices\n #print \" meta_matrices[meta_ctr] = \", meta_matrices[meta_ctr]\n user_vector = meta_matrices[meta_ctr][user]\n #print \" user_vector = \", user_vector\n #print \" len(user_metas) = \", len(user_metas)\n #print \" meta_ctr = \", meta_ctr\n #print \"meta = \", meta\n #misc_functions.step()\n \n # normalizing counts of visited metas to use them as weights later\n if max(user_vector) != 0:\n user_metas.append(1.0 * user_vector / max(user_vector))\n else:\n user_metas.append(zeros((len(user_vector), ), dtype = float))\n #print \" user_metas[meta_ctr] = \", user_metas[meta_ctr]\n #print \" user_metas[meta_ctr].shape = \", user_metas[meta_ctr].shape\n \n #for item in test_items:\n for cluster in cur_cluster[1 : ]:\n start_cluster_item = int(cluster.split(\"\\t\")[0])\n stop_cluster_item = int(cluster.split(\"\\t\")[2])\n \n cluster_items = range(start_cluster_item, stop_cluster_item + 1)\n \n for item in cluster_items:\n meta_value = item_X_meta_matrix[item, meta]\n \n # PRICE\n if meta == 8:\n meta_value = priceToPriceCat(meta_value)\n \n # CITY HEURISTIC\n if meta == 11:\n if user_metas[meta_ctr][meta_value - 1] < CITY_TRESHOLD:\n values[:, item - coords[1]] *= CITY_COEF\n \"\"\"\n # DAYTIME\n if meta == 17:\n meta_value = dayTime(meta_value)\n \"\"\"\n \n #print \" meta_value = \", meta_value\n #print \" item = \", item\n #step()\n values[meta_ctr][item - coords[1]] = (user_metas[meta_ctr])[meta_value - 1]\n \n \"\"\"HEURISTICS \"\"\"\n \n \n \n \n \n \"\"\"\\\\ HEURISTICS \"\"\"\n\n meta_ctr += 1\n #print \"values[:, 0:10] = \", values[:, 0:10]\n prediction_vector = numpy.sum(META_WEIGHTS * values, axis = 0)\n #print \"prediction_vector[0:10] = \", prediction_vector[0:10]\n #print \"sum(prediction_vector) = \", sum(prediction_vector)\n prediction_matrix[user - coords[0]] = prediction_vector\n \n #step()\n \n# ===== END OF MAIN CYCLE ===== \n\n result_matrix = scipy.sparse.csr_matrix(prediction_matrix)\n scipy.io.mmio.mmwrite(prediction_file_name, result_matrix, field = 'real', precision = 5)","def prediction(self, x):\n t = self.model.predict(x.reshape(1, -1))\n return t","def proba_redefined_predict(model,X,weigh,classes=string.ascii_lowercase):\n\n y_proba=model.predict_proba(X)\n tuned=renorm(y_proba,weigh)\n y_max_arg=tuned.argmax(axis=1)\n predict=to_class(y_max_arg,classes)\n \n return predict","def predict(probs):\n return np.argmax(probs, axis=0)","def svd_flip(u, v, u_based_decision=True):\n if u_based_decision:\n # columns of u, rows of v\n max_abs_cols = np.argmax(np.abs(u), axis=0)\n signs = np.sign(u[max_abs_cols, range(u.shape[1])])\n u *= signs\n v *= signs[:, np.newaxis]\n else:\n # rows of v, columns of u\n max_abs_rows = np.argmax(np.abs(v), axis=1)\n signs = np.sign(v[range(v.shape[0]), max_abs_rows])\n u *= signs\n v *= signs[:, np.newaxis]\n return u, v","def Controlled(U):\n shp = U.shape\n new_ten = scipy.linalg.block_diag(np.eye(*shp), U)\n return new_ten.reshape(2, shp[0], 2, shp[1])","def make_k_matrix(self):\r\n K = self.uv_vol + self.Epsilon * self.guv_vol + \\\r\n (self.Epsilon / self.Beta) * self.uv_bound\r\n return K","def predict(self): \n return self.model.predict(self.test_x)","def predict(self, X_test):\n if self.basis_func is not None:\n X_transformed = self.basis_func(X_test)\n else:\n X_transformed = X_test\n\n # Marginalise predictions over hyperparameters\n mu = np.zeros([len(self.hypers), X_transformed.shape[0]])\n var = np.zeros([len(self.hypers), X_transformed.shape[0]])\n\n for i, h in enumerate(self.hypers):\n mu[i] = np.dot(self.models[i][0].T, X_transformed.T)\n var[i] = 1. / h[1] + np.diag(np.dot(np.dot(X_transformed, self.models[i][1]), X_transformed.T))\n\n m = mu.mean(axis=0)\n v = var.mean(axis=0)\n # Clip negative variances and set them to the smallest\n # positive float value\n if v.shape[0] == 1:\n v = np.clip(v, np.finfo(v.dtype).eps, np.inf)\n else:\n v = np.clip(v, np.finfo(v.dtype).eps, np.inf)\n v[np.where((v < np.finfo(v.dtype).eps) & (v > -np.finfo(v.dtype).eps))] = 0\n\n return m, v","def get_predictive(self, x, k):\n phi_x = self.base(x)\n phi_z = self.base(self.prev_tasks_tensors[k])\n k_xx = phi_x @ phi_x.T\n k_xz = phi_x @ phi_z.T\n k_zz = phi_z @ phi_z.T\n k_zz_ = torch.inverse(k_zz)\n mu_u = self.prev_tasks_distr[k].mean\n cov_u = self.prev_tasks_distr[k].covariance_matrix\n\n mu = phi_x @ phi_z.T @ k_zz_ @ mu_u\n sigma = k_xx + k_xz @ k_zz_ @ (cov_u - k_zz) @ k_zz_ @ k_xz.T\n sigma *= torch.eye(sigma.shape[0]).to(self.device) #we are interested only \n #in diagonal part for inference\n return MultivariateNormal(loc=mu, covariance_matrix=sigma)","def get_uv(u, v):\n uv = np.zeros((2, 2))\n uv[0][0] = u[0]\n uv[1][0] = u[1]\n uv[0][1] = v[0]\n uv[1][1] = v[1]\n return uv","def predict_proba(self):\n ...","def cross_entropy(U, V):\n return -np.sum(U * np.log(V))","def full_matrix(self):\n # print(self.b,np.shape(self.b))\n # print(self.b_u[:, np.newaxis])\n # print(self.b_i[np.newaxis:, ],\"TTTT\")\n # print(self.P.dot(self.Q.T))\n if (self.type=='bias'):\n return self.b + self.b_u[:, np.newaxis] + self.b_i[np.newaxis:, ] + self.P.dot(self.Q.T)\n elif (self.type=='nonbias'):\n return self.P.dot(self.Q.T)","def make_predictions(self):\n \n self.Y = self.X.dot(self.w)","def prediction(self, x):\n if len(x.shape)==1:\n x = np.reshape(x, (1, x.shape[0]))\n\n all_predict = np.zeros((x.shape[0], self.number_model))\n for i in range(self.number_model):\n curr_predict = self.all_model[i].predict(x)\n all_predict[:,i] = curr_predict\n all_predict = all_predict.astype(np.int)\n final_predict = np.argmax(np.apply_along_axis(np.bincount, axis=1, arr=all_predict, minlength=8),axis=1)\n return final_predict","def _raw_predict(self, Xnew, full_cov=False, kern=None):\n mu, var = self.posterior._raw_predict(kern=self.kern if kern is None else kern, Xnew=Xnew,\n pred_var=self._predictive_variable, full_cov=full_cov)\n if self.mean_function is not None:\n mu += self.mean_function.f(Xnew)\n return mu, var","def predict(self, X_test):\n return np.ones(X_test.shape[0], dtype=np.int32) * -1","def predict(probs):\n # Your code here.\n return np.argmax(probs, axis=1)","def predict(self, user, item):\n return self.user_vectors[user, :].dot(self.item_vectors[item, :].T)","def generate_prediction_matrix(list_of_models, list_of_tfidf, X_test):\n n = len(X_test)\n m = len(list_of_models)\n \n prediction_matrix = np.ones((n,m))\n \n for i, model in enumerate(list_of_models):\n print(f\"Generating predictions for model: {i+1}\")\n model = list_of_models[i]\n tfidf = list_of_tfidf[i]\n try:\n X_test_tfidf = tfidf.transform(X_test)\n predictions = model.predict_proba(X_test_tfidf)[:,1]\n except Exception as e:\n print(str(e))\n print(predictions)\n prediction_matrix[:,i] *= predictions\n \n return prediction_matrix","def _raw_predict(self, _Xnew, which_parts='all', full_cov=False, stop=False):\r\n Kx = self.kern.K(_Xnew, self.X, which_parts=which_parts).T\r\n # KiKx = np.dot(self.Ki, Kx)\r\n KiKx, _ = dpotrs(self.L, np.asfortranarray(Kx), lower=1)\r\n mu = np.dot(KiKx.T, self.likelihood.Y)\r\n if full_cov:\r\n Kxx = self.kern.K(_Xnew, which_parts=which_parts)\r\n var = Kxx - np.dot(KiKx.T, Kx)\r\n else:\r\n Kxx = self.kern.Kdiag(_Xnew, which_parts=which_parts)\r\n var = Kxx - np.sum(np.multiply(KiKx, Kx), 0)\r\n var = var[:, None]\r\n if stop:\r\n debug_this # @UndefinedVariable\r\n return mu, var","def get_vis_residuals(\n model: MPoLModel,\n u_true: NDArray[floating[Any]],\n v_true: NDArray[floating[Any]],\n V_true: NDArray[complexfloating[Any, Any]],\n channel: int = 0,\n) -> NDArray[complexfloating[Any, Any]]:\n nufft = NuFFT(coords=model.coords, nchan=model.nchan, uu=u_true, vv=v_true)\n\n vis_model = nufft(model.icube())\n # convert to numpy, select channel\n vis_model = vis_model.detach().numpy()[channel]\n\n vis_resid: NDArray[complexfloating[Any, Any]]\n vis_resid = V_true - vis_model\n\n return vis_resid","def predict(self, eval_features):\n\t\tinput_ids = torch.tensor(eval_features.input_ids, dtype=torch.long).to(self.device).unsqueeze(0)\n\t\tinput_mask = torch.tensor(eval_features.input_mask, dtype=torch.long).to(self.device).unsqueeze(0)\n\t\tsegment_ids = torch.tensor(eval_features.segment_ids, dtype=torch.long).to(self.device).unsqueeze(0)\n\t\t\n\t\twith torch.no_grad():\n\t\t\tlogits = self.model(input_ids, segment_ids, input_mask)\n\t\t\tlogits = logits.to(\"cpu\")\n\t\t\tsoftmax_logits = F.softmax(logits[0], dim=0).numpy()\n\t\t\tprint(\"softmax score : \", softmax_logits)\n# final_logits = list(zip(list(map(lambda x : self.reverse_label_map[np.ravel(np.where(softmax_logits==x))[0]], softmax_logits )), softmax_logits))\n\t\tpred = np.argmax(softmax_logits)\n\t\tprob = np.max(softmax_logits)\n\t\t\n\t\treturn pred , prob","def InverseMatrix(matrix,vector):\r\n # Unveri reversible matrix\r\n if Determinant(matrix, 1) == 0:\r\n print(\"Error,Singular Matrix\\n\")\r\n return\r\n # result matrix initialized as singularity matrix\r\n result = MakeIMatrix(len(matrix), len(matrix))\r\n # loop for each row\r\n for i in range(len(matrix[0])):\r\n # turn the pivot into 1 (make elementary matrix and multiply with the result matrix )\r\n # pivoting process\r\n matrix, vector = RowXchange(matrix, vector)\r\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\r\n elementary[i][i] = 1/matrix[i][i]\r\n result = MultiplyMatrix(elementary, result)\r\n matrix = MultiplyMatrix(elementary, matrix)\r\n # make elementary loop to iterate for each row and subtracrt the number below (specific) pivot to zero (make\r\n # elementary matrix and multiply with the result matrix )\r\n for j in range(i+1, len(matrix)):\r\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\r\n elementary[j][i] = -(matrix[j][i])\r\n matrix = MultiplyMatrix(elementary, matrix)\r\n result = MultiplyMatrix(elementary, result)\r\n\r\n\r\n # after finishing with the lower part of the matrix subtract the numbers above the pivot with elementary for loop\r\n # (make elementary matrix and multiply with the result matrix )\r\n for i in range(len(matrix[0])-1, 0, -1):\r\n for j in range(i-1, -1, -1):\r\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\r\n elementary[j][i] = -(matrix[j][i])\r\n matrix = MultiplyMatrix(elementary, matrix)\r\n result = MultiplyMatrix(elementary, result)\r\n\r\n return result","def predict(self):\n path = self._artifact_repo.artifact_path(self._ARTIFACT_MODEL)\n model = tf.keras.models.load_model(path)\n\n _, _, x_test, y_test = self._load_data()\n x_test = tf.keras.utils.normalize(x_test, axis=1)\n\n preds = model.predict(x_test)\n self._show_cf_matrix(np.array([np.argmax(probas) for probas in preds]), y_test)","def setup_t_matrix(dq_W_E_vec, dq_B_H_vec):\n n_quaternions = len(dq_W_E_vec)\n t_matrix = np.zeros([6 * n_quaternions, 8])\n for i in range(n_quaternions):\n t_matrix[i * 6:i * 6 + 6, :] = setup_s_matrix(dq_W_E_vec[i], dq_B_H_vec[i])\n\n rank_t_matrix = np.linalg.matrix_rank(t_matrix, tol=5e-2)\n U, s, V = np.linalg.svd(t_matrix)\n # print(\"t_matrix: \\n{}\".format(t_matrix))\n # print(\"Rank(t_matrix): {}\".format(rank_t_matrix))\n # assert rank_t_matrix == 6, (\"T should have rank 6 otherwise we can not find \"\n # \"a rigid transform.\", rank_t_matrix, s)\n return t_matrix.copy()","def _set_u_matirx(self):\n c_matrix = self.get_c_matrix()\n u_matrix, d_matrix, _ = np.linalg.svd(c_matrix)\n self.u_matrix = np.matrix(u_matrix)","def train_model(train_table: pd.DataFrame, viewed_table: pd.DataFrame) -> List:\n\n \"\"\"\"\"\"\n # construct numpy array\n #nan_data = train_table.replace(0.0, np.NaN).to_numpy()\n #user_ratings_mean = np.nanmean(nan_data, axis=1)\n unviewed_table = viewed_table.apply(lambda x: 1 - x)\n # unviewed = unviewed_table.to_numpy()\n\n # construct numpy array\n data = train_table.to_numpy()\n user_ratings_mean = np.mean(data, axis=1)\n # factors in individual interpretation of the scale\n data_demeaned = data - user_ratings_mean.reshape(-1, 1)\n\n # use scipy sparse's svd to avoid 'killed: 9' memory issues\n U, sigma, Vt = svds(data_demeaned, k=25)\n\n sigma = np.diag(sigma)\n\n all_predictions = np.dot(np.dot(U, sigma), Vt) + user_ratings_mean.reshape(-1, 1)\n all_predictions_table = pd.DataFrame(all_predictions).set_index(viewed_table.index)\n all_predictions_table.set_axis(viewed_table.columns, axis='columns', inplace=True)\n\n\n # given already viewed movies a rating of 0. Note these will still be taken ahead of adverse movies\n predictions_table = pd.DataFrame(np.multiply(all_predictions_table,\n unviewed_table.to_numpy()).set_index(viewed_table.index))\n predictions_table.set_axis(viewed_table.columns, axis='columns', inplace=True)\n\n return [all_predictions_table, predictions_table]","def _minimal_predict(Classifier, vector, threshold):\n return Classifier.predict(array([vector.tolist()]), threshold)","def full(self):\n\n # Compute tensor unfolding along first mode\n unf = self.factors[0] @ khatri_rao(self.factors[1:]).T\n\n # Inverse unfolding along first mode\n return np.reshape(unf, self.shape)","def predict(self, x):\n \n\n return predictions"],"string":"[\n \"def compute_low_rank_matrix( self, u, s, v, rank ):\\n u_approx = u[ :, :rank ]\\n s_approx = s[ :rank ]\\n sum_taken_percent = np.sum( s_approx ) / float( np.sum( s ) )\\n s_approx = np.diag( np.array( s_approx ) )\\n v_approx = v[ :rank, : ]\\n return [ u_approx.dot( s_approx ).dot( v_approx ), sum_taken_percent ]\",\n \"def prediction(self, v, imu_meas):\\n # YOUR CODE HERE\\n pass\",\n \"def predict(self, u=0):\\n self.x = np.dot(self.transition_matrix, self.x) + np.dot(self.control_matrix, u)\\n\\n self.prediction_covariance = np.dot(\\n np.dot(self.transition_matrix, self.prediction_covariance), self.transition_matrix.T\\n ) + self.process_covariance\\n\\n return self.x\",\n \"def predict(self, X_test, V = None):\\n\\t\\tif X_test.ndim == 1:\\n\\t\\t\\tX_test = X_test[:,np.newaxis]\\n\\t\\tif X_test.shape[1] == self.D:\\n\\t\\t\\tX_test = np.concatenate((np.ones((X_test.shape[0],1)), X_test), axis = 1) #adding dummy variable for the bias\\n\\t\\tif V is None:\\n\\t\\t\\tV = self.V\\n\\t\\tres = np.matmul(X_test,V) #(N,K)\\n\\t\\tres = np.exp(res) + 1e-5 #(N,K)\\n\\t\\tres = np.divide(res.T, np.sum(res, axis = 1)).T #(N,K) normalizing\\n\\n\\t\\treturn res\",\n \"def predict(self, u):\\n\\n dtheta_l = self.current_state_estimate[0,0]\\n dtheta_r = self.current_state_estimate[1,0]\\n v = self.current_state_estimate[2,0]\\n w = self.current_state_estimate[3,0]\\n x = self.current_state_estimate[4,0]\\n y = self.current_state_estimate[5,0]\\n theta = self.current_state_estimate[6,0]\\n vl = u[0,0]\\n vr = u[1,0]\\n \\n # Vary noise with input voltage\\n if abs(self.current_state_estimate[0,0]) < .03:\\n self.Q[0,0] = .0000001\\n dtheta_l = 0\\n\\n else:\\n self.Q[0,0] = abs(vl)*.03/3000+.03\\n\\n if abs(self.current_state_estimate[1,0]) < .03:\\n self.Q[1,1] = .0000001\\n dtheta_r = 0\\n else:\\n self.Q[1,1] = abs(vr)*.03/3000+.03\\n\\n ## TRANSITION ESTIMATE\\n self.current_state_estimate[0] += self.dt*(self.k2_l*dtheta_l + self.k1_l*vl)\\n self.current_state_estimate[1] += self.dt*(self.k2_r*dtheta_r + self.k1_r*vr)\\n self.current_state_estimate[2] = self.r/2 * (self.current_state_estimate[0] + self.current_state_estimate[1])\\n self.current_state_estimate[3] = self.r/self.l * (self.current_state_estimate[1] - self.current_state_estimate[0])\\n self.current_state_estimate[4] += (self.dt)*self.current_state_estimate[2]*math.cos(theta)\\n self.current_state_estimate[5] += (self.dt)*self.current_state_estimate[2]*math.sin(theta)\\n self.current_state_estimate[6] += (self.dt)*self.current_state_estimate[3]\\n \\n ## TRANISTION PROBABILITY\\n # only propogate the things that can move\\n self.A[0:7, 0:7] = np.array([[1+self.dt*self.k2_l, 0, 0, 0, 0, 0, 0],\\\\\\n [0, 1+self.dt*self.k2_r, 0, 0, 0, 0, 0],\\\\\\n [self.r/2, self.r/2, 0, 0, 0, 0, 0],\\\\\\n [-self.r/self.l, self.r/self.l, 0, 0, 0, 0, 0],\\\\\\n [0, 0, math.cos(theta)*self.dt , 0, 1, 0, -v*math.sin(theta)*self.dt],\\\\\\n [0, 0, math.sin(theta)*self.dt , 0, 0, 1, v*math.cos(theta)*self.dt],\\\\\\n [0, 0, 0, self.dt, 0, 0, 1]])\\n \\n self.current_prob_estimate = np.dot(np.dot(self.A, self.current_prob_estimate), np.transpose(self.A)) + self.Q\",\n \"def predict(self, u):\\n\\n A = self._mat_desc[\\\"A\\\"]\\n B = self._mat_desc[\\\"B\\\"]\\n\\n # update the prediction of the state vector\\n self._state_vec = self._motion_model(self._state_vec_prev, A, B, u)\\n\\n P = self._mat_desc[\\\"P\\\"]\\n Q = self._mat_desc[\\\"Q\\\"]\\n L = self._mat_desc[\\\"L\\\"]\\n L_T = L.T\\n F = self._mat_desc[\\\"F\\\"]\\n F_T = F.T\\n P = F * P * F_T + L * Q * L_T\\n self._mat_desc[\\\"P\\\"] = P\",\n \"def _estimate_ratings(self, U, V):\\n Rhat = np.matmul(U, V.transpose()) # estimate R with UV^T\\n Rhat = np.where(self.R_missing, 0, Rhat) # fill in missing values of R with 0s\\n return Rhat\",\n \"def predict(self, u=0):\\n\\n self.predict_x(u)\\n \\n W = np.concatenate((dot(self.F, self.U), self.Uq), axis=1)\\n D = np.concatenate((self.D, self.Dq))\\n self.U, self.D = mwgs(W, D)\\n\\n # save prior\\n self.x_prior = np.copy(self.x)\\n self.U_prior = np.copy(self.U)\\n self.D_prior = np.copy(self.D)\",\n \"def matrix_deflation(X_curr, Y_curr, X_orig, Y_orig, u, v):\\n Xp = X_curr\\n Yp = Y_curr\\n #u = u / (np.sqrt(np.sum(u**2)+1e-7))\\n #v = v / (np.sqrt(np.sum(v**2)+1e-7))\\n\\n qx = np.dot(Xp.T,np.dot(X_orig,u))\\n qx = qx / (np.sqrt(np.sum(qx**2)+1e-7))\\n #qx = qx.astype('float16')\\n Xp = Xp - np.dot(Xp,qx).dot(qx.T)\\n X = Xp.reshape(1,Xp.shape[0],Xp.shape[1])\\n\\n qy = np.dot(Yp.T,np.dot(Y_orig,v))\\n qy = qy / (np.sqrt(np.sum(qy**2)+1e-7))\\n #qy = qy.astype('float16')\\n Yp = Yp - np.dot(Yp,qy).dot(qy.T)\\n Y = Yp.reshape(1,Yp.shape[0],Yp.shape[1])\\n\\n return X, Y\",\n \"def get_prediction(self, u=0):\\n raise \\\"Not implemented yet\\\"\\n\\n x = dot(self._F, self._x) + dot(self._B, u)\\n P = dot3(self._F, self._P, self._F.T) + self.Q\\n return (x, P)\",\n \"def matrix_deflation(X_curr, Y_curr, X_orig, Y_orig, u, v):\\n Xp = X_curr\\n Yp = Y_curr\\n\\n qx = np.dot(Xp.T,np.dot(X_orig,u))\\n qx = qx / (np.sqrt(np.sum(qx**2)+1e-7))\\n Xp = Xp - np.dot(Xp,qx).dot(qx.T)\\n\\n qy = np.dot(Yp.T,np.dot(Y_orig,v))\\n qy = qy / (np.sqrt(np.sum(qy**2)+1e-7))\\n Yp = Yp - np.dot(Yp,qy).dot(qy.T)\\n\\n Xp = (Xp - np.mean(Xp)) / np.std(Xp)\\n Yp = (Yp - np.mean(Yp)) / np.std(Yp)\\n\\n return Xp, Yp\",\n \"def predict(self, user: torch.tensor, k: int):\\n pass\",\n \"def _predicted(self):\\n return np.matmul(self.x, self.solution)\",\n \"def predict_x(self, u=0):\\n self.x = dot(self.F, self.x) + dot(self.B, u)\",\n \"def predict(self):\\n add = np.ones(len(self.X_test))\\n X_add = np.c_[add, self.X_test]\\n pred = np.dot(X_add, self.w_result.T)\\n\\n pred[pred > 0] = 1\\n pred[pred < 0] = 0\\n return pred\",\n \"def get_u(m):\\n U = m.copy()\\n for i in range(1, U.shape[0]):\\n U[i, :i] = 0\\n return U\",\n \"def predict(self, x_test_unvec, verbose=True):\\n y_test_probas = self.predict_proba(x_test_unvec, verbose=verbose)\\n return np.argmax(y_test_probas, axis=1)\",\n \"def predict(self, x: np.ndarray, u: np.ndarray, t: int = None, noise: np.ndarray = None):\",\n \"def get_predictions(self, x_train_single):\\n\\n x_row = x_train_single.toarray()\\n x_row = cp.array(x_row.reshape(-1, 1))\\n #x_row = cupyx.scipy.sparse.csr_matrix(x_row)\\n\\t\\n #h = cupyx.scipy.sparse.csr_matrix.dot(self.weights, x_row)\\n h = cp.matmul(self.weights,x_row)\\n h = cp.reshape(h,(self.num_models))\\n h = cp.asnumpy(h)\\n \\n cp.cuda.Stream.null.synchronize()\\n return h.tolist()\\n #y = []\\n #for val in h:\\n # y.append(val[0])\\n \\n #return y\",\n \"def pred(self,u,i):\\r\\n if self.user_based:\\r\\n bias=self.mu[u]\\r\\n else:\\r\\n bias=self.mu[i]\\r\\n pred=self.X[i,:].dot(self.W[:,u])+bias\\r\\n if pred<0:\\r\\n return 0\\r\\n if pred>5:\\r\\n return 5\\r\\n return pred\",\n \"def predict(self, test_set_):\\n\\n test_set = np.array(test_set_)\\n n_samples, n_features = test_set.shape\\n\\n assert n_features == self.features\\n\\n single_feature = test_set[:, self.bestn]\\n h = np.ones((n_samples))\\n h[single_feature*self.bestd < self.bestp*self.bestd] = -1\\n return h\",\n \"def get_batch_predictions_MFE(rnn, X, target):\\n\\n out = rnn.forward(X, mean_field_inference=True)\\n arr_preds = nn.functional.softmax(out, dim=-1).data.cpu().numpy()\\n arr_target = target.detach().cpu().numpy()\\n\\n return arr_preds, arr_target\",\n \"def _generate_predictions(self, data):\\n\\n return np.zeros(data.shape[0])\",\n \"def find_optimal_low_rank_matrix( self, orig_similarity_matrix, orig_rank, u, s, v, singular_reduction ):\\n '''rank_list = list()\\n sum_singular_values = list()\\n for rank in range( 0, orig_rank ):\\n compute_result = self.compute_low_rank_matrix( u, s, v, rank + 1 )\\n rank_list.append( ( rank + 1 ) / float( orig_rank ) )\\n sum_singular_values.append( compute_result[ 1 ] )\\n utils._plot_singular_values_rank( rank_list, sum_singular_values )'''\\n return self.compute_low_rank_matrix( u, s, v, int( singular_reduction * orig_rank ) )\",\n \"def predict_all(self):\\n # DONE return prediction for all users\\n return self._user_factors.dot(self._item_factors.T)\",\n \"def offset_to_uvd(self, x):\\n self.batch_size = x.shape[0]\\n self.W = x.shape[2]\\n self.H = x.shape[3] \\n self.D = 5\\n self.grid_size = self.W*self.H*self.D\\n \\n grid_linear = x.reshape(self.batch_size, 64, -1)\\n\\n index = torch.from_numpy(np.asarray(np.unravel_index(np.arange(self.grid_size), \\n (self.W, self.H, self.D)))).type(torch.FloatTensor)\\n u = index[0, :].unsqueeze(0).expand(21, -1)\\n v = index[1, :].unsqueeze(0).expand(21, -1)\\n z = index[2, :].unsqueeze(0).expand(21, -1)\\n\\n if self.device != \\\"cpu\\\":\\n u = u.cuda()\\n v = v.cuda()\\n z = z.cuda()\\n\\n pred_uvd_no_offset = grid_linear[:, :63, :].reshape(self.batch_size, 21, 3, self.grid_size)\\n pred_conf = grid_linear[:, 63, :].reshape(self.batch_size, self.W, self.H, self.D)\\n pred_conf = torch.sigmoid(pred_conf)\\n \\n # middle finger root is hand root\\n pred_uvd_no_offset[:, self.hand_root, :, :] = torch.sigmoid(pred_uvd_no_offset[:, self.hand_root, :, :])\\n \\n pred_uvd = pred_uvd_no_offset.clone().detach()\\n pred_uvd[:, :, 0, :] = (pred_uvd[:, :, 0, :] + u) / self.W\\n pred_uvd[:, :, 1, :] = (pred_uvd[:, :, 1, :] + v) / self.H\\n pred_uvd[:, :, 2, :] = (pred_uvd[:, :, 2, :] + z) / self.D\\n \\n pred_uvd_no_offset = pred_uvd_no_offset.reshape(self.batch_size, 21, 3, self.W, self.H, self.D)\\n \\n return pred_uvd_no_offset, pred_uvd, pred_conf\",\n \"def get_predictions(self, model, inputs=None):\\n if inputs is None:\\n inputs = self.inputs\\n\\n refl_id = BaseModel.get_refl_id(inputs)\\n iobs = BaseModel.get_intensities(inputs).flatten()\\n sig_iobs = BaseModel.get_uncertainties(inputs).flatten()\\n asu_id,H = self.asu_collection.to_asu_id_and_miller_index(refl_id)\\n #ipred = model(inputs)\\n ipred,sigipred = model.prediction_mean_stddev(inputs)\\n\\n h,k,l = H.T\\n results = ()\\n for i,asu in enumerate(self.asu_collection):\\n idx = asu_id == i\\n idx = idx.flatten()\\n output = rs.DataSet({\\n 'H' : h[idx],\\n 'K' : k[idx],\\n 'L' : l[idx],\\n 'Iobs' : iobs[idx],\\n 'SigIobs' : sig_iobs[idx],\\n 'Ipred' : ipred[idx],\\n 'SigIpred' : sigipred[idx],\\n }, \\n cell=asu.cell, \\n spacegroup=asu.spacegroup,\\n merged=False,\\n ).infer_mtz_dtypes().set_index(['H', 'K', 'L'])\\n results += (output, )\\n return results\",\n \"def get_batch_predictions(rnn, X, target):\\n\\n out = rnn.forward(X)\\n arr_preds = nn.functional.softmax(out, dim=-1).data.cpu().numpy()\\n arr_target = target.detach().cpu().numpy()\\n\\n return arr_preds, arr_target\",\n \"def make_predictions(model, x_test, y_test):\\r\\n preds = model.predict(x_test)\\r\\n y_hat = np.argmax(preds, axis=-1)\\r\\n print(type(y_test))\\r\\n y_test.columns = [0, 1]\\r\\n y = y_test.idxmax(axis=1)\\r\\n print(y_hat.shape)\\r\\n print(y.shape)\\r\\n return y_hat, y\",\n \"def prediction(self, v, imu_meas):\\n\\n omega = -imu_meas[3]\\n\\n current_time = imu_meas[4]\\n theta = self.x[2]\\n\\n if self.last_time is None:\\n dt = 0\\n else:\\n dt = current_time - self.last_time\\n self.last_time = current_time\\n\\n # jacobian of state transition function\\n dfdx = np.eye(3) + dt * np.array([(0, 0, -v * np.sin(theta)),\\n (0, 0, v * np.cos(theta)),\\n (0, 0, 0)])\\n dfdn = dt * np.array(((math.cos(theta), 1),\\n (math.sin(theta), 1), (1, 1)))\\n xp = self.x + dt * \\\\\\n np.array((v * np.cos(theta), v * np.sin(theta), omega))\\n Pp = np.dot(np.dot(dfdx, self.P_t), dfdx.T) + \\\\\\n np.dot(np.dot(dfdn, self.Q_t), dfdn.T)\\n\\n return xp, Pp\",\n \"def predict_only(self):\",\n \"def nnPredict(w1,w2,data): \\r\\n \\r\\n labels = np.array([])\\r\\n #Your code here\\r\\n #Get bias dimension\\r\\n bias_dimension = data.shape[0]\\r\\n\\r\\n #Fill it all with ones\\r\\n bias = np.ones((bias_dimension,1))\\r\\n\\r\\n #Add bias to weights \\r\\n data_with_bias = np.concatenate((data,bias),1)\\r\\n\\r\\n #Feed Foward Start By Multiplying Training data by weights of w1\\r\\n z2 = np.dot(data_with_bias,np.transpose(w1))\\r\\n\\r\\n #Apply Sigmoid function\\r\\n a2= sigmoid(z2)\\r\\n #Apply Another Bias Dimension to the new matrix\\r\\n\\r\\n #bias_dimension=a2.shape[0]\\r\\n #bias = np.ones((bias_dimension,1))\\r\\n a2_bias= np.concatenate((a2,bias),1)\\r\\n\\r\\n #Multiply new matrix by the weights of w2\\r\\n z3 = np.dot(a2_bias,np.transpose(w2))\\r\\n \\r\\n #Apply Sigmoid Function to the new data\\r\\n y= sigmoid(z3)\\r\\n\\r\\n #find max value and add that digit to the labels vector\\r\\n labels= np.zeros((y.shape[0],1))\\r\\n count=0\\r\\n for x in y:\\r\\n index=0\\r\\n max=0\\r\\n inmax=0\\r\\n for p in x:\\r\\n if p >= max:\\r\\n max=p\\r\\n inmax=index\\r\\n index+=1\\r\\n labels[count][0]=inmax\\r\\n count+=1\\r\\n \\r\\n print('results n ', labels)\\r\\n return labels\",\n \"def predict(self, input_data):\\n assert len(input_data.shape) == 2\\n assert input_data.shape[1] == self.training_data[0].shape[1]\\n\\n l = self.kernel.get_kernel_matrix(self.training_data[0], input_data)\\n y = numpy.dot(l.T, self.alpha)\\n\\n beta = scipy.linalg.solve_triangular(self.u, l, trans='T')\\n c = scipy.linalg.solve_triangular(self.u, beta)\\n v = self.kernel.get_kernel_diagonal(input_data) - numpy.sum(l * c, axis=0)\\n return numpy.asarray(y).flatten(), numpy.asarray(v).reshape((v.size, 1))\",\n \"def predict_for_customers(self,):\\n return self.user_vectors.dot(self.item_vectors.T)\",\n \"def _multiply_matrix(self, v):\\n\\n self.inputs.grad.data.zero_()\\n\\n with torch.no_grad():\\n v_features = self.lpips_model.features(self.inputs.detach() +\\n self.h * v)\\n D_phi_v = (\\n normalize_flatten_features(v_features) -\\n self.input_features\\n ) / self.h\\n\\n torch.sum(self.input_features * D_phi_v).backward(retain_graph=True)\\n\\n return self.inputs.grad.data.clone()\",\n \"def hadamard(u: np.ndarray, v: np.ndarray) -> np.ndarray:\\n\\n return u * v\",\n \"def _raw_predict(self,_Xnew,slices=None, full_cov=False):\\n Kx = self.kern.K(self.X,_Xnew, slices1=self.Xslices,slices2=slices)\\n mu = np.dot(np.dot(Kx.T,self.Ki),self.likelihood.Y)\\n KiKx = np.dot(self.Ki,Kx)\\n if full_cov:\\n Kxx = self.kern.K(_Xnew, slices1=slices,slices2=slices)\\n var = Kxx - np.dot(KiKx.T,Kx)\\n else:\\n Kxx = self.kern.Kdiag(_Xnew, slices=slices)\\n var = Kxx - np.sum(np.multiply(KiKx,Kx),0)\\n var = var[:,None]\\n return mu, var\",\n \"def gen_U(self, n_dims, n, V):\\n cov = np.eye(n_dims)\\n\\n U = []\\n for v in V:\\n μ = np.zeros(n_dims)\\n U_for_class_v = m_normal(μ, cov, n)\\n U_for_class_v -= U_for_class_v.mean(axis=0)\\n U_for_class_v += v # Center at v to control test results.\\n U.append(U_for_class_v)\\n\\n # To control the test result, each set of u's sums to its respective v.\\n for x in range(len(U)):\\n are_same = np.allclose(V[x], U[x].mean(axis=0))\\n assert are_same == True\\n\\n U = np.vstack(U)\\n\\n return U\",\n \"def get_confmatrix(self,y_pred,y_test):\",\n \"def get_preds(training_data: np.mat, mcol_b: np.mat, tau: float) -> np.ndarray:\\r\\n ypred = local_weight_regression(training_data, mcol_b, tau)\\r\\n return ypred\",\n \"def predict_all(self):\\n return self.Bi + tf.matmul(self.Gu, self.Gi, transpose_b=True) \\\\\\n + tf.matmul(self.Tu, tf.matmul(self.F, self.E), transpose_b=True) \\\\\\n + tf.squeeze(tf.matmul(self.F, self.Bp))\",\n \"def oldPredict(self, data):\\n\\n predictions = []\\n\\n if len(self.observations) < self.k_neighbors:\\n print(f\\\"Data length ({len(data)}) was too small.\\\")\\n\\n for row in data:\\n neighbors_info = {}\\n\\n for row_index in range(len(self.observations)):\\n distance = self.calcualteEuclideanDistance(self.observations[row_index], row)\\n if len(neighbors_info) > self.k_neighbors - 1:\\n largest_distance = max(neighbors_info.keys())\\n if distance < largest_distance:\\n neighbors_info[distance] = self.labels[row_index]\\n del neighbors_info[largest_distance]\\n else:\\n neighbors_info[distance] = self.labels[row_index]\\n\\n unique_values = set(neighbors_info.values())\\n if len(unique_values) == 1:\\n value = unique_values.pop()\\n predictions.append(value)\\n else:\\n best_value = 0\\n best_value_weight = 0\\n for label in unique_values:\\n weight = 0\\n for distance in neighbors_info.keys():\\n if label == neighbors_info[distance]:\\n if 'inverse_distance' == self.weight_type:\\n weight += self.calulateWeightedVote(distance)\\n elif 'no_weight' == self.weight_type:\\n weight += 1\\n else:\\n print(\\\"Not a valid_weight_type.\\\")\\n\\n if weight > best_value_weight:\\n best_value_weight = weight\\n best_value = label\\n\\n predictions.append(best_value)\\n # print(f\\\"Neighbors Info: {neighbors_info}\\\")\\n\\n return predictions\",\n \"def predict(self, predPoints=None):\",\n \"def cross_matrix(v):\\n\\treturn np.array([\\n\\t\\t[ 0, -v[2], v[1]],\\n\\t\\t[ v[2], 0, -v[0]],\\n\\t\\t[-v[1], v[0], 0]])\",\n \"def gen_pred(model, indices, inp):\\n preds = model.predict(inp)#, label)\\n print(np.argmax(preds))\\n for k,v in indices.items():\\n print(k)\\n if v == np.argmax(preds):\\n print(k)\\n new_inp = np.roll(inp, -1, 1)\\n new_inp[0][-1] = eye[indices[k]]\\n return new_inp\",\n \"def predict_mat(self):\\n mat = self.covs_mat.dot(self.alpha)\\n return mat.reshape(self.shape)\",\n \"def nnPredict(w1,w2,data):\\n \\n labels = np.array([])\\n \\n # create bias row\\n bias_row =np.ones((np.size(data,0),1))\\n \\n # concatenate bias with data matrix\\n data=np.concatenate((data,bias_row),axis=1)\\n \\n #Calculate input to hidden layer\\n intput_hidden_layer= np.dot(data,w1.transpose()) \\n \\n #Calculate output of hidden layer using sigmoid function\\n output_hidden_layer= sigmoid(intput_hidden_layer)\\n \\n #Calculate input to output nodes\\n input_with_bias = np.concatenate((output_hidden_layer,bias_row),axis=1) \\n input_output_node= np.dot(input_with_bias,w2.transpose()) \\n \\n # Calculate output of output layer\\n output_layer= sigmoid(input_output_node) \\n \\n # get index of maximum from all rows in ouput layer matrix\\n labels = np.argmax(output_layer,axis=1) \\n \\n return labels\",\n \"def s2s_predict(self, gmv_data, model): \\r\\n\\r\\n test_X1 = gmv_data[-self.pre_time-self.input_len:\\r\\n -self.pre_time].reshape(1, -1, self.input_dim)\\r\\n pre1 = model.predict(test_X1) \\r\\n\\r\\n test_X2 = np.concatenate((test_X1[0][14:], pre1[0])).\\\\\\r\\n reshape(1, -1, self.input_dim)\\r\\n pre2 = model.predict(test_X2)\\r\\n\\r\\n test_X3 = np.concatenate((test_X2[0][7:], pre1[0][0:7])).\\\\\\r\\n reshape(1, -1, self.input_dim)\\r\\n pre3 = model.predict(test_X3)\\r\\n\\r\\n pre = np.concatenate((pre1[0], pre2[0], pre3[0][7:]))\\r\\n\\r\\n return pre\",\n \"def nnPredict(w1,w2,data): \\r\\n #Similar to the forward pass stage in nnObj\\r\\n trans_w1=w1.T\\r\\n trans_w2=w2.T\\r\\n\\r\\n x=np.column_stack((data,np.ones(len(data))))\\r\\n #equation1\\r\\n eq1=np.dot(x,trans_w1)\\r\\n \\r\\n #equation2\\r\\n z=sigmoid(eq1)\\r\\n\\r\\n z=np.column_stack((z,np.ones(len(z))))\\r\\n\\r\\n eq3=np.dot(z,trans_w2)\\r\\n\\r\\n o=sigmoid(eq3)\\r\\n\\r\\n labels = np.argmax(o, 1) #Return the index of the number which has maximum value\\r\\n return labels\",\n \"def reflection_matrix(v):\\n n = len(v)\\n v = np.array(v)[np.newaxis]\\n return np.eye(n) - 2 * np.dot(v.T, v)\",\n \"def predict(self, test):\\n\\n test_scores = self.score(test)\\n user_ids = test[self.col_user].map(self.user2index).values\\n\\n # create mapping of new items to zeros\\n item_ids = test[self.col_item].map(self.item2index).values\\n nans = np.isnan(item_ids)\\n if any(nans):\\n logger.warning(\\n \\\"Items found in test not seen during training, new items will have score of 0\\\"\\n )\\n test_scores = np.append(test_scores, np.zeros((self.n_users, 1)), axis=1)\\n item_ids[nans] = self.n_items\\n item_ids = item_ids.astype(\\\"int64\\\")\\n\\n df = pd.DataFrame(\\n {\\n self.col_user: test[self.col_user].values,\\n self.col_item: test[self.col_item].values,\\n self.col_prediction: test_scores[user_ids, item_ids],\\n }\\n )\\n\\n return df\",\n \"def toMatrix(self,v):\\n return Matrix([[v.x],[v.y],[v.z]])\",\n \"def predict_all(self):\\n return numpy.dot(self.P, self.Q.T)\",\n \"def predict(self, X_test):\\n \\n X_test = np.insert(X_test, 0, 1, axis=1)\\n Y_out = self.W.T.dot(X_test.T)\\n pred = np.argmax(Y_out, axis=0)\\n \\n \\n return pred\",\n \"def predict(self, X):\\n pred = np.zeros(X.shape[0])\\n ### YOUR CODE HERE 1-3 lines\\n probabilities = np.array([model.probability(X) for model in self.models])\\n pred=np.argmax(probabilities, axis=0)\\n ### END CODE\\n assert pred.shape == (X.shape[0],)\\n return pred\",\n \"def predict(self):\\n for src_p, pair in enumerate(self.pairs):\\n dst_p = pair[1].argmax()\\n dst_ind = pair[0][dst_p]\\n\\n self.vector_field.append(np.hstack([self.frame_0[src_p], self.frame_1[dst_ind]]))\\n\\n self.vector_field = np.vstack(self.vector_field)\\n\\n return self.vector_field\",\n \"def predict(self, params, test):\\n vect_logit = np.vectorize(logit)\\n vect_comp = np.vectorize(complement)\\n n_test = np.shape(test)[0]\\n prior = self.model_prior\\n conditional = self.model_conditional\\n K = len(prior)\\n p = np.shape(conditional)[1]\\n test_p = np.shape(test)[1]\\n if p != test_p:\\n print \\\"Error: Number of training and testing features differ\\\"\\n return\\n preds = []\\n weight = vect_logit(conditional)\\n # Stores weight matrix\\n condition_comp = vect_comp(conditional)\\n intercept = np.log(\\n prior) + np.sum(np.apply_along_axis(np.log, 1, condition_comp), axis=1)\\n # Stores intercept vector\\n weight = weight.transpose()\\n classifier = test.dot(weight) + intercept\\n preds = np.argmax(classifier, axis=1) + 1\\n # Add 1 because the classes have a 1-based index\\n preds = preds.reshape(n_test, 1)\\n return preds\",\n \"def predict(self, X):\",\n \"def predict(self, X):\",\n \"def predict(self):\\n train_array = np.array(self.labels != 0, dtype=float)\\n if not self.ising:\\n labels_logit = self.ising_weights['vertices']\\n else:\\n neigh_num = self.adj.dot(train_array)\\n neigh_num = np.where(neigh_num == 0, 1, neigh_num)\\n neigh_weights = self.ising_weights['edges'] * self.labels\\n labels_logit = (np.multiply(neigh_weights, neigh_num**(-1))\\n + self.ising_weights['vertices'])\\n self.prediction = np.where(labels_logit > 0, 1, -1)\\n return self\",\n \"def predict(self, X:np.ndarray) -> np.ndarray:\\n n_obs = X.shape[0]\\n n_classes = self.mu.shape[0]\\n n_features = self.mu.shape[1]\\n\\n # initalize the output vector\\n y = np.empty(n_obs,dtype=int)\\n #d=np.linalg.det()\\n c_=np.zeros(n_classes)\\n a=np.zeros((n_features,n_features))\\n for j,x in enumerate(X):\\n for i in range(n_classes):\\n diag=self.sigma[i].diagonal()\\n np.fill_diagonal(a,diag)\\n #print(a,i)\\n #sig_inv=np.linalg.inv(self.sigma[i]) #l'nverse de la matrice sigma\\n sig_inv=np.linalg.inv(a)\\n x_u=x - self.mu[i] \\n #c_[i]=-((n_features/2.)*log(2*pi) + 0.5*log(np.linalg.det(self.sigma[i]))) - 0.5*((x_u.T).dot(sig_inv)).dot(x_u)\\n c_[i]=-0.5*log(np.linalg.det(self.sigma[i])) - 0.5*((x_u.T).dot(sig_inv)).dot(x_u) + log(self.priors[i])\\n y[j]=np.argmax(c_)\\n \\n #print(y)\\n return y\",\n \"def predict(self, X):\\n pred = None\\n ### YOUR CODE HERE\\n dat = X[:, self.idx]\\n n = X.shape[0] \\n decision = (dat < self.val).astype(int)\\n # values = np.c_[np.ones(n)*self.left, np.ones(n)*self.right]\\n pred = decision * self.left + (1-decision) * self.right\\n ### END CODE\\n return pred\",\n \"def get_svd(self,new_df):\\n\\n\\t\\tnew_matrix = new_df.as_matrix()\\n\\t\\t\\n\\t\\t#get the mean score of users\\n\\t\\tmean_score = np.mean(new_matrix,axis = 1)\\n\\t\\tnew_matrix_dm = new_matrix - mean_score.reshape(-1,1)\\n\\t\\t#decompose interaction matrix into U, Vt, Sigma\\n\\t\\tU, sigma, Vt = svds(new_matrix_dm, k = 5)\\n\\t\\tsigma = np.diag(sigma)\\n\\t\\tall_user_predicted_ratings = np.dot(np.dot(U, sigma), Vt) + mean_score.reshape(-1, 1)\\n\\t\\tpreds_df = pd.DataFrame(all_user_predicted_ratings, columns = new_df.columns)\\n\\t\\tpreds_df = preds_df.round(1)\\n\\n\\t\\treturn preds_df\",\n \"def proba_redefined_predict(model,X,weigh):\\n\\n y_proba=model.predict_proba(X)\\n tuned=renorm(y_proba,weigh)\\n y_max_arg=tuned.argmax(axis=1)\\n predict=to_class(y_max_arg,model.classes_)\\n\\n return predict\",\n \"def getPredictions(self):\\n\\t\\tself.bestLabel = self.testingProbs.apply(lambda x: x.argmax(),1)\",\n \"def prediction(self, x):\\n pred = np.dot(self.fonction_base_polynomiale(x),self.w)\\n if pred.shape == (1,):\\n return pred[0]\\n else:\\n return pred\",\n \"def predict(self, data):\\r\\n x = []\\r\\n x.append(data.sampled_matrix())\\r\\n x = np.array(x)\\r\\n x = np.reshape(x, (x.shape[0], x.shape[1], 1))\\r\\n\\r\\n result = self.model.predict(x)\\r\\n return result\",\n \"def predict(self, xs, **kwargs):\",\n \"def prediction(prediction_file_name, clusters_list, svd_use_flag):\\n \\n coords = misc_functions.getWindowCoords()\\n \\n test_users = range(coords[0], coords[2] + 1) \\n test_items = range(coords[1], coords[3] + 1)\\n \\n #print \\\"len(test_users) = \\\", len(test_users)\\n #print \\\"len(test_items) = \\\", len(test_items)\\n #print \\\"test_items = \\\", test_items\\n \\n # this matrix to be written as result finally\\n #misc_functions.step()\\n prediction_matrix = zeros((len(test_users), len(test_items)), dtype = float)\\n \\n training_matrix = scipy.io.mmio.mmread(\\\"history.mtx\\\").tocsr()\\n \\n item_X_meta_matrix = scipy.io.mmio.mmread(\\\"../../../well_done/items-metas_global.mtx\\\").toarray()\\n \\n # getting meta matrices for corresponding using metas\\n meta_ctr = 0\\n meta_matrices = []\\n for meta in METAS_TO_USE:\\n if svd_use_flag:\\n meta_matrice_file_name = \\\"users-\\\" + METAS_TO_USE[meta] + \\\".svd.mtx\\\"\\n else:\\n meta_matrice_file_name = \\\"users-\\\" + METAS_TO_USE[meta] + \\\".mtx\\\"\\n exec(\\\"meta_matrices.append(scipy.io.mmio.mmread(\\\\\\\"\\\" + meta_matrice_file_name + \\\"\\\\\\\").toarray())\\\")\\n\\n #user_counter = 0\\n #for user in test_users:\\n for cur_cluster in clusters_list:\\n \\n #print \\\"cur_cluster[0] = \\\", cur_cluster[0]\\n user = int (cur_cluster[0].split(\\\"\\\\t\\\")[1])\\n #print \\\"user #\\\", user\\n \\n #user_metas = {} - changed to list because of problem with dimension\\n user_metas = []\\n \\n values = zeros((len(METAS_TO_USE), len(test_items)), dtype = float)\\n meta_ctr = 0\\n for meta in METAS_TO_USE:\\n \\n #print \\\" meta_matrices = \\\", meta_matrices\\n #print \\\" meta_matrices[meta_ctr] = \\\", meta_matrices[meta_ctr]\\n user_vector = meta_matrices[meta_ctr][user]\\n #print \\\" user_vector = \\\", user_vector\\n #print \\\" len(user_metas) = \\\", len(user_metas)\\n #print \\\" meta_ctr = \\\", meta_ctr\\n #print \\\"meta = \\\", meta\\n #misc_functions.step()\\n \\n # normalizing counts of visited metas to use them as weights later\\n if max(user_vector) != 0:\\n user_metas.append(1.0 * user_vector / max(user_vector))\\n else:\\n user_metas.append(zeros((len(user_vector), ), dtype = float))\\n #print \\\" user_metas[meta_ctr] = \\\", user_metas[meta_ctr]\\n #print \\\" user_metas[meta_ctr].shape = \\\", user_metas[meta_ctr].shape\\n \\n #for item in test_items:\\n for cluster in cur_cluster[1 : ]:\\n start_cluster_item = int(cluster.split(\\\"\\\\t\\\")[0])\\n stop_cluster_item = int(cluster.split(\\\"\\\\t\\\")[2])\\n \\n cluster_items = range(start_cluster_item, stop_cluster_item + 1)\\n \\n for item in cluster_items:\\n meta_value = item_X_meta_matrix[item, meta]\\n \\n # PRICE\\n if meta == 8:\\n meta_value = priceToPriceCat(meta_value)\\n \\n # CITY HEURISTIC\\n if meta == 11:\\n if user_metas[meta_ctr][meta_value - 1] < CITY_TRESHOLD:\\n values[:, item - coords[1]] *= CITY_COEF\\n \\\"\\\"\\\"\\n # DAYTIME\\n if meta == 17:\\n meta_value = dayTime(meta_value)\\n \\\"\\\"\\\"\\n \\n #print \\\" meta_value = \\\", meta_value\\n #print \\\" item = \\\", item\\n #step()\\n values[meta_ctr][item - coords[1]] = (user_metas[meta_ctr])[meta_value - 1]\\n \\n \\\"\\\"\\\"HEURISTICS \\\"\\\"\\\"\\n \\n \\n \\n \\n \\n \\\"\\\"\\\"\\\\\\\\ HEURISTICS \\\"\\\"\\\"\\n\\n meta_ctr += 1\\n #print \\\"values[:, 0:10] = \\\", values[:, 0:10]\\n prediction_vector = numpy.sum(META_WEIGHTS * values, axis = 0)\\n #print \\\"prediction_vector[0:10] = \\\", prediction_vector[0:10]\\n #print \\\"sum(prediction_vector) = \\\", sum(prediction_vector)\\n prediction_matrix[user - coords[0]] = prediction_vector\\n \\n #step()\\n \\n# ===== END OF MAIN CYCLE ===== \\n\\n result_matrix = scipy.sparse.csr_matrix(prediction_matrix)\\n scipy.io.mmio.mmwrite(prediction_file_name, result_matrix, field = 'real', precision = 5)\",\n \"def prediction(self, x):\\n t = self.model.predict(x.reshape(1, -1))\\n return t\",\n \"def proba_redefined_predict(model,X,weigh,classes=string.ascii_lowercase):\\n\\n y_proba=model.predict_proba(X)\\n tuned=renorm(y_proba,weigh)\\n y_max_arg=tuned.argmax(axis=1)\\n predict=to_class(y_max_arg,classes)\\n \\n return predict\",\n \"def predict(probs):\\n return np.argmax(probs, axis=0)\",\n \"def svd_flip(u, v, u_based_decision=True):\\n if u_based_decision:\\n # columns of u, rows of v\\n max_abs_cols = np.argmax(np.abs(u), axis=0)\\n signs = np.sign(u[max_abs_cols, range(u.shape[1])])\\n u *= signs\\n v *= signs[:, np.newaxis]\\n else:\\n # rows of v, columns of u\\n max_abs_rows = np.argmax(np.abs(v), axis=1)\\n signs = np.sign(v[range(v.shape[0]), max_abs_rows])\\n u *= signs\\n v *= signs[:, np.newaxis]\\n return u, v\",\n \"def Controlled(U):\\n shp = U.shape\\n new_ten = scipy.linalg.block_diag(np.eye(*shp), U)\\n return new_ten.reshape(2, shp[0], 2, shp[1])\",\n \"def make_k_matrix(self):\\r\\n K = self.uv_vol + self.Epsilon * self.guv_vol + \\\\\\r\\n (self.Epsilon / self.Beta) * self.uv_bound\\r\\n return K\",\n \"def predict(self): \\n return self.model.predict(self.test_x)\",\n \"def predict(self, X_test):\\n if self.basis_func is not None:\\n X_transformed = self.basis_func(X_test)\\n else:\\n X_transformed = X_test\\n\\n # Marginalise predictions over hyperparameters\\n mu = np.zeros([len(self.hypers), X_transformed.shape[0]])\\n var = np.zeros([len(self.hypers), X_transformed.shape[0]])\\n\\n for i, h in enumerate(self.hypers):\\n mu[i] = np.dot(self.models[i][0].T, X_transformed.T)\\n var[i] = 1. / h[1] + np.diag(np.dot(np.dot(X_transformed, self.models[i][1]), X_transformed.T))\\n\\n m = mu.mean(axis=0)\\n v = var.mean(axis=0)\\n # Clip negative variances and set them to the smallest\\n # positive float value\\n if v.shape[0] == 1:\\n v = np.clip(v, np.finfo(v.dtype).eps, np.inf)\\n else:\\n v = np.clip(v, np.finfo(v.dtype).eps, np.inf)\\n v[np.where((v < np.finfo(v.dtype).eps) & (v > -np.finfo(v.dtype).eps))] = 0\\n\\n return m, v\",\n \"def get_predictive(self, x, k):\\n phi_x = self.base(x)\\n phi_z = self.base(self.prev_tasks_tensors[k])\\n k_xx = phi_x @ phi_x.T\\n k_xz = phi_x @ phi_z.T\\n k_zz = phi_z @ phi_z.T\\n k_zz_ = torch.inverse(k_zz)\\n mu_u = self.prev_tasks_distr[k].mean\\n cov_u = self.prev_tasks_distr[k].covariance_matrix\\n\\n mu = phi_x @ phi_z.T @ k_zz_ @ mu_u\\n sigma = k_xx + k_xz @ k_zz_ @ (cov_u - k_zz) @ k_zz_ @ k_xz.T\\n sigma *= torch.eye(sigma.shape[0]).to(self.device) #we are interested only \\n #in diagonal part for inference\\n return MultivariateNormal(loc=mu, covariance_matrix=sigma)\",\n \"def get_uv(u, v):\\n uv = np.zeros((2, 2))\\n uv[0][0] = u[0]\\n uv[1][0] = u[1]\\n uv[0][1] = v[0]\\n uv[1][1] = v[1]\\n return uv\",\n \"def predict_proba(self):\\n ...\",\n \"def cross_entropy(U, V):\\n return -np.sum(U * np.log(V))\",\n \"def full_matrix(self):\\n # print(self.b,np.shape(self.b))\\n # print(self.b_u[:, np.newaxis])\\n # print(self.b_i[np.newaxis:, ],\\\"TTTT\\\")\\n # print(self.P.dot(self.Q.T))\\n if (self.type=='bias'):\\n return self.b + self.b_u[:, np.newaxis] + self.b_i[np.newaxis:, ] + self.P.dot(self.Q.T)\\n elif (self.type=='nonbias'):\\n return self.P.dot(self.Q.T)\",\n \"def make_predictions(self):\\n \\n self.Y = self.X.dot(self.w)\",\n \"def prediction(self, x):\\n if len(x.shape)==1:\\n x = np.reshape(x, (1, x.shape[0]))\\n\\n all_predict = np.zeros((x.shape[0], self.number_model))\\n for i in range(self.number_model):\\n curr_predict = self.all_model[i].predict(x)\\n all_predict[:,i] = curr_predict\\n all_predict = all_predict.astype(np.int)\\n final_predict = np.argmax(np.apply_along_axis(np.bincount, axis=1, arr=all_predict, minlength=8),axis=1)\\n return final_predict\",\n \"def _raw_predict(self, Xnew, full_cov=False, kern=None):\\n mu, var = self.posterior._raw_predict(kern=self.kern if kern is None else kern, Xnew=Xnew,\\n pred_var=self._predictive_variable, full_cov=full_cov)\\n if self.mean_function is not None:\\n mu += self.mean_function.f(Xnew)\\n return mu, var\",\n \"def predict(self, X_test):\\n return np.ones(X_test.shape[0], dtype=np.int32) * -1\",\n \"def predict(probs):\\n # Your code here.\\n return np.argmax(probs, axis=1)\",\n \"def predict(self, user, item):\\n return self.user_vectors[user, :].dot(self.item_vectors[item, :].T)\",\n \"def generate_prediction_matrix(list_of_models, list_of_tfidf, X_test):\\n n = len(X_test)\\n m = len(list_of_models)\\n \\n prediction_matrix = np.ones((n,m))\\n \\n for i, model in enumerate(list_of_models):\\n print(f\\\"Generating predictions for model: {i+1}\\\")\\n model = list_of_models[i]\\n tfidf = list_of_tfidf[i]\\n try:\\n X_test_tfidf = tfidf.transform(X_test)\\n predictions = model.predict_proba(X_test_tfidf)[:,1]\\n except Exception as e:\\n print(str(e))\\n print(predictions)\\n prediction_matrix[:,i] *= predictions\\n \\n return prediction_matrix\",\n \"def _raw_predict(self, _Xnew, which_parts='all', full_cov=False, stop=False):\\r\\n Kx = self.kern.K(_Xnew, self.X, which_parts=which_parts).T\\r\\n # KiKx = np.dot(self.Ki, Kx)\\r\\n KiKx, _ = dpotrs(self.L, np.asfortranarray(Kx), lower=1)\\r\\n mu = np.dot(KiKx.T, self.likelihood.Y)\\r\\n if full_cov:\\r\\n Kxx = self.kern.K(_Xnew, which_parts=which_parts)\\r\\n var = Kxx - np.dot(KiKx.T, Kx)\\r\\n else:\\r\\n Kxx = self.kern.Kdiag(_Xnew, which_parts=which_parts)\\r\\n var = Kxx - np.sum(np.multiply(KiKx, Kx), 0)\\r\\n var = var[:, None]\\r\\n if stop:\\r\\n debug_this # @UndefinedVariable\\r\\n return mu, var\",\n \"def get_vis_residuals(\\n model: MPoLModel,\\n u_true: NDArray[floating[Any]],\\n v_true: NDArray[floating[Any]],\\n V_true: NDArray[complexfloating[Any, Any]],\\n channel: int = 0,\\n) -> NDArray[complexfloating[Any, Any]]:\\n nufft = NuFFT(coords=model.coords, nchan=model.nchan, uu=u_true, vv=v_true)\\n\\n vis_model = nufft(model.icube())\\n # convert to numpy, select channel\\n vis_model = vis_model.detach().numpy()[channel]\\n\\n vis_resid: NDArray[complexfloating[Any, Any]]\\n vis_resid = V_true - vis_model\\n\\n return vis_resid\",\n \"def predict(self, eval_features):\\n\\t\\tinput_ids = torch.tensor(eval_features.input_ids, dtype=torch.long).to(self.device).unsqueeze(0)\\n\\t\\tinput_mask = torch.tensor(eval_features.input_mask, dtype=torch.long).to(self.device).unsqueeze(0)\\n\\t\\tsegment_ids = torch.tensor(eval_features.segment_ids, dtype=torch.long).to(self.device).unsqueeze(0)\\n\\t\\t\\n\\t\\twith torch.no_grad():\\n\\t\\t\\tlogits = self.model(input_ids, segment_ids, input_mask)\\n\\t\\t\\tlogits = logits.to(\\\"cpu\\\")\\n\\t\\t\\tsoftmax_logits = F.softmax(logits[0], dim=0).numpy()\\n\\t\\t\\tprint(\\\"softmax score : \\\", softmax_logits)\\n# final_logits = list(zip(list(map(lambda x : self.reverse_label_map[np.ravel(np.where(softmax_logits==x))[0]], softmax_logits )), softmax_logits))\\n\\t\\tpred = np.argmax(softmax_logits)\\n\\t\\tprob = np.max(softmax_logits)\\n\\t\\t\\n\\t\\treturn pred , prob\",\n \"def InverseMatrix(matrix,vector):\\r\\n # Unveri reversible matrix\\r\\n if Determinant(matrix, 1) == 0:\\r\\n print(\\\"Error,Singular Matrix\\\\n\\\")\\r\\n return\\r\\n # result matrix initialized as singularity matrix\\r\\n result = MakeIMatrix(len(matrix), len(matrix))\\r\\n # loop for each row\\r\\n for i in range(len(matrix[0])):\\r\\n # turn the pivot into 1 (make elementary matrix and multiply with the result matrix )\\r\\n # pivoting process\\r\\n matrix, vector = RowXchange(matrix, vector)\\r\\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\\r\\n elementary[i][i] = 1/matrix[i][i]\\r\\n result = MultiplyMatrix(elementary, result)\\r\\n matrix = MultiplyMatrix(elementary, matrix)\\r\\n # make elementary loop to iterate for each row and subtracrt the number below (specific) pivot to zero (make\\r\\n # elementary matrix and multiply with the result matrix )\\r\\n for j in range(i+1, len(matrix)):\\r\\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\\r\\n elementary[j][i] = -(matrix[j][i])\\r\\n matrix = MultiplyMatrix(elementary, matrix)\\r\\n result = MultiplyMatrix(elementary, result)\\r\\n\\r\\n\\r\\n # after finishing with the lower part of the matrix subtract the numbers above the pivot with elementary for loop\\r\\n # (make elementary matrix and multiply with the result matrix )\\r\\n for i in range(len(matrix[0])-1, 0, -1):\\r\\n for j in range(i-1, -1, -1):\\r\\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\\r\\n elementary[j][i] = -(matrix[j][i])\\r\\n matrix = MultiplyMatrix(elementary, matrix)\\r\\n result = MultiplyMatrix(elementary, result)\\r\\n\\r\\n return result\",\n \"def predict(self):\\n path = self._artifact_repo.artifact_path(self._ARTIFACT_MODEL)\\n model = tf.keras.models.load_model(path)\\n\\n _, _, x_test, y_test = self._load_data()\\n x_test = tf.keras.utils.normalize(x_test, axis=1)\\n\\n preds = model.predict(x_test)\\n self._show_cf_matrix(np.array([np.argmax(probas) for probas in preds]), y_test)\",\n \"def setup_t_matrix(dq_W_E_vec, dq_B_H_vec):\\n n_quaternions = len(dq_W_E_vec)\\n t_matrix = np.zeros([6 * n_quaternions, 8])\\n for i in range(n_quaternions):\\n t_matrix[i * 6:i * 6 + 6, :] = setup_s_matrix(dq_W_E_vec[i], dq_B_H_vec[i])\\n\\n rank_t_matrix = np.linalg.matrix_rank(t_matrix, tol=5e-2)\\n U, s, V = np.linalg.svd(t_matrix)\\n # print(\\\"t_matrix: \\\\n{}\\\".format(t_matrix))\\n # print(\\\"Rank(t_matrix): {}\\\".format(rank_t_matrix))\\n # assert rank_t_matrix == 6, (\\\"T should have rank 6 otherwise we can not find \\\"\\n # \\\"a rigid transform.\\\", rank_t_matrix, s)\\n return t_matrix.copy()\",\n \"def _set_u_matirx(self):\\n c_matrix = self.get_c_matrix()\\n u_matrix, d_matrix, _ = np.linalg.svd(c_matrix)\\n self.u_matrix = np.matrix(u_matrix)\",\n \"def train_model(train_table: pd.DataFrame, viewed_table: pd.DataFrame) -> List:\\n\\n \\\"\\\"\\\"\\\"\\\"\\\"\\n # construct numpy array\\n #nan_data = train_table.replace(0.0, np.NaN).to_numpy()\\n #user_ratings_mean = np.nanmean(nan_data, axis=1)\\n unviewed_table = viewed_table.apply(lambda x: 1 - x)\\n # unviewed = unviewed_table.to_numpy()\\n\\n # construct numpy array\\n data = train_table.to_numpy()\\n user_ratings_mean = np.mean(data, axis=1)\\n # factors in individual interpretation of the scale\\n data_demeaned = data - user_ratings_mean.reshape(-1, 1)\\n\\n # use scipy sparse's svd to avoid 'killed: 9' memory issues\\n U, sigma, Vt = svds(data_demeaned, k=25)\\n\\n sigma = np.diag(sigma)\\n\\n all_predictions = np.dot(np.dot(U, sigma), Vt) + user_ratings_mean.reshape(-1, 1)\\n all_predictions_table = pd.DataFrame(all_predictions).set_index(viewed_table.index)\\n all_predictions_table.set_axis(viewed_table.columns, axis='columns', inplace=True)\\n\\n\\n # given already viewed movies a rating of 0. Note these will still be taken ahead of adverse movies\\n predictions_table = pd.DataFrame(np.multiply(all_predictions_table,\\n unviewed_table.to_numpy()).set_index(viewed_table.index))\\n predictions_table.set_axis(viewed_table.columns, axis='columns', inplace=True)\\n\\n return [all_predictions_table, predictions_table]\",\n \"def _minimal_predict(Classifier, vector, threshold):\\n return Classifier.predict(array([vector.tolist()]), threshold)\",\n \"def full(self):\\n\\n # Compute tensor unfolding along first mode\\n unf = self.factors[0] @ khatri_rao(self.factors[1:]).T\\n\\n # Inverse unfolding along first mode\\n return np.reshape(unf, self.shape)\",\n \"def predict(self, x):\\n \\n\\n return predictions\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68731123","0.6112549","0.60515124","0.60183614","0.5982911","0.5939187","0.58090305","0.57974684","0.578775","0.574525","0.5728702","0.5567461","0.5479815","0.54721326","0.54661137","0.5449834","0.54436517","0.541722","0.54135686","0.5375098","0.53690135","0.5365648","0.5361823","0.53526825","0.53516567","0.53214437","0.5318949","0.53140116","0.5304396","0.53038377","0.53026557","0.5298433","0.52981037","0.52971077","0.528754","0.5281845","0.52814204","0.52702373","0.52652097","0.52595687","0.52524203","0.5252133","0.5238156","0.52336717","0.5221588","0.52114725","0.5196418","0.5192851","0.51916337","0.51799375","0.51729447","0.51603895","0.51571226","0.5155511","0.5151028","0.5148709","0.5145041","0.51424366","0.51424366","0.5137345","0.51371974","0.51350254","0.5131595","0.51255107","0.51202196","0.5117283","0.51150966","0.5114315","0.5113006","0.51061434","0.5104186","0.50882024","0.50878364","0.5081085","0.5079598","0.50747335","0.50671136","0.5063691","0.5063251","0.5063014","0.5051709","0.50475776","0.5039711","0.50323343","0.5029673","0.5027608","0.5025488","0.50231427","0.50225157","0.5022111","0.50196534","0.5016432","0.5011506","0.50065243","0.5006499","0.5005228","0.49992913","0.49992582","0.49985904","0.49958318"],"string":"[\n \"0.68731123\",\n \"0.6112549\",\n \"0.60515124\",\n \"0.60183614\",\n \"0.5982911\",\n \"0.5939187\",\n \"0.58090305\",\n \"0.57974684\",\n \"0.578775\",\n \"0.574525\",\n \"0.5728702\",\n \"0.5567461\",\n \"0.5479815\",\n \"0.54721326\",\n \"0.54661137\",\n \"0.5449834\",\n \"0.54436517\",\n \"0.541722\",\n \"0.54135686\",\n \"0.5375098\",\n \"0.53690135\",\n \"0.5365648\",\n \"0.5361823\",\n \"0.53526825\",\n \"0.53516567\",\n \"0.53214437\",\n \"0.5318949\",\n \"0.53140116\",\n \"0.5304396\",\n \"0.53038377\",\n \"0.53026557\",\n \"0.5298433\",\n \"0.52981037\",\n \"0.52971077\",\n \"0.528754\",\n \"0.5281845\",\n \"0.52814204\",\n \"0.52702373\",\n \"0.52652097\",\n \"0.52595687\",\n \"0.52524203\",\n \"0.5252133\",\n \"0.5238156\",\n \"0.52336717\",\n \"0.5221588\",\n \"0.52114725\",\n \"0.5196418\",\n \"0.5192851\",\n \"0.51916337\",\n \"0.51799375\",\n \"0.51729447\",\n \"0.51603895\",\n \"0.51571226\",\n \"0.5155511\",\n \"0.5151028\",\n \"0.5148709\",\n \"0.5145041\",\n \"0.51424366\",\n \"0.51424366\",\n \"0.5137345\",\n \"0.51371974\",\n \"0.51350254\",\n \"0.5131595\",\n \"0.51255107\",\n \"0.51202196\",\n \"0.5117283\",\n \"0.51150966\",\n \"0.5114315\",\n \"0.5113006\",\n \"0.51061434\",\n \"0.5104186\",\n \"0.50882024\",\n \"0.50878364\",\n \"0.5081085\",\n \"0.5079598\",\n \"0.50747335\",\n \"0.50671136\",\n \"0.5063691\",\n \"0.5063251\",\n \"0.5063014\",\n \"0.5051709\",\n \"0.50475776\",\n \"0.5039711\",\n \"0.50323343\",\n \"0.5029673\",\n \"0.5027608\",\n \"0.5025488\",\n \"0.50231427\",\n \"0.50225157\",\n \"0.5022111\",\n \"0.50196534\",\n \"0.5016432\",\n \"0.5011506\",\n \"0.50065243\",\n \"0.5006499\",\n \"0.5005228\",\n \"0.49992913\",\n \"0.49992582\",\n \"0.49985904\",\n \"0.49958318\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7002625"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83690,"cells":{"query":{"kind":"string","value":"Updates the low rank structure of self.u and self.v based on the `mat` input. Performs singular value decomposition on the matrix and selects the last `self.rank` entries."},"document":{"kind":"string","value":"def update_params(self, mat):\n assert mat.shape == self.shape\n a, s, b = np.linalg.svd(mat, full_matrices=False)\n self.u = a[:, :self.rank]*s[:self.rank]\n self.v = b.T[:, :self.rank]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def find_optimal_low_rank_matrix( self, orig_similarity_matrix, orig_rank, u, s, v, singular_reduction ):\n '''rank_list = list()\n sum_singular_values = list()\n for rank in range( 0, orig_rank ):\n compute_result = self.compute_low_rank_matrix( u, s, v, rank + 1 )\n rank_list.append( ( rank + 1 ) / float( orig_rank ) )\n sum_singular_values.append( compute_result[ 1 ] )\n utils._plot_singular_values_rank( rank_list, sum_singular_values )'''\n return self.compute_low_rank_matrix( u, s, v, int( singular_reduction * orig_rank ) )","def compute_low_rank_matrix( self, u, s, v, rank ):\n u_approx = u[ :, :rank ]\n s_approx = s[ :rank ]\n sum_taken_percent = np.sum( s_approx ) / float( np.sum( s ) )\n s_approx = np.diag( np.array( s_approx ) )\n v_approx = v[ :rank, : ]\n return [ u_approx.dot( s_approx ).dot( v_approx ), sum_taken_percent ]","def _set_u_matirx(self):\n c_matrix = self.get_c_matrix()\n u_matrix, d_matrix, _ = np.linalg.svd(c_matrix)\n self.u_matrix = np.matrix(u_matrix)","def read_mat(self, mat):\n self.N = len(mat)\n self.mat = mat\n for i in range(len(mat)):\n self.mat[i,i] = np.inf","def svd_compress_gs(mat, k):\n U, singular_vals, V = np.linalg.svd(mat)\n rank = len(singular_vals)\n print(\"Image rank %r\" % rank)\n if k > rank:\n print(\"k is larger than rank of image %r\" % rank)\n return mat\n # take columns less than k from U\n U_p = U[:, :k]\n # take rows less than k from V\n V_p = V[:k, :]\n # build the new S matrix with top k diagnal elements\n S_p = np.zeros((k, k), mat.dtype)\n for i in range(k):\n S_p[i][i] = singular_vals[i]\n print(\"U_p shape {0}, S_p shape {1}, V_p shape {2}\".format(\n U_p.shape, S_p.shape, V_p.shape))\n compressed = np.dot(np.dot(U_p, S_p), V_p)\n ss = ssim(mat, compressed,\n dynamic_range=compressed.max() - compressed.min())\n print(\"Strucural similarity: %r\" % ss)\n return U_p, S_p, V_p","def svd_compress_gs(mat, k):\n U, singular_vals, V = np.linalg.svd(mat)\n rank = len(singular_vals)\n print(\"Image rank %r\" % rank)\n if k > rank:\n print(\"k is larger than rank of image %r\" % rank)\n return mat\n # take columns less than k from U\n U_p = U[:, :k]\n # take rows less than k from V\n V_p = V[:k, :]\n # build the new S matrix with top k diagnal elements\n S_p = np.zeros((k, k), mat.dtype)\n for i in range(k):\n S_p[i][i] = singular_vals[i]\n print(\"U_p shape {0}, S_p shape {1}, V_p shape {2}\".format(\n U_p.shape, S_p.shape, V_p.shape))\n compressed = np.dot(np.dot(U_p, S_p), V_p)\n ss = ssim(mat, compressed,\n dynamic_range=compressed.max() - compressed.min())\n print(\"Strucural similarity: %r\" % ss)\n return U_p, S_p, V_p, ss","def inverse_head(self, gauss_order = 3, inv_head_mat_file = None):\n\n LOG.info(\"Computing HeadMat...\")\n head_matrix = om.HeadMat(self.om_head, gauss_order)\n LOG.info(\"head_matrix: %d x %d\" % (head_matrix.nlin(), \n head_matrix.ncol()))\n\n LOG.info(\"Inverting HeadMat...\")\n hminv = head_matrix.inverse()\n LOG.info(\"inverse head_matrix: %d x %d\" % (hminv.nlin(), hminv.ncol()))\n\n if inv_head_mat_file is not None:\n LOG.info(\"Saving inverse_head matrix as %s...\" % inv_head_mat_file)\n hminv.save(os.path.join(OM_STORAGE_DIR,\n inv_head_mat_file + OM_SAVE_SUFFIX)) #~5GB\n return hminv","def svd(matrix, rank=None):\n if matrix.ndim != 2:\n raise ValueError('Input should be a two-dimensional array. matrix.ndim is {} != 2'.format(matrix.ndim))\n dim_1, dim_2 = matrix.shape\n if dim_1 <= dim_2:\n min_dim = dim_1\n else:\n min_dim = dim_2\n\n if rank is None or rank >= min_dim:\n # Default on standard SVD\n U, S, V = scipy.linalg.svd(matrix)\n U, S, V = U[:, :rank], S[:rank], V[:rank, :]\n return U, S, V\n\n else:\n # We can perform a partial SVD\n # First choose whether to use X * X.T or X.T *X\n if dim_1 < dim_2:\n S, U = scipy.sparse.linalg.eigsh(np.dot(matrix, matrix.T), k=rank, which='LM')\n S = np.sqrt(S)\n V = np.dot(matrix.T, U * 1 / S[None, :])\n else:\n S, V = scipy.sparse.linalg.eigsh(np.dot(matrix.T, matrix), k=rank, which='LM')\n S = np.sqrt(S)\n U = np.dot(matrix, V) * 1 / S[None, :]\n\n # WARNING: here, V is still the transpose of what it should be\n U, S, V = U[:, ::-1], S[::-1], V[:, ::-1]\n return U, S, V.T","def __init__(self, A, rank=0):\r\n _u, _s, _v = np.linalg.svd(A, full_matrices=0)\r\n \r\n self.rank = rank\r\n\r\n self.U = _u[:,:self.rank].copy()\r\n self.S = _s[:self.rank].copy()\r\n self.SI = np.matrix(np.diag(self.S)).getI()\r\n self.VT = _v[:self.rank,:].copy()\r\n \r\n self._var = [ e/(_s**2).sum() for e in (_s**2).cumsum() ][self.rank-1]","def update_params(self, mat):\n assert mat.shape == self.shape\n vec = mat.reshape(mat.size)\n self.alpha = np.linalg.solve(self.covs_mat.T.dot(self.covs_mat),\n self.covs_mat.T.dot(vec))","def get_singular_values(matrix, n):\n singular_values = None\n u, s, v = svd(matrix)\n ### YOUR CODE HERE\n pass\n ### END YOUR CODE\n return singular_values","def _set_ls_matrices(self):\n zz_t = self.z_matrix * self.z_matrix.transpose()\n l, s, l_t = np.linalg.svd(zz_t)\n s[self.p:] = 0\n self.l_matrix = np.matrix(l)\n self.s_matirx = np.matrix(np.diag(s))","def matrix_svd(\n self,\n chis=None,\n eps=0,\n print_errors=\"deprecated\",\n break_degenerate=False,\n degeneracy_eps=1e-6,\n sparse=False,\n trunc_err_func=None,\n ):\n if print_errors != \"deprecated\":\n msg = (\n \"The `print_errors` keyword argument has been deprecated, \"\n \"and has no effect. Rely instead on getting the error as a \"\n \"return value, and print it yourself.\"\n )\n warnings.warn(msg)\n chis = self._matrix_decomp_format_chis(chis, eps)\n maxchi = max(chis)\n assert self.defval == 0\n assert self.invar\n\n # SVD each sector at a time.\n # While doing so, also keep track of a list of all singular values, as\n # well as a heap that gives the negative of the largest singular value\n # in each sector. These will be needed later when deciding how to\n # truncate the decomposition.\n svds = {}\n dims = {}\n minus_next_sings = []\n all_sings = []\n for k, v in self.sects.items():\n if 0 in v.shape:\n shp = v.shape\n m = min(shp)\n u = np.empty((shp[0], m), dtype=self.dtype)\n s = np.empty((m,), dtype=np.float_)\n v = np.empty((m, shp[1]), dtype=self.dtype)\n else:\n if sparse and maxchi < min(v.shape) - 1:\n u, s, v = spsla.svds(\n v, k=maxchi, return_singular_vectors=True\n )\n order = np.argsort(-s)\n u = u[:, order]\n s = s[order]\n v = v[order, :]\n else:\n u, s, v = np.linalg.svd(v, full_matrices=False)\n svd = (s, u, v)\n svds[k] = svd\n dims[k] = 0\n sings = svd[0]\n all_sings.append(sings)\n if 0 not in sings.shape:\n heapq.heappush(minus_next_sings, (-sings[0], k))\n try:\n all_sings = np.concatenate(all_sings)\n except ValueError:\n all_sings = np.array((0,))\n\n if sparse:\n norm_sq = self.norm_sq()\n else:\n norm_sq = None\n\n # Figure out what bond dimension to truncate to, how this bond\n # dimension is distributed over the different sectors, and what the\n # truncation error is.\n chi, dims, rel_err = type(self)._find_trunc_dim(\n all_sings,\n svds,\n minus_next_sings,\n dims,\n chis=chis,\n eps=eps,\n break_degenerate=break_degenerate,\n degeneracy_eps=degeneracy_eps,\n trunc_err_func=trunc_err_func,\n norm_sq=norm_sq,\n )\n\n # Truncate each block and create the dim for the new index.\n new_dim = []\n new_qim = []\n svds = {k: v for k, v in svds.items() if dims[k] > 0}\n for k, v in svds.items():\n d = dims[k]\n if d > 0:\n new_dim.append(d)\n new_qim.append(k[0])\n svds[k] = (v[0][:d], v[1][:, :d], v[2][:d, :])\n else:\n del svds[k]\n\n # Initialize U, S, V.\n d = self.dirs[0]\n U = type(self)(\n [self.shape[0], new_dim],\n qhape=[self.qhape[0], new_qim],\n dirs=[d, -d],\n qodulus=self.qodulus,\n dtype=self.dtype,\n charge=0,\n )\n S = type(self)(\n [new_dim],\n qhape=[new_qim],\n dirs=[d],\n qodulus=self.qodulus,\n dtype=np.float_,\n invar=False,\n charge=0,\n )\n V = type(self)(\n [new_dim, self.shape[1]],\n qhape=[new_qim, self.qhape[1]],\n dirs=[d, self.dirs[1]],\n qodulus=self.qodulus,\n dtype=self.dtype,\n charge=self.charge,\n )\n\n # Set the blocks of U, S and V.\n for k, v in svds.items():\n k_U = (k[0], k[0])\n S[(k[0],)] = v[0]\n U[k_U] = v[1]\n V[k] = v[2]\n\n return U, S, V, rel_err","def get_singular_values(matrix, n):\n singular_values = None\n u, s, v = svd(matrix)\n ### YOUR CODE HERE\n singular_values=s[0:n]\n ### END YOUR CODE\n return singular_values","def update_model(X, U, S, k, n, mu,\n svdmethod='full',\n missingmethod='zero'):\n\n if len(X) == 0:\n printt(\"Error: No data in X.\")\n return None, None, None, -1, None\n #print('%d items in X' % X.shape[1])\n #print('init U:', U)\n\n # If there is no previous U, and we just got a single item in X,\n # set U to all 0's (degenerate SVD),\n # and return it with mu.\n # (PR #22 sets first value to 1; see decals implementation)\n if len(U) == 0 and X.shape[1] == 1:\n mu = X\n # Do this no matter what. Let mu get NaNs in it as needed.\n U = np.zeros_like(mu)\n U[0] = 1\n S = np.array([0])\n n = 1\n pcts = [1.0]\n return U, S, mu, n, pcts\n\n ###########################################################################\n # Do full SVD of X if this is requested, regardless of what is in U \n # Also, if n = 0 or U is empty, start from scratch\n output_k = False\n if svdmethod == 'full' or len(U) == 0 or n == 0:\n if n == 0:\n if len(U) == 0:\n printt(\"----- initial SVD -----\")\n output_k = True\n else:\n # Reshape so we don't have an empty dimension (yay python)\n U = U.reshape(-1, 1)\n elif len(U) == 0:\n printt(\"WARNING: N (number of items modeled by U) is %d, not zero, but U is empty!\" % n)\n\n # Bootstrap\n if missingmethod == 'ignore':\n printt(\"ERROR: ignore with full is not possible under ordinary circumstances.\")\n printt(\"Use --increm-brand to impute for NaNs.\")\n printt(\"For now, we are filling NaNs with 0.\")\n X = copy.deepcopy(X)\n z = np.where(np.isnan(X))\n X[z] = 0\n\n mu = np.mean(X, axis=1).reshape(-1,1)\n X = X - mu\n U, S, V = linalg.svd(X, full_matrices=False)\n printt('Just did full SVD on %d items.' % X.shape[1])\n #print('X:', X)\n #print('U:', U)\n # Reset U to all 0's if we only have one item in X (degenerate SVD)\n if X.shape[1] == 1:\n U = np.zeros_like(U)\n \n # Keep only the first k components\n S_full = S\n S = S[0:k]\n U = U[:,0:k]\n\n # Update n to number of new items in X\n n = X.shape[1]\n \n ###########################################################################\n # Incremental SVD from Ross\n elif svdmethod == 'increm-ross':\n # Incremental SVD from Ross et al. 2008\n # \"Incremental Learning for Robust Visual Tracking\"\n # based on Lim and Ross's sklm.m implementation in MATLAB.\n\n # This method DOES NOT handle missing values.\n if missingmethod == 'ignore':\n print('ERROR: increm-ross cannot handle missing values.')\n print('If they are present, try svdmethod=increm-brand')\n print(' or use missingmethod=zero to zero-fill.')\n print('If there are no missing values, specify missingmethod=none.')\n sys.exit(1)\n\n n_new = X.shape[1]\n \n # Compute mean\n # Weirdly, the later 'X-mu_new' is MUCH faster if you reshape as shown.\n # This is because of differences in the way numpy treats a 1d array versus a 2d column.\n mu_new = np.mean(X, axis=1).reshape(-1,1)\n\n # Subtract the mean, append it as a column vector, and update mu\n # X - mu_new will be zero if X has only 1 item\n mu_old = mu\n # New mu is a weighted sum of old and new mus\n mu = (n * mu_old + n_new * mu_new) / (n + n_new)\n B = np.hstack((X - mu,\n math.sqrt(n_new * n/float(n_new+n)) * \\\n (mu_old - mu_new)))\n printt(\"Now tracking mean for %d -> %d items; mu.min %f, mu.max %f \" % \\\n (n, n+n_new, np.nanmin(mu), np.nanmax(mu)))\n n = n + n_new\n\n if S.all() == 0:\n npcs = U.shape[1]\n diagS = np.zeros((npcs, npcs))\n else:\n diagS = np.diag(S)\n\n # I don't think this is right. At this point B is the augmented\n # matrix rather than the single observation.\n proj = np.dot(U.T, B)\n reproj_err = B - np.dot(U, proj)\n\n # to get orthogonal form of reproj_err\n # This should return q with dimensions [d(X) by n_new+1], square\n q, dummy = linalg.qr(reproj_err, mode='full')\n # print('q.shape should be 7x2: ', q.shape)\n Q = np.hstack((U, q))\n\n # From Ross and Lim, 2008\n # R = [ [ Sigma, U.T * X ] [ 0, orthog. component of reproj error ] ]\n k_now = diagS.shape[0]\n new_dim = k_now + n_new + 1\n R = np.zeros((new_dim, new_dim))\n R[0:k_now,0:k_now] = diagS\n R[0:k_now,k_now:] = proj\n orthog_reproj_err = np.dot(q.T, reproj_err)\n R[k_now:, k_now:] = orthog_reproj_err\n \n # Perform SVD of R. Then finally update U.\n U, S, V = linalg.svd(R, full_matrices=False)\n printt('Just did increm-ross SVD on %d items.' % n)\n\n U = np.dot(Q, U)\n \n # Keep only the first k components\n U = U[:,0:min([n,k])]\n S_full = S\n S = S[0:min([n,k])]\n\n ###########################################################################\n # Incremental SVD from Brand\n elif svdmethod == 'increm-brand':\n # Pulled out James's attempt to handle NaNs into\n # increm-brand-james.py. Starting over from scratch here.\n n_new = X.shape[1]\n\n if n_new != 1:\n print(\"WARNING: increm-brand will probably only work by adding one item at a time.\")\n input('\\nPress enter to continue or ^C/EOF to exit. ')\n\n if missingmethod == 'ignore':\n # 1. Update mu\n mu_old = mu\n mu_new = X\n\n # Be careful! For any pre-existing NaNs in mu,\n # let mu_new fill them in. Can't get any worse!\n naninds = np.where(np.isnan(mu_old))[0]\n if naninds.size > 0:\n mu_old[naninds,0] = mu_new[naninds,0]\n # And likewise for mu_new -- fill with good values from mu_old.\n naninds = np.where(np.isnan(mu_new))[0]\n if naninds.size > 0:\n mu_new[naninds,0] = mu_old[naninds,0]\n # At this point, the only NaNs that should appear are\n # values that were NaN for both mu and X to start with.\n # They will stay NaN and that's okay.\n \n # New mu is a weighted sum of old and new mus\n mu = (n * mu_old + n_new * mu_new) / (n + n_new)\n printt(\"Now tracking mean for %d -> %d items; mu.min %f, mu.max %f \" % \\\n (n, n+n_new, np.nanmin(mu), np.nanmax(mu)))\n n = n + n_new\n\n # 2. Subtract off the mean\n X = X - mu\n\n # 3. Compute L, the projection of X onto U\n # Note: this will only work for a single item in X\n goodinds = np.where(~np.isnan(X))[0]\n #print('X: %d of %d are good.' % (len(goodinds), X.shape[0]))\n\n diagS = np.diag(S)\n # This is Brand's method, which involves S:\n L = np.dot(diagS,\n np.dot(np.linalg.pinv(np.dot(U[goodinds,:],\n diagS)),\n X[goodinds,:]))\n # Simplified version that does not use S (but is probably wrong):\n #L = np.dot(U[goodinds,:].T,\n # X[goodinds,:])\n # Top row of the Q matrix (eqn 12, Brand 2002)\n Q1 = np.hstack([diagS, L])\n\n # 4. Compute J, the orthogonal basis of H, which is\n # the component of X orthog to U (i.e., unrepresentable direction)\n # 5. Compute K, the projection of X onto J (i.e., unrep. content)\n K = linalg.norm(X[goodinds,:] - np.dot(U[goodinds,:],\n np.dot(U[goodinds,:].T,\n X[goodinds,:])))\n # H = X - UL\n J = np.zeros((U.shape[0], 1))\n J[goodinds] = np.dot(K,\n np.linalg.pinv(X[goodinds,:] -\n np.dot(U[goodinds,:],\n L))).T\n \n # Bottom row of Q matrix (eqn 12, Brand 2002)\n Q2 = np.hstack([np.zeros([1, len(S)]), np.array(K).reshape(1,1)])\n Q = np.vstack([Q1, Q2])\n\n # 6. Take the SVD of Q\n Uq, Sq, Vq = linalg.svd(Q, full_matrices=False)\n\n # 7. Update U and S (eqn 4, Brand 2002)\n # Note: Since J is zero-filled for badinds, now U is too.\n # Alternatively, we give J NaNs and let them get into U as well.\n # I think that is a worse idea though.\n U = np.dot(np.hstack([U, J]), Uq)\n S = Sq\n # Updating V requires knowing old V,\n # but we don't need the new one either so it's okay to skip.\n\n printt('Just did increm-brand SVD on %d items.' % n)\n \n ############# end ###########\n \n else: # No missing values (or not 'ignore')\n # 1. Update mu\n mu_old = mu\n mu_new = X\n # New mu is a weighted sum of old and new mus\n mu = (n * mu_old + n_new * mu_new) / (n + n_new)\n n = n + n_new\n\n # 2. Subtract off the mean\n X = X - mu\n\n # 3. Compute L, the projection of X onto U\n L = np.dot(U.T, X)\n Q1 = np.hstack([np.diag(S), L])\n\n # 4. Compute J, the orthogonal basis of H, which is\n # the component of X orthog to U (i.e., unrepresentable direction)\n # 5. Compute K, the projection of X onto J (i.e., unrep. content)\n JK = X - np.dot(U, L)\n (J, K) = linalg.qr(JK)\n\n Q2 = np.hstack([np.zeros([1, len(S)]), np.array(K).reshape(1,1)])\n Q = np.vstack([Q1, Q2])\n\n # 6. Take the SVD of Q\n Uq, Sq, Vq = linalg.svd(Q, full_matrices=False)\n\n # 7. Update U and S (eqn 4, Brand 2002)\n U = np.dot(np.hstack([U, J]), Uq)\n S = Sq\n # V requires knowing old V,\n # but we don't need the new one either so it's okay.\n \n printt('Just did regular increm SVD on %d items.' % n)\n\n # Keep only the first k components\n U = U[:,0:min([n,k])]\n S = S[0:min([n,k])]\n\n Usum = U.sum(1)\n\n\n ###########################################################################\n # We have a bad svdmethod, but somehow didn't catch it earlier.\n else:\n printt(\"504: Bad Gateway in protocol <Skynet_authentication.exe>\")\n return None, None, None, None, None\n\n indivpcts = None\n\n # This only works if a full SVD was done\n if (svdmethod == 'full' and output_k and opts['k_var'] == -773038.0):\n # Calculate percent variance captured by each \n cumsum = np.cumsum(S_full)\n #print(cumsum.shape)\n if cumsum[-1] != 0:\n indivpcts = S / cumsum[-1]\n indivpcts = indivpcts[0:k] # truncate to first k\n cumpercents = cumsum / cumsum[-1]\n else:\n indivpcts = []\n\n # Calculate percent variance captured\n if k >= cumsum.shape[0]:\n printt('Cannot estimate data variance; specified k (%d) exceeds the number of SVs (%d).' % (k, cumsum.shape[0]))\n else:\n printt(\"Selected value of k=%d captures %5.2f%% of the data variance\" % \\\n (k, cumpercents[k-1] * 100))\n if opts['pause']: input(\"Press enter to continue\\n\")\n\n #print('U:', U)\n #print('mu:', mu)\n return U, S, mu, n, indivpcts","def normalize_mat(mat):\n # Gather matrix columns indices.\n gather_split_i = 0\n gather_avg_5_i = 1\n gather_avg_25_i = 2\n gather_avg_50_i = 3\n gather_volume_i = 4\n gather_dates_indicator_i = 5\n # Normalize prices. We want to keep relationship between prices\n # (eg. avg_5 > split) untouched, so we use single set of max and mean for\n # split and all averages.\n prices_indices = [\n gather_split_i, gather_avg_5_i, gather_avg_25_i, gather_avg_50_i\n ]\n mat[:, prices_indices] /= np.max(mat[:, prices_indices])\n mat[:, prices_indices] *= 2\n mat[:, prices_indices] -= np.mean(mat[:, prices_indices])\n # Normalize volume.\n mat[:, gather_volume_i] /= np.max(mat[:, gather_volume_i])\n mat[:, gather_volume_i] *= 2\n mat[:, gather_volume_i] -= np.mean(mat[:, gather_volume_i])\n # Subtract 1.0 from dates indicator multiplied by 2.0 as it is already in\n # range 0.0, 1.0 and we don't want characteristic values to vary between\n # matrices as it is data outside of one company scope.\n dates_indicator_mean = 1.0\n mat[:, gather_dates_indicator_i] *= 2\n mat[:, gather_dates_indicator_i] -= dates_indicator_mean\n return mat","def svd(matrix):\n u = None\n s = None\n v = None\n ### YOUR CODE HERE\n (u,s,v)=np.linalg.svd(matrix)\n ### END YOUR CODE\n\n return u, s, v","def svd(matrix, approach):\n\n # Getting the eigenvalues and vectors of transpose(A) * A for V and Sigma\n a = mat_multiply(transpose(matrix), matrix)\n if approach == \"qr\":\n V, sigma, iterations = qr_eig(a)\n else:\n V, sigma, iterations = eig(a)\n\n # Sorting singular values and the colums of V accordingly\n V = transpose(V)\n\n singular_values = list()\n sorted_V = list()\n\n r = 0\n for i in range(rows(sigma)):\n singular_values.append([(sigma[i][i]), i])\n if sigma[i][i] > math.exp(-8):\n r += 1\n\n singular_values.sort(key=first_item, reverse=True)\n\n sigma_r = eye(r)\n sigma_r_inv = eye(r)\n\n # Constructing the sorted U and sigma matrices\n i, j = 0, 0\n for value in singular_values:\n if value[0] > math.exp(-8):\n sorted_V.append(V[value[1]])\n sigma_r[j][j] = value[0] ** (1 / 2)\n sigma_r_inv[j][j] = 1 / (value[0] ** (1 / 2))\n j += 1\n i += 1\n\n # Constructing U by multiplying V and sigma inverse\n sorted_U = mat_multiply(mat_multiply(matrix, transpose(sorted_V)), sigma_r_inv)\n\n return (sorted_U, sigma_r, sorted_V, r, iterations)","def normalize(self,matrix):\n for i in range(self.N):\n matrix[self.N-1][i] = 0\n for i in range(self.n):\n matrix[self.N - 1][self.index(i,i)] = 1\n return matrix","def _compute_s_matrix(self, system_std_dev: tf.Tensor) -> None:\n self.s_matrix_inv = self._kronecker_product(\n tf.diag(tf.reshape(tf.ones_like(system_std_dev, dtype=tf.float64)\n / system_std_dev, [-1])),\n tf.eye(self.n_points_int, dtype=tf.float64))\n return","def rebuild_svd(self, U, S, V, k): # [5pts]\n \n N,D = U.shape[0],V.shape[0]\n \n \n if U.ndim == 3:\n Xrebuild = np.zeros((N,D,3))\n for i in range(3):\n U_temp = U[:,0:k,i]\n S_temp = S[:,i]\n S_temp = np.diag(S_temp[0:k])\n V_temp = V[0:k,:,i]\n Xrebuild_temp = U_temp@S_temp@V_temp\n Xrebuild[:,:,i] = Xrebuild_temp\n else:\n U_new = U[:,0:k]\n S_new = np.diag(S[0:k])\n V_new = V[0:k,:]\n Xrebuild = U_new@S_new@V_new\n\n return Xrebuild","def incremental_svd(A, qr_flg=False):\n\n m = 256\n n = 7291\n\n n0 = 256\n\n if A.shape[0] != m or A.shape[1] != n: raise ValueError('Error: incorrect matrix size')\n\n start = time.clock()\n\n A0 = A[:, :n0]\n U, s, V = ln.svd(A0, full_matrices=False)\n\n # NOTE: s is a vector; np.diag(s) will produce a diagonal matrix\n for i in range(n0, n):\n\n # new matrix is just a single vector (i-th column of A)\n A1 = np.matrix(A[:, i]).T\n\n if qr_flg:\n J, K = ln.qr(A1 - np.dot(np.dot(U, U.T), A1))\n U_, s_, V_ = ln.svd(\n np.vstack((\n np.hstack((np.diag(s), np.dot(U.T, A1))),\n np.hstack((np.zeros((K.shape[0], s.shape[0])), K))\n )),\n full_matrices=False)\n\n # update the result of SVD\n U = np.dot(np.hstack((U, J)), U_)\n\n else:\n U_, s_, V_ = ln.svd(np.hstack((np.diag(s), np.dot(U.T, A1))), full_matrices=False)\n U = np.dot(U, U_)\n\n s = s_\n\n # NOTE: V from svd on NumPy is already transposed\n V = np.dot(V_,\n np.vstack((\n np.hstack((V, np.zeros((V.shape[0], i+1-V.shape[1])))),\n np.hstack((np.zeros((V_.shape[1]-V.shape[0], V.shape[1])), np.eye(V_.shape[1]-V.shape[0], i+1-V.shape[1])))\n ))\n )\n\n # for next computation, update A0\n A0 = np.hstack((A0, A1))\n\n elapsed_time = time.clock() - start\n print 'time:', elapsed_time\n\n return U, s, V","def _normal_matvec(matvec, x):\n matvec_x, vjp = jax.vjp(matvec, x)\n return vjp(matvec_x)[0]","def InverseMatrix(matrix,vector):\r\n # Unveri reversible matrix\r\n if Determinant(matrix, 1) == 0:\r\n print(\"Error,Singular Matrix\\n\")\r\n return\r\n # result matrix initialized as singularity matrix\r\n result = MakeIMatrix(len(matrix), len(matrix))\r\n # loop for each row\r\n for i in range(len(matrix[0])):\r\n # turn the pivot into 1 (make elementary matrix and multiply with the result matrix )\r\n # pivoting process\r\n matrix, vector = RowXchange(matrix, vector)\r\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\r\n elementary[i][i] = 1/matrix[i][i]\r\n result = MultiplyMatrix(elementary, result)\r\n matrix = MultiplyMatrix(elementary, matrix)\r\n # make elementary loop to iterate for each row and subtracrt the number below (specific) pivot to zero (make\r\n # elementary matrix and multiply with the result matrix )\r\n for j in range(i+1, len(matrix)):\r\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\r\n elementary[j][i] = -(matrix[j][i])\r\n matrix = MultiplyMatrix(elementary, matrix)\r\n result = MultiplyMatrix(elementary, result)\r\n\r\n\r\n # after finishing with the lower part of the matrix subtract the numbers above the pivot with elementary for loop\r\n # (make elementary matrix and multiply with the result matrix )\r\n for i in range(len(matrix[0])-1, 0, -1):\r\n for j in range(i-1, -1, -1):\r\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\r\n elementary[j][i] = -(matrix[j][i])\r\n matrix = MultiplyMatrix(elementary, matrix)\r\n result = MultiplyMatrix(elementary, result)\r\n\r\n return result","def smith_nf(matrix):\n\n A=np.copy(matrix)\n if (np.around(A) != A).any():\n raise Exception('This function requires integer input.')\n\n # This looks much like an SVD algorithm that first bidiagonalizes\n # A by Givens rotations and then chases zeros, except for\n # the construction of the 2 by 2 elementary transformation.\n\n m, n = A.shape\n\n S = A\n U = np.eye(m)\n V = np.eye(n)\n\n # Bidiagonalize S with elementary Hermite transforms.\n for j in range(min(m, n)):\n # Zero column j below the diagonal.\n for i in range(j+1, m):\n if S[i, j]:\n # Construct an elementary Hermite transformation E\n # to zero S(i,j) by combining rows i and j.\n E = ehermite(S[j, j], S[i, j])\n # Apply the transform to S and U.\n S[[j, i], :] = np.dot(E, S[[j, i], :])\n # U[:, [j, i]] = U[:, [j, i]] / E\n U[:, [j, i]] = left_matrix_division(U[:, [j, i]], E) # solving the left matrix division\n\n # % Zero row j after the superdiagonal.\n for i in range(j+2, n):\n if S[j, i]:\n # Construct an elementary Hermite transformation E\n # to zero S(j,i) by combining columns j+1 and i.\n E = ehermite(S[j, j+1], S[j, i])\n # Apply the transform to S and V.\n S[:, [j+1, i]] = np.dot(S[:, [j+1, i]], E.T)\n # V[:, [j+1, i]] = V[:, [j+1, i]] / E\n V[:, [j+1, i]] = left_matrix_division(V[:, [j+1, i]], E) # solving the left matrix division\n\n # Now S is upper bidiagonal.\n # Chase the superdiagonal nonzeros away.\n\n D = np.diag(S, 1)\n while any(D):\n b = min(np.where(D))[0]\n # Start chasing bulge at first nonzero superdiagonal element.\n # To guarantee reduction in S(b,b), first make S(b,b) positive\n # and make S(b,b+1) nonnegative and less than S(b,b).\n if S[b, b] < 0:\n S[b, :] = -S[b, :]\n U[:, b] = -U[:, b]\n\n q = np.floor(S[b, b+1] / S[b, b])\n E = np.array([[1, 0], [-q, 1]])\n S[:, [b, b+1]] = np.dot(S[:, [b, b+1]], E.T)\n # V[:, [b, b+1]] = V[:, [b, b+1]] / E\n V[:, [b, b+1]] = left_matrix_division(V[:, [b, b+1]], E) # solving the left matrix division\n\n if S[b, b+1]:\n # Zero the first nonzero superdiagonal element\n # using columns b and b+1, to start the bulge at S(b+1,b).\n E = ehermite(S[b, b], S[b, b+1])\n S[:, [b, b+1]] = np.dot(S[:, [b, b+1]], E.T)\n # V[:, [b, b+1]] = V[:, [b, b+1]] / E\n V[:, [b, b+1]] = left_matrix_division(V[:, [b, b+1]], E)\n\n for j in range(min(m, n)):\n if j+1 < m:\n # Zero S(j+1,j) using rows j and j+1.\n E = ehermite(S[j, j], S[j+1, j])\n S[[j, j+1], :] = np.dot(E, S[[j, j+1], :])\n # U[:, [j, j+1]] = U[:, [j, j+1]] / E\n U[:, [j, j+1]] = left_matrix_division(U[:, [j, j+1]], E)\n if j+2 < n:\n # Zero S(j,j+2) using columns j+1 and j+2.\n E = ehermite(S[j, j+1], S[j, j+2])\n S[:, [j+1, j+2]] = np.dot(S[:, [j+1, j+2]], E.T)\n # V[:, [j+1, j+2]] = V[:, [j+1, j+2]] / E\n V[:, [j+1, j+2]] = left_matrix_division(V[:, [j+1, j+2]], E)\n D = np.diag(S, 1)\n\n # Now S is diagonal. Make it nonnegative.\n\n for j in range(min(m, n)):\n if S[j, j] < 0:\n S[j, :] = -S[j, :]\n U[:, j] = -U[:, j]\n\n # Squeeze factors to lower right to enforce divisibility condition.\n\n for i in range(min(m, n)):\n for j in range(i+1, min(m, n)):\n # Replace S(i,i), S(j,j) by their gcd and lcm respectively.\n a = S[i, i]\n b = S[j, j]\n [c, d, g] = extgcd(a, b)\n E = np.array([[1, d], [-b/g, a*c/g]])\n F = np.array([[c, 1], [-b*d/g, a/g]])\n S[np.ix_([i, j], [i, j])] = np.dot(np.dot(E, S[:, [i, j]][[i, j], :]), F.T)\n # S[i, i] = tmp_arr[0, 0]\n # S[i, j] = tmp_arr[0, 1]\n # S[j, i] = tmp_arr[1, 0]\n # S[j, j] = tmp_arr[1, 1]\n U[:, [i, j]] = left_matrix_division(U[:, [i, j]], E)\n V[:, [i, j]] = left_matrix_division(V[:, [i, j]], F)\n\n U = np.around(U)\n V = np.around(V)\n return U, S, V","def matrix_inv(mat):\n\ta = mat[0,0]\n\tb = mat[0,1]\n\tc = mat[0,2]\n\td = mat[1,0]\n\te = mat[1,1]\n\tf = mat[1,2]\n\tg = mat[2,0]\n\th = mat[2,1]\n\ti = mat[2,2]\n\n\tdet = b*f*g + c*d*h + a*e*i - a*f*h - b*d*i - c*e*g\n\n\tinvmat = np.zeros((3,3))\n\tinvmat[0,0] = (e*i - f*h) / det\n\tinvmat[0,1] = (c*h - b*i) / det\n\tinvmat[0,2] = (b*f - c*e) / det\n\tinvmat[1,0] = (f*g - d*i) / det\n\tinvmat[1,1] = (a*i - c*g) / det\n\tinvmat[1,2] = (c*d - a*f) / det\n\tinvmat[2,0] = (d*h - e*g) / det\n\tinvmat[2,1] = (b*g - a*h) / det\n\tinvmat[2,2] = (a*e - b*d) / det\n\treturn invmat","def populate_from_qrev_mat(self, mat_data):\n\n # Variables passed to the constructor\n\n if type(mat_data.frequency_hz) is np.ndarray:\n self.frequency_khz = mat_data.frequency_hz\n elif np.isnan(mat_data.frequency_hz):\n self.frequency_khz = None\n else:\n self.frequency_khz = mat_data.frequency_hz\n self.orig_coord_sys = mat_data.origCoordSys\n self.nav_ref = mat_data.navRef\n\n # Data requiring manipulation if only 1 ensemble\n if type(mat_data.u_mps) is float:\n self.raw_vel_mps = mat_data.rawVel_mps.reshape(mat_data.rawVel_mps.shape[0], 1)\n # Coordinate transformed data\n self.coord_sys = np.array([mat_data.coordSys])\n self.u_mps = np.array([mat_data.u_mps])\n self.v_mps = np.array([mat_data.v_mps])\n self.w_mps = np.array([mat_data.w_mps])\n self.d_mps = np.array([mat_data.d_mps])\n\n self.bottom_mode = np.array([mat_data.bottomMode])\n\n # Processed data\n self.u_processed_mps = np.array([mat_data.uProcessed_mps])\n self.v_processed_mps = np.array([mat_data.vProcessed_mps])\n self.processed_source = np.array([mat_data.processedSource])\n self.valid_data = np.array([ mat_data.validData]).astype(bool)\n self.valid_data = self.valid_data.reshape(-1, 1)\n self.smooth_speed = np.array([mat_data.smoothSpeed])\n self.smooth_upper_limit = np.array([mat_data.smoothUpperLimit])\n self.smooth_lower_limit = np.array([mat_data.smoothLowerLimit])\n else:\n self.raw_vel_mps = mat_data.rawVel_mps\n # Coordinate transformed data\n self.coord_sys = mat_data.coordSys\n self.u_mps = mat_data.u_mps\n self.v_mps = mat_data.v_mps\n self.w_mps = mat_data.w_mps\n self.d_mps = mat_data.d_mps\n\n self.bottom_mode = mat_data.bottomMode\n\n # Processed data\n self.u_processed_mps = mat_data.uProcessed_mps\n self.v_processed_mps = mat_data.vProcessed_mps\n self.processed_source = mat_data.processedSource\n self.valid_data = mat_data.validData.astype(bool)\n self.smooth_speed = mat_data.smoothSpeed\n self.smooth_upper_limit = mat_data.smoothUpperLimit\n self.smooth_lower_limit = mat_data.smoothLowerLimit\n\n self.num_invalid = mat_data.numInvalid\n # Error velocity filter\n if type(mat_data.dFilter) is np.ndarray:\n self.d_filter = None\n else:\n self.d_filter = mat_data.dFilter\n\n # Error velocity threshold\n if type(mat_data.dFilterThreshold) is np.ndarray:\n self.d_filter_threshold = None\n else:\n self.d_filter_threshold = mat_data.dFilterThreshold\n\n # Vertical velocity filter\n if type(mat_data.wFilter) is np.ndarray:\n self.w_filter = None\n else:\n self.w_filter = mat_data.wFilter\n\n # Vertical velocity threshold\n if type(mat_data.wFilterThreshold) is np.ndarray:\n self.w_filter_threshold = None\n else:\n self.w_filter_threshold = mat_data.wFilterThreshold\n\n # GPS quality filter\n if type(mat_data.gpsDiffQualFilter) is np.ndarray:\n self.gps_diff_qual_filter = None\n else:\n self.gps_diff_qual_filter = mat_data.gpsDiffQualFilter\n\n # GPS altitude filter\n if type(mat_data.gpsAltitudeFilter) is np.ndarray:\n self.gps_altitude_filter = None\n else:\n self.gps_altitude_filter = mat_data.gpsAltitudeFilter\n\n # GPS altitude threshold\n if type(mat_data.gpsAltitudeFilterChange) is np.ndarray:\n self.gps_altitude_filter_change = None\n else:\n self.gps_altitude_filter_change = mat_data.gpsAltitudeFilterChange\n\n # HDOP filter\n if type(mat_data.gpsHDOPFilter) is np.ndarray:\n self.gps_HDOP_filter = None\n else:\n self.gps_HDOP_filter = mat_data.gpsHDOPFilter\n\n # HDOP max threshold\n if type(mat_data.gpsHDOPFilterMax) is np.ndarray:\n self.gps_HDOP_filter_max = None\n else:\n self.gps_HDOP_filter_max = mat_data.gpsHDOPFilterMax\n\n # HDOP change threshold\n if type(mat_data.gpsHDOPFilterChange) is np.ndarray:\n self.gps_HDOP_filter_change = None\n else:\n self.gps_HDOP_filter_change = mat_data.gpsHDOPFilterChange\n\n # Other filters\n self.smooth_filter = mat_data.smoothFilter\n self.interpolate = mat_data.interpolate\n self.beam_filter = mat_data.beamFilter","def normalize_matrix(mat):\n return (mat + abs(mat.min())) / (mat.max() - mat.min())","def StandardizeMatrix(mat):\n nObjs = len(mat)\n avgs = sum(mat,0)/float(nObjs)\n mat -= avgs\n devs =sqrt(sum(mat*mat,0)/(float(nObjs-1)))\n try:\n newMat = mat/devs\n except OverflowError:\n newMat = numpy.zeros(mat.shape,'d')\n for i in range(mat.shape[1]):\n if devs[i] != 0.0:\n newMat[:,i] = mat[:,i]/devs[i]\n return newMat","def fit_svd(self):\n\n # U has the eigenvectors of G.Gt as columns ()\n # S has square roots of the eigenvalues of G.Gt and Gt.G in its diagonal\n # The square roos of the eigenvalues are called singular values\n # V has the eigenvectors of Gt.G as columns ()\n # full_matrices set to false will set the Vt matrix to a shape m x n\n\n U, S, Vt = linalg.svd(self.norm_matrix, full_matrices=False)\n\n # Compute the eigenvalues\n eig_val = (S ** 2)\n\n # Explained_variance tell us how much of the variance in the data each eigen value explains\n explained_variance = eig_val / (self.n_samples - 1)\n # total_var is the total variance in the data\n total_var = explained_variance.sum()\n explained_variance_ratio = explained_variance / total_var\n # The cumulative sum of all ratios\n ratio_cumsum = np.cumsum(explained_variance_ratio)\n\n # We search in the cumsum for the index of the value which, when added, corresponds to the quality_percent\n # The index of the cumsum gives us the components we need to add to explain X quality percent of our data\n n_components = np.searchsorted(ratio_cumsum, self.quality_percent, side='right') + 1\n\n self.components = Vt[:n_components]\n print(\"The principal components have been calculated using svd\", self.components.shape)\n\n return self.components","def set_matrix(self, name, mat):\n self._matrices[name] = mat","def posdef_eig_svd(mat):\n evals, evecs, _ = tf.svd(mat)\n\n return evals, evecs","def _mat2vec(self, mat):\n return mat.flatten('F')","def lowest_rank_approx(A, err):\r\n U, Si, Vh = la.svd(A)\r\n for i in range(len(Si)):\r\n #raise error if there are no nonzero singular values less than error\r\n if Si[i] == 0:\r\n raise ValueError(\"A cannot be approximated in tolerance by matrix of lesser rank\")\r\n\r\n #for greatest singular value less than error\r\n if Si[i] < err:\r\n #svd approximate for rank s\r\n Si_hat = np.diag(Si[:i])\r\n U_hat = U[:, :i]\r\n Vh_hat = Vh[:i, :]\r\n #return new A and num of entries needed\r\n return U_hat @ Si_hat @ Vh_hat, U_hat.size + i + Vh_hat.size","def normalize(self):\n det = self._mat[0][0]*self._mat[1][1] - self._mat[0][1]*self._mat[1][0]\n for i in range(2):\n for j in range(2):\n self._mat[i][j] = (self._mat[i][j])/(np.sqrt(det))","def normalize_vecs(mat):\n #convert to array for operation\n order = len(mat.shape) - 1\n mat = COO(mat)\n row_sums = mat.sum(axis=order)\n mat = DOK(mat)\n for point in mat.data:\n divisor = row_sums[point[:-1]]\n mat[point] = mat[point] / divisor\n mat = COO(mat)\n return mat","def set_gpm_by_svd(self, threshold):\n assert len(self.M) > 0\n\n self.M_vec = []\n self.M_val = []\n\n index = np.arange(len(self.M))\n np.random.shuffle(index)\n\n for k, idx in enumerate(index):\n if k < min(self.mem_batch_size, len(self.M)):\n ox, oy, ot = self.M[idx]\n if k == 0:\n mx = ox.unsqueeze(0)\n else:\n mx = torch.cat((mx, ox.unsqueeze(0)), 0)\n\n # handle gpus if specified\n if self.cuda:\n mx = mx.cuda()\n\n with torch.no_grad():\n rep = self.net.forward(mx, svd=True)\n\n for i in range(len(rep)):\n # rep[i]: n_samples * n_features\n assert rep[i].ndim == 2\n\n u, s, v = torch.svd(rep[i].detach().cpu())\n\n if threshold[i] < 1:\n r = torch.cumsum(s ** 2, 0) / torch.cumsum(s ** 2, 0)[-1]\n k = torch.searchsorted(r, threshold[i]) + 1\n elif threshold[i] > 10:\n # differ with thres = 1\n k = int(threshold[i])\n else:\n k = len(s)\n\n if k > 0:\n self.M_vec.append(v[:, :k].cpu())\n self.M_val.append(s[:k].cpu())","def inverse(self,mat):\n result = np.linalg.inv(mat)\n self.out = result\n return self.out","def solveLinearSingular(aMat, bVec, isParameterized=False, defaultValue=1):\n solution = aMat.gauss_jordan_solve(bVec)\n solutionVec = solution[0]\n if not isParameterized:\n parameterMat = solution[1]\n for parameter in parameterMat:\n solutionVec = solutionVec.subs(parameter, defaultValue)\n solutionVec = solutionVec.evalf()\n return solutionVec","def mds_torch(pre_dist_mat, weights=None, iters=10, tol=1e-5, eigen=False, verbose=0):\n device, dtype = pre_dist_mat.device, pre_dist_mat.type()\n # ensure batched MDS\n pre_dist_mat = expand_dims_to(pre_dist_mat, length = ( 3 - len(pre_dist_mat.shape) ))\n # start\n batch, N, _ = pre_dist_mat.shape\n diag_idxs = np.arange(N)\n his = [torch.tensor([np.inf]*batch, device=device)]\n\n # initialize by eigendecomposition: https://www.lptmc.jussieu.fr/user/lesne/bioinformatics.pdf\n # follow : https://www.biorxiv.org/content/10.1101/2020.11.27.401232v1.full.pdf\n D = pre_dist_mat**2\n M = 0.5 * (D[:, :1, :] + D[:, :, :1] - D) \n # do loop svd bc it's faster: (2-3x in CPU and 1-2x in GPU)\n # https://discuss.pytorch.org/t/batched-svd-lowrank-being-much-slower-than-loop-implementation-both-cpu-and-gpu/119336\n svds = [torch.svd_lowrank(mi) for mi in M]\n u = torch.stack([svd[0] for svd in svds], dim=0)\n s = torch.stack([svd[1] for svd in svds], dim=0)\n v = torch.stack([svd[2] for svd in svds], dim=0)\n best_3d_coords = torch.bmm(u, torch.diag_embed(s).abs().sqrt())[..., :3]\n\n # only eigen - way faster but not weights\n if weights is None and eigen==True:\n return torch.transpose( best_3d_coords, -1, -2), torch.zeros_like(torch.stack(his, dim=0))\n elif eigen==True:\n if verbose:\n print(\"Can't use eigen flag if weights are active. Fallback to iterative\")\n\n # continue the iterative way\n if weights is None:\n weights = torch.ones_like(pre_dist_mat)\n\n # iterative updates:\n for i in range(iters):\n # compute distance matrix of coords and stress\n best_3d_coords = best_3d_coords.contiguous()\n dist_mat = torch.cdist(best_3d_coords, best_3d_coords, p=2).clone()\n\n stress = ( weights * (dist_mat - pre_dist_mat)**2 ).sum(dim=(-1,-2)) * 0.5\n # perturb - update X using the Guttman transform - sklearn-like\n dist_mat[ dist_mat <= 0 ] += 1e-7\n ratio = weights * (pre_dist_mat / dist_mat)\n B = -ratio\n B[:, diag_idxs, diag_idxs] += ratio.sum(dim=-1)\n\n # update\n coords = (1. / N * torch.matmul(B, best_3d_coords))\n dis = torch.norm(coords, dim=(-1, -2))\n\n if verbose >= 2:\n print('it: %d, stress %s' % (i, stress))\n # update metrics if relative improvement above tolerance\n if (his[-1] - stress / dis).mean() <= tol:\n if verbose:\n print('breaking at iteration %d with stress %s' % (i,\n stress / dis))\n break\n\n best_3d_coords = coords\n his.append( stress / dis )\n\n x = torch.transpose(best_3d_coords, -1,-2)#, torch.stack(his, dim=0) ,historic_stresses: (batch x steps)\n x = x.permute(0,2,1)\n return x","def StandardizeMatrix(mat):\n nObjs = len(mat)\n avgs = sum(mat, 0) / float(nObjs)\n mat -= avgs\n devs = math.sqrt(sum(mat * mat, 0) / (float(nObjs - 1)))\n try:\n newMat = mat / devs\n except OverflowError:\n newMat = numpy.zeros(mat.shape, 'd')\n for i in range(mat.shape[1]):\n if devs[i] != 0.0:\n newMat[:, i] = mat[:, i] / devs[i]\n return newMat","def update_projection(self, prior_mat, variable_mat, feature_mat):\n new_variable = {'mu': np.zeros(variable_mat['mu'].shape),\n 'sigma': np.zeros(variable_mat['sigma'].shape)}\n prior_expect = (prior_mat['alpha'] / prior_mat['beta'])\\\n .transpose().tolist()\n\n for i in range(self.R):\n new_variable['sigma'][i, :, :] = np.linalg.inv(\n np.diag(prior_expect[i])\n + (self.kkt_mat / self.sigma_h))\n new_variable['mu'][:, i] = np.dot(\n new_variable['sigma'][i, :, :],\n np.dot(self.kernel_mat,\n feature_mat['mu'][i, :].transpose())\n / self.sigma_h)\n\n return new_variable","def calculate_k_SVD(smooth_spreadsheet_matrix, k):\n U_unitary_matrix, singular_value, V_unitary_matrix = linalg.svd(smooth_spreadsheet_matrix)\n S_full_squared_matrix = np.zeros((k, k))\n np.fill_diagonal(S_full_squared_matrix, np.sqrt(singular_value[:k]))\n U_unitary_matrix = U_unitary_matrix[:, :k]\n return U_unitary_matrix, S_full_squared_matrix","def build_mat(self):\n for row, s in enumerate(self.S):\n for col, t in enumerate(self.T):\n\n if self.symmetric and row > col:\n pass\n\n else:\n self.mat[row, col] = self.kernel(s, t, self.n)\n\n if self.symmetric:\n self.mat = self.symmetrize(self.mat)\n else:\n for idx, s in enumerate(self.S):\n self.test_normalization[idx] = self.kernel(s, s, self.n)","def _sparse_projection(self,mat,sparsity=1,random_seed=10):\n [n,_] = mat.shape\n sketch = np.zeros((self.rp_dim ,n),dtype=float)\n for i in range(n):\n nnz_loc = np.random.choice(self.rp_dim ,size=sparsity,replace=False)\n nnz_sign = np.random.choice([-1,1],size=sparsity,replace=True)\n sketch[nnz_loc,i] = nnz_sign\n self.sketch_mat = sketch\n return (1./np.sqrt(sparsity))*sketch@mat","def my_scale_sim_mat(w):\n rowsum = np.array(np.sum(w, axis=1), dtype=np.float32)\n r_inv = np.power(rowsum, -1).flatten()\n r_inv[np.isinf(r_inv)] = 0.\n r_mat_inv = sp.diags(r_inv)\n w = r_mat_inv.dot(w)\n return w","def MATSOL(N,A):\r\n\r\n X = np.zeros((N+1),dtype=float) # X.shape = N+1\r\n NROW = np.arange(0,N+1,dtype=int) # NROW.shape = N+1\r\n\r\n for i in np.arange(N): # loop through rows\r\n AMAX = np.max(np.abs(A[NROW[i:],i])) # max value for column, all later rows\r\n ip = np.argmax(np.abs(A[NROW[i:],i]))+i # index of above\r\n \r\n if(abs(AMAX) <= 1E-08):\r\n print('Singular matrix --> No unique solution exists')\r\n return X\r\n \r\n if(NROW[i] != NROW[ip]): # swap rows\r\n NC = NROW[i].copy()\r\n NROW[i] = NROW[ip].copy()\r\n NROW[ip] = NC.copy()\r\n \r\n \r\n COEF = A[NROW[i+1:],i]/A[NROW[i],i] # normalize column values by maximum magnitude value (AMAX > 0)\r\n A[NROW[i+1:],i+1:] = A[NROW[i+1:],i+1:] - np.dot(COEF[:,None],A[NROW[i],i+1:][None,:]) # normalize/reduce matrix\r\n \r\n \r\n if(abs(A[NROW[N],N]) <= 1E-08):\r\n print('Singular matrix --> No unique solution exists')\r\n return X\r\n \r\n X[N] = A[NROW[N],N+1]/A[NROW[N],N] # downstream edge\r\n i = N-1\r\n while (i >= 0):\r\n# SUMM = 0.0\r\n# j = i+1\r\n \r\n SUMM = np.sum(A[NROW[i],i+1:N+1]*X[i+1:N+1]) # do not include final column\r\n \r\n# while (j <= N-1):\r\n# SUMM = A[NROW[i],j]*X[j] + SUMM\r\n# j = j+1\r\n # print(SUMM,SUMM2)\r\n \r\n X[i] = (A[NROW[i],N+1] - SUMM)/A[NROW[i],i]\r\n i = i-1\r\n return X","def gauss_seidel_solver(self, mat, rhs):\n x = np.zeros_like(rhs)\n for it_count in range(1, self.iterations_number):\n x_new = np.zeros_like(x)\n if self.verbose > 1:\n print(\"Iteration {0}: {1}\".format(it_count, x))\n for i in range(mat.shape[0]):\n s1 = np.dot(mat[i, :i], x_new[:i])\n s2 = np.dot(mat[i, i + 1:], x[i + 1:])\n x_new[i] = (rhs[i] - s1 - s2) / mat[i, i]\n if np.allclose(x, x_new, rtol=1e-8):\n break\n x = x_new\n return x","def truncated_svd(A,k=None):","def transform(self, mat: TxMatrix) -> None:\n super().transform(mat)\n self.scale = self.scale * mat.scale","def scaling(mat, factor):\n\treturn mat / (mat + factor)","def _matvec(x):\n return _normal_matvec(matvec, x)","def build_normalized(self):\n for row, s in enumerate(self.S):\n for col, t in enumerate(self.T):\n\n if self.symmetric and row > col:\n pass\n\n elif self.symmetric and row == col:\n self.normalized_mat[row, col] = 1\n\n else:\n self.normalized_mat[row, col] = self.normalize(row, col)\n\n if self.symmetric:\n self.normalized_mat = self.symmetrize(self.normalized_mat)","def mumps_eigsh(matrix, k, sigma, **kwargs):\n class LuInv(sla.LinearOperator):\n\n def __init__(self, matrix):\n instance = kwant.linalg.mumps.MUMPSContext()\n instance.analyze(matrix, ordering='pord')\n instance.factor(matrix)\n self.solve = instance.solve\n sla.LinearOperator.__init__(self, matrix.dtype, matrix.shape)\n\n def _matvec(self, x):\n return self.solve(x.astype(self.dtype))\n\n opinv = LuInv(matrix - sigma * sp.identity(matrix.shape[0]))\n return sla.eigsh(matrix, k, sigma=sigma, OPinv=opinv, **kwargs)","def test_set_matrix_vec(self, backend, vecmat, elements, elem_vnode,\n kernel_inc_vec, kernel_set_vec, g, skip_cuda):\n op2.par_loop(kernel_inc_vec, elements(3,3),\n vecmat((elem_vnode[op2.i[0]], elem_vnode[op2.i[1]]), op2.INC),\n g(op2.READ))\n # Check we have ones in the matrix\n assert vecmat.array.sum() == 2*2*3*3*elements.size\n op2.par_loop(kernel_set_vec, elements(3,3),\n vecmat((elem_vnode[op2.i[0]], elem_vnode[op2.i[1]]), op2.WRITE),\n g(op2.READ))\n # Check we have set all values in the matrix to 1\n assert_allclose(vecmat.array, numpy.ones_like(vecmat.array))\n vecmat.zero()","def do_numeric_factorization(self, matrix):\n if self._nnz is None:\n raise RuntimeError('Call do_symbolic_factorization first.')\n if type(matrix) == np.ndarray:\n matrix = coo_matrix(matrix)\n if not isspmatrix_coo(matrix):\n matrix = matrix.tocoo()\n nrows, ncols = matrix.shape\n if nrows != ncols:\n raise ValueError('matrix is not square')\n if self._dim != nrows:\n raise ValueError('The shape of the matrix changed between symbolic and numeric factorization')\n if self._nnz != matrix.nnz:\n raise ValueError('The number of nonzeros changed between symbolic and numeric factorization')\n self.mumps.set_centralized_assembled_values(matrix.data)\n self.mumps.run(job=2)","def inv(matrix):\n if sp.sparse.issparse(matrix):\n result = spla.inv(matrix)\n else:\n result = sp.linalg.inv(matrix)\n return result","def _scale(self, normalize, mat):\n mat = mat.astype(float)\n if normalize:\n mat = sklearn_norm(mat,\n feature_range=(0, 1),\n axis=0,\n copy=True)\n else:\n return mat\n return mat","def update_mass_matrix(self, sim, joint_index):\n mass_matrix = np.ndarray(shape=(len(sim.data.qvel) ** 2,), dtype=np.float64, order='C')\n # print(self.current_joint_position)\n # print(mass_matrix)\n mujoco_py.cymj._mj_fullM(sim.model, mass_matrix, sim.data.qM)\n mass_matrix = np.reshape(mass_matrix, (len(sim.data.qvel), len(sim.data.qvel)))\n self.mass_matrix = mass_matrix[joint_index, :][:, joint_index]\n \n # self.mass_matrix = np.array([[ 2.25726539e+00, -2.62750718e-06, 1.60412060e+00,\n # 2.62750718e-06, -5.43221706e-01, 2.62750718e-06,\n # -1.98486117e-01],\n # [-2.62750718e-06, 2.28637709e+00, -6.58357876e-06,\n # -1.16381227e+00, -4.11331754e-06, -4.00056093e-01,\n # 2.53844900e-18],\n # [ 1.60412060e+00, -6.58357876e-06, 1.60070894e+00,\n # 6.58357876e-06, -5.02987276e-01, 6.58357876e-06,\n # -1.89718057e-01],\n # [ 2.62750718e-06, -1.16381227e+00, 6.58357876e-06,\n # 1.43272976e+00, 4.11331754e-06, 4.01913080e-01,\n # -2.53381454e-18],\n # [-5.43221706e-01, -4.11331754e-06, -5.02987276e-01,\n # 4.11331754e-06, 5.11565111e-01, 4.11331754e-06,\n # 1.96115254e-01],\n # [ 2.62750718e-06, -4.00056093e-01, 6.58357876e-06,\n # 4.01913080e-01, 4.11331754e-06, 3.22014223e-01,\n # -2.53991699e-18],\n # [-1.98486117e-01, 2.53844900e-18, -1.89718057e-01,\n # -2.53381454e-18, 1.96115254e-01, -2.53991699e-18,\n # 2.00104011e-01]])","def compute_svd(self,data,k):\n m, n =data.shape\n n = self.comm1.allreduce(n)\n print(m,n)\n if k==-1:\n k = min(m,n)\n args = parse()\n args.m,args.n,args.k,args.comm = m,n,k,self.comms\n args.eps = np.finfo(data.dtype).eps\n if args.m<args.n: args.p_r,args.p_c = 1,self.size\n dsvd = DistSVD(args, data)\n singularValues, U, V = dsvd.svd()\n rel_error = dsvd.rel_error(U, np.diag(singularValues), V)\n if self.global_rank==0: print('relative error is:', rel_error )\n return singularValues,U,V,rel_error","def matSet(mat, r, c, v):\n mat[r][c]=v","def Sinv(self):\n Wplus = np.matrix(np.diag(self.w**2 + 1.0))\n return self.priorSinvh * self.V.T * Wplus * self.V * self.priorSinvh","def update_matrix(self, ope, mat):\n ope_coord = []\n for coord in self.coord_name:\n if np.isnan(ope[coord]):\n return\n ope_coord.append(int(ope[coord]))\n mat[tuple(ope_coord)] += 1","def normalised(cls, mat, axis=-1, order=2):\n norm = np.linalg.norm(\n mat, axis=axis, ord=order, keepdims=True)\n norm[norm == 0] = 1\n return mat / norm","def update(mat) -> np.ndarray:\n return mat","def doolittle_factorization(self, matrix=None):\n try:\n local_matrix = self.matrix.matrix if not matrix else matrix.matrix\n except AttributeError:\n local_matrix = matrix\n \n (result, upper, lower, temp_sum) = (0.0, [[]], [[]], 0.0)\n for i in range(len(local_matrix)):\n lower.append([])\n for j in range(len(local_matrix[i])):\n lower[i].append(0)\n \n lower.remove([])\n\n for i in range(len(local_matrix)):\n for j in range(len(local_matrix[i])):\n temp_sum = 0.0\n for k in range(i):\n temp_sum += lower[i][k] * upper[k][j]\n result = local_matrix[i][j] - temp_sum\n upper[i].append(round(result, 9))\n upper.append([])\n \n for j in range(len(local_matrix[i])):\n temp_sum = 0.0\n for k in range(i):\n temp_sum += lower[j][k] * upper[k][i]\n result = local_matrix[j][i] - temp_sum\n lower[j][i] = round(result / upper[i][i], 9)\n\n upper.remove([])\n upper = Matrix(upper, name=\"U\")\n lower = Matrix(lower, name=\"L\")\n\n print(\"Las matrices son: \")\n upper.print_matrix()\n lower.print_matrix()\n\n print(\"Al multiplicarlas queda\")\n comprobation = lower.multiply_matrix(upper.matrix)\n comprobation.set_name(\"comprobación de la factorización LU\")\n comprobation.print_matrix()\n\n return (lower, upper)","def update_distmatrix(min_idx, dist_matrix):\n i, j = min_idx\n new_cluster_dist = np.minimum(dist_matrix[i, :], dist_matrix[j, :])\n new_cluster_dist[i] = np.inf\n \n dist_matrix[i, :] = new_cluster_dist\n dist_matrix[:, i] = new_cluster_dist\n \n dist_matrix[j, :] = np.inf\n dist_matrix[:, j] = np.inf\n \n return dist_matrix","def _apply_inverse(matrix, V, options=None):\n\n default_options = _options(matrix)\n\n if options is None:\n options = next(iter(default_options.values()))\n elif isinstance(options, str):\n if options == 'least_squares':\n for k, v in default_options.items():\n if k.startswith('least_squares'):\n options = v\n break\n assert not isinstance(options, str)\n else:\n options = default_options[options]\n else:\n assert 'type' in options and options['type'] in default_options \\\n and options.keys() <= default_options[options['type']].keys()\n user_options = options\n options = default_options[user_options['type']]\n options.update(user_options)\n\n promoted_type = np.promote_types(matrix.dtype, V.dtype)\n R = np.empty((len(V), matrix.shape[1]), dtype=promoted_type)\n\n if options['type'] == 'solve':\n for i, VV in enumerate(V):\n try:\n R[i] = np.linalg.solve(matrix, VV)\n except np.linalg.LinAlgError as e:\n raise InversionError('{}: {}'.format(str(type(e)), str(e)))\n elif options['type'] == 'least_squares_lstsq':\n for i, VV in enumerate(V):\n try:\n R[i], _, _, _ = np.linalg.lstsq(matrix, VV, rcond=options['rcond'])\n except np.linalg.LinAlgError as e:\n raise InversionError('{}: {}'.format(str(type(e)), str(e)))\n elif options['type'] == 'bicgstab':\n for i, VV in enumerate(V):\n R[i], info = bicgstab(matrix, VV, tol=options['tol'], maxiter=options['maxiter'])\n if info != 0:\n if info > 0:\n raise InversionError('bicgstab failed to converge after {} iterations'.format(info))\n else:\n raise InversionError('bicgstab failed with error code {} (illegal input or breakdown)'.\n format(info))\n elif options['type'] == 'bicgstab_spilu':\n # workaround for https://github.com/pymor/pymor/issues/171\n try:\n ilu = spilu(matrix, drop_tol=options['spilu_drop_tol'], fill_factor=options['spilu_fill_factor'],\n drop_rule=options['spilu_drop_rule'], permc_spec=options['spilu_permc_spec'])\n except TypeError as t:\n logger = getLogger('pymor.operators.numpy._apply_inverse')\n logger.error(\"ignoring drop_rule in ilu factorization\")\n ilu = spilu(matrix, drop_tol=options['spilu_drop_tol'], fill_factor=options['spilu_fill_factor'],\n permc_spec=options['spilu_permc_spec'])\n precond = LinearOperator(matrix.shape, ilu.solve)\n for i, VV in enumerate(V):\n R[i], info = bicgstab(matrix, VV, tol=options['tol'], maxiter=options['maxiter'], M=precond)\n if info != 0:\n if info > 0:\n raise InversionError('bicgstab failed to converge after {} iterations'.format(info))\n else:\n raise InversionError('bicgstab failed with error code {} (illegal input or breakdown)'.\n format(info))\n elif options['type'] == 'spsolve':\n try:\n # maybe remove unusable factorization:\n if hasattr(matrix, 'factorization'):\n fdtype = matrix.factorizationdtype\n if not np.can_cast(V.dtype, fdtype, casting='safe'):\n del matrix.factorization\n\n if list(map(int, scipy.version.version.split('.'))) >= [0, 14, 0]:\n if hasattr(matrix, 'factorization'):\n # we may use a complex factorization of a real matrix to\n # apply it to a real vector. In that case, we downcast\n # the result here, removing the imaginary part,\n # which should be zero.\n R = matrix.factorization.solve(V.T).T.astype(promoted_type, copy=False)\n elif options['keep_factorization']:\n # the matrix is always converted to the promoted type.\n # if matrix.dtype == promoted_type, this is a no_op\n matrix.factorization = splu(matrix_astype_nocopy(matrix, promoted_type), permc_spec=options['permc_spec'])\n matrix.factorizationdtype = promoted_type\n R = matrix.factorization.solve(V.T).T\n else:\n # the matrix is always converted to the promoted type.\n # if matrix.dtype == promoted_type, this is a no_op\n R = spsolve(matrix_astype_nocopy(matrix, promoted_type), V.T, permc_spec=options['permc_spec']).T\n else:\n # see if-part for documentation\n if hasattr(matrix, 'factorization'):\n for i, VV in enumerate(V):\n R[i] = matrix.factorization.solve(VV).astype(promoted_type, copy=False)\n elif options['keep_factorization']:\n matrix.factorization = splu(matrix_astype_nocopy(matrix, promoted_type), permc_spec=options['permc_spec'])\n matrix.factorizationdtype = promoted_type\n for i, VV in enumerate(V):\n R[i] = matrix.factorization.solve(VV)\n elif len(V) > 1:\n factorization = splu(matrix_astype_nocopy(matrix, promoted_type), permc_spec=options['permc_spec'])\n for i, VV in enumerate(V):\n R[i] = factorization.solve(VV)\n else:\n R = spsolve(matrix_astype_nocopy(matrix, promoted_type), V.T, permc_spec=options['permc_spec']).reshape((1, -1))\n except RuntimeError as e:\n raise InversionError(e)\n elif options['type'] == 'lgmres':\n for i, VV in enumerate(V):\n R[i], info = lgmres(matrix, VV.copy(i),\n tol=options['tol'],\n maxiter=options['maxiter'],\n inner_m=options['inner_m'],\n outer_k=options['outer_k'])\n if info > 0:\n raise InversionError('lgmres failed to converge after {} iterations'.format(info))\n assert info == 0\n elif options['type'] == 'least_squares_lsmr':\n for i, VV in enumerate(V):\n R[i], info, itn, _, _, _, _, _ = lsmr(matrix, VV.copy(i),\n damp=options['damp'],\n atol=options['atol'],\n btol=options['btol'],\n conlim=options['conlim'],\n maxiter=options['maxiter'],\n show=options['show'])\n assert 0 <= info <= 7\n if info == 7:\n raise InversionError('lsmr failed to converge after {} iterations'.format(itn))\n elif options['type'] == 'least_squares_lsqr':\n for i, VV in enumerate(V):\n R[i], info, itn, _, _, _, _, _, _, _ = lsqr(matrix, VV.copy(i),\n damp=options['damp'],\n atol=options['atol'],\n btol=options['btol'],\n conlim=options['conlim'],\n iter_lim=options['iter_lim'],\n show=options['show'])\n assert 0 <= info <= 7\n if info == 7:\n raise InversionError('lsmr failed to converge after {} iterations'.format(itn))\n elif options['type'] == 'pyamg':\n if len(V) > 0:\n V_iter = iter(enumerate(V))\n R[0], ml = pyamg.solve(matrix, next(V_iter)[1],\n tol=options['tol'],\n maxiter=options['maxiter'],\n return_solver=True)\n for i, VV in V_iter:\n R[i] = pyamg.solve(matrix, VV,\n tol=options['tol'],\n maxiter=options['maxiter'],\n existing_solver=ml)\n elif options['type'] == 'pyamg-rs':\n ml = pyamg.ruge_stuben_solver(matrix,\n strength=options['strength'],\n CF=options['CF'],\n presmoother=options['presmoother'],\n postsmoother=options['postsmoother'],\n max_levels=options['max_levels'],\n max_coarse=options['max_coarse'],\n coarse_solver=options['coarse_solver'])\n for i, VV in enumerate(V):\n R[i] = ml.solve(VV,\n tol=options['tol'],\n maxiter=options['maxiter'],\n cycle=options['cycle'],\n accel=options['accel'])\n elif options['type'] == 'pyamg-sa':\n ml = pyamg.smoothed_aggregation_solver(matrix,\n symmetry=options['symmetry'],\n strength=options['strength'],\n aggregate=options['aggregate'],\n smooth=options['smooth'],\n presmoother=options['presmoother'],\n postsmoother=options['postsmoother'],\n improve_candidates=options['improve_candidates'],\n max_levels=options['max_levels'],\n max_coarse=options['max_coarse'],\n diagonal_dominance=options['diagonal_dominance'])\n for i, VV in enumerate(V):\n R[i] = ml.solve(VV,\n tol=options['tol'],\n maxiter=options['maxiter'],\n cycle=options['cycle'],\n accel=options['accel'])\n elif options['type'].startswith('generic') or options['type'].startswith('least_squares_generic'):\n logger = getLogger('pymor.operators.numpy._apply_inverse')\n logger.warn('You have selected a (potentially slow) generic solver for a NumPy matrix operator!')\n from pymor.operators.numpy import NumpyMatrixOperator\n from pymor.vectorarrays.numpy import NumpyVectorArray\n return genericsolvers.apply_inverse(NumpyMatrixOperator(matrix),\n NumpyVectorArray(V, copy=False),\n options=options).data\n else:\n raise ValueError('Unknown solver type')\n return R","def mat_from_cond(cond_num, m=50, n=50, min_sing=None):\n assert min(m,n) > 1\n if cond_num < 1:\n raise la.linAlgError('Condition number must be greater than or equal to 1')\n\n if min_sing is None:\n min_sing = abs(np.random.randn())\n\n max_sing = min_sing * float(cond_num)\n s = np.array(sorted([np.random.uniform(low=min_sing, high=max_sing) for _ in range(min(m,n)-2)] + [min_sing, max_sing], reverse=True))\n\n A = np.random.randn(m, n)\n u,_,v = la.svd(A, full_matrices=False)\n\n # Sparse? instead of np.diag(s)\n return np.dot(u, np.dot(np.diag(s), v))","def normalize(self, matrix):\n eigvals, eigvecs = np.linalg.eig(matrix)\n Sdiag = np.diagonal(np.linalg.inv(eigvecs)@matrix@eigvecs)\n S12diag = Sdiag**-.5\n S12 = np.zeros((len(S12diag), len(S12diag)))\n np.fill_diagonal(S12, S12diag)\n return S12","def _setMatrixRow(self, row):\n item = self._item()\n if item is not None:\n matrix = item.getMatrix()\n matrix[self._index, :] = row.x(), row.y(), row.z()\n item.setMatrix(matrix)","def invert_L1_svd():","def uniform_matrixf(self, name, mat):\n if self.getStatus():\n loc = glGetUniformLocation(self.program, name)\n glUniformMatrix4fv(loc, 1, False, (ctypes.c_float * 16)(*mat))","def solve_lu(matvec: Callable, b: jnp.ndarray) -> jnp.ndarray:\n if len(b.shape) == 0:\n return b / _materialize_array(matvec, b.shape)\n elif len(b.shape) == 1:\n A = _materialize_array(matvec, b.shape, b.dtype)\n return jax.numpy.linalg.solve(A, b)\n elif len(b.shape) == 2:\n A = _materialize_array(matvec, b.shape, b.dtype) # 4d array (tensor)\n A = A.reshape(-1, b.shape[0] * b.shape[1]) # 2d array (matrix)\n return jax.numpy.linalg.solve(A, b.ravel()).reshape(*b.shape)\n else:\n raise NotImplementedError","def _sp_matrix_wrapper(matrix):\n if isinstance(matrix, _sp_matrix.SpMatrix):\n return SpMatrix().swap_(matrix)\n elif isinstance(matrix, _sp_matrix.DoubleSpMatrix):\n return DoubleSpMatrix().swap_(matrix)\n else:\n raise TypeError(\"unrecognized input type\")","def _loadMatFile(self, filename):\n matfile = scipy.io.loadmat(filename)\n\n self.StokesI = np.transpose(matfile['StokesI'])\n self.StokesQ = np.transpose(matfile['StokesQ'])\n self.StokesU = np.transpose(matfile['StokesU'])\n self.StokesV = np.transpose(matfile['StokesV'])\n self.detectorPosition = matfile['detectorPosition'][0]\n self.detectorDirection = matfile['detectorDirection'][0]\n self.detectorVisang = matfile['detectorVisang']\n\n try: self.wall = np.transpose(matfile['wall'])\n except KeyError: pass\n\n try: self.wall = np.transpose(matfile['separatrix'])\n except KeyError: pass","def svd(matrix):\n u = None\n s = None\n v = None\n ### YOUR CODE HERE\n pass\n ### END YOUR CODE\n\n return u, s, v","def __init__(self, shape, rank, sigma):\n assert isinstance(sigma, int)\n assert sigma > 0.0\n assert isinstance(shape, tuple)\n assert isinstance(rank, int)\n assert rank > 0\n assert rank <= min(*shape)\n self.shape = shape\n self.rank = rank\n self.sigma = sigma\n\n self.weight_mat = np.empty(self.shape)\n self.weight_mat.fill(1.0/sigma**2)\n\n self.u = np.zeros((self.shape[0], self.rank))\n self.v = np.zeros((self.shape[1], self.rank))","def resolves_matrix(self):\n self.P = np.linalg.solve(self.M, self.f)","def _fit_stochastic(self, R, U, V, seed):\n Rhat = self._estimate_ratings(U=U, V=V) # Get Rhat, the estimate of R\n np.random.seed(seed) # set random seed\n for _ in range(self.n_iter): # until we've reached n_iter...\n n = np.random.choice(self.N) # randomly choose a user\n m = np.random.choice(self.M) # randomly choose an item\n un_grad = -(R[n,m] - Rhat[n,m])*V[m] # gradient with respect to u_n vector\n vm_grad = -(R[n,m] - Rhat[n,m])*U[n] # gradient with respect to v_m vector\n U[n] -= self.lr*un_grad # update \n V[m] -= self.lr*vm_grad # update\n Rhat = self._estimate_ratings(U=U, V=V) # form new estimates\n self.Rhat, self.U, self.V = Rhat, U, V","def _symmetric_matrix_square_root(mat, eps=1e-10):\n # Unlike numpy, tensorflow's return order is (s, u, v)\n s, u, v = linalg_ops.svd(mat)\n # sqrt is unstable around 0, just use 0 in such case\n si = array_ops.where(math_ops.less(s, eps), s, math_ops.sqrt(s))\n # Note that the v returned by Tensorflow is v = V\n # (when referencing the equation A = U S V^T)\n # This is unlike Numpy which returns v = V^T\n return math_ops.matmul(\n math_ops.matmul(u, array_ops.diag(si)), v, transpose_b=True)","def calc_matrix(mat_a, mat_d, case):\n nodes, = get_valdict(case, 'nodes')\n for i in range(0, nodes):\n for j in range(0, nodes):\n if i == j and i == 0:\n aW, aE, aP, Su = equation_nodes('left', case)\n mat_a[i, j] = aP\n mat_a[i, j+1] = -aE\n mat_d[i] = Su\n elif i == j and (i > 0 and i < nodes-1):\n aW, aE, aP, Su = equation_nodes('mid', case)\n mat_a[i, j-1] = -aW\n mat_a[i, j] = aP\n mat_a[i, j+1] = -aE\n mat_d[i] = Su\n elif i == j and (i == nodes-1):\n aW, aE, aP, Su = equation_nodes('right', case)\n mat_a[i, j-1] = -aW\n mat_a[i, j] = aP\n mat_d[i] = Su","def relax(self):\n # print(\"putin\", self.level.rhs.reshape(-1)[:])\n # print(\"getout\", self.solver(self.level.rhs.reshape(-1)))\n\n self.level.mid[:] = self.solver(self.level.rhs.reshape(-1)).reshape(self.level.mid.shape)","def get_prox_nuclear(self, x_matrix, scale_factor, prev_u0=None):\n if self.gamma_num_s is None or self.gamma_num_s > 18:\n u, s, vt = np.linalg.svd(x_matrix)\n else:\n tol = scale_factor/10.\n try:\n k = max(1, self.gamma_num_s)\n if prev_u0 is not None:\n u, s, vt = sp.sparse.linalg.svds(x_matrix, v0=prev_u0, k=k, which=\"LM\", tol=tol)\n else:\n u, s, vt = sp.sparse.linalg.svds(x_matrix, k=k, which=\"LM\", tol=tol)\n u = np.matrix(u)\n vt = np.matrix(vt)\n except ValueError as e:\n print \"value error svd\", e\n u, s, vt = np.linalg.svd(x_matrix)\n\n num_nonzero_orig = (np.where(s > scale_factor))[0].size\n thres_s = np.maximum(s - scale_factor, 0)\n nuc_norm = np.linalg.norm(thres_s, ord=1)\n self.gamma_num_s = (np.where(thres_s > 0))[0].size\n\n if s.size > 0:\n prev_u0 = u[:,0]\n else:\n prev_u0 = None\n\n return u * np.diag(thres_s) * vt, nuc_norm, prev_u0","def __init__(self, mat: np.ndarray):\n # Check mat\n try:\n mat = np.asarray(mat)\n except ValueError:\n print(\"Input matrix must be a numpy array.\")\n # Init from super class\n super(LinearOperatorFromMatrix, self).__init__(shape=mat.shape, dtype=mat.dtype)\n\n # Matrix corresponding to the linear operator\n self.mat = mat\n\n # Adjoint\n self.adjoint = mat.conj().transpose()\n\n # Corresponding Gram matrix\n self.gram = self.adjoint @ mat\n\n # Spectral norm, Lipschitz constant\n self.norm = self.lipschitz_cst = np.sqrt(\n spsparse.eigs(self.gram, k=1, which='LM', return_eigenvectors=False, maxiter=int(5e4)))","def implement_svd(data):\n u, s, v = torch.svd(data) # implement svd\n # note: the u returned by this function only includes the top values.\n # u * s will be equivalent due to the zero terms, but will run more efficiently with this implementation.\n s = torch.diag(s) # turn s into a diagonal matrix\n transformed_matrix = torch.mm(u, s) # u * s\n return l21_reg(s), transformed_matrix # return the L2,1 regularization term and matrix","def _symmetric_matrix_division(\n matrix: Union[np.ndarray, scipy.sparse.spmatrix],\n vec: np.ndarray,\n vec_right: Optional[np.ndarray] = None,\n scalar: float = 1.0,\n value_zero_division: Union[str, float] = \"raise\",\n) -> Union[np.ndarray, scipy.sparse.csr_matrix,]:\n\n if matrix.ndim != 2:\n raise ValueError(\"Parameter 'matrix' must be a two dimensional array.\")\n\n if matrix.shape[0] != matrix.shape[1] and vec_right is None:\n raise ValueError(\n \"If 'matrix' is non-square, then 'vec_right' must be provided.\"\n )\n\n vec = vec.astype(float)\n\n if (vec == 0.0).any():\n if value_zero_division == \"raise\":\n raise ZeroDivisionError(\n f\"Encountered zero values in division in {(vec == 0).sum()} points.\"\n )\n else:\n # division results into 'nan' without raising a ZeroDivisionWarning. The\n # nan values will be replaced later\n vec[vec == 0.0] = np.nan\n\n vec_inv_left = np.reciprocal(vec)\n\n if vec_right is None:\n vec_inv_right = vec_inv_left.view()\n else:\n vec_right = vec_right.astype(float)\n if (vec_right == 0.0).any():\n if value_zero_division == \"raise\":\n raise ZeroDivisionError(\n f\"Encountered zero values in division in {(vec == 0).sum()}\"\n )\n else:\n vec_right[vec_right == 0.0] = np.inf\n\n vec_inv_right = np.reciprocal(vec_right.astype(float))\n\n if vec_inv_left.ndim != 1 or vec_inv_left.shape[0] != matrix.shape[0]:\n raise ValueError(\n f\"Invalid input: 'vec.shape={vec.shape}' is not compatible with \"\n f\"'matrix.shape={matrix.shape}'.\"\n )\n\n if vec_inv_right.ndim != 1 or vec_inv_right.shape[0] != matrix.shape[1]:\n raise ValueError(\n f\"Invalid input: 'vec_right.shape={vec_inv_right.shape}' is not compatible \"\n f\"with 'matrix.shape={matrix.shape}'.\"\n )\n\n if scipy.sparse.issparse(matrix):\n left_inv_diag_sparse = scipy.sparse.spdiags(\n vec_inv_left, 0, m=matrix.shape[0], n=matrix.shape[0]\n )\n right_inv_diag_sparse = scipy.sparse.spdiags(\n vec_inv_right, 0, m=matrix.shape[1], n=matrix.shape[1]\n )\n\n # The performance of DIA-sparse matrices is good if the matrix is actually\n # sparse. I.e. the performance drops for a sparse-dense-sparse multiplication.\n\n # The zeros are removed in the matrix multiplication, but because 'matrix' is\n # usually a distance matrix we need to preserve the \"true zeros\"!\n matrix.data[matrix.data == 0] = np.inf\n matrix = left_inv_diag_sparse @ matrix @ right_inv_diag_sparse\n\n matrix.data[np.isinf(matrix.data)] = 0\n\n # this imposes precedence order\n # --> np.inf/np.nan -> np.nan\n # i.e. for cases with 0/0, set 'value_zero_division'\n if isinstance(value_zero_division, (int, float)):\n matrix.data[np.isnan(matrix.data)] = value_zero_division\n\n else:\n # This computes efficiently:\n # np.diag(1/vector_elements) @ matrix @ np.diag(1/vector_elements)\n matrix = diagmat_dot_mat(vec_inv_left, matrix, out=matrix)\n matrix = mat_dot_diagmat(matrix, vec_inv_right, out=matrix)\n\n if isinstance(value_zero_division, (int, float)):\n matrix[np.isnan(matrix)] = value_zero_division\n\n # sparse and dense\n if vec_right is None:\n matrix = remove_numeric_noise_symmetric_matrix(matrix)\n\n if scalar != 1.0:\n scalar = 1.0 / scalar\n matrix = np.multiply(matrix, scalar, out=matrix)\n\n return matrix","def normalize(self):\r\n max = np.amax(self.matrix)\r\n min = np.amin(self.matrix)\r\n\r\n self.matrix = ((self.matrix - min) / (max - min))","def transform(self, mat: TxMatrix) -> None:\n super().transform(mat)\n\n nodes = self.nodes\n for i, pos in enumerate(nodes):\n nodes[i] = mat.sample(*pos)","def lu(matrix):\n SIZE = matrix.shape[0]\n BS = np.BLOCKSIZE\n\n if matrix.shape[0] != matrix.shape[0]:\n raise Exception(\"LU only supports squared matricis\")\n if not matrix.dist():\n raise Exception(\"The matrix is not distributed\")\n\n if(SIZE % np.BLOCKSIZE != 0):\n raise Exception(\"The matrix dimensions must be divisible \"\\\n \"with np.BLOCKSIZE(%d)\"%np.BLOCKSIZE)\n\n (prow,pcol) = matrix.pgrid()\n A = np.zeros((SIZE,SIZE), dtype=matrix.dtype, dist=True);A += matrix\n L = np.zeros((SIZE,SIZE), dtype=matrix.dtype, dist=True)\n U = np.zeros((SIZE,SIZE), dtype=matrix.dtype, dist=True)\n tmpL = np.zeros((SIZE,SIZE), dtype=matrix.dtype, dist=True)\n tmpU = np.zeros((SIZE,SIZE), dtype=matrix.dtype, dist=True)\n for k in xrange(0,SIZE,BS):\n bs = min(BS,SIZE - k) #Current block size\n kb = k / BS # k as block index\n\n #Compute vertical multiplier\n slice = ((kb,kb+1),(kb,kb+1))\n for a,l,u in zip(A.blocks(slice), L.blocks(slice), U.blocks(slice)):\n (p,tl,tu) = linalg.lu(a)\n if not (np.diag(p) == 1).all():#We do not support pivoting\n raise Exception(\"Pivoting was needed!\")\n #There seems to be a transpose bug in SciPy's LU\n l[:] = tl.T\n u[:] = tu.T\n\n #Replicate diagonal block horizontal and vertical\n for tk in xrange(k+bs,SIZE,BS):\n tbs = min(BS,SIZE - tk) #Current block size\n L[tk:tk+tbs,k:k+bs] = U[k:k+tbs,k:k+bs]\n U[k:k+bs,tk:tk+tbs] = L[k:k+bs,k:k+tbs]\n\n if k+bs < SIZE:\n #Compute horizontal multiplier\n slice = ((kb,kb+1),(kb+1,SIZE/BS))\n for a,u in zip(A.blocks(slice), U.blocks(slice)):\n u[:] = np.linalg.solve(u.T,a.T).T\n\n #Compute vertical multiplier\n slice = ((kb+1,SIZE/BS),(kb,kb+1))\n for a,l in zip(A.blocks(slice), L.blocks(slice)):\n l[:] = np.linalg.solve(l,a)\n\n #Apply to remaining submatrix\n A -= pyHPC.summa(L[:,:k+bs],U[:k+bs,:], ao=(k+bs,k),\n bo=(k,k+bs), co=(k+bs,k+bs))\n\n return (L, U)","def from_matrix(cls, matrix, tensorized_row_shape, tensorized_column_shape, rank, factorization='CP', **kwargs):\n try:\n cls = cls._factorizations[factorization.lower()]\n except KeyError:\n raise ValueError(f'Got factorization={factorization} but expected'\n f'one of {cls._factorizations.keys()}')\n return cls.from_matrix(matrix, tensorized_row_shape, tensorized_column_shape, rank, **kwargs)","def tensor_train_matrix(tensor, rank, svd=\"truncated_svd\", verbose=False):\n order = tl.ndim(tensor)\n n_input = order // 2 # (n_output = n_input)\n\n if tl.ndim(tensor) != n_input * 2:\n msg = \"The tensor should have as many dimensions for inputs and outputs, i.e. order should be even \"\n msg += f\"but got a tensor of order tl.ndim(tensor)={order} which is odd.\"\n raise ValueError(msg)\n\n in_shape = tl.shape(tensor)[:n_input]\n out_shape = tl.shape(tensor)[n_input:]\n\n if n_input == 1:\n # A TTM with a single factor is just a matrix...\n return TTMatrix([tensor.reshape(1, in_shape[0], out_shape[0], 1)])\n\n new_idx = list(\n [\n idx\n for tuple_ in zip(range(n_input), range(n_input, 2 * n_input))\n for idx in tuple_\n ]\n )\n new_shape = list([a * b for (a, b) in zip(in_shape, out_shape)])\n tensor = tl.reshape(tl.transpose(tensor, new_idx), new_shape)\n\n factors = tensor_train(tensor, rank, svd=svd, verbose=verbose).factors\n for i in range(len(factors)):\n factors[i] = tl.reshape(\n factors[i], (factors[i].shape[0], in_shape[i], out_shape[i], -1)\n )\n\n return TTMatrix(factors)","def lu_decomposition(self):\n if self.rows_count() != self.columns_count():\n raise ValueError(\"Matrix needs to me square for LU decomposition.\")\n for i in range(self.rows_count() - 1):\n for j in range(i + 1, self.rows_count()):\n if self[i, i] == 0: # or abs(self[i, i]) <= 0.000001):\n raise ValueError(\"Can't divide by 0\")\n self[j, i] = self[j, i] / self[i, i]\n for k in range(i + 1, self.rows_count()):\n self[j, k] -= self[j, i] * self[i, k]","def linear_least_squares(M, v):\n \n B = copy(M)\n [m,n] = shape(B)\n if rank(B) != min(m,n):\n print('Warning: can not be solved since the rank of the matrix is not its maximum value')\n return nan\n else:\n \n A = copy(M)\n At = transpose(M)\n b = copy(v)\n b = transpose(b)\n \n AtA = dot(At, A)\n Atb = transpose(dot(At, b))\n print(AtA, Atb)\n \n x = gauss_elimination(AtA, Atb)\n print('x*:')\n return x","def normalize_distancematrix(self):\n INF = self.distmat.max().max()\n df = self.distmat.fillna(INF)\n self.distmat = (df - df.min()) / (df.max() - df.min())","def set_sudoku_matrix(self, matrix):\n self.sudoku_matrix = matrix","def svd(self):\n U, s, Vh = la.svd(self)\n S = np.zeros(self.shape)\n np.fill_diagonal(S, s)\n return (Matrix(U), Matrix(S), Matrix(Vh))","def normalize(self, row, col):\n if self.symmetric:\n return self.mat[row, col] / sqrt(self.train_normalization[row] * self.train_normalization[col])\n\n else:\n return self.mat[row, col] / sqrt(self.test_normalization[row] * self.train_normalization[col])","def roll_up_matrix(matrix_dict, l_matrix):\n frontier = set([(x, 0) for x in range(l_matrix)])\n while frontier:\n new_frontier = set()\n for x, y in frontier:\n # down\n if is_valid_index(x+1, y, l_matrix):\n updated = update_value(x+1, y, x, y, matrix_dict)\n if updated:\n new_frontier.add((x+1, y))\n # right\n if is_valid_index(x, y+1, l_matrix):\n updated = update_value(x, y+1, x, y, matrix_dict)\n if updated:\n new_frontier.add((x, y+1))\n # up\n if is_valid_index(x-1, y, l_matrix):\n updated = update_value(x-1, y, x, y, matrix_dict)\n if updated:\n new_frontier.add((x-1, y))\n frontier = new_frontier","def one_step(self):\r\n assert (self.uv_vol is not None)\r\n assert (self.guv_vol is not None)\r\n assert (self.uv_bound is not None)\r\n assert (self.vf_vect_bound is not None)\r\n assert (self.vF_vect_vol is not None)\r\n # Shape checks\r\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\r\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\r\n assert (self.vF_vect_vol.shape == self.vf_vect_bound.shape)\r\n assert (self.uv_vol.shape[0] == self.uv_vol.shape[1])\r\n assert (self.uv_vol.shape == self.guv_vol.shape)\r\n assert (self.uv_vol.shape == self.uv_bound.shape)\r\n assert (self.uv_vol.shape[0] == self.vF_vect_vol.shape[0])\r\n \r\n if self.step == 0:\r\n self.check_k_matrix_stability()\r\n # print(\"Epsilon is :\"+str(self.Epsilon))\r\n # print(\"Beta is :\"+str(self.Beta))\r\n\r\n # Form \"Stiffness\" matrix:\r\n K = self.make_k_matrix()\r\n # Form \"Force\" vector: \r\n f = self.vF_vect_vol + (self.Epsilon / self.Beta) * self.vf_vect_bound\r\n\r\n # print(\"FORCE VECTOR:\")\r\n # print(f)\r\n # print(\"STIFFNESS MATRIX\")\r\n # print(K)\r\n # print(\"UV_VOL\")\r\n # print(self.uv_vol)\r\n # print(\"EPSILON * GUV_VOL\")\r\n # print(self.Epsilon * self.guv_vol)\r\n # print(\"UV_BOUND * COEFF\")\r\n # print((self.Epsilon / self.Beta) * self.uv_bound)\r\n sol = scipy_sparse_linsolve(K, f)\r\n # print(\"SOLUTION\")\r\n # print(sol)\r\n return sol"],"string":"[\n \"def find_optimal_low_rank_matrix( self, orig_similarity_matrix, orig_rank, u, s, v, singular_reduction ):\\n '''rank_list = list()\\n sum_singular_values = list()\\n for rank in range( 0, orig_rank ):\\n compute_result = self.compute_low_rank_matrix( u, s, v, rank + 1 )\\n rank_list.append( ( rank + 1 ) / float( orig_rank ) )\\n sum_singular_values.append( compute_result[ 1 ] )\\n utils._plot_singular_values_rank( rank_list, sum_singular_values )'''\\n return self.compute_low_rank_matrix( u, s, v, int( singular_reduction * orig_rank ) )\",\n \"def compute_low_rank_matrix( self, u, s, v, rank ):\\n u_approx = u[ :, :rank ]\\n s_approx = s[ :rank ]\\n sum_taken_percent = np.sum( s_approx ) / float( np.sum( s ) )\\n s_approx = np.diag( np.array( s_approx ) )\\n v_approx = v[ :rank, : ]\\n return [ u_approx.dot( s_approx ).dot( v_approx ), sum_taken_percent ]\",\n \"def _set_u_matirx(self):\\n c_matrix = self.get_c_matrix()\\n u_matrix, d_matrix, _ = np.linalg.svd(c_matrix)\\n self.u_matrix = np.matrix(u_matrix)\",\n \"def read_mat(self, mat):\\n self.N = len(mat)\\n self.mat = mat\\n for i in range(len(mat)):\\n self.mat[i,i] = np.inf\",\n \"def svd_compress_gs(mat, k):\\n U, singular_vals, V = np.linalg.svd(mat)\\n rank = len(singular_vals)\\n print(\\\"Image rank %r\\\" % rank)\\n if k > rank:\\n print(\\\"k is larger than rank of image %r\\\" % rank)\\n return mat\\n # take columns less than k from U\\n U_p = U[:, :k]\\n # take rows less than k from V\\n V_p = V[:k, :]\\n # build the new S matrix with top k diagnal elements\\n S_p = np.zeros((k, k), mat.dtype)\\n for i in range(k):\\n S_p[i][i] = singular_vals[i]\\n print(\\\"U_p shape {0}, S_p shape {1}, V_p shape {2}\\\".format(\\n U_p.shape, S_p.shape, V_p.shape))\\n compressed = np.dot(np.dot(U_p, S_p), V_p)\\n ss = ssim(mat, compressed,\\n dynamic_range=compressed.max() - compressed.min())\\n print(\\\"Strucural similarity: %r\\\" % ss)\\n return U_p, S_p, V_p\",\n \"def svd_compress_gs(mat, k):\\n U, singular_vals, V = np.linalg.svd(mat)\\n rank = len(singular_vals)\\n print(\\\"Image rank %r\\\" % rank)\\n if k > rank:\\n print(\\\"k is larger than rank of image %r\\\" % rank)\\n return mat\\n # take columns less than k from U\\n U_p = U[:, :k]\\n # take rows less than k from V\\n V_p = V[:k, :]\\n # build the new S matrix with top k diagnal elements\\n S_p = np.zeros((k, k), mat.dtype)\\n for i in range(k):\\n S_p[i][i] = singular_vals[i]\\n print(\\\"U_p shape {0}, S_p shape {1}, V_p shape {2}\\\".format(\\n U_p.shape, S_p.shape, V_p.shape))\\n compressed = np.dot(np.dot(U_p, S_p), V_p)\\n ss = ssim(mat, compressed,\\n dynamic_range=compressed.max() - compressed.min())\\n print(\\\"Strucural similarity: %r\\\" % ss)\\n return U_p, S_p, V_p, ss\",\n \"def inverse_head(self, gauss_order = 3, inv_head_mat_file = None):\\n\\n LOG.info(\\\"Computing HeadMat...\\\")\\n head_matrix = om.HeadMat(self.om_head, gauss_order)\\n LOG.info(\\\"head_matrix: %d x %d\\\" % (head_matrix.nlin(), \\n head_matrix.ncol()))\\n\\n LOG.info(\\\"Inverting HeadMat...\\\")\\n hminv = head_matrix.inverse()\\n LOG.info(\\\"inverse head_matrix: %d x %d\\\" % (hminv.nlin(), hminv.ncol()))\\n\\n if inv_head_mat_file is not None:\\n LOG.info(\\\"Saving inverse_head matrix as %s...\\\" % inv_head_mat_file)\\n hminv.save(os.path.join(OM_STORAGE_DIR,\\n inv_head_mat_file + OM_SAVE_SUFFIX)) #~5GB\\n return hminv\",\n \"def svd(matrix, rank=None):\\n if matrix.ndim != 2:\\n raise ValueError('Input should be a two-dimensional array. matrix.ndim is {} != 2'.format(matrix.ndim))\\n dim_1, dim_2 = matrix.shape\\n if dim_1 <= dim_2:\\n min_dim = dim_1\\n else:\\n min_dim = dim_2\\n\\n if rank is None or rank >= min_dim:\\n # Default on standard SVD\\n U, S, V = scipy.linalg.svd(matrix)\\n U, S, V = U[:, :rank], S[:rank], V[:rank, :]\\n return U, S, V\\n\\n else:\\n # We can perform a partial SVD\\n # First choose whether to use X * X.T or X.T *X\\n if dim_1 < dim_2:\\n S, U = scipy.sparse.linalg.eigsh(np.dot(matrix, matrix.T), k=rank, which='LM')\\n S = np.sqrt(S)\\n V = np.dot(matrix.T, U * 1 / S[None, :])\\n else:\\n S, V = scipy.sparse.linalg.eigsh(np.dot(matrix.T, matrix), k=rank, which='LM')\\n S = np.sqrt(S)\\n U = np.dot(matrix, V) * 1 / S[None, :]\\n\\n # WARNING: here, V is still the transpose of what it should be\\n U, S, V = U[:, ::-1], S[::-1], V[:, ::-1]\\n return U, S, V.T\",\n \"def __init__(self, A, rank=0):\\r\\n _u, _s, _v = np.linalg.svd(A, full_matrices=0)\\r\\n \\r\\n self.rank = rank\\r\\n\\r\\n self.U = _u[:,:self.rank].copy()\\r\\n self.S = _s[:self.rank].copy()\\r\\n self.SI = np.matrix(np.diag(self.S)).getI()\\r\\n self.VT = _v[:self.rank,:].copy()\\r\\n \\r\\n self._var = [ e/(_s**2).sum() for e in (_s**2).cumsum() ][self.rank-1]\",\n \"def update_params(self, mat):\\n assert mat.shape == self.shape\\n vec = mat.reshape(mat.size)\\n self.alpha = np.linalg.solve(self.covs_mat.T.dot(self.covs_mat),\\n self.covs_mat.T.dot(vec))\",\n \"def get_singular_values(matrix, n):\\n singular_values = None\\n u, s, v = svd(matrix)\\n ### YOUR CODE HERE\\n pass\\n ### END YOUR CODE\\n return singular_values\",\n \"def _set_ls_matrices(self):\\n zz_t = self.z_matrix * self.z_matrix.transpose()\\n l, s, l_t = np.linalg.svd(zz_t)\\n s[self.p:] = 0\\n self.l_matrix = np.matrix(l)\\n self.s_matirx = np.matrix(np.diag(s))\",\n \"def matrix_svd(\\n self,\\n chis=None,\\n eps=0,\\n print_errors=\\\"deprecated\\\",\\n break_degenerate=False,\\n degeneracy_eps=1e-6,\\n sparse=False,\\n trunc_err_func=None,\\n ):\\n if print_errors != \\\"deprecated\\\":\\n msg = (\\n \\\"The `print_errors` keyword argument has been deprecated, \\\"\\n \\\"and has no effect. Rely instead on getting the error as a \\\"\\n \\\"return value, and print it yourself.\\\"\\n )\\n warnings.warn(msg)\\n chis = self._matrix_decomp_format_chis(chis, eps)\\n maxchi = max(chis)\\n assert self.defval == 0\\n assert self.invar\\n\\n # SVD each sector at a time.\\n # While doing so, also keep track of a list of all singular values, as\\n # well as a heap that gives the negative of the largest singular value\\n # in each sector. These will be needed later when deciding how to\\n # truncate the decomposition.\\n svds = {}\\n dims = {}\\n minus_next_sings = []\\n all_sings = []\\n for k, v in self.sects.items():\\n if 0 in v.shape:\\n shp = v.shape\\n m = min(shp)\\n u = np.empty((shp[0], m), dtype=self.dtype)\\n s = np.empty((m,), dtype=np.float_)\\n v = np.empty((m, shp[1]), dtype=self.dtype)\\n else:\\n if sparse and maxchi < min(v.shape) - 1:\\n u, s, v = spsla.svds(\\n v, k=maxchi, return_singular_vectors=True\\n )\\n order = np.argsort(-s)\\n u = u[:, order]\\n s = s[order]\\n v = v[order, :]\\n else:\\n u, s, v = np.linalg.svd(v, full_matrices=False)\\n svd = (s, u, v)\\n svds[k] = svd\\n dims[k] = 0\\n sings = svd[0]\\n all_sings.append(sings)\\n if 0 not in sings.shape:\\n heapq.heappush(minus_next_sings, (-sings[0], k))\\n try:\\n all_sings = np.concatenate(all_sings)\\n except ValueError:\\n all_sings = np.array((0,))\\n\\n if sparse:\\n norm_sq = self.norm_sq()\\n else:\\n norm_sq = None\\n\\n # Figure out what bond dimension to truncate to, how this bond\\n # dimension is distributed over the different sectors, and what the\\n # truncation error is.\\n chi, dims, rel_err = type(self)._find_trunc_dim(\\n all_sings,\\n svds,\\n minus_next_sings,\\n dims,\\n chis=chis,\\n eps=eps,\\n break_degenerate=break_degenerate,\\n degeneracy_eps=degeneracy_eps,\\n trunc_err_func=trunc_err_func,\\n norm_sq=norm_sq,\\n )\\n\\n # Truncate each block and create the dim for the new index.\\n new_dim = []\\n new_qim = []\\n svds = {k: v for k, v in svds.items() if dims[k] > 0}\\n for k, v in svds.items():\\n d = dims[k]\\n if d > 0:\\n new_dim.append(d)\\n new_qim.append(k[0])\\n svds[k] = (v[0][:d], v[1][:, :d], v[2][:d, :])\\n else:\\n del svds[k]\\n\\n # Initialize U, S, V.\\n d = self.dirs[0]\\n U = type(self)(\\n [self.shape[0], new_dim],\\n qhape=[self.qhape[0], new_qim],\\n dirs=[d, -d],\\n qodulus=self.qodulus,\\n dtype=self.dtype,\\n charge=0,\\n )\\n S = type(self)(\\n [new_dim],\\n qhape=[new_qim],\\n dirs=[d],\\n qodulus=self.qodulus,\\n dtype=np.float_,\\n invar=False,\\n charge=0,\\n )\\n V = type(self)(\\n [new_dim, self.shape[1]],\\n qhape=[new_qim, self.qhape[1]],\\n dirs=[d, self.dirs[1]],\\n qodulus=self.qodulus,\\n dtype=self.dtype,\\n charge=self.charge,\\n )\\n\\n # Set the blocks of U, S and V.\\n for k, v in svds.items():\\n k_U = (k[0], k[0])\\n S[(k[0],)] = v[0]\\n U[k_U] = v[1]\\n V[k] = v[2]\\n\\n return U, S, V, rel_err\",\n \"def get_singular_values(matrix, n):\\n singular_values = None\\n u, s, v = svd(matrix)\\n ### YOUR CODE HERE\\n singular_values=s[0:n]\\n ### END YOUR CODE\\n return singular_values\",\n \"def update_model(X, U, S, k, n, mu,\\n svdmethod='full',\\n missingmethod='zero'):\\n\\n if len(X) == 0:\\n printt(\\\"Error: No data in X.\\\")\\n return None, None, None, -1, None\\n #print('%d items in X' % X.shape[1])\\n #print('init U:', U)\\n\\n # If there is no previous U, and we just got a single item in X,\\n # set U to all 0's (degenerate SVD),\\n # and return it with mu.\\n # (PR #22 sets first value to 1; see decals implementation)\\n if len(U) == 0 and X.shape[1] == 1:\\n mu = X\\n # Do this no matter what. Let mu get NaNs in it as needed.\\n U = np.zeros_like(mu)\\n U[0] = 1\\n S = np.array([0])\\n n = 1\\n pcts = [1.0]\\n return U, S, mu, n, pcts\\n\\n ###########################################################################\\n # Do full SVD of X if this is requested, regardless of what is in U \\n # Also, if n = 0 or U is empty, start from scratch\\n output_k = False\\n if svdmethod == 'full' or len(U) == 0 or n == 0:\\n if n == 0:\\n if len(U) == 0:\\n printt(\\\"----- initial SVD -----\\\")\\n output_k = True\\n else:\\n # Reshape so we don't have an empty dimension (yay python)\\n U = U.reshape(-1, 1)\\n elif len(U) == 0:\\n printt(\\\"WARNING: N (number of items modeled by U) is %d, not zero, but U is empty!\\\" % n)\\n\\n # Bootstrap\\n if missingmethod == 'ignore':\\n printt(\\\"ERROR: ignore with full is not possible under ordinary circumstances.\\\")\\n printt(\\\"Use --increm-brand to impute for NaNs.\\\")\\n printt(\\\"For now, we are filling NaNs with 0.\\\")\\n X = copy.deepcopy(X)\\n z = np.where(np.isnan(X))\\n X[z] = 0\\n\\n mu = np.mean(X, axis=1).reshape(-1,1)\\n X = X - mu\\n U, S, V = linalg.svd(X, full_matrices=False)\\n printt('Just did full SVD on %d items.' % X.shape[1])\\n #print('X:', X)\\n #print('U:', U)\\n # Reset U to all 0's if we only have one item in X (degenerate SVD)\\n if X.shape[1] == 1:\\n U = np.zeros_like(U)\\n \\n # Keep only the first k components\\n S_full = S\\n S = S[0:k]\\n U = U[:,0:k]\\n\\n # Update n to number of new items in X\\n n = X.shape[1]\\n \\n ###########################################################################\\n # Incremental SVD from Ross\\n elif svdmethod == 'increm-ross':\\n # Incremental SVD from Ross et al. 2008\\n # \\\"Incremental Learning for Robust Visual Tracking\\\"\\n # based on Lim and Ross's sklm.m implementation in MATLAB.\\n\\n # This method DOES NOT handle missing values.\\n if missingmethod == 'ignore':\\n print('ERROR: increm-ross cannot handle missing values.')\\n print('If they are present, try svdmethod=increm-brand')\\n print(' or use missingmethod=zero to zero-fill.')\\n print('If there are no missing values, specify missingmethod=none.')\\n sys.exit(1)\\n\\n n_new = X.shape[1]\\n \\n # Compute mean\\n # Weirdly, the later 'X-mu_new' is MUCH faster if you reshape as shown.\\n # This is because of differences in the way numpy treats a 1d array versus a 2d column.\\n mu_new = np.mean(X, axis=1).reshape(-1,1)\\n\\n # Subtract the mean, append it as a column vector, and update mu\\n # X - mu_new will be zero if X has only 1 item\\n mu_old = mu\\n # New mu is a weighted sum of old and new mus\\n mu = (n * mu_old + n_new * mu_new) / (n + n_new)\\n B = np.hstack((X - mu,\\n math.sqrt(n_new * n/float(n_new+n)) * \\\\\\n (mu_old - mu_new)))\\n printt(\\\"Now tracking mean for %d -> %d items; mu.min %f, mu.max %f \\\" % \\\\\\n (n, n+n_new, np.nanmin(mu), np.nanmax(mu)))\\n n = n + n_new\\n\\n if S.all() == 0:\\n npcs = U.shape[1]\\n diagS = np.zeros((npcs, npcs))\\n else:\\n diagS = np.diag(S)\\n\\n # I don't think this is right. At this point B is the augmented\\n # matrix rather than the single observation.\\n proj = np.dot(U.T, B)\\n reproj_err = B - np.dot(U, proj)\\n\\n # to get orthogonal form of reproj_err\\n # This should return q with dimensions [d(X) by n_new+1], square\\n q, dummy = linalg.qr(reproj_err, mode='full')\\n # print('q.shape should be 7x2: ', q.shape)\\n Q = np.hstack((U, q))\\n\\n # From Ross and Lim, 2008\\n # R = [ [ Sigma, U.T * X ] [ 0, orthog. component of reproj error ] ]\\n k_now = diagS.shape[0]\\n new_dim = k_now + n_new + 1\\n R = np.zeros((new_dim, new_dim))\\n R[0:k_now,0:k_now] = diagS\\n R[0:k_now,k_now:] = proj\\n orthog_reproj_err = np.dot(q.T, reproj_err)\\n R[k_now:, k_now:] = orthog_reproj_err\\n \\n # Perform SVD of R. Then finally update U.\\n U, S, V = linalg.svd(R, full_matrices=False)\\n printt('Just did increm-ross SVD on %d items.' % n)\\n\\n U = np.dot(Q, U)\\n \\n # Keep only the first k components\\n U = U[:,0:min([n,k])]\\n S_full = S\\n S = S[0:min([n,k])]\\n\\n ###########################################################################\\n # Incremental SVD from Brand\\n elif svdmethod == 'increm-brand':\\n # Pulled out James's attempt to handle NaNs into\\n # increm-brand-james.py. Starting over from scratch here.\\n n_new = X.shape[1]\\n\\n if n_new != 1:\\n print(\\\"WARNING: increm-brand will probably only work by adding one item at a time.\\\")\\n input('\\\\nPress enter to continue or ^C/EOF to exit. ')\\n\\n if missingmethod == 'ignore':\\n # 1. Update mu\\n mu_old = mu\\n mu_new = X\\n\\n # Be careful! For any pre-existing NaNs in mu,\\n # let mu_new fill them in. Can't get any worse!\\n naninds = np.where(np.isnan(mu_old))[0]\\n if naninds.size > 0:\\n mu_old[naninds,0] = mu_new[naninds,0]\\n # And likewise for mu_new -- fill with good values from mu_old.\\n naninds = np.where(np.isnan(mu_new))[0]\\n if naninds.size > 0:\\n mu_new[naninds,0] = mu_old[naninds,0]\\n # At this point, the only NaNs that should appear are\\n # values that were NaN for both mu and X to start with.\\n # They will stay NaN and that's okay.\\n \\n # New mu is a weighted sum of old and new mus\\n mu = (n * mu_old + n_new * mu_new) / (n + n_new)\\n printt(\\\"Now tracking mean for %d -> %d items; mu.min %f, mu.max %f \\\" % \\\\\\n (n, n+n_new, np.nanmin(mu), np.nanmax(mu)))\\n n = n + n_new\\n\\n # 2. Subtract off the mean\\n X = X - mu\\n\\n # 3. Compute L, the projection of X onto U\\n # Note: this will only work for a single item in X\\n goodinds = np.where(~np.isnan(X))[0]\\n #print('X: %d of %d are good.' % (len(goodinds), X.shape[0]))\\n\\n diagS = np.diag(S)\\n # This is Brand's method, which involves S:\\n L = np.dot(diagS,\\n np.dot(np.linalg.pinv(np.dot(U[goodinds,:],\\n diagS)),\\n X[goodinds,:]))\\n # Simplified version that does not use S (but is probably wrong):\\n #L = np.dot(U[goodinds,:].T,\\n # X[goodinds,:])\\n # Top row of the Q matrix (eqn 12, Brand 2002)\\n Q1 = np.hstack([diagS, L])\\n\\n # 4. Compute J, the orthogonal basis of H, which is\\n # the component of X orthog to U (i.e., unrepresentable direction)\\n # 5. Compute K, the projection of X onto J (i.e., unrep. content)\\n K = linalg.norm(X[goodinds,:] - np.dot(U[goodinds,:],\\n np.dot(U[goodinds,:].T,\\n X[goodinds,:])))\\n # H = X - UL\\n J = np.zeros((U.shape[0], 1))\\n J[goodinds] = np.dot(K,\\n np.linalg.pinv(X[goodinds,:] -\\n np.dot(U[goodinds,:],\\n L))).T\\n \\n # Bottom row of Q matrix (eqn 12, Brand 2002)\\n Q2 = np.hstack([np.zeros([1, len(S)]), np.array(K).reshape(1,1)])\\n Q = np.vstack([Q1, Q2])\\n\\n # 6. Take the SVD of Q\\n Uq, Sq, Vq = linalg.svd(Q, full_matrices=False)\\n\\n # 7. Update U and S (eqn 4, Brand 2002)\\n # Note: Since J is zero-filled for badinds, now U is too.\\n # Alternatively, we give J NaNs and let them get into U as well.\\n # I think that is a worse idea though.\\n U = np.dot(np.hstack([U, J]), Uq)\\n S = Sq\\n # Updating V requires knowing old V,\\n # but we don't need the new one either so it's okay to skip.\\n\\n printt('Just did increm-brand SVD on %d items.' % n)\\n \\n ############# end ###########\\n \\n else: # No missing values (or not 'ignore')\\n # 1. Update mu\\n mu_old = mu\\n mu_new = X\\n # New mu is a weighted sum of old and new mus\\n mu = (n * mu_old + n_new * mu_new) / (n + n_new)\\n n = n + n_new\\n\\n # 2. Subtract off the mean\\n X = X - mu\\n\\n # 3. Compute L, the projection of X onto U\\n L = np.dot(U.T, X)\\n Q1 = np.hstack([np.diag(S), L])\\n\\n # 4. Compute J, the orthogonal basis of H, which is\\n # the component of X orthog to U (i.e., unrepresentable direction)\\n # 5. Compute K, the projection of X onto J (i.e., unrep. content)\\n JK = X - np.dot(U, L)\\n (J, K) = linalg.qr(JK)\\n\\n Q2 = np.hstack([np.zeros([1, len(S)]), np.array(K).reshape(1,1)])\\n Q = np.vstack([Q1, Q2])\\n\\n # 6. Take the SVD of Q\\n Uq, Sq, Vq = linalg.svd(Q, full_matrices=False)\\n\\n # 7. Update U and S (eqn 4, Brand 2002)\\n U = np.dot(np.hstack([U, J]), Uq)\\n S = Sq\\n # V requires knowing old V,\\n # but we don't need the new one either so it's okay.\\n \\n printt('Just did regular increm SVD on %d items.' % n)\\n\\n # Keep only the first k components\\n U = U[:,0:min([n,k])]\\n S = S[0:min([n,k])]\\n\\n Usum = U.sum(1)\\n\\n\\n ###########################################################################\\n # We have a bad svdmethod, but somehow didn't catch it earlier.\\n else:\\n printt(\\\"504: Bad Gateway in protocol <Skynet_authentication.exe>\\\")\\n return None, None, None, None, None\\n\\n indivpcts = None\\n\\n # This only works if a full SVD was done\\n if (svdmethod == 'full' and output_k and opts['k_var'] == -773038.0):\\n # Calculate percent variance captured by each \\n cumsum = np.cumsum(S_full)\\n #print(cumsum.shape)\\n if cumsum[-1] != 0:\\n indivpcts = S / cumsum[-1]\\n indivpcts = indivpcts[0:k] # truncate to first k\\n cumpercents = cumsum / cumsum[-1]\\n else:\\n indivpcts = []\\n\\n # Calculate percent variance captured\\n if k >= cumsum.shape[0]:\\n printt('Cannot estimate data variance; specified k (%d) exceeds the number of SVs (%d).' % (k, cumsum.shape[0]))\\n else:\\n printt(\\\"Selected value of k=%d captures %5.2f%% of the data variance\\\" % \\\\\\n (k, cumpercents[k-1] * 100))\\n if opts['pause']: input(\\\"Press enter to continue\\\\n\\\")\\n\\n #print('U:', U)\\n #print('mu:', mu)\\n return U, S, mu, n, indivpcts\",\n \"def normalize_mat(mat):\\n # Gather matrix columns indices.\\n gather_split_i = 0\\n gather_avg_5_i = 1\\n gather_avg_25_i = 2\\n gather_avg_50_i = 3\\n gather_volume_i = 4\\n gather_dates_indicator_i = 5\\n # Normalize prices. We want to keep relationship between prices\\n # (eg. avg_5 > split) untouched, so we use single set of max and mean for\\n # split and all averages.\\n prices_indices = [\\n gather_split_i, gather_avg_5_i, gather_avg_25_i, gather_avg_50_i\\n ]\\n mat[:, prices_indices] /= np.max(mat[:, prices_indices])\\n mat[:, prices_indices] *= 2\\n mat[:, prices_indices] -= np.mean(mat[:, prices_indices])\\n # Normalize volume.\\n mat[:, gather_volume_i] /= np.max(mat[:, gather_volume_i])\\n mat[:, gather_volume_i] *= 2\\n mat[:, gather_volume_i] -= np.mean(mat[:, gather_volume_i])\\n # Subtract 1.0 from dates indicator multiplied by 2.0 as it is already in\\n # range 0.0, 1.0 and we don't want characteristic values to vary between\\n # matrices as it is data outside of one company scope.\\n dates_indicator_mean = 1.0\\n mat[:, gather_dates_indicator_i] *= 2\\n mat[:, gather_dates_indicator_i] -= dates_indicator_mean\\n return mat\",\n \"def svd(matrix):\\n u = None\\n s = None\\n v = None\\n ### YOUR CODE HERE\\n (u,s,v)=np.linalg.svd(matrix)\\n ### END YOUR CODE\\n\\n return u, s, v\",\n \"def svd(matrix, approach):\\n\\n # Getting the eigenvalues and vectors of transpose(A) * A for V and Sigma\\n a = mat_multiply(transpose(matrix), matrix)\\n if approach == \\\"qr\\\":\\n V, sigma, iterations = qr_eig(a)\\n else:\\n V, sigma, iterations = eig(a)\\n\\n # Sorting singular values and the colums of V accordingly\\n V = transpose(V)\\n\\n singular_values = list()\\n sorted_V = list()\\n\\n r = 0\\n for i in range(rows(sigma)):\\n singular_values.append([(sigma[i][i]), i])\\n if sigma[i][i] > math.exp(-8):\\n r += 1\\n\\n singular_values.sort(key=first_item, reverse=True)\\n\\n sigma_r = eye(r)\\n sigma_r_inv = eye(r)\\n\\n # Constructing the sorted U and sigma matrices\\n i, j = 0, 0\\n for value in singular_values:\\n if value[0] > math.exp(-8):\\n sorted_V.append(V[value[1]])\\n sigma_r[j][j] = value[0] ** (1 / 2)\\n sigma_r_inv[j][j] = 1 / (value[0] ** (1 / 2))\\n j += 1\\n i += 1\\n\\n # Constructing U by multiplying V and sigma inverse\\n sorted_U = mat_multiply(mat_multiply(matrix, transpose(sorted_V)), sigma_r_inv)\\n\\n return (sorted_U, sigma_r, sorted_V, r, iterations)\",\n \"def normalize(self,matrix):\\n for i in range(self.N):\\n matrix[self.N-1][i] = 0\\n for i in range(self.n):\\n matrix[self.N - 1][self.index(i,i)] = 1\\n return matrix\",\n \"def _compute_s_matrix(self, system_std_dev: tf.Tensor) -> None:\\n self.s_matrix_inv = self._kronecker_product(\\n tf.diag(tf.reshape(tf.ones_like(system_std_dev, dtype=tf.float64)\\n / system_std_dev, [-1])),\\n tf.eye(self.n_points_int, dtype=tf.float64))\\n return\",\n \"def rebuild_svd(self, U, S, V, k): # [5pts]\\n \\n N,D = U.shape[0],V.shape[0]\\n \\n \\n if U.ndim == 3:\\n Xrebuild = np.zeros((N,D,3))\\n for i in range(3):\\n U_temp = U[:,0:k,i]\\n S_temp = S[:,i]\\n S_temp = np.diag(S_temp[0:k])\\n V_temp = V[0:k,:,i]\\n Xrebuild_temp = U_temp@S_temp@V_temp\\n Xrebuild[:,:,i] = Xrebuild_temp\\n else:\\n U_new = U[:,0:k]\\n S_new = np.diag(S[0:k])\\n V_new = V[0:k,:]\\n Xrebuild = U_new@S_new@V_new\\n\\n return Xrebuild\",\n \"def incremental_svd(A, qr_flg=False):\\n\\n m = 256\\n n = 7291\\n\\n n0 = 256\\n\\n if A.shape[0] != m or A.shape[1] != n: raise ValueError('Error: incorrect matrix size')\\n\\n start = time.clock()\\n\\n A0 = A[:, :n0]\\n U, s, V = ln.svd(A0, full_matrices=False)\\n\\n # NOTE: s is a vector; np.diag(s) will produce a diagonal matrix\\n for i in range(n0, n):\\n\\n # new matrix is just a single vector (i-th column of A)\\n A1 = np.matrix(A[:, i]).T\\n\\n if qr_flg:\\n J, K = ln.qr(A1 - np.dot(np.dot(U, U.T), A1))\\n U_, s_, V_ = ln.svd(\\n np.vstack((\\n np.hstack((np.diag(s), np.dot(U.T, A1))),\\n np.hstack((np.zeros((K.shape[0], s.shape[0])), K))\\n )),\\n full_matrices=False)\\n\\n # update the result of SVD\\n U = np.dot(np.hstack((U, J)), U_)\\n\\n else:\\n U_, s_, V_ = ln.svd(np.hstack((np.diag(s), np.dot(U.T, A1))), full_matrices=False)\\n U = np.dot(U, U_)\\n\\n s = s_\\n\\n # NOTE: V from svd on NumPy is already transposed\\n V = np.dot(V_,\\n np.vstack((\\n np.hstack((V, np.zeros((V.shape[0], i+1-V.shape[1])))),\\n np.hstack((np.zeros((V_.shape[1]-V.shape[0], V.shape[1])), np.eye(V_.shape[1]-V.shape[0], i+1-V.shape[1])))\\n ))\\n )\\n\\n # for next computation, update A0\\n A0 = np.hstack((A0, A1))\\n\\n elapsed_time = time.clock() - start\\n print 'time:', elapsed_time\\n\\n return U, s, V\",\n \"def _normal_matvec(matvec, x):\\n matvec_x, vjp = jax.vjp(matvec, x)\\n return vjp(matvec_x)[0]\",\n \"def InverseMatrix(matrix,vector):\\r\\n # Unveri reversible matrix\\r\\n if Determinant(matrix, 1) == 0:\\r\\n print(\\\"Error,Singular Matrix\\\\n\\\")\\r\\n return\\r\\n # result matrix initialized as singularity matrix\\r\\n result = MakeIMatrix(len(matrix), len(matrix))\\r\\n # loop for each row\\r\\n for i in range(len(matrix[0])):\\r\\n # turn the pivot into 1 (make elementary matrix and multiply with the result matrix )\\r\\n # pivoting process\\r\\n matrix, vector = RowXchange(matrix, vector)\\r\\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\\r\\n elementary[i][i] = 1/matrix[i][i]\\r\\n result = MultiplyMatrix(elementary, result)\\r\\n matrix = MultiplyMatrix(elementary, matrix)\\r\\n # make elementary loop to iterate for each row and subtracrt the number below (specific) pivot to zero (make\\r\\n # elementary matrix and multiply with the result matrix )\\r\\n for j in range(i+1, len(matrix)):\\r\\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\\r\\n elementary[j][i] = -(matrix[j][i])\\r\\n matrix = MultiplyMatrix(elementary, matrix)\\r\\n result = MultiplyMatrix(elementary, result)\\r\\n\\r\\n\\r\\n # after finishing with the lower part of the matrix subtract the numbers above the pivot with elementary for loop\\r\\n # (make elementary matrix and multiply with the result matrix )\\r\\n for i in range(len(matrix[0])-1, 0, -1):\\r\\n for j in range(i-1, -1, -1):\\r\\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\\r\\n elementary[j][i] = -(matrix[j][i])\\r\\n matrix = MultiplyMatrix(elementary, matrix)\\r\\n result = MultiplyMatrix(elementary, result)\\r\\n\\r\\n return result\",\n \"def smith_nf(matrix):\\n\\n A=np.copy(matrix)\\n if (np.around(A) != A).any():\\n raise Exception('This function requires integer input.')\\n\\n # This looks much like an SVD algorithm that first bidiagonalizes\\n # A by Givens rotations and then chases zeros, except for\\n # the construction of the 2 by 2 elementary transformation.\\n\\n m, n = A.shape\\n\\n S = A\\n U = np.eye(m)\\n V = np.eye(n)\\n\\n # Bidiagonalize S with elementary Hermite transforms.\\n for j in range(min(m, n)):\\n # Zero column j below the diagonal.\\n for i in range(j+1, m):\\n if S[i, j]:\\n # Construct an elementary Hermite transformation E\\n # to zero S(i,j) by combining rows i and j.\\n E = ehermite(S[j, j], S[i, j])\\n # Apply the transform to S and U.\\n S[[j, i], :] = np.dot(E, S[[j, i], :])\\n # U[:, [j, i]] = U[:, [j, i]] / E\\n U[:, [j, i]] = left_matrix_division(U[:, [j, i]], E) # solving the left matrix division\\n\\n # % Zero row j after the superdiagonal.\\n for i in range(j+2, n):\\n if S[j, i]:\\n # Construct an elementary Hermite transformation E\\n # to zero S(j,i) by combining columns j+1 and i.\\n E = ehermite(S[j, j+1], S[j, i])\\n # Apply the transform to S and V.\\n S[:, [j+1, i]] = np.dot(S[:, [j+1, i]], E.T)\\n # V[:, [j+1, i]] = V[:, [j+1, i]] / E\\n V[:, [j+1, i]] = left_matrix_division(V[:, [j+1, i]], E) # solving the left matrix division\\n\\n # Now S is upper bidiagonal.\\n # Chase the superdiagonal nonzeros away.\\n\\n D = np.diag(S, 1)\\n while any(D):\\n b = min(np.where(D))[0]\\n # Start chasing bulge at first nonzero superdiagonal element.\\n # To guarantee reduction in S(b,b), first make S(b,b) positive\\n # and make S(b,b+1) nonnegative and less than S(b,b).\\n if S[b, b] < 0:\\n S[b, :] = -S[b, :]\\n U[:, b] = -U[:, b]\\n\\n q = np.floor(S[b, b+1] / S[b, b])\\n E = np.array([[1, 0], [-q, 1]])\\n S[:, [b, b+1]] = np.dot(S[:, [b, b+1]], E.T)\\n # V[:, [b, b+1]] = V[:, [b, b+1]] / E\\n V[:, [b, b+1]] = left_matrix_division(V[:, [b, b+1]], E) # solving the left matrix division\\n\\n if S[b, b+1]:\\n # Zero the first nonzero superdiagonal element\\n # using columns b and b+1, to start the bulge at S(b+1,b).\\n E = ehermite(S[b, b], S[b, b+1])\\n S[:, [b, b+1]] = np.dot(S[:, [b, b+1]], E.T)\\n # V[:, [b, b+1]] = V[:, [b, b+1]] / E\\n V[:, [b, b+1]] = left_matrix_division(V[:, [b, b+1]], E)\\n\\n for j in range(min(m, n)):\\n if j+1 < m:\\n # Zero S(j+1,j) using rows j and j+1.\\n E = ehermite(S[j, j], S[j+1, j])\\n S[[j, j+1], :] = np.dot(E, S[[j, j+1], :])\\n # U[:, [j, j+1]] = U[:, [j, j+1]] / E\\n U[:, [j, j+1]] = left_matrix_division(U[:, [j, j+1]], E)\\n if j+2 < n:\\n # Zero S(j,j+2) using columns j+1 and j+2.\\n E = ehermite(S[j, j+1], S[j, j+2])\\n S[:, [j+1, j+2]] = np.dot(S[:, [j+1, j+2]], E.T)\\n # V[:, [j+1, j+2]] = V[:, [j+1, j+2]] / E\\n V[:, [j+1, j+2]] = left_matrix_division(V[:, [j+1, j+2]], E)\\n D = np.diag(S, 1)\\n\\n # Now S is diagonal. Make it nonnegative.\\n\\n for j in range(min(m, n)):\\n if S[j, j] < 0:\\n S[j, :] = -S[j, :]\\n U[:, j] = -U[:, j]\\n\\n # Squeeze factors to lower right to enforce divisibility condition.\\n\\n for i in range(min(m, n)):\\n for j in range(i+1, min(m, n)):\\n # Replace S(i,i), S(j,j) by their gcd and lcm respectively.\\n a = S[i, i]\\n b = S[j, j]\\n [c, d, g] = extgcd(a, b)\\n E = np.array([[1, d], [-b/g, a*c/g]])\\n F = np.array([[c, 1], [-b*d/g, a/g]])\\n S[np.ix_([i, j], [i, j])] = np.dot(np.dot(E, S[:, [i, j]][[i, j], :]), F.T)\\n # S[i, i] = tmp_arr[0, 0]\\n # S[i, j] = tmp_arr[0, 1]\\n # S[j, i] = tmp_arr[1, 0]\\n # S[j, j] = tmp_arr[1, 1]\\n U[:, [i, j]] = left_matrix_division(U[:, [i, j]], E)\\n V[:, [i, j]] = left_matrix_division(V[:, [i, j]], F)\\n\\n U = np.around(U)\\n V = np.around(V)\\n return U, S, V\",\n \"def matrix_inv(mat):\\n\\ta = mat[0,0]\\n\\tb = mat[0,1]\\n\\tc = mat[0,2]\\n\\td = mat[1,0]\\n\\te = mat[1,1]\\n\\tf = mat[1,2]\\n\\tg = mat[2,0]\\n\\th = mat[2,1]\\n\\ti = mat[2,2]\\n\\n\\tdet = b*f*g + c*d*h + a*e*i - a*f*h - b*d*i - c*e*g\\n\\n\\tinvmat = np.zeros((3,3))\\n\\tinvmat[0,0] = (e*i - f*h) / det\\n\\tinvmat[0,1] = (c*h - b*i) / det\\n\\tinvmat[0,2] = (b*f - c*e) / det\\n\\tinvmat[1,0] = (f*g - d*i) / det\\n\\tinvmat[1,1] = (a*i - c*g) / det\\n\\tinvmat[1,2] = (c*d - a*f) / det\\n\\tinvmat[2,0] = (d*h - e*g) / det\\n\\tinvmat[2,1] = (b*g - a*h) / det\\n\\tinvmat[2,2] = (a*e - b*d) / det\\n\\treturn invmat\",\n \"def populate_from_qrev_mat(self, mat_data):\\n\\n # Variables passed to the constructor\\n\\n if type(mat_data.frequency_hz) is np.ndarray:\\n self.frequency_khz = mat_data.frequency_hz\\n elif np.isnan(mat_data.frequency_hz):\\n self.frequency_khz = None\\n else:\\n self.frequency_khz = mat_data.frequency_hz\\n self.orig_coord_sys = mat_data.origCoordSys\\n self.nav_ref = mat_data.navRef\\n\\n # Data requiring manipulation if only 1 ensemble\\n if type(mat_data.u_mps) is float:\\n self.raw_vel_mps = mat_data.rawVel_mps.reshape(mat_data.rawVel_mps.shape[0], 1)\\n # Coordinate transformed data\\n self.coord_sys = np.array([mat_data.coordSys])\\n self.u_mps = np.array([mat_data.u_mps])\\n self.v_mps = np.array([mat_data.v_mps])\\n self.w_mps = np.array([mat_data.w_mps])\\n self.d_mps = np.array([mat_data.d_mps])\\n\\n self.bottom_mode = np.array([mat_data.bottomMode])\\n\\n # Processed data\\n self.u_processed_mps = np.array([mat_data.uProcessed_mps])\\n self.v_processed_mps = np.array([mat_data.vProcessed_mps])\\n self.processed_source = np.array([mat_data.processedSource])\\n self.valid_data = np.array([ mat_data.validData]).astype(bool)\\n self.valid_data = self.valid_data.reshape(-1, 1)\\n self.smooth_speed = np.array([mat_data.smoothSpeed])\\n self.smooth_upper_limit = np.array([mat_data.smoothUpperLimit])\\n self.smooth_lower_limit = np.array([mat_data.smoothLowerLimit])\\n else:\\n self.raw_vel_mps = mat_data.rawVel_mps\\n # Coordinate transformed data\\n self.coord_sys = mat_data.coordSys\\n self.u_mps = mat_data.u_mps\\n self.v_mps = mat_data.v_mps\\n self.w_mps = mat_data.w_mps\\n self.d_mps = mat_data.d_mps\\n\\n self.bottom_mode = mat_data.bottomMode\\n\\n # Processed data\\n self.u_processed_mps = mat_data.uProcessed_mps\\n self.v_processed_mps = mat_data.vProcessed_mps\\n self.processed_source = mat_data.processedSource\\n self.valid_data = mat_data.validData.astype(bool)\\n self.smooth_speed = mat_data.smoothSpeed\\n self.smooth_upper_limit = mat_data.smoothUpperLimit\\n self.smooth_lower_limit = mat_data.smoothLowerLimit\\n\\n self.num_invalid = mat_data.numInvalid\\n # Error velocity filter\\n if type(mat_data.dFilter) is np.ndarray:\\n self.d_filter = None\\n else:\\n self.d_filter = mat_data.dFilter\\n\\n # Error velocity threshold\\n if type(mat_data.dFilterThreshold) is np.ndarray:\\n self.d_filter_threshold = None\\n else:\\n self.d_filter_threshold = mat_data.dFilterThreshold\\n\\n # Vertical velocity filter\\n if type(mat_data.wFilter) is np.ndarray:\\n self.w_filter = None\\n else:\\n self.w_filter = mat_data.wFilter\\n\\n # Vertical velocity threshold\\n if type(mat_data.wFilterThreshold) is np.ndarray:\\n self.w_filter_threshold = None\\n else:\\n self.w_filter_threshold = mat_data.wFilterThreshold\\n\\n # GPS quality filter\\n if type(mat_data.gpsDiffQualFilter) is np.ndarray:\\n self.gps_diff_qual_filter = None\\n else:\\n self.gps_diff_qual_filter = mat_data.gpsDiffQualFilter\\n\\n # GPS altitude filter\\n if type(mat_data.gpsAltitudeFilter) is np.ndarray:\\n self.gps_altitude_filter = None\\n else:\\n self.gps_altitude_filter = mat_data.gpsAltitudeFilter\\n\\n # GPS altitude threshold\\n if type(mat_data.gpsAltitudeFilterChange) is np.ndarray:\\n self.gps_altitude_filter_change = None\\n else:\\n self.gps_altitude_filter_change = mat_data.gpsAltitudeFilterChange\\n\\n # HDOP filter\\n if type(mat_data.gpsHDOPFilter) is np.ndarray:\\n self.gps_HDOP_filter = None\\n else:\\n self.gps_HDOP_filter = mat_data.gpsHDOPFilter\\n\\n # HDOP max threshold\\n if type(mat_data.gpsHDOPFilterMax) is np.ndarray:\\n self.gps_HDOP_filter_max = None\\n else:\\n self.gps_HDOP_filter_max = mat_data.gpsHDOPFilterMax\\n\\n # HDOP change threshold\\n if type(mat_data.gpsHDOPFilterChange) is np.ndarray:\\n self.gps_HDOP_filter_change = None\\n else:\\n self.gps_HDOP_filter_change = mat_data.gpsHDOPFilterChange\\n\\n # Other filters\\n self.smooth_filter = mat_data.smoothFilter\\n self.interpolate = mat_data.interpolate\\n self.beam_filter = mat_data.beamFilter\",\n \"def normalize_matrix(mat):\\n return (mat + abs(mat.min())) / (mat.max() - mat.min())\",\n \"def StandardizeMatrix(mat):\\n nObjs = len(mat)\\n avgs = sum(mat,0)/float(nObjs)\\n mat -= avgs\\n devs =sqrt(sum(mat*mat,0)/(float(nObjs-1)))\\n try:\\n newMat = mat/devs\\n except OverflowError:\\n newMat = numpy.zeros(mat.shape,'d')\\n for i in range(mat.shape[1]):\\n if devs[i] != 0.0:\\n newMat[:,i] = mat[:,i]/devs[i]\\n return newMat\",\n \"def fit_svd(self):\\n\\n # U has the eigenvectors of G.Gt as columns ()\\n # S has square roots of the eigenvalues of G.Gt and Gt.G in its diagonal\\n # The square roos of the eigenvalues are called singular values\\n # V has the eigenvectors of Gt.G as columns ()\\n # full_matrices set to false will set the Vt matrix to a shape m x n\\n\\n U, S, Vt = linalg.svd(self.norm_matrix, full_matrices=False)\\n\\n # Compute the eigenvalues\\n eig_val = (S ** 2)\\n\\n # Explained_variance tell us how much of the variance in the data each eigen value explains\\n explained_variance = eig_val / (self.n_samples - 1)\\n # total_var is the total variance in the data\\n total_var = explained_variance.sum()\\n explained_variance_ratio = explained_variance / total_var\\n # The cumulative sum of all ratios\\n ratio_cumsum = np.cumsum(explained_variance_ratio)\\n\\n # We search in the cumsum for the index of the value which, when added, corresponds to the quality_percent\\n # The index of the cumsum gives us the components we need to add to explain X quality percent of our data\\n n_components = np.searchsorted(ratio_cumsum, self.quality_percent, side='right') + 1\\n\\n self.components = Vt[:n_components]\\n print(\\\"The principal components have been calculated using svd\\\", self.components.shape)\\n\\n return self.components\",\n \"def set_matrix(self, name, mat):\\n self._matrices[name] = mat\",\n \"def posdef_eig_svd(mat):\\n evals, evecs, _ = tf.svd(mat)\\n\\n return evals, evecs\",\n \"def _mat2vec(self, mat):\\n return mat.flatten('F')\",\n \"def lowest_rank_approx(A, err):\\r\\n U, Si, Vh = la.svd(A)\\r\\n for i in range(len(Si)):\\r\\n #raise error if there are no nonzero singular values less than error\\r\\n if Si[i] == 0:\\r\\n raise ValueError(\\\"A cannot be approximated in tolerance by matrix of lesser rank\\\")\\r\\n\\r\\n #for greatest singular value less than error\\r\\n if Si[i] < err:\\r\\n #svd approximate for rank s\\r\\n Si_hat = np.diag(Si[:i])\\r\\n U_hat = U[:, :i]\\r\\n Vh_hat = Vh[:i, :]\\r\\n #return new A and num of entries needed\\r\\n return U_hat @ Si_hat @ Vh_hat, U_hat.size + i + Vh_hat.size\",\n \"def normalize(self):\\n det = self._mat[0][0]*self._mat[1][1] - self._mat[0][1]*self._mat[1][0]\\n for i in range(2):\\n for j in range(2):\\n self._mat[i][j] = (self._mat[i][j])/(np.sqrt(det))\",\n \"def normalize_vecs(mat):\\n #convert to array for operation\\n order = len(mat.shape) - 1\\n mat = COO(mat)\\n row_sums = mat.sum(axis=order)\\n mat = DOK(mat)\\n for point in mat.data:\\n divisor = row_sums[point[:-1]]\\n mat[point] = mat[point] / divisor\\n mat = COO(mat)\\n return mat\",\n \"def set_gpm_by_svd(self, threshold):\\n assert len(self.M) > 0\\n\\n self.M_vec = []\\n self.M_val = []\\n\\n index = np.arange(len(self.M))\\n np.random.shuffle(index)\\n\\n for k, idx in enumerate(index):\\n if k < min(self.mem_batch_size, len(self.M)):\\n ox, oy, ot = self.M[idx]\\n if k == 0:\\n mx = ox.unsqueeze(0)\\n else:\\n mx = torch.cat((mx, ox.unsqueeze(0)), 0)\\n\\n # handle gpus if specified\\n if self.cuda:\\n mx = mx.cuda()\\n\\n with torch.no_grad():\\n rep = self.net.forward(mx, svd=True)\\n\\n for i in range(len(rep)):\\n # rep[i]: n_samples * n_features\\n assert rep[i].ndim == 2\\n\\n u, s, v = torch.svd(rep[i].detach().cpu())\\n\\n if threshold[i] < 1:\\n r = torch.cumsum(s ** 2, 0) / torch.cumsum(s ** 2, 0)[-1]\\n k = torch.searchsorted(r, threshold[i]) + 1\\n elif threshold[i] > 10:\\n # differ with thres = 1\\n k = int(threshold[i])\\n else:\\n k = len(s)\\n\\n if k > 0:\\n self.M_vec.append(v[:, :k].cpu())\\n self.M_val.append(s[:k].cpu())\",\n \"def inverse(self,mat):\\n result = np.linalg.inv(mat)\\n self.out = result\\n return self.out\",\n \"def solveLinearSingular(aMat, bVec, isParameterized=False, defaultValue=1):\\n solution = aMat.gauss_jordan_solve(bVec)\\n solutionVec = solution[0]\\n if not isParameterized:\\n parameterMat = solution[1]\\n for parameter in parameterMat:\\n solutionVec = solutionVec.subs(parameter, defaultValue)\\n solutionVec = solutionVec.evalf()\\n return solutionVec\",\n \"def mds_torch(pre_dist_mat, weights=None, iters=10, tol=1e-5, eigen=False, verbose=0):\\n device, dtype = pre_dist_mat.device, pre_dist_mat.type()\\n # ensure batched MDS\\n pre_dist_mat = expand_dims_to(pre_dist_mat, length = ( 3 - len(pre_dist_mat.shape) ))\\n # start\\n batch, N, _ = pre_dist_mat.shape\\n diag_idxs = np.arange(N)\\n his = [torch.tensor([np.inf]*batch, device=device)]\\n\\n # initialize by eigendecomposition: https://www.lptmc.jussieu.fr/user/lesne/bioinformatics.pdf\\n # follow : https://www.biorxiv.org/content/10.1101/2020.11.27.401232v1.full.pdf\\n D = pre_dist_mat**2\\n M = 0.5 * (D[:, :1, :] + D[:, :, :1] - D) \\n # do loop svd bc it's faster: (2-3x in CPU and 1-2x in GPU)\\n # https://discuss.pytorch.org/t/batched-svd-lowrank-being-much-slower-than-loop-implementation-both-cpu-and-gpu/119336\\n svds = [torch.svd_lowrank(mi) for mi in M]\\n u = torch.stack([svd[0] for svd in svds], dim=0)\\n s = torch.stack([svd[1] for svd in svds], dim=0)\\n v = torch.stack([svd[2] for svd in svds], dim=0)\\n best_3d_coords = torch.bmm(u, torch.diag_embed(s).abs().sqrt())[..., :3]\\n\\n # only eigen - way faster but not weights\\n if weights is None and eigen==True:\\n return torch.transpose( best_3d_coords, -1, -2), torch.zeros_like(torch.stack(his, dim=0))\\n elif eigen==True:\\n if verbose:\\n print(\\\"Can't use eigen flag if weights are active. Fallback to iterative\\\")\\n\\n # continue the iterative way\\n if weights is None:\\n weights = torch.ones_like(pre_dist_mat)\\n\\n # iterative updates:\\n for i in range(iters):\\n # compute distance matrix of coords and stress\\n best_3d_coords = best_3d_coords.contiguous()\\n dist_mat = torch.cdist(best_3d_coords, best_3d_coords, p=2).clone()\\n\\n stress = ( weights * (dist_mat - pre_dist_mat)**2 ).sum(dim=(-1,-2)) * 0.5\\n # perturb - update X using the Guttman transform - sklearn-like\\n dist_mat[ dist_mat <= 0 ] += 1e-7\\n ratio = weights * (pre_dist_mat / dist_mat)\\n B = -ratio\\n B[:, diag_idxs, diag_idxs] += ratio.sum(dim=-1)\\n\\n # update\\n coords = (1. / N * torch.matmul(B, best_3d_coords))\\n dis = torch.norm(coords, dim=(-1, -2))\\n\\n if verbose >= 2:\\n print('it: %d, stress %s' % (i, stress))\\n # update metrics if relative improvement above tolerance\\n if (his[-1] - stress / dis).mean() <= tol:\\n if verbose:\\n print('breaking at iteration %d with stress %s' % (i,\\n stress / dis))\\n break\\n\\n best_3d_coords = coords\\n his.append( stress / dis )\\n\\n x = torch.transpose(best_3d_coords, -1,-2)#, torch.stack(his, dim=0) ,historic_stresses: (batch x steps)\\n x = x.permute(0,2,1)\\n return x\",\n \"def StandardizeMatrix(mat):\\n nObjs = len(mat)\\n avgs = sum(mat, 0) / float(nObjs)\\n mat -= avgs\\n devs = math.sqrt(sum(mat * mat, 0) / (float(nObjs - 1)))\\n try:\\n newMat = mat / devs\\n except OverflowError:\\n newMat = numpy.zeros(mat.shape, 'd')\\n for i in range(mat.shape[1]):\\n if devs[i] != 0.0:\\n newMat[:, i] = mat[:, i] / devs[i]\\n return newMat\",\n \"def update_projection(self, prior_mat, variable_mat, feature_mat):\\n new_variable = {'mu': np.zeros(variable_mat['mu'].shape),\\n 'sigma': np.zeros(variable_mat['sigma'].shape)}\\n prior_expect = (prior_mat['alpha'] / prior_mat['beta'])\\\\\\n .transpose().tolist()\\n\\n for i in range(self.R):\\n new_variable['sigma'][i, :, :] = np.linalg.inv(\\n np.diag(prior_expect[i])\\n + (self.kkt_mat / self.sigma_h))\\n new_variable['mu'][:, i] = np.dot(\\n new_variable['sigma'][i, :, :],\\n np.dot(self.kernel_mat,\\n feature_mat['mu'][i, :].transpose())\\n / self.sigma_h)\\n\\n return new_variable\",\n \"def calculate_k_SVD(smooth_spreadsheet_matrix, k):\\n U_unitary_matrix, singular_value, V_unitary_matrix = linalg.svd(smooth_spreadsheet_matrix)\\n S_full_squared_matrix = np.zeros((k, k))\\n np.fill_diagonal(S_full_squared_matrix, np.sqrt(singular_value[:k]))\\n U_unitary_matrix = U_unitary_matrix[:, :k]\\n return U_unitary_matrix, S_full_squared_matrix\",\n \"def build_mat(self):\\n for row, s in enumerate(self.S):\\n for col, t in enumerate(self.T):\\n\\n if self.symmetric and row > col:\\n pass\\n\\n else:\\n self.mat[row, col] = self.kernel(s, t, self.n)\\n\\n if self.symmetric:\\n self.mat = self.symmetrize(self.mat)\\n else:\\n for idx, s in enumerate(self.S):\\n self.test_normalization[idx] = self.kernel(s, s, self.n)\",\n \"def _sparse_projection(self,mat,sparsity=1,random_seed=10):\\n [n,_] = mat.shape\\n sketch = np.zeros((self.rp_dim ,n),dtype=float)\\n for i in range(n):\\n nnz_loc = np.random.choice(self.rp_dim ,size=sparsity,replace=False)\\n nnz_sign = np.random.choice([-1,1],size=sparsity,replace=True)\\n sketch[nnz_loc,i] = nnz_sign\\n self.sketch_mat = sketch\\n return (1./np.sqrt(sparsity))*sketch@mat\",\n \"def my_scale_sim_mat(w):\\n rowsum = np.array(np.sum(w, axis=1), dtype=np.float32)\\n r_inv = np.power(rowsum, -1).flatten()\\n r_inv[np.isinf(r_inv)] = 0.\\n r_mat_inv = sp.diags(r_inv)\\n w = r_mat_inv.dot(w)\\n return w\",\n \"def MATSOL(N,A):\\r\\n\\r\\n X = np.zeros((N+1),dtype=float) # X.shape = N+1\\r\\n NROW = np.arange(0,N+1,dtype=int) # NROW.shape = N+1\\r\\n\\r\\n for i in np.arange(N): # loop through rows\\r\\n AMAX = np.max(np.abs(A[NROW[i:],i])) # max value for column, all later rows\\r\\n ip = np.argmax(np.abs(A[NROW[i:],i]))+i # index of above\\r\\n \\r\\n if(abs(AMAX) <= 1E-08):\\r\\n print('Singular matrix --> No unique solution exists')\\r\\n return X\\r\\n \\r\\n if(NROW[i] != NROW[ip]): # swap rows\\r\\n NC = NROW[i].copy()\\r\\n NROW[i] = NROW[ip].copy()\\r\\n NROW[ip] = NC.copy()\\r\\n \\r\\n \\r\\n COEF = A[NROW[i+1:],i]/A[NROW[i],i] # normalize column values by maximum magnitude value (AMAX > 0)\\r\\n A[NROW[i+1:],i+1:] = A[NROW[i+1:],i+1:] - np.dot(COEF[:,None],A[NROW[i],i+1:][None,:]) # normalize/reduce matrix\\r\\n \\r\\n \\r\\n if(abs(A[NROW[N],N]) <= 1E-08):\\r\\n print('Singular matrix --> No unique solution exists')\\r\\n return X\\r\\n \\r\\n X[N] = A[NROW[N],N+1]/A[NROW[N],N] # downstream edge\\r\\n i = N-1\\r\\n while (i >= 0):\\r\\n# SUMM = 0.0\\r\\n# j = i+1\\r\\n \\r\\n SUMM = np.sum(A[NROW[i],i+1:N+1]*X[i+1:N+1]) # do not include final column\\r\\n \\r\\n# while (j <= N-1):\\r\\n# SUMM = A[NROW[i],j]*X[j] + SUMM\\r\\n# j = j+1\\r\\n # print(SUMM,SUMM2)\\r\\n \\r\\n X[i] = (A[NROW[i],N+1] - SUMM)/A[NROW[i],i]\\r\\n i = i-1\\r\\n return X\",\n \"def gauss_seidel_solver(self, mat, rhs):\\n x = np.zeros_like(rhs)\\n for it_count in range(1, self.iterations_number):\\n x_new = np.zeros_like(x)\\n if self.verbose > 1:\\n print(\\\"Iteration {0}: {1}\\\".format(it_count, x))\\n for i in range(mat.shape[0]):\\n s1 = np.dot(mat[i, :i], x_new[:i])\\n s2 = np.dot(mat[i, i + 1:], x[i + 1:])\\n x_new[i] = (rhs[i] - s1 - s2) / mat[i, i]\\n if np.allclose(x, x_new, rtol=1e-8):\\n break\\n x = x_new\\n return x\",\n \"def truncated_svd(A,k=None):\",\n \"def transform(self, mat: TxMatrix) -> None:\\n super().transform(mat)\\n self.scale = self.scale * mat.scale\",\n \"def scaling(mat, factor):\\n\\treturn mat / (mat + factor)\",\n \"def _matvec(x):\\n return _normal_matvec(matvec, x)\",\n \"def build_normalized(self):\\n for row, s in enumerate(self.S):\\n for col, t in enumerate(self.T):\\n\\n if self.symmetric and row > col:\\n pass\\n\\n elif self.symmetric and row == col:\\n self.normalized_mat[row, col] = 1\\n\\n else:\\n self.normalized_mat[row, col] = self.normalize(row, col)\\n\\n if self.symmetric:\\n self.normalized_mat = self.symmetrize(self.normalized_mat)\",\n \"def mumps_eigsh(matrix, k, sigma, **kwargs):\\n class LuInv(sla.LinearOperator):\\n\\n def __init__(self, matrix):\\n instance = kwant.linalg.mumps.MUMPSContext()\\n instance.analyze(matrix, ordering='pord')\\n instance.factor(matrix)\\n self.solve = instance.solve\\n sla.LinearOperator.__init__(self, matrix.dtype, matrix.shape)\\n\\n def _matvec(self, x):\\n return self.solve(x.astype(self.dtype))\\n\\n opinv = LuInv(matrix - sigma * sp.identity(matrix.shape[0]))\\n return sla.eigsh(matrix, k, sigma=sigma, OPinv=opinv, **kwargs)\",\n \"def test_set_matrix_vec(self, backend, vecmat, elements, elem_vnode,\\n kernel_inc_vec, kernel_set_vec, g, skip_cuda):\\n op2.par_loop(kernel_inc_vec, elements(3,3),\\n vecmat((elem_vnode[op2.i[0]], elem_vnode[op2.i[1]]), op2.INC),\\n g(op2.READ))\\n # Check we have ones in the matrix\\n assert vecmat.array.sum() == 2*2*3*3*elements.size\\n op2.par_loop(kernel_set_vec, elements(3,3),\\n vecmat((elem_vnode[op2.i[0]], elem_vnode[op2.i[1]]), op2.WRITE),\\n g(op2.READ))\\n # Check we have set all values in the matrix to 1\\n assert_allclose(vecmat.array, numpy.ones_like(vecmat.array))\\n vecmat.zero()\",\n \"def do_numeric_factorization(self, matrix):\\n if self._nnz is None:\\n raise RuntimeError('Call do_symbolic_factorization first.')\\n if type(matrix) == np.ndarray:\\n matrix = coo_matrix(matrix)\\n if not isspmatrix_coo(matrix):\\n matrix = matrix.tocoo()\\n nrows, ncols = matrix.shape\\n if nrows != ncols:\\n raise ValueError('matrix is not square')\\n if self._dim != nrows:\\n raise ValueError('The shape of the matrix changed between symbolic and numeric factorization')\\n if self._nnz != matrix.nnz:\\n raise ValueError('The number of nonzeros changed between symbolic and numeric factorization')\\n self.mumps.set_centralized_assembled_values(matrix.data)\\n self.mumps.run(job=2)\",\n \"def inv(matrix):\\n if sp.sparse.issparse(matrix):\\n result = spla.inv(matrix)\\n else:\\n result = sp.linalg.inv(matrix)\\n return result\",\n \"def _scale(self, normalize, mat):\\n mat = mat.astype(float)\\n if normalize:\\n mat = sklearn_norm(mat,\\n feature_range=(0, 1),\\n axis=0,\\n copy=True)\\n else:\\n return mat\\n return mat\",\n \"def update_mass_matrix(self, sim, joint_index):\\n mass_matrix = np.ndarray(shape=(len(sim.data.qvel) ** 2,), dtype=np.float64, order='C')\\n # print(self.current_joint_position)\\n # print(mass_matrix)\\n mujoco_py.cymj._mj_fullM(sim.model, mass_matrix, sim.data.qM)\\n mass_matrix = np.reshape(mass_matrix, (len(sim.data.qvel), len(sim.data.qvel)))\\n self.mass_matrix = mass_matrix[joint_index, :][:, joint_index]\\n \\n # self.mass_matrix = np.array([[ 2.25726539e+00, -2.62750718e-06, 1.60412060e+00,\\n # 2.62750718e-06, -5.43221706e-01, 2.62750718e-06,\\n # -1.98486117e-01],\\n # [-2.62750718e-06, 2.28637709e+00, -6.58357876e-06,\\n # -1.16381227e+00, -4.11331754e-06, -4.00056093e-01,\\n # 2.53844900e-18],\\n # [ 1.60412060e+00, -6.58357876e-06, 1.60070894e+00,\\n # 6.58357876e-06, -5.02987276e-01, 6.58357876e-06,\\n # -1.89718057e-01],\\n # [ 2.62750718e-06, -1.16381227e+00, 6.58357876e-06,\\n # 1.43272976e+00, 4.11331754e-06, 4.01913080e-01,\\n # -2.53381454e-18],\\n # [-5.43221706e-01, -4.11331754e-06, -5.02987276e-01,\\n # 4.11331754e-06, 5.11565111e-01, 4.11331754e-06,\\n # 1.96115254e-01],\\n # [ 2.62750718e-06, -4.00056093e-01, 6.58357876e-06,\\n # 4.01913080e-01, 4.11331754e-06, 3.22014223e-01,\\n # -2.53991699e-18],\\n # [-1.98486117e-01, 2.53844900e-18, -1.89718057e-01,\\n # -2.53381454e-18, 1.96115254e-01, -2.53991699e-18,\\n # 2.00104011e-01]])\",\n \"def compute_svd(self,data,k):\\n m, n =data.shape\\n n = self.comm1.allreduce(n)\\n print(m,n)\\n if k==-1:\\n k = min(m,n)\\n args = parse()\\n args.m,args.n,args.k,args.comm = m,n,k,self.comms\\n args.eps = np.finfo(data.dtype).eps\\n if args.m<args.n: args.p_r,args.p_c = 1,self.size\\n dsvd = DistSVD(args, data)\\n singularValues, U, V = dsvd.svd()\\n rel_error = dsvd.rel_error(U, np.diag(singularValues), V)\\n if self.global_rank==0: print('relative error is:', rel_error )\\n return singularValues,U,V,rel_error\",\n \"def matSet(mat, r, c, v):\\n mat[r][c]=v\",\n \"def Sinv(self):\\n Wplus = np.matrix(np.diag(self.w**2 + 1.0))\\n return self.priorSinvh * self.V.T * Wplus * self.V * self.priorSinvh\",\n \"def update_matrix(self, ope, mat):\\n ope_coord = []\\n for coord in self.coord_name:\\n if np.isnan(ope[coord]):\\n return\\n ope_coord.append(int(ope[coord]))\\n mat[tuple(ope_coord)] += 1\",\n \"def normalised(cls, mat, axis=-1, order=2):\\n norm = np.linalg.norm(\\n mat, axis=axis, ord=order, keepdims=True)\\n norm[norm == 0] = 1\\n return mat / norm\",\n \"def update(mat) -> np.ndarray:\\n return mat\",\n \"def doolittle_factorization(self, matrix=None):\\n try:\\n local_matrix = self.matrix.matrix if not matrix else matrix.matrix\\n except AttributeError:\\n local_matrix = matrix\\n \\n (result, upper, lower, temp_sum) = (0.0, [[]], [[]], 0.0)\\n for i in range(len(local_matrix)):\\n lower.append([])\\n for j in range(len(local_matrix[i])):\\n lower[i].append(0)\\n \\n lower.remove([])\\n\\n for i in range(len(local_matrix)):\\n for j in range(len(local_matrix[i])):\\n temp_sum = 0.0\\n for k in range(i):\\n temp_sum += lower[i][k] * upper[k][j]\\n result = local_matrix[i][j] - temp_sum\\n upper[i].append(round(result, 9))\\n upper.append([])\\n \\n for j in range(len(local_matrix[i])):\\n temp_sum = 0.0\\n for k in range(i):\\n temp_sum += lower[j][k] * upper[k][i]\\n result = local_matrix[j][i] - temp_sum\\n lower[j][i] = round(result / upper[i][i], 9)\\n\\n upper.remove([])\\n upper = Matrix(upper, name=\\\"U\\\")\\n lower = Matrix(lower, name=\\\"L\\\")\\n\\n print(\\\"Las matrices son: \\\")\\n upper.print_matrix()\\n lower.print_matrix()\\n\\n print(\\\"Al multiplicarlas queda\\\")\\n comprobation = lower.multiply_matrix(upper.matrix)\\n comprobation.set_name(\\\"comprobación de la factorización LU\\\")\\n comprobation.print_matrix()\\n\\n return (lower, upper)\",\n \"def update_distmatrix(min_idx, dist_matrix):\\n i, j = min_idx\\n new_cluster_dist = np.minimum(dist_matrix[i, :], dist_matrix[j, :])\\n new_cluster_dist[i] = np.inf\\n \\n dist_matrix[i, :] = new_cluster_dist\\n dist_matrix[:, i] = new_cluster_dist\\n \\n dist_matrix[j, :] = np.inf\\n dist_matrix[:, j] = np.inf\\n \\n return dist_matrix\",\n \"def _apply_inverse(matrix, V, options=None):\\n\\n default_options = _options(matrix)\\n\\n if options is None:\\n options = next(iter(default_options.values()))\\n elif isinstance(options, str):\\n if options == 'least_squares':\\n for k, v in default_options.items():\\n if k.startswith('least_squares'):\\n options = v\\n break\\n assert not isinstance(options, str)\\n else:\\n options = default_options[options]\\n else:\\n assert 'type' in options and options['type'] in default_options \\\\\\n and options.keys() <= default_options[options['type']].keys()\\n user_options = options\\n options = default_options[user_options['type']]\\n options.update(user_options)\\n\\n promoted_type = np.promote_types(matrix.dtype, V.dtype)\\n R = np.empty((len(V), matrix.shape[1]), dtype=promoted_type)\\n\\n if options['type'] == 'solve':\\n for i, VV in enumerate(V):\\n try:\\n R[i] = np.linalg.solve(matrix, VV)\\n except np.linalg.LinAlgError as e:\\n raise InversionError('{}: {}'.format(str(type(e)), str(e)))\\n elif options['type'] == 'least_squares_lstsq':\\n for i, VV in enumerate(V):\\n try:\\n R[i], _, _, _ = np.linalg.lstsq(matrix, VV, rcond=options['rcond'])\\n except np.linalg.LinAlgError as e:\\n raise InversionError('{}: {}'.format(str(type(e)), str(e)))\\n elif options['type'] == 'bicgstab':\\n for i, VV in enumerate(V):\\n R[i], info = bicgstab(matrix, VV, tol=options['tol'], maxiter=options['maxiter'])\\n if info != 0:\\n if info > 0:\\n raise InversionError('bicgstab failed to converge after {} iterations'.format(info))\\n else:\\n raise InversionError('bicgstab failed with error code {} (illegal input or breakdown)'.\\n format(info))\\n elif options['type'] == 'bicgstab_spilu':\\n # workaround for https://github.com/pymor/pymor/issues/171\\n try:\\n ilu = spilu(matrix, drop_tol=options['spilu_drop_tol'], fill_factor=options['spilu_fill_factor'],\\n drop_rule=options['spilu_drop_rule'], permc_spec=options['spilu_permc_spec'])\\n except TypeError as t:\\n logger = getLogger('pymor.operators.numpy._apply_inverse')\\n logger.error(\\\"ignoring drop_rule in ilu factorization\\\")\\n ilu = spilu(matrix, drop_tol=options['spilu_drop_tol'], fill_factor=options['spilu_fill_factor'],\\n permc_spec=options['spilu_permc_spec'])\\n precond = LinearOperator(matrix.shape, ilu.solve)\\n for i, VV in enumerate(V):\\n R[i], info = bicgstab(matrix, VV, tol=options['tol'], maxiter=options['maxiter'], M=precond)\\n if info != 0:\\n if info > 0:\\n raise InversionError('bicgstab failed to converge after {} iterations'.format(info))\\n else:\\n raise InversionError('bicgstab failed with error code {} (illegal input or breakdown)'.\\n format(info))\\n elif options['type'] == 'spsolve':\\n try:\\n # maybe remove unusable factorization:\\n if hasattr(matrix, 'factorization'):\\n fdtype = matrix.factorizationdtype\\n if not np.can_cast(V.dtype, fdtype, casting='safe'):\\n del matrix.factorization\\n\\n if list(map(int, scipy.version.version.split('.'))) >= [0, 14, 0]:\\n if hasattr(matrix, 'factorization'):\\n # we may use a complex factorization of a real matrix to\\n # apply it to a real vector. In that case, we downcast\\n # the result here, removing the imaginary part,\\n # which should be zero.\\n R = matrix.factorization.solve(V.T).T.astype(promoted_type, copy=False)\\n elif options['keep_factorization']:\\n # the matrix is always converted to the promoted type.\\n # if matrix.dtype == promoted_type, this is a no_op\\n matrix.factorization = splu(matrix_astype_nocopy(matrix, promoted_type), permc_spec=options['permc_spec'])\\n matrix.factorizationdtype = promoted_type\\n R = matrix.factorization.solve(V.T).T\\n else:\\n # the matrix is always converted to the promoted type.\\n # if matrix.dtype == promoted_type, this is a no_op\\n R = spsolve(matrix_astype_nocopy(matrix, promoted_type), V.T, permc_spec=options['permc_spec']).T\\n else:\\n # see if-part for documentation\\n if hasattr(matrix, 'factorization'):\\n for i, VV in enumerate(V):\\n R[i] = matrix.factorization.solve(VV).astype(promoted_type, copy=False)\\n elif options['keep_factorization']:\\n matrix.factorization = splu(matrix_astype_nocopy(matrix, promoted_type), permc_spec=options['permc_spec'])\\n matrix.factorizationdtype = promoted_type\\n for i, VV in enumerate(V):\\n R[i] = matrix.factorization.solve(VV)\\n elif len(V) > 1:\\n factorization = splu(matrix_astype_nocopy(matrix, promoted_type), permc_spec=options['permc_spec'])\\n for i, VV in enumerate(V):\\n R[i] = factorization.solve(VV)\\n else:\\n R = spsolve(matrix_astype_nocopy(matrix, promoted_type), V.T, permc_spec=options['permc_spec']).reshape((1, -1))\\n except RuntimeError as e:\\n raise InversionError(e)\\n elif options['type'] == 'lgmres':\\n for i, VV in enumerate(V):\\n R[i], info = lgmres(matrix, VV.copy(i),\\n tol=options['tol'],\\n maxiter=options['maxiter'],\\n inner_m=options['inner_m'],\\n outer_k=options['outer_k'])\\n if info > 0:\\n raise InversionError('lgmres failed to converge after {} iterations'.format(info))\\n assert info == 0\\n elif options['type'] == 'least_squares_lsmr':\\n for i, VV in enumerate(V):\\n R[i], info, itn, _, _, _, _, _ = lsmr(matrix, VV.copy(i),\\n damp=options['damp'],\\n atol=options['atol'],\\n btol=options['btol'],\\n conlim=options['conlim'],\\n maxiter=options['maxiter'],\\n show=options['show'])\\n assert 0 <= info <= 7\\n if info == 7:\\n raise InversionError('lsmr failed to converge after {} iterations'.format(itn))\\n elif options['type'] == 'least_squares_lsqr':\\n for i, VV in enumerate(V):\\n R[i], info, itn, _, _, _, _, _, _, _ = lsqr(matrix, VV.copy(i),\\n damp=options['damp'],\\n atol=options['atol'],\\n btol=options['btol'],\\n conlim=options['conlim'],\\n iter_lim=options['iter_lim'],\\n show=options['show'])\\n assert 0 <= info <= 7\\n if info == 7:\\n raise InversionError('lsmr failed to converge after {} iterations'.format(itn))\\n elif options['type'] == 'pyamg':\\n if len(V) > 0:\\n V_iter = iter(enumerate(V))\\n R[0], ml = pyamg.solve(matrix, next(V_iter)[1],\\n tol=options['tol'],\\n maxiter=options['maxiter'],\\n return_solver=True)\\n for i, VV in V_iter:\\n R[i] = pyamg.solve(matrix, VV,\\n tol=options['tol'],\\n maxiter=options['maxiter'],\\n existing_solver=ml)\\n elif options['type'] == 'pyamg-rs':\\n ml = pyamg.ruge_stuben_solver(matrix,\\n strength=options['strength'],\\n CF=options['CF'],\\n presmoother=options['presmoother'],\\n postsmoother=options['postsmoother'],\\n max_levels=options['max_levels'],\\n max_coarse=options['max_coarse'],\\n coarse_solver=options['coarse_solver'])\\n for i, VV in enumerate(V):\\n R[i] = ml.solve(VV,\\n tol=options['tol'],\\n maxiter=options['maxiter'],\\n cycle=options['cycle'],\\n accel=options['accel'])\\n elif options['type'] == 'pyamg-sa':\\n ml = pyamg.smoothed_aggregation_solver(matrix,\\n symmetry=options['symmetry'],\\n strength=options['strength'],\\n aggregate=options['aggregate'],\\n smooth=options['smooth'],\\n presmoother=options['presmoother'],\\n postsmoother=options['postsmoother'],\\n improve_candidates=options['improve_candidates'],\\n max_levels=options['max_levels'],\\n max_coarse=options['max_coarse'],\\n diagonal_dominance=options['diagonal_dominance'])\\n for i, VV in enumerate(V):\\n R[i] = ml.solve(VV,\\n tol=options['tol'],\\n maxiter=options['maxiter'],\\n cycle=options['cycle'],\\n accel=options['accel'])\\n elif options['type'].startswith('generic') or options['type'].startswith('least_squares_generic'):\\n logger = getLogger('pymor.operators.numpy._apply_inverse')\\n logger.warn('You have selected a (potentially slow) generic solver for a NumPy matrix operator!')\\n from pymor.operators.numpy import NumpyMatrixOperator\\n from pymor.vectorarrays.numpy import NumpyVectorArray\\n return genericsolvers.apply_inverse(NumpyMatrixOperator(matrix),\\n NumpyVectorArray(V, copy=False),\\n options=options).data\\n else:\\n raise ValueError('Unknown solver type')\\n return R\",\n \"def mat_from_cond(cond_num, m=50, n=50, min_sing=None):\\n assert min(m,n) > 1\\n if cond_num < 1:\\n raise la.linAlgError('Condition number must be greater than or equal to 1')\\n\\n if min_sing is None:\\n min_sing = abs(np.random.randn())\\n\\n max_sing = min_sing * float(cond_num)\\n s = np.array(sorted([np.random.uniform(low=min_sing, high=max_sing) for _ in range(min(m,n)-2)] + [min_sing, max_sing], reverse=True))\\n\\n A = np.random.randn(m, n)\\n u,_,v = la.svd(A, full_matrices=False)\\n\\n # Sparse? instead of np.diag(s)\\n return np.dot(u, np.dot(np.diag(s), v))\",\n \"def normalize(self, matrix):\\n eigvals, eigvecs = np.linalg.eig(matrix)\\n Sdiag = np.diagonal(np.linalg.inv(eigvecs)@matrix@eigvecs)\\n S12diag = Sdiag**-.5\\n S12 = np.zeros((len(S12diag), len(S12diag)))\\n np.fill_diagonal(S12, S12diag)\\n return S12\",\n \"def _setMatrixRow(self, row):\\n item = self._item()\\n if item is not None:\\n matrix = item.getMatrix()\\n matrix[self._index, :] = row.x(), row.y(), row.z()\\n item.setMatrix(matrix)\",\n \"def invert_L1_svd():\",\n \"def uniform_matrixf(self, name, mat):\\n if self.getStatus():\\n loc = glGetUniformLocation(self.program, name)\\n glUniformMatrix4fv(loc, 1, False, (ctypes.c_float * 16)(*mat))\",\n \"def solve_lu(matvec: Callable, b: jnp.ndarray) -> jnp.ndarray:\\n if len(b.shape) == 0:\\n return b / _materialize_array(matvec, b.shape)\\n elif len(b.shape) == 1:\\n A = _materialize_array(matvec, b.shape, b.dtype)\\n return jax.numpy.linalg.solve(A, b)\\n elif len(b.shape) == 2:\\n A = _materialize_array(matvec, b.shape, b.dtype) # 4d array (tensor)\\n A = A.reshape(-1, b.shape[0] * b.shape[1]) # 2d array (matrix)\\n return jax.numpy.linalg.solve(A, b.ravel()).reshape(*b.shape)\\n else:\\n raise NotImplementedError\",\n \"def _sp_matrix_wrapper(matrix):\\n if isinstance(matrix, _sp_matrix.SpMatrix):\\n return SpMatrix().swap_(matrix)\\n elif isinstance(matrix, _sp_matrix.DoubleSpMatrix):\\n return DoubleSpMatrix().swap_(matrix)\\n else:\\n raise TypeError(\\\"unrecognized input type\\\")\",\n \"def _loadMatFile(self, filename):\\n matfile = scipy.io.loadmat(filename)\\n\\n self.StokesI = np.transpose(matfile['StokesI'])\\n self.StokesQ = np.transpose(matfile['StokesQ'])\\n self.StokesU = np.transpose(matfile['StokesU'])\\n self.StokesV = np.transpose(matfile['StokesV'])\\n self.detectorPosition = matfile['detectorPosition'][0]\\n self.detectorDirection = matfile['detectorDirection'][0]\\n self.detectorVisang = matfile['detectorVisang']\\n\\n try: self.wall = np.transpose(matfile['wall'])\\n except KeyError: pass\\n\\n try: self.wall = np.transpose(matfile['separatrix'])\\n except KeyError: pass\",\n \"def svd(matrix):\\n u = None\\n s = None\\n v = None\\n ### YOUR CODE HERE\\n pass\\n ### END YOUR CODE\\n\\n return u, s, v\",\n \"def __init__(self, shape, rank, sigma):\\n assert isinstance(sigma, int)\\n assert sigma > 0.0\\n assert isinstance(shape, tuple)\\n assert isinstance(rank, int)\\n assert rank > 0\\n assert rank <= min(*shape)\\n self.shape = shape\\n self.rank = rank\\n self.sigma = sigma\\n\\n self.weight_mat = np.empty(self.shape)\\n self.weight_mat.fill(1.0/sigma**2)\\n\\n self.u = np.zeros((self.shape[0], self.rank))\\n self.v = np.zeros((self.shape[1], self.rank))\",\n \"def resolves_matrix(self):\\n self.P = np.linalg.solve(self.M, self.f)\",\n \"def _fit_stochastic(self, R, U, V, seed):\\n Rhat = self._estimate_ratings(U=U, V=V) # Get Rhat, the estimate of R\\n np.random.seed(seed) # set random seed\\n for _ in range(self.n_iter): # until we've reached n_iter...\\n n = np.random.choice(self.N) # randomly choose a user\\n m = np.random.choice(self.M) # randomly choose an item\\n un_grad = -(R[n,m] - Rhat[n,m])*V[m] # gradient with respect to u_n vector\\n vm_grad = -(R[n,m] - Rhat[n,m])*U[n] # gradient with respect to v_m vector\\n U[n] -= self.lr*un_grad # update \\n V[m] -= self.lr*vm_grad # update\\n Rhat = self._estimate_ratings(U=U, V=V) # form new estimates\\n self.Rhat, self.U, self.V = Rhat, U, V\",\n \"def _symmetric_matrix_square_root(mat, eps=1e-10):\\n # Unlike numpy, tensorflow's return order is (s, u, v)\\n s, u, v = linalg_ops.svd(mat)\\n # sqrt is unstable around 0, just use 0 in such case\\n si = array_ops.where(math_ops.less(s, eps), s, math_ops.sqrt(s))\\n # Note that the v returned by Tensorflow is v = V\\n # (when referencing the equation A = U S V^T)\\n # This is unlike Numpy which returns v = V^T\\n return math_ops.matmul(\\n math_ops.matmul(u, array_ops.diag(si)), v, transpose_b=True)\",\n \"def calc_matrix(mat_a, mat_d, case):\\n nodes, = get_valdict(case, 'nodes')\\n for i in range(0, nodes):\\n for j in range(0, nodes):\\n if i == j and i == 0:\\n aW, aE, aP, Su = equation_nodes('left', case)\\n mat_a[i, j] = aP\\n mat_a[i, j+1] = -aE\\n mat_d[i] = Su\\n elif i == j and (i > 0 and i < nodes-1):\\n aW, aE, aP, Su = equation_nodes('mid', case)\\n mat_a[i, j-1] = -aW\\n mat_a[i, j] = aP\\n mat_a[i, j+1] = -aE\\n mat_d[i] = Su\\n elif i == j and (i == nodes-1):\\n aW, aE, aP, Su = equation_nodes('right', case)\\n mat_a[i, j-1] = -aW\\n mat_a[i, j] = aP\\n mat_d[i] = Su\",\n \"def relax(self):\\n # print(\\\"putin\\\", self.level.rhs.reshape(-1)[:])\\n # print(\\\"getout\\\", self.solver(self.level.rhs.reshape(-1)))\\n\\n self.level.mid[:] = self.solver(self.level.rhs.reshape(-1)).reshape(self.level.mid.shape)\",\n \"def get_prox_nuclear(self, x_matrix, scale_factor, prev_u0=None):\\n if self.gamma_num_s is None or self.gamma_num_s > 18:\\n u, s, vt = np.linalg.svd(x_matrix)\\n else:\\n tol = scale_factor/10.\\n try:\\n k = max(1, self.gamma_num_s)\\n if prev_u0 is not None:\\n u, s, vt = sp.sparse.linalg.svds(x_matrix, v0=prev_u0, k=k, which=\\\"LM\\\", tol=tol)\\n else:\\n u, s, vt = sp.sparse.linalg.svds(x_matrix, k=k, which=\\\"LM\\\", tol=tol)\\n u = np.matrix(u)\\n vt = np.matrix(vt)\\n except ValueError as e:\\n print \\\"value error svd\\\", e\\n u, s, vt = np.linalg.svd(x_matrix)\\n\\n num_nonzero_orig = (np.where(s > scale_factor))[0].size\\n thres_s = np.maximum(s - scale_factor, 0)\\n nuc_norm = np.linalg.norm(thres_s, ord=1)\\n self.gamma_num_s = (np.where(thres_s > 0))[0].size\\n\\n if s.size > 0:\\n prev_u0 = u[:,0]\\n else:\\n prev_u0 = None\\n\\n return u * np.diag(thres_s) * vt, nuc_norm, prev_u0\",\n \"def __init__(self, mat: np.ndarray):\\n # Check mat\\n try:\\n mat = np.asarray(mat)\\n except ValueError:\\n print(\\\"Input matrix must be a numpy array.\\\")\\n # Init from super class\\n super(LinearOperatorFromMatrix, self).__init__(shape=mat.shape, dtype=mat.dtype)\\n\\n # Matrix corresponding to the linear operator\\n self.mat = mat\\n\\n # Adjoint\\n self.adjoint = mat.conj().transpose()\\n\\n # Corresponding Gram matrix\\n self.gram = self.adjoint @ mat\\n\\n # Spectral norm, Lipschitz constant\\n self.norm = self.lipschitz_cst = np.sqrt(\\n spsparse.eigs(self.gram, k=1, which='LM', return_eigenvectors=False, maxiter=int(5e4)))\",\n \"def implement_svd(data):\\n u, s, v = torch.svd(data) # implement svd\\n # note: the u returned by this function only includes the top values.\\n # u * s will be equivalent due to the zero terms, but will run more efficiently with this implementation.\\n s = torch.diag(s) # turn s into a diagonal matrix\\n transformed_matrix = torch.mm(u, s) # u * s\\n return l21_reg(s), transformed_matrix # return the L2,1 regularization term and matrix\",\n \"def _symmetric_matrix_division(\\n matrix: Union[np.ndarray, scipy.sparse.spmatrix],\\n vec: np.ndarray,\\n vec_right: Optional[np.ndarray] = None,\\n scalar: float = 1.0,\\n value_zero_division: Union[str, float] = \\\"raise\\\",\\n) -> Union[np.ndarray, scipy.sparse.csr_matrix,]:\\n\\n if matrix.ndim != 2:\\n raise ValueError(\\\"Parameter 'matrix' must be a two dimensional array.\\\")\\n\\n if matrix.shape[0] != matrix.shape[1] and vec_right is None:\\n raise ValueError(\\n \\\"If 'matrix' is non-square, then 'vec_right' must be provided.\\\"\\n )\\n\\n vec = vec.astype(float)\\n\\n if (vec == 0.0).any():\\n if value_zero_division == \\\"raise\\\":\\n raise ZeroDivisionError(\\n f\\\"Encountered zero values in division in {(vec == 0).sum()} points.\\\"\\n )\\n else:\\n # division results into 'nan' without raising a ZeroDivisionWarning. The\\n # nan values will be replaced later\\n vec[vec == 0.0] = np.nan\\n\\n vec_inv_left = np.reciprocal(vec)\\n\\n if vec_right is None:\\n vec_inv_right = vec_inv_left.view()\\n else:\\n vec_right = vec_right.astype(float)\\n if (vec_right == 0.0).any():\\n if value_zero_division == \\\"raise\\\":\\n raise ZeroDivisionError(\\n f\\\"Encountered zero values in division in {(vec == 0).sum()}\\\"\\n )\\n else:\\n vec_right[vec_right == 0.0] = np.inf\\n\\n vec_inv_right = np.reciprocal(vec_right.astype(float))\\n\\n if vec_inv_left.ndim != 1 or vec_inv_left.shape[0] != matrix.shape[0]:\\n raise ValueError(\\n f\\\"Invalid input: 'vec.shape={vec.shape}' is not compatible with \\\"\\n f\\\"'matrix.shape={matrix.shape}'.\\\"\\n )\\n\\n if vec_inv_right.ndim != 1 or vec_inv_right.shape[0] != matrix.shape[1]:\\n raise ValueError(\\n f\\\"Invalid input: 'vec_right.shape={vec_inv_right.shape}' is not compatible \\\"\\n f\\\"with 'matrix.shape={matrix.shape}'.\\\"\\n )\\n\\n if scipy.sparse.issparse(matrix):\\n left_inv_diag_sparse = scipy.sparse.spdiags(\\n vec_inv_left, 0, m=matrix.shape[0], n=matrix.shape[0]\\n )\\n right_inv_diag_sparse = scipy.sparse.spdiags(\\n vec_inv_right, 0, m=matrix.shape[1], n=matrix.shape[1]\\n )\\n\\n # The performance of DIA-sparse matrices is good if the matrix is actually\\n # sparse. I.e. the performance drops for a sparse-dense-sparse multiplication.\\n\\n # The zeros are removed in the matrix multiplication, but because 'matrix' is\\n # usually a distance matrix we need to preserve the \\\"true zeros\\\"!\\n matrix.data[matrix.data == 0] = np.inf\\n matrix = left_inv_diag_sparse @ matrix @ right_inv_diag_sparse\\n\\n matrix.data[np.isinf(matrix.data)] = 0\\n\\n # this imposes precedence order\\n # --> np.inf/np.nan -> np.nan\\n # i.e. for cases with 0/0, set 'value_zero_division'\\n if isinstance(value_zero_division, (int, float)):\\n matrix.data[np.isnan(matrix.data)] = value_zero_division\\n\\n else:\\n # This computes efficiently:\\n # np.diag(1/vector_elements) @ matrix @ np.diag(1/vector_elements)\\n matrix = diagmat_dot_mat(vec_inv_left, matrix, out=matrix)\\n matrix = mat_dot_diagmat(matrix, vec_inv_right, out=matrix)\\n\\n if isinstance(value_zero_division, (int, float)):\\n matrix[np.isnan(matrix)] = value_zero_division\\n\\n # sparse and dense\\n if vec_right is None:\\n matrix = remove_numeric_noise_symmetric_matrix(matrix)\\n\\n if scalar != 1.0:\\n scalar = 1.0 / scalar\\n matrix = np.multiply(matrix, scalar, out=matrix)\\n\\n return matrix\",\n \"def normalize(self):\\r\\n max = np.amax(self.matrix)\\r\\n min = np.amin(self.matrix)\\r\\n\\r\\n self.matrix = ((self.matrix - min) / (max - min))\",\n \"def transform(self, mat: TxMatrix) -> None:\\n super().transform(mat)\\n\\n nodes = self.nodes\\n for i, pos in enumerate(nodes):\\n nodes[i] = mat.sample(*pos)\",\n \"def lu(matrix):\\n SIZE = matrix.shape[0]\\n BS = np.BLOCKSIZE\\n\\n if matrix.shape[0] != matrix.shape[0]:\\n raise Exception(\\\"LU only supports squared matricis\\\")\\n if not matrix.dist():\\n raise Exception(\\\"The matrix is not distributed\\\")\\n\\n if(SIZE % np.BLOCKSIZE != 0):\\n raise Exception(\\\"The matrix dimensions must be divisible \\\"\\\\\\n \\\"with np.BLOCKSIZE(%d)\\\"%np.BLOCKSIZE)\\n\\n (prow,pcol) = matrix.pgrid()\\n A = np.zeros((SIZE,SIZE), dtype=matrix.dtype, dist=True);A += matrix\\n L = np.zeros((SIZE,SIZE), dtype=matrix.dtype, dist=True)\\n U = np.zeros((SIZE,SIZE), dtype=matrix.dtype, dist=True)\\n tmpL = np.zeros((SIZE,SIZE), dtype=matrix.dtype, dist=True)\\n tmpU = np.zeros((SIZE,SIZE), dtype=matrix.dtype, dist=True)\\n for k in xrange(0,SIZE,BS):\\n bs = min(BS,SIZE - k) #Current block size\\n kb = k / BS # k as block index\\n\\n #Compute vertical multiplier\\n slice = ((kb,kb+1),(kb,kb+1))\\n for a,l,u in zip(A.blocks(slice), L.blocks(slice), U.blocks(slice)):\\n (p,tl,tu) = linalg.lu(a)\\n if not (np.diag(p) == 1).all():#We do not support pivoting\\n raise Exception(\\\"Pivoting was needed!\\\")\\n #There seems to be a transpose bug in SciPy's LU\\n l[:] = tl.T\\n u[:] = tu.T\\n\\n #Replicate diagonal block horizontal and vertical\\n for tk in xrange(k+bs,SIZE,BS):\\n tbs = min(BS,SIZE - tk) #Current block size\\n L[tk:tk+tbs,k:k+bs] = U[k:k+tbs,k:k+bs]\\n U[k:k+bs,tk:tk+tbs] = L[k:k+bs,k:k+tbs]\\n\\n if k+bs < SIZE:\\n #Compute horizontal multiplier\\n slice = ((kb,kb+1),(kb+1,SIZE/BS))\\n for a,u in zip(A.blocks(slice), U.blocks(slice)):\\n u[:] = np.linalg.solve(u.T,a.T).T\\n\\n #Compute vertical multiplier\\n slice = ((kb+1,SIZE/BS),(kb,kb+1))\\n for a,l in zip(A.blocks(slice), L.blocks(slice)):\\n l[:] = np.linalg.solve(l,a)\\n\\n #Apply to remaining submatrix\\n A -= pyHPC.summa(L[:,:k+bs],U[:k+bs,:], ao=(k+bs,k),\\n bo=(k,k+bs), co=(k+bs,k+bs))\\n\\n return (L, U)\",\n \"def from_matrix(cls, matrix, tensorized_row_shape, tensorized_column_shape, rank, factorization='CP', **kwargs):\\n try:\\n cls = cls._factorizations[factorization.lower()]\\n except KeyError:\\n raise ValueError(f'Got factorization={factorization} but expected'\\n f'one of {cls._factorizations.keys()}')\\n return cls.from_matrix(matrix, tensorized_row_shape, tensorized_column_shape, rank, **kwargs)\",\n \"def tensor_train_matrix(tensor, rank, svd=\\\"truncated_svd\\\", verbose=False):\\n order = tl.ndim(tensor)\\n n_input = order // 2 # (n_output = n_input)\\n\\n if tl.ndim(tensor) != n_input * 2:\\n msg = \\\"The tensor should have as many dimensions for inputs and outputs, i.e. order should be even \\\"\\n msg += f\\\"but got a tensor of order tl.ndim(tensor)={order} which is odd.\\\"\\n raise ValueError(msg)\\n\\n in_shape = tl.shape(tensor)[:n_input]\\n out_shape = tl.shape(tensor)[n_input:]\\n\\n if n_input == 1:\\n # A TTM with a single factor is just a matrix...\\n return TTMatrix([tensor.reshape(1, in_shape[0], out_shape[0], 1)])\\n\\n new_idx = list(\\n [\\n idx\\n for tuple_ in zip(range(n_input), range(n_input, 2 * n_input))\\n for idx in tuple_\\n ]\\n )\\n new_shape = list([a * b for (a, b) in zip(in_shape, out_shape)])\\n tensor = tl.reshape(tl.transpose(tensor, new_idx), new_shape)\\n\\n factors = tensor_train(tensor, rank, svd=svd, verbose=verbose).factors\\n for i in range(len(factors)):\\n factors[i] = tl.reshape(\\n factors[i], (factors[i].shape[0], in_shape[i], out_shape[i], -1)\\n )\\n\\n return TTMatrix(factors)\",\n \"def lu_decomposition(self):\\n if self.rows_count() != self.columns_count():\\n raise ValueError(\\\"Matrix needs to me square for LU decomposition.\\\")\\n for i in range(self.rows_count() - 1):\\n for j in range(i + 1, self.rows_count()):\\n if self[i, i] == 0: # or abs(self[i, i]) <= 0.000001):\\n raise ValueError(\\\"Can't divide by 0\\\")\\n self[j, i] = self[j, i] / self[i, i]\\n for k in range(i + 1, self.rows_count()):\\n self[j, k] -= self[j, i] * self[i, k]\",\n \"def linear_least_squares(M, v):\\n \\n B = copy(M)\\n [m,n] = shape(B)\\n if rank(B) != min(m,n):\\n print('Warning: can not be solved since the rank of the matrix is not its maximum value')\\n return nan\\n else:\\n \\n A = copy(M)\\n At = transpose(M)\\n b = copy(v)\\n b = transpose(b)\\n \\n AtA = dot(At, A)\\n Atb = transpose(dot(At, b))\\n print(AtA, Atb)\\n \\n x = gauss_elimination(AtA, Atb)\\n print('x*:')\\n return x\",\n \"def normalize_distancematrix(self):\\n INF = self.distmat.max().max()\\n df = self.distmat.fillna(INF)\\n self.distmat = (df - df.min()) / (df.max() - df.min())\",\n \"def set_sudoku_matrix(self, matrix):\\n self.sudoku_matrix = matrix\",\n \"def svd(self):\\n U, s, Vh = la.svd(self)\\n S = np.zeros(self.shape)\\n np.fill_diagonal(S, s)\\n return (Matrix(U), Matrix(S), Matrix(Vh))\",\n \"def normalize(self, row, col):\\n if self.symmetric:\\n return self.mat[row, col] / sqrt(self.train_normalization[row] * self.train_normalization[col])\\n\\n else:\\n return self.mat[row, col] / sqrt(self.test_normalization[row] * self.train_normalization[col])\",\n \"def roll_up_matrix(matrix_dict, l_matrix):\\n frontier = set([(x, 0) for x in range(l_matrix)])\\n while frontier:\\n new_frontier = set()\\n for x, y in frontier:\\n # down\\n if is_valid_index(x+1, y, l_matrix):\\n updated = update_value(x+1, y, x, y, matrix_dict)\\n if updated:\\n new_frontier.add((x+1, y))\\n # right\\n if is_valid_index(x, y+1, l_matrix):\\n updated = update_value(x, y+1, x, y, matrix_dict)\\n if updated:\\n new_frontier.add((x, y+1))\\n # up\\n if is_valid_index(x-1, y, l_matrix):\\n updated = update_value(x-1, y, x, y, matrix_dict)\\n if updated:\\n new_frontier.add((x-1, y))\\n frontier = new_frontier\",\n \"def one_step(self):\\r\\n assert (self.uv_vol is not None)\\r\\n assert (self.guv_vol is not None)\\r\\n assert (self.uv_bound is not None)\\r\\n assert (self.vf_vect_bound is not None)\\r\\n assert (self.vF_vect_vol is not None)\\r\\n # Shape checks\\r\\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\\r\\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\\r\\n assert (self.vF_vect_vol.shape == self.vf_vect_bound.shape)\\r\\n assert (self.uv_vol.shape[0] == self.uv_vol.shape[1])\\r\\n assert (self.uv_vol.shape == self.guv_vol.shape)\\r\\n assert (self.uv_vol.shape == self.uv_bound.shape)\\r\\n assert (self.uv_vol.shape[0] == self.vF_vect_vol.shape[0])\\r\\n \\r\\n if self.step == 0:\\r\\n self.check_k_matrix_stability()\\r\\n # print(\\\"Epsilon is :\\\"+str(self.Epsilon))\\r\\n # print(\\\"Beta is :\\\"+str(self.Beta))\\r\\n\\r\\n # Form \\\"Stiffness\\\" matrix:\\r\\n K = self.make_k_matrix()\\r\\n # Form \\\"Force\\\" vector: \\r\\n f = self.vF_vect_vol + (self.Epsilon / self.Beta) * self.vf_vect_bound\\r\\n\\r\\n # print(\\\"FORCE VECTOR:\\\")\\r\\n # print(f)\\r\\n # print(\\\"STIFFNESS MATRIX\\\")\\r\\n # print(K)\\r\\n # print(\\\"UV_VOL\\\")\\r\\n # print(self.uv_vol)\\r\\n # print(\\\"EPSILON * GUV_VOL\\\")\\r\\n # print(self.Epsilon * self.guv_vol)\\r\\n # print(\\\"UV_BOUND * COEFF\\\")\\r\\n # print((self.Epsilon / self.Beta) * self.uv_bound)\\r\\n sol = scipy_sparse_linsolve(K, f)\\r\\n # print(\\\"SOLUTION\\\")\\r\\n # print(sol)\\r\\n return sol\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6372859","0.55725044","0.55620676","0.55460334","0.5260916","0.5249304","0.51922536","0.5169905","0.51028615","0.5082861","0.5073029","0.50590885","0.5045953","0.49488217","0.49206302","0.49198195","0.49189126","0.49091235","0.4873962","0.4863568","0.48529962","0.48524916","0.48320243","0.48165432","0.48099524","0.47883737","0.47873408","0.47710377","0.47660923","0.4761045","0.4747531","0.4716121","0.4709864","0.46853107","0.46593267","0.46563908","0.46521178","0.46313068","0.46257618","0.46033782","0.45955867","0.45923096","0.45906067","0.4576089","0.45730507","0.45721558","0.4563943","0.4552536","0.4548286","0.45296353","0.4525868","0.45244724","0.45024362","0.44927245","0.44903478","0.44887337","0.44885385","0.44815743","0.44531697","0.44499096","0.4448012","0.44454896","0.4444484","0.4442316","0.44396964","0.44334096","0.44303507","0.44269153","0.44249898","0.44135606","0.4403838","0.43939924","0.43908125","0.43886083","0.43872112","0.43606308","0.43559","0.4354466","0.43446335","0.43425542","0.4337778","0.43249696","0.4320359","0.43163234","0.43056005","0.43048167","0.43006292","0.43005463","0.42954916","0.42870575","0.42864415","0.42757207","0.42588478","0.42569304","0.4256413","0.42531636","0.42489752","0.4248508","0.42413723","0.42410696"],"string":"[\n \"0.6372859\",\n \"0.55725044\",\n \"0.55620676\",\n \"0.55460334\",\n \"0.5260916\",\n \"0.5249304\",\n \"0.51922536\",\n \"0.5169905\",\n \"0.51028615\",\n \"0.5082861\",\n \"0.5073029\",\n \"0.50590885\",\n \"0.5045953\",\n \"0.49488217\",\n \"0.49206302\",\n \"0.49198195\",\n \"0.49189126\",\n \"0.49091235\",\n \"0.4873962\",\n \"0.4863568\",\n \"0.48529962\",\n \"0.48524916\",\n \"0.48320243\",\n \"0.48165432\",\n \"0.48099524\",\n \"0.47883737\",\n \"0.47873408\",\n \"0.47710377\",\n \"0.47660923\",\n \"0.4761045\",\n \"0.4747531\",\n \"0.4716121\",\n \"0.4709864\",\n \"0.46853107\",\n \"0.46593267\",\n \"0.46563908\",\n \"0.46521178\",\n \"0.46313068\",\n \"0.46257618\",\n \"0.46033782\",\n \"0.45955867\",\n \"0.45923096\",\n \"0.45906067\",\n \"0.4576089\",\n \"0.45730507\",\n \"0.45721558\",\n \"0.4563943\",\n \"0.4552536\",\n \"0.4548286\",\n \"0.45296353\",\n \"0.4525868\",\n \"0.45244724\",\n \"0.45024362\",\n \"0.44927245\",\n \"0.44903478\",\n \"0.44887337\",\n \"0.44885385\",\n \"0.44815743\",\n \"0.44531697\",\n \"0.44499096\",\n \"0.4448012\",\n \"0.44454896\",\n \"0.4444484\",\n \"0.4442316\",\n \"0.44396964\",\n \"0.44334096\",\n \"0.44303507\",\n \"0.44269153\",\n \"0.44249898\",\n \"0.44135606\",\n \"0.4403838\",\n \"0.43939924\",\n \"0.43908125\",\n \"0.43886083\",\n \"0.43872112\",\n \"0.43606308\",\n \"0.43559\",\n \"0.4354466\",\n \"0.43446335\",\n \"0.43425542\",\n \"0.4337778\",\n \"0.43249696\",\n \"0.4320359\",\n \"0.43163234\",\n \"0.43056005\",\n \"0.43048167\",\n \"0.43006292\",\n \"0.43005463\",\n \"0.42954916\",\n \"0.42870575\",\n \"0.42864415\",\n \"0.42757207\",\n \"0.42588478\",\n \"0.42569304\",\n \"0.4256413\",\n \"0.42531636\",\n \"0.42489752\",\n \"0.4248508\",\n \"0.42413723\",\n \"0.42410696\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7536742"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83691,"cells":{"query":{"kind":"string","value":"This is f's docstring."},"document":{"kind":"string","value":"def f(x, y, z=3):\n pass # pragma: nocover"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def func_doc():","def __doc__(self, ???):","def __doc__(self):\n return self.fget.__doc__","def DocString():\n return","def docstring_hack():\n pass","def main_docstring():","def _add_doc(func, doc):\r\n func.__doc__ = doc","def _add_doc(func, doc):\r\n func.__doc__ = doc","def _add_doc(func, doc):\r\n func.__doc__ = doc","def get_full_descriptionf(self, *args, **kwargs):\n\n def func(f):\n doc = f.__doc__\n self.get_full_description(doc or \"\", *args, **kwargs)\n return f\n\n return func","def _add_doc(func, doc):\n func.__doc__ = doc","def test_fs_func_docstrings(self):\n for func in self.fs_f:\n self.assertIsNot(func[1].__doc__, None,\n \"{:s} method needs a docstring\".format(func[0]))\n self.assertTrue(len(func[1].__doc__) >= 1,\n \"{:s} method needs a docstring\".format(func[0]))","def doc_string():\n pass # pass does nothing","def fini_doc(self):\n raise NotImplementedError()","def public_fn_with_googley_docstring(self, name, another, state=None):\n return 0","def get_documentation(self, *args, **dargs):\n pass","def description_from_docstring(self, fn):\n docstring = getattr(fn, '__doc__', None) or ''\n description = normalize_indent(docstring)\n return self.description(description)(fn)","def empty_fn_docstr():","def consistent_documentation():\n\n return 3","def fopenhelp(self):","def old_function_with_docstring(x, y):\n return x + y","def docs():","def undoc(func):\n return func","def test_doc():\n pass","def docstrings(param1, param2):\n return \"example string\"","def __call__(self, func):\n func.__doc__ = self.doc\n return func","def doc_apply(doc):\n\n def wrapper(func):\n func.__doc__ = doc\n return func\n\n return wrapper","def test_user_func_docstrings(self):\n for func in self.student_f:\n self.assertIsNot(func[1].__doc__, None,\n \"{:s} method needs a docstring\".format(func[0]))\n self.assertTrue(len(func[1].__doc__) >= 1,\n \"{:s} method needs a docstring\".format(func[0]))","def docstring(func):\n try:\n lines = func.__doc__.strip().split(\"\\n\")\n return [line.strip() for line in lines]\n except AttributeError:\n return None","def init_doc(self):\n raise NotImplementedError()","def __init__(self, func):\n self.doc = func.__doc__","def read_documentation(self, fid):\r\n\r\n lin = self.read_line(fid)\r\n while lin[0] != ':':\r\n self.documentation.append(lin)\r\n lin = self.read_line(fid)\r\n return lin","def _get_cmd_description(fct):\n try:\n return fct.__doc__.strip('\\n')\n except:\n return \"\"","def empty_fn_docstr_pass():\n pass","def getDoc(self):\r\n return self.__doc__","def __repr__(self):\n\t\treturn self.func.__doc__","def getHelp(self,func = None):\n if func == None:\n print(self.__doc__)\n pass\n else:\n print(func.__doc__)\n pass","def __repr__(self):\r\n return self.func.__doc__","def __repr__(self):\r\n return self.func.__doc__","def __repr__(self):\r\n return self.func.__doc__","def __repr__(self):\r\n return self.func.__doc__","def __repr__(self):\r\n return self.func.__doc__","def __repr__(self):\r\n return self.func.__doc__","def __repr__(self):\n return self.func.__doc__","def __repr__(self):\n return self.func.__doc__","def __repr__(self):\n return self.func.__doc__","def _get_doc(self, name):\r\n doc = \"No documentation for %s\" % name\r\n\r\n engine = self._engine\r\n if not engine:\r\n msg = \"Session is not open\"\r\n raise Oct2PyError(msg)\r\n doc = engine.eval('help(\"%s\")' % name, silent=True)\r\n\r\n if \"syntax error:\" in doc.lower():\r\n raise Oct2PyError(doc)\r\n\r\n if \"error:\" in doc.lower():\r\n doc = engine.eval('type(\"%s\")' % name, silent=True)\r\n doc = \"\\n\".join(doc.splitlines()[:3])\r\n\r\n default = self.feval.__doc__\r\n default = \" \" + default[default.find(\"func_args:\") :] # type:ignore\r\n default = \"\\n\".join([line[8:] for line in default.splitlines()])\r\n\r\n doc = \"\\n\".join(doc.splitlines())\r\n doc = \"\\n\" + doc + \"\\n\\nParameters\\n----------\\n\" + default\r\n doc += \"\\n**kwargs - Deprecated keyword arguments\\n\\n\"\r\n doc += \"Notes\\n-----\\n\"\r\n doc += \"Keyword arguments to dynamic functions are deprecated.\\n\"\r\n doc += \"The `plot_*` kwargs will be ignored, but the rest will\\n\"\r\n doc += \"used as key - value pairs as in version 3.x.\\n\"\r\n doc += \"Use `set_plot_settings()` for plot settings, and use\\n\"\r\n doc += \"`func_args` directly for key - value pairs.\"\r\n return doc","def __repr__(self):\n return self.func.__doc__","def __repr__(self):\n return self.func.__doc__","def __repr__(self):\n return self.func.__doc__","def __repr__(self):\n return self.func.__doc__","def __repr__(self):\n return self.func.__doc__","def __repr__(self):\n return self.func.__doc__","def __repr__(self):\n return self.func.__doc__","def __repr__(self):\n return self.func.__doc__","def save_docstring(self, key):\n\n def func(f):\n self.params[key] = f.__doc__ or \"\"\n return f\n\n return func","def docstring_example(name, age, role='manager'):\n print(name, age, role)","def docstring_format(*values):\n\n def _decorator_(function):\n function.__doc__ = function.__doc__.format(*values).replace('_', '\\_')\n return function\n\n return _decorator_","def guess(cls, docstring):","def bus_func_doc(self, bus):\n return None","def show_details(name, f, is_partial=False):\n print '%s:' % name\n print '\\tobject:', f\n if not is_partial:\n print '\\t__name__:', f.__name__\n print '\\t__doc__', repr(f.__doc__)\n if is_partial:\n print '\\tfunc:', f.func\n print '\\targs:', f.args\n print '\\tkeywords:', f.keywords\n return","def pythondoc(self, irc, msg, args, num, req):\n self.googleq('http://docs.python.org/library/', req, num, irc)","def def_textface_doctests():","def explain(self):","def wrapper(func):\n docstring = func.__doc__\n helpdict = parse_docstring(\n docstring, key_symbol=key_symbol,\n description_symbol=description_symbol)\n func.helpdict = helpdict\n # remove markers\n docstring = docstring.replace(key_symbol, '')\n func.__doc__ = docstring.replace(description_symbol, '')\n return func","def describe(f, verbose=False):\n return better_arg_spec(f, verbose)","def test_docstring(self):\n self.assertTrue(len(FileStorage.__doc__) > 1)\n self.assertTrue(len(FileStorage.all.__doc__) > 1)\n self.assertTrue(len(FileStorage.new.__doc__) > 1)\n self.assertTrue(len(FileStorage.save.__doc__) > 1)\n self.assertTrue(len(FileStorage.reload.__doc__) > 1)","def documentation_only():\n pass","def documento():\r\n\tpass","def test_doc_fun(self):\n for fun in self.functions:\n self.assertTrue(len(fun.__doc__) > 0)","def test_user_func_docstrings(self):\n for func in self.user_f:\n self.assertIsNot(func[1].__doc__, None,\n \"{:s} method needs a docstring\".format(func[0]))\n self.assertTrue(len(func[1].__doc__) >= 1,\n \"{:s} method needs a docstring\".format(func[0]))","def magic_pdoc(self, parameter_s=''):\n self._inspect('pdoc',parameter_s)","def triple_quote_docs():\n return","def test_state_func_docstrings(self):\n for func in self.state_f:\n self.assertIsNot(func[1].__doc__, None,\n \"{:s} method failed in docstring\".format(func[0]))\n self.assertTrue(len(func[1].__doc__) >= 1,\n \"{:s} method failed in docstring\".format(func[0]))","def get_main_help(self):\r\n return __doc__.strip()","def _summary(function):\n if not function.__doc__:\n return \"{}.\".format(function.__name__.capitalize())\n result = []\n for word in function.__doc__.split():\n result.append(word)\n if word.endswith(\".\"):\n break\n return \" \".join(result)","def function(self, name):\n return function_documentor(name)","def cppdoc(self, irc, msg, args, num, req):\n self.googleq('www.cplusplus.com/reference/', req, num, irc)","def test_dbs_func_docstrings(self):\n for func in self.dbs_f:\n self.assertIsNot(func[1].__doc__, None,\n \"{:s} method needs a docstring\".format(func[0]))\n self.assertTrue(len(func[1].__doc__) >= 1,\n \"{:s} method needs a docstring\".format(func[0]))","def test_dbs_func_docstrings(self):\n for func in self.dbs_f:\n self.assertIsNot(func[1].__doc__, None,\n \"{:s} method needs a docstring\".format(func[0]))\n self.assertTrue(len(func[1].__doc__) >= 1,\n \"{:s} method needs a docstring\".format(func[0]))","def get_doc(cls_or_func):\n try:\n return cls_or_func.__doc__.split(\"\\n\")[0].strip()\n except (AttributeError, IndexError):\n return None","def dummy(doc):\r\n return doc","def summary_from_docstring(self, fn):\n docstring = getattr(fn, '__doc__', None) or ''\n description = normalize_indent(docstring)\n summary = description.split('\\n', 1)[0].strip()[:120]\n return self.summary(summary)(fn)","def test_docstring(self):\n self.assertIsNotNone(Review.__doc__)","def has_docstring(func):\n\n return func.__doc__ is not None","def f():","def f():","def test_docstring(self):\n self.assertIsNotNone(Review.__doc__)\n self.assertIsNotNone(Review.text.__doc__)","def fn(): # fn definition # help2\r\n print(my_text)","def get_summaryf(self, *args, **kwargs):\n\n def func(f):\n doc = f.__doc__\n self.get_summary(doc or \"\", *args, **kwargs)\n return f\n\n return func","def brief_documentation(method: object) -> str:\n doc = method.__doc__\n if doc is not None:\n lines = doc.splitlines()\n if len(lines) > 0:\n return lines[0]\n return ''","def docstring_parameter(*args, **kwargs):\n\n def dec(obj):\n obj.__doc__ = obj.__doc__.format(*args, **kwargs)\n return obj\n\n return dec","def fluid_func_doc(self, label):\n indices = list(range(1, self.num_i + 1))\n if len(indices) > 1:\n indices = ', '.join(str(idx) for idx in indices)\n else:\n indices = str(indices[0])\n latex = (\n r'0=x_{fl\\mathrm{,in,}i}-x_{fl\\mathrm{,out,}i}\\;'\n r'\\forall fl \\in\\text{network fluids,}'\n r'\\; \\forall i \\in [' + indices + r']')\n return generate_latex_eq(self, latex, label)","def store_documentation(self, file_path, *args, **dargs):\n pass","def docstring(self):\n raw_description = self.qualifiers.get(\"description\")\n\n # short circuit if there isn't a description to process\n if not raw_description:\n _LOGGER.debug(\"No raw description found in MOF, substituting placeholder\")\n return \"No documentation in MOF\"\n\n # process the raw description, normalizing whitespace and special characters\n _LOGGER.debug(\"Normalizing raw description from MOF:\\n%s\", raw_description)\n normalized_lines = []\n for raw_line in raw_description:\n # split to normalize \\n in the entry\n normalized_line_elements = []\n for text in raw_line.split():\n # strip leading/trailing whitespace\n stripped_text = text.strip()\n # escape any special rst characters\n escaped_text = stripped_text.replace('*', '\\*')\n # add to normalized line elements\n normalized_line_elements.append(escaped_text)\n # create normalized line and save it\n normalized_line = \" \".join(normalized_line_elements)\n normalized_lines.append(normalized_line)\n\n # create and return the normalized line block\n normalized_description = \"\\n\".join(normalized_lines)\n _LOGGER.debug(\"Normalized description is:\\n%s\", normalized_description)\n return normalized_description","def lispdoc(self, irc, msg, args, num, req):\n self.googleq('http://lispdoc.com/', req, num, irc)","def sayHello():\r\n#we can specify two choices one that gives the purpose of the function with docstring\r\n\r\n print(\"Hello from module.py!\")\r\n a=list\r\n c=\"a\"+\"i\"\r\n print(c)\r\n # calling docstring command can later be made into a function\r","def name(self):\n return self.__doc__.split('\\n')[0]","def description():","def test_module_doc(self):\n self.assertTrue(len(r.__doc__) > 10)","def docstring(self) -> str:\n out = f\"{self.model.__module__}.{self.model.__qualname__}\"\n docstring = inspect.getdoc(self.model)\n if docstring:\n out += \"\\n\\n\" + docstring\n return out"],"string":"[\n \"def func_doc():\",\n \"def __doc__(self, ???):\",\n \"def __doc__(self):\\n return self.fget.__doc__\",\n \"def DocString():\\n return\",\n \"def docstring_hack():\\n pass\",\n \"def main_docstring():\",\n \"def _add_doc(func, doc):\\r\\n func.__doc__ = doc\",\n \"def _add_doc(func, doc):\\r\\n func.__doc__ = doc\",\n \"def _add_doc(func, doc):\\r\\n func.__doc__ = doc\",\n \"def get_full_descriptionf(self, *args, **kwargs):\\n\\n def func(f):\\n doc = f.__doc__\\n self.get_full_description(doc or \\\"\\\", *args, **kwargs)\\n return f\\n\\n return func\",\n \"def _add_doc(func, doc):\\n func.__doc__ = doc\",\n \"def test_fs_func_docstrings(self):\\n for func in self.fs_f:\\n self.assertIsNot(func[1].__doc__, None,\\n \\\"{:s} method needs a docstring\\\".format(func[0]))\\n self.assertTrue(len(func[1].__doc__) >= 1,\\n \\\"{:s} method needs a docstring\\\".format(func[0]))\",\n \"def doc_string():\\n pass # pass does nothing\",\n \"def fini_doc(self):\\n raise NotImplementedError()\",\n \"def public_fn_with_googley_docstring(self, name, another, state=None):\\n return 0\",\n \"def get_documentation(self, *args, **dargs):\\n pass\",\n \"def description_from_docstring(self, fn):\\n docstring = getattr(fn, '__doc__', None) or ''\\n description = normalize_indent(docstring)\\n return self.description(description)(fn)\",\n \"def empty_fn_docstr():\",\n \"def consistent_documentation():\\n\\n return 3\",\n \"def fopenhelp(self):\",\n \"def old_function_with_docstring(x, y):\\n return x + y\",\n \"def docs():\",\n \"def undoc(func):\\n return func\",\n \"def test_doc():\\n pass\",\n \"def docstrings(param1, param2):\\n return \\\"example string\\\"\",\n \"def __call__(self, func):\\n func.__doc__ = self.doc\\n return func\",\n \"def doc_apply(doc):\\n\\n def wrapper(func):\\n func.__doc__ = doc\\n return func\\n\\n return wrapper\",\n \"def test_user_func_docstrings(self):\\n for func in self.student_f:\\n self.assertIsNot(func[1].__doc__, None,\\n \\\"{:s} method needs a docstring\\\".format(func[0]))\\n self.assertTrue(len(func[1].__doc__) >= 1,\\n \\\"{:s} method needs a docstring\\\".format(func[0]))\",\n \"def docstring(func):\\n try:\\n lines = func.__doc__.strip().split(\\\"\\\\n\\\")\\n return [line.strip() for line in lines]\\n except AttributeError:\\n return None\",\n \"def init_doc(self):\\n raise NotImplementedError()\",\n \"def __init__(self, func):\\n self.doc = func.__doc__\",\n \"def read_documentation(self, fid):\\r\\n\\r\\n lin = self.read_line(fid)\\r\\n while lin[0] != ':':\\r\\n self.documentation.append(lin)\\r\\n lin = self.read_line(fid)\\r\\n return lin\",\n \"def _get_cmd_description(fct):\\n try:\\n return fct.__doc__.strip('\\\\n')\\n except:\\n return \\\"\\\"\",\n \"def empty_fn_docstr_pass():\\n pass\",\n \"def getDoc(self):\\r\\n return self.__doc__\",\n \"def __repr__(self):\\n\\t\\treturn self.func.__doc__\",\n \"def getHelp(self,func = None):\\n if func == None:\\n print(self.__doc__)\\n pass\\n else:\\n print(func.__doc__)\\n pass\",\n \"def __repr__(self):\\r\\n return self.func.__doc__\",\n \"def __repr__(self):\\r\\n return self.func.__doc__\",\n \"def __repr__(self):\\r\\n return self.func.__doc__\",\n \"def __repr__(self):\\r\\n return self.func.__doc__\",\n \"def __repr__(self):\\r\\n return self.func.__doc__\",\n \"def __repr__(self):\\r\\n return self.func.__doc__\",\n \"def __repr__(self):\\n return self.func.__doc__\",\n \"def __repr__(self):\\n return self.func.__doc__\",\n \"def __repr__(self):\\n return self.func.__doc__\",\n \"def _get_doc(self, name):\\r\\n doc = \\\"No documentation for %s\\\" % name\\r\\n\\r\\n engine = self._engine\\r\\n if not engine:\\r\\n msg = \\\"Session is not open\\\"\\r\\n raise Oct2PyError(msg)\\r\\n doc = engine.eval('help(\\\"%s\\\")' % name, silent=True)\\r\\n\\r\\n if \\\"syntax error:\\\" in doc.lower():\\r\\n raise Oct2PyError(doc)\\r\\n\\r\\n if \\\"error:\\\" in doc.lower():\\r\\n doc = engine.eval('type(\\\"%s\\\")' % name, silent=True)\\r\\n doc = \\\"\\\\n\\\".join(doc.splitlines()[:3])\\r\\n\\r\\n default = self.feval.__doc__\\r\\n default = \\\" \\\" + default[default.find(\\\"func_args:\\\") :] # type:ignore\\r\\n default = \\\"\\\\n\\\".join([line[8:] for line in default.splitlines()])\\r\\n\\r\\n doc = \\\"\\\\n\\\".join(doc.splitlines())\\r\\n doc = \\\"\\\\n\\\" + doc + \\\"\\\\n\\\\nParameters\\\\n----------\\\\n\\\" + default\\r\\n doc += \\\"\\\\n**kwargs - Deprecated keyword arguments\\\\n\\\\n\\\"\\r\\n doc += \\\"Notes\\\\n-----\\\\n\\\"\\r\\n doc += \\\"Keyword arguments to dynamic functions are deprecated.\\\\n\\\"\\r\\n doc += \\\"The `plot_*` kwargs will be ignored, but the rest will\\\\n\\\"\\r\\n doc += \\\"used as key - value pairs as in version 3.x.\\\\n\\\"\\r\\n doc += \\\"Use `set_plot_settings()` for plot settings, and use\\\\n\\\"\\r\\n doc += \\\"`func_args` directly for key - value pairs.\\\"\\r\\n return doc\",\n \"def __repr__(self):\\n return self.func.__doc__\",\n \"def __repr__(self):\\n return self.func.__doc__\",\n \"def __repr__(self):\\n return self.func.__doc__\",\n \"def __repr__(self):\\n return self.func.__doc__\",\n \"def __repr__(self):\\n return self.func.__doc__\",\n \"def __repr__(self):\\n return self.func.__doc__\",\n \"def __repr__(self):\\n return self.func.__doc__\",\n \"def __repr__(self):\\n return self.func.__doc__\",\n \"def save_docstring(self, key):\\n\\n def func(f):\\n self.params[key] = f.__doc__ or \\\"\\\"\\n return f\\n\\n return func\",\n \"def docstring_example(name, age, role='manager'):\\n print(name, age, role)\",\n \"def docstring_format(*values):\\n\\n def _decorator_(function):\\n function.__doc__ = function.__doc__.format(*values).replace('_', '\\\\_')\\n return function\\n\\n return _decorator_\",\n \"def guess(cls, docstring):\",\n \"def bus_func_doc(self, bus):\\n return None\",\n \"def show_details(name, f, is_partial=False):\\n print '%s:' % name\\n print '\\\\tobject:', f\\n if not is_partial:\\n print '\\\\t__name__:', f.__name__\\n print '\\\\t__doc__', repr(f.__doc__)\\n if is_partial:\\n print '\\\\tfunc:', f.func\\n print '\\\\targs:', f.args\\n print '\\\\tkeywords:', f.keywords\\n return\",\n \"def pythondoc(self, irc, msg, args, num, req):\\n self.googleq('http://docs.python.org/library/', req, num, irc)\",\n \"def def_textface_doctests():\",\n \"def explain(self):\",\n \"def wrapper(func):\\n docstring = func.__doc__\\n helpdict = parse_docstring(\\n docstring, key_symbol=key_symbol,\\n description_symbol=description_symbol)\\n func.helpdict = helpdict\\n # remove markers\\n docstring = docstring.replace(key_symbol, '')\\n func.__doc__ = docstring.replace(description_symbol, '')\\n return func\",\n \"def describe(f, verbose=False):\\n return better_arg_spec(f, verbose)\",\n \"def test_docstring(self):\\n self.assertTrue(len(FileStorage.__doc__) > 1)\\n self.assertTrue(len(FileStorage.all.__doc__) > 1)\\n self.assertTrue(len(FileStorage.new.__doc__) > 1)\\n self.assertTrue(len(FileStorage.save.__doc__) > 1)\\n self.assertTrue(len(FileStorage.reload.__doc__) > 1)\",\n \"def documentation_only():\\n pass\",\n \"def documento():\\r\\n\\tpass\",\n \"def test_doc_fun(self):\\n for fun in self.functions:\\n self.assertTrue(len(fun.__doc__) > 0)\",\n \"def test_user_func_docstrings(self):\\n for func in self.user_f:\\n self.assertIsNot(func[1].__doc__, None,\\n \\\"{:s} method needs a docstring\\\".format(func[0]))\\n self.assertTrue(len(func[1].__doc__) >= 1,\\n \\\"{:s} method needs a docstring\\\".format(func[0]))\",\n \"def magic_pdoc(self, parameter_s=''):\\n self._inspect('pdoc',parameter_s)\",\n \"def triple_quote_docs():\\n return\",\n \"def test_state_func_docstrings(self):\\n for func in self.state_f:\\n self.assertIsNot(func[1].__doc__, None,\\n \\\"{:s} method failed in docstring\\\".format(func[0]))\\n self.assertTrue(len(func[1].__doc__) >= 1,\\n \\\"{:s} method failed in docstring\\\".format(func[0]))\",\n \"def get_main_help(self):\\r\\n return __doc__.strip()\",\n \"def _summary(function):\\n if not function.__doc__:\\n return \\\"{}.\\\".format(function.__name__.capitalize())\\n result = []\\n for word in function.__doc__.split():\\n result.append(word)\\n if word.endswith(\\\".\\\"):\\n break\\n return \\\" \\\".join(result)\",\n \"def function(self, name):\\n return function_documentor(name)\",\n \"def cppdoc(self, irc, msg, args, num, req):\\n self.googleq('www.cplusplus.com/reference/', req, num, irc)\",\n \"def test_dbs_func_docstrings(self):\\n for func in self.dbs_f:\\n self.assertIsNot(func[1].__doc__, None,\\n \\\"{:s} method needs a docstring\\\".format(func[0]))\\n self.assertTrue(len(func[1].__doc__) >= 1,\\n \\\"{:s} method needs a docstring\\\".format(func[0]))\",\n \"def test_dbs_func_docstrings(self):\\n for func in self.dbs_f:\\n self.assertIsNot(func[1].__doc__, None,\\n \\\"{:s} method needs a docstring\\\".format(func[0]))\\n self.assertTrue(len(func[1].__doc__) >= 1,\\n \\\"{:s} method needs a docstring\\\".format(func[0]))\",\n \"def get_doc(cls_or_func):\\n try:\\n return cls_or_func.__doc__.split(\\\"\\\\n\\\")[0].strip()\\n except (AttributeError, IndexError):\\n return None\",\n \"def dummy(doc):\\r\\n return doc\",\n \"def summary_from_docstring(self, fn):\\n docstring = getattr(fn, '__doc__', None) or ''\\n description = normalize_indent(docstring)\\n summary = description.split('\\\\n', 1)[0].strip()[:120]\\n return self.summary(summary)(fn)\",\n \"def test_docstring(self):\\n self.assertIsNotNone(Review.__doc__)\",\n \"def has_docstring(func):\\n\\n return func.__doc__ is not None\",\n \"def f():\",\n \"def f():\",\n \"def test_docstring(self):\\n self.assertIsNotNone(Review.__doc__)\\n self.assertIsNotNone(Review.text.__doc__)\",\n \"def fn(): # fn definition # help2\\r\\n print(my_text)\",\n \"def get_summaryf(self, *args, **kwargs):\\n\\n def func(f):\\n doc = f.__doc__\\n self.get_summary(doc or \\\"\\\", *args, **kwargs)\\n return f\\n\\n return func\",\n \"def brief_documentation(method: object) -> str:\\n doc = method.__doc__\\n if doc is not None:\\n lines = doc.splitlines()\\n if len(lines) > 0:\\n return lines[0]\\n return ''\",\n \"def docstring_parameter(*args, **kwargs):\\n\\n def dec(obj):\\n obj.__doc__ = obj.__doc__.format(*args, **kwargs)\\n return obj\\n\\n return dec\",\n \"def fluid_func_doc(self, label):\\n indices = list(range(1, self.num_i + 1))\\n if len(indices) > 1:\\n indices = ', '.join(str(idx) for idx in indices)\\n else:\\n indices = str(indices[0])\\n latex = (\\n r'0=x_{fl\\\\mathrm{,in,}i}-x_{fl\\\\mathrm{,out,}i}\\\\;'\\n r'\\\\forall fl \\\\in\\\\text{network fluids,}'\\n r'\\\\; \\\\forall i \\\\in [' + indices + r']')\\n return generate_latex_eq(self, latex, label)\",\n \"def store_documentation(self, file_path, *args, **dargs):\\n pass\",\n \"def docstring(self):\\n raw_description = self.qualifiers.get(\\\"description\\\")\\n\\n # short circuit if there isn't a description to process\\n if not raw_description:\\n _LOGGER.debug(\\\"No raw description found in MOF, substituting placeholder\\\")\\n return \\\"No documentation in MOF\\\"\\n\\n # process the raw description, normalizing whitespace and special characters\\n _LOGGER.debug(\\\"Normalizing raw description from MOF:\\\\n%s\\\", raw_description)\\n normalized_lines = []\\n for raw_line in raw_description:\\n # split to normalize \\\\n in the entry\\n normalized_line_elements = []\\n for text in raw_line.split():\\n # strip leading/trailing whitespace\\n stripped_text = text.strip()\\n # escape any special rst characters\\n escaped_text = stripped_text.replace('*', '\\\\*')\\n # add to normalized line elements\\n normalized_line_elements.append(escaped_text)\\n # create normalized line and save it\\n normalized_line = \\\" \\\".join(normalized_line_elements)\\n normalized_lines.append(normalized_line)\\n\\n # create and return the normalized line block\\n normalized_description = \\\"\\\\n\\\".join(normalized_lines)\\n _LOGGER.debug(\\\"Normalized description is:\\\\n%s\\\", normalized_description)\\n return normalized_description\",\n \"def lispdoc(self, irc, msg, args, num, req):\\n self.googleq('http://lispdoc.com/', req, num, irc)\",\n \"def sayHello():\\r\\n#we can specify two choices one that gives the purpose of the function with docstring\\r\\n\\r\\n print(\\\"Hello from module.py!\\\")\\r\\n a=list\\r\\n c=\\\"a\\\"+\\\"i\\\"\\r\\n print(c)\\r\\n # calling docstring command can later be made into a function\\r\",\n \"def name(self):\\n return self.__doc__.split('\\\\n')[0]\",\n \"def description():\",\n \"def test_module_doc(self):\\n self.assertTrue(len(r.__doc__) > 10)\",\n \"def docstring(self) -> str:\\n out = f\\\"{self.model.__module__}.{self.model.__qualname__}\\\"\\n docstring = inspect.getdoc(self.model)\\n if docstring:\\n out += \\\"\\\\n\\\\n\\\" + docstring\\n return out\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79845726","0.73985684","0.73007876","0.7260358","0.72601354","0.7231814","0.7113083","0.7113083","0.7113083","0.7067614","0.70261246","0.69841033","0.6801731","0.67647177","0.66249096","0.6610375","0.66060334","0.6599858","0.6567463","0.6557377","0.6538244","0.6534646","0.6509945","0.6497378","0.64685273","0.6424645","0.64230496","0.64195126","0.6405251","0.6394038","0.63907236","0.63893324","0.6331115","0.632142","0.63201845","0.63173693","0.6316404","0.62993616","0.62993616","0.62993616","0.62993616","0.62993616","0.628321","0.6269104","0.6269104","0.6269104","0.6264636","0.6262099","0.6262099","0.6262099","0.6262099","0.6262099","0.6262099","0.6262099","0.6262099","0.62537676","0.62516904","0.6236316","0.6216887","0.6215439","0.62142223","0.6213311","0.6205502","0.6201173","0.6190901","0.6174267","0.61715406","0.6167711","0.61391574","0.61391145","0.61214226","0.60802597","0.6075084","0.606841","0.60633737","0.60367763","0.603492","0.60261816","0.60256356","0.60256356","0.60200334","0.60191554","0.60162896","0.60116756","0.601064","0.60045075","0.60045075","0.5995219","0.59935105","0.59876573","0.5982283","0.5978882","0.5976222","0.59716946","0.5968304","0.5959052","0.5953032","0.5948224","0.59424967","0.59406435","0.5933814"],"string":"[\n \"0.79845726\",\n \"0.73985684\",\n \"0.73007876\",\n \"0.7260358\",\n \"0.72601354\",\n \"0.7231814\",\n \"0.7113083\",\n \"0.7113083\",\n \"0.7113083\",\n \"0.7067614\",\n \"0.70261246\",\n \"0.69841033\",\n \"0.6801731\",\n \"0.67647177\",\n \"0.66249096\",\n \"0.6610375\",\n \"0.66060334\",\n \"0.6599858\",\n \"0.6567463\",\n \"0.6557377\",\n \"0.6538244\",\n \"0.6534646\",\n \"0.6509945\",\n \"0.6497378\",\n \"0.64685273\",\n \"0.6424645\",\n \"0.64230496\",\n \"0.64195126\",\n \"0.6405251\",\n \"0.6394038\",\n \"0.63907236\",\n \"0.63893324\",\n \"0.6331115\",\n \"0.632142\",\n \"0.63201845\",\n \"0.63173693\",\n \"0.6316404\",\n \"0.62993616\",\n \"0.62993616\",\n \"0.62993616\",\n \"0.62993616\",\n \"0.62993616\",\n \"0.628321\",\n \"0.6269104\",\n \"0.6269104\",\n \"0.6269104\",\n \"0.6264636\",\n \"0.6262099\",\n \"0.6262099\",\n \"0.6262099\",\n \"0.6262099\",\n \"0.6262099\",\n \"0.6262099\",\n \"0.6262099\",\n \"0.6262099\",\n \"0.62537676\",\n \"0.62516904\",\n \"0.6236316\",\n \"0.6216887\",\n \"0.6215439\",\n \"0.62142223\",\n \"0.6213311\",\n \"0.6205502\",\n \"0.6201173\",\n \"0.6190901\",\n \"0.6174267\",\n \"0.61715406\",\n \"0.6167711\",\n \"0.61391574\",\n \"0.61391145\",\n \"0.61214226\",\n \"0.60802597\",\n \"0.6075084\",\n \"0.606841\",\n \"0.60633737\",\n \"0.60367763\",\n \"0.603492\",\n \"0.60261816\",\n \"0.60256356\",\n \"0.60256356\",\n \"0.60200334\",\n \"0.60191554\",\n \"0.60162896\",\n \"0.60116756\",\n \"0.601064\",\n \"0.60045075\",\n \"0.60045075\",\n \"0.5995219\",\n \"0.59935105\",\n \"0.59876573\",\n \"0.5982283\",\n \"0.5978882\",\n \"0.5976222\",\n \"0.59716946\",\n \"0.5968304\",\n \"0.5959052\",\n \"0.5953032\",\n \"0.5948224\",\n \"0.59424967\",\n \"0.59406435\",\n \"0.5933814\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83692,"cells":{"query":{"kind":"string","value":"Test getting an analysis when it exists in the database."},"document":{"kind":"string","value":"def test_get_analysis_with_id(analysis_store: MockStore):\n # GIVEN a store with an analysis\n existing_analysis: Analysis = analysis_store.get_query(table=Analysis).first()\n\n # WHEN accessing it by ID\n analysis: Analysis = analysis_store.get_analysis_with_id(analysis_id=existing_analysis.id)\n\n # THEN it should return the same analysis\n assert analysis == existing_analysis"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_get_analysis_with_id_when_missing(analysis_store: MockStore):\n # GIVEN an id that doesn't exist\n missing_analysis_id = 12312423534\n\n # WHEN accessing the analysis\n analysis: Analysis = analysis_store.get_analysis_with_id(analysis_id=missing_analysis_id)\n\n # THEN it should return None\n assert not analysis","def test_data_source_soaps_id_exists_get(self):\n pass","def test_exist(self):\n with self.assertRaises(IncompetentQiitaDeveloperError):\n MetadataTemplate.exists(self.study)","def test_analysis_match(self):\n self.api.observable_add('test.com')\n results = self.api.analysis_match(['test.com', 'unknown.com'])\n known = [o['value'] for o in results['known']]\n self.assertIn('test.com', known)\n self.assertIn('unknown.com', results['unknown'])","def test_get_study_missing(self):\n self.assertIsNone(self.storage.get_study('missing'))","def test_no_one_in_db(self):\n q = self.generate_query('view_manager_report', ())\n res = self.execute_query(q)\n expected = []\n assert len(res) == 0, f'There is suppose to be an empty summary {res}'\n assert res == expected, f'The result is suppose to be empty {res}'","def test_data_source_soaps_find_one_get(self):\n pass","def test_exists_true(self):\n self.assertTrue(SampleTemplate.exists(self.test_study.id))","def test_exists_true(self):\n self.assertTrue(Sample.exists(self.sample_id, self.sample_template))","def testDatabase(self):\n con = self.getMetadataDatabaseConnection()\n if con:\n return True","def test_check_database_exists(self):\n query_result = [{'streamalert': True}]\n self.client.athena_client = MockAthenaClient(results=query_result)\n\n assert_true(self.client.check_database_exists())","def test_get(self, init_db, audit):\n assert Audit.get(audit.id) == audit","def test_workflows_id_exists_get(self):\n pass","def test_query_1(self):\n with app.test_request_context():\n agency_none = db.session.query(\n Agency).filter_by(name=\"not here\").first()\n self.assertTrue(agency_none is None)","def test_article_exist(self):\n\n article = Article.objects.get(title='Test title')\n self.assertEqual(article.author, 'Roman')","def test_if_the_view_for_the_first_exists(self): \n test_song = Song.objects.get(title=\"fake\")\n response = self.client.get('/songs/'+str(test_song.pk)+'/')\n self.assertEqual(response.status_code, 200)","def checkIfMeasuringObjectExists(table, name, fk):\n\ttry:\n\t\tcon = sqlite3.connect('PampDb.db')\n\t\tcur = con.cursor()\n\t\tcur.execute(\"SELECT * FROM \" + table + \" WHERE name='\" + name + \"'\")\n\t\tob = cur.fetchall()\n\t\tbo = False\n\t\tif not ob:\n\t\t\tcur.execute(\"INSERT INTO '\" + table + \"' (name, organisationId) VALUES ('\" + name + \"', '\" + str(fk) + \"')\")\n\t\t\tcon.commit()\n\t\t\tcur.execute(\"SELECT * FROM \" + table + \" WHERE name='\" + name + \"'\")\n\t\t\tobj = cur.fetchall()\n\t\t\tcorObj = obj[0]\n\t\t\treturn corObj\n\t\telse:\n\t\t\tfor row in ob:\n\t\t\t\tif row[2] == fk:\n\t\t\t\t\tbo = True\n\t\t\t\t\treturn row\n\t\t\tif not bo:\n\t\t\t\tcur.execute(\"INSERT INTO '\" + table + \"' (name, organisationId) VALUES ('\" + name + \"', '\" + str(fk) + \"')\")\n\t\t\t\tcon.commit()\n\t\t\t\tcur.execute(\"SELECT * FROM \" + table + \" WHERE name='\" + name + \"' AND organisationId='\" + str(fk) + \"'\")\n\t\t\t\tobj = cur.fetchall()\n\t\t\t\tcorObj = obj[0]\n\t\t\t\treturn corObj\n\t\tcon.commit()\n\t\tcon.close()\n\texcept:\n\t\tprint('Could not run function checkIfMeasuringObjectExists from DbController')","def test_import(self):\n self.import_report(self.report_json)\n self.database.reports.insert_one.assert_called_once()","def test_includes_one_new_dataset(self):\n new_dataset = factories.SourceDatasetFactory.create(source_study_version=self.study_version_3)\n response = self.client.get(self.get_url(self.study.pk))\n context = response.context\n table = context['source_dataset_table']\n self.assertIn(new_dataset, table.data)","def createAnalysis(self, study_id):\n try:\n con = self.getSFFDatabaseConnection()\n analysis_id=0\n db_output=con.cursor().callproc('create_analysis',\n [study_id,analysis_id])\n return db_output[1]\n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), str(e))\n return False","def test_add():\n\n conn = psycopg2.connect(host=\"sculptor.stat.cmu.edu\", database=c.DB_USER,\n user=c.DB_USER, password=c.DB_PASSWORD)\n cur = conn.cursor()\n cur.execute(\"\"\" SELECT COUNT(*) FROM songs WHERE song_title = SHERlocked\n artist_name = unknown\"\"\")\n count = cur.fetchone()[0]\n assert count != 0","async def test_get_empty(subject: AnalysisStore, protocol_store: ProtocolStore) -> None:\n protocol_store.insert(make_dummy_protocol_resource(\"protocol-id\"))\n\n full_result = await subject.get_by_protocol(\"protocol-id\")\n summaries_result = subject.get_summaries_by_protocol(\"protocol-id\")\n\n assert full_result == []\n assert summaries_result == []\n\n with pytest.raises(AnalysisNotFoundError, match=\"analysis-id\"):\n await subject.get(\"analysis-id\")","def test_finds_no_traits_if_dataset_search_doesnt_match(self):\n dataset = factories.SourceDatasetFactory.create(i_dbgap_description='a dataset about demographic measurements')\n trait = factories.SourceTraitFactory.create(i_description='lorem ipsum', source_dataset=dataset)\n response = self.client.get(self.get_url(), {'description': 'lorem', 'dataset_description': 'something'})\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)\n self.assertEqual(len(context['results_table'].rows), 0)","def test_exists(self):\n d = self._examineOrSelect()\n self._response(b'* 3 EXISTS')\n self.assertEqual(\n self.successResultOf(d),\n {'READ-WRITE': False, 'EXISTS': 3})","def test_exists_false(self):\n self.assertFalse(SampleTemplate.exists(self.new_study.id))","def test_exists(self):\n with self.assertRaises(IncompetentQiitaDeveloperError):\n BaseSample.exists('SKM7.640188', SampleTemplate(1))","def test_func(self):\n return (Student.objects.filter(user=self.request.user).exists())","def test_exists_true(self):\n self.assertTrue(PrepSample.exists(self.sample_id, self.prep_template))","def test_context_data_with_valid_search_and_a_specified_study(self):\n dataset = factories.SourceDatasetFactory.create(i_dbgap_description='lorem ipsum')\n study = dataset.source_study_version.study\n factories.SourceDatasetFactory.create(i_dbgap_description='lorem other')\n get = {'description': 'lorem', 'studies': [study.pk]}\n response = self.client.get(self.get_url(), get)\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceDatasetTableFull)\n self.assertQuerysetEqual(context['results_table'].data, [repr(dataset)])","def test_exists_false(self):\n self.assertFalse(Sample.exists('Not_a_Sample', self.sample_template))","def test_check_table_exists(self):\n query_result = [{'alerts': True}]\n self.client.athena_client = MockAthenaClient(results=query_result)\n\n result = self.client.check_table_exists('unit-test')\n assert_true(result)\n\n generated_results_key = 'unit-testing/{}'.format(datetime.now().strftime('%Y/%m/%d'))\n assert_equal(self.client.athena_results_key, generated_results_key)","def test_stats_get(self):\n stats_store = StatsStore()\n\n gen_stats = stats_store.general_stats_get(\"inexisting_stats\")\n assert not gen_stats","def test_c_get_existing_records(self):\n\n success = True\n records = get_existing_records(location, database)\n\n if records['variable'].values[0] != value:\n success = False\n\n for function in records['function'].values:\n if function not in outcome_methods:\n success = False\n\n if records[records['function'] == 'nanmean']['value'].values != 2.143:\n success = False\n\n if records[records['function'] == 'nanpercentile_25']['value'].values != 1.0:\n success = False\n\n if records[records['function'] == 'nanpercentile_75']['value'].values != 2.5:\n success = False\n\n if not np.isnan(records[records['function'] == 'std']['value'].values[0]):\n success = False\n\n assert(success)","def test_context_data_info_message_for_one_result(self):\n factories.SourceDatasetFactory.create(\n i_dbgap_description='lorem ipsum',\n source_study_version__study=self.study)\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\n messages = list(response.wsgi_request._messages)\n self.assertEqual(len(messages), 1)\n self.assertEqual(str(messages[0]), '1 result found.')","def dataset_exists(es_url, id, es_index=\"grq\"):\n\n total, id = check_dataset(es_url, id, es_index)\n if total > 0:\n return True\n return False","def test_context_data_only_finds_results_in_requested_study(self):\n dataset = factories.SourceDatasetFactory.create(\n i_dbgap_description='lorem ipsum',\n source_study_version__study=self.study)\n factories.SourceDatasetFactory.create(i_dbgap_description='lorem ipsum')\n get = {'description': 'lorem'}\n response = self.client.get(self.get_url(self.study.pk), get)\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceDatasetTableFull)\n self.assertQuerysetEqual(context['results_table'].data, [repr(dataset)])","async def test_26() -> None:\n LOG.debug(\"Test query for non-existing query targeting three datasets, using MISS. (expect data shown)\")\n payload = {\n \"referenceName\": \"MT\",\n \"start\": 10,\n \"referenceBases\": \"T\",\n \"alternateBases\": \"C\",\n \"assemblyId\": \"GRCh38\",\n \"datasetIds\": [\"urn:hg:1000genome\", \"urn:hg:1000genome:controlled\", \"urn:hg:1000genome:registered\"],\n \"includeDatasetResponses\": \"MISS\",\n }\n headers = {\"Authorization\": f\"Bearer {TOKEN}\"}\n async with aiohttp.ClientSession(headers=headers) as session:\n async with session.post(\"http://localhost:5050/query\", data=json.dumps(payload)) as resp:\n data = await resp.json()\n assert data[\"exists\"] is False, sys.exit(\"Query POST Endpoint Error!\")\n assert len(data[\"datasetAlleleResponses\"]) == 3, sys.exit(\"Should be able to retrieve missing datasets.\")","def test_case18(self):\n\n result = self.graph1.studentExists(\"student1\")\n\n self.assertTrue(result)","def test_dataset_found_when_querying_number_in_name(self):\n models.SourceTrait.objects.all().delete()\n # Use a different study to ensure that one of the pre-created datasets doesn't match.\n dataset_name = 'unlikely_24601_dataset'\n # Use an accession that won't match for one dataset but not the other\n dataset_name_match = factories.SourceDatasetFactory.create(\n dataset_name=dataset_name,\n i_accession=123456,\n source_study_version=self.source_study_version\n )\n dataset_accession_match = factories.SourceDatasetFactory.create(\n dataset_name='other_name',\n i_accession=24601,\n source_study_version=self.source_study_version\n )\n url = self.get_url(self.study.pk)\n response = self.client.get(url, {'q': 246})\n returned_pks = get_autocomplete_view_ids(response)\n self.assertEqual(sorted(returned_pks), sorted([dataset_name_match.i_id, dataset_accession_match.i_id]))","async def test_23() -> None:\n LOG.debug(\"Test query for targeting a non-existing PUBLIC datasets, using ALL. (expect no data shown)\")\n payload = {\n \"referenceName\": \"MT\",\n \"start\": 9,\n \"referenceBases\": \"T\",\n \"alternateBases\": \"C\",\n \"assemblyId\": \"GRCh38\",\n \"datasetIds\": [\"urn:hg:1111genome\"],\n \"includeDatasetResponses\": \"ALL\",\n }\n headers = {\"Authorization\": f\"Bearer {TOKEN}\"}\n async with aiohttp.ClientSession(headers=headers) as session:\n async with session.post(\"http://localhost:5050/query\", data=json.dumps(payload)) as resp:\n data = await resp.json()\n assert data[\"exists\"] is False, sys.exit(\"Query POST Endpoint Error!\")\n assert len(data[\"datasetAlleleResponses\"]) == 0, sys.exit(\"Should be able to retrieve only public.\")","def testQuery(self):\n # Clear anything first\n for i in range(10):\n row_name = \"aff4:/row:%s\" % i\n data_store.DB.Set(row_name, \"metadata:%s\" % i, str(i), timestamp=5,\n token=self.token)\n data_store.DB.Set(row_name, \"aff4:type\", \"test\", token=self.token)\n\n # Retrieve all subjects with metadata:5 set:\n rows = [row for row in data_store.DB.Query(\n [\"metadata:5\"], data_store.DB.filter.HasPredicateFilter(\"metadata:5\"),\n subject_prefix=\"aff4:/row:\", token=self.token)]\n\n self.assertEqual(len(rows), 1)\n self.assertEqual(rows[0][\"subject\"][0][0], \"aff4:/row:5\")\n self.assertEqual(rows[0][\"metadata:5\"][0][0], \"5\")\n self.assertEqual(rows[0][\"metadata:5\"][0][1], 5)","def test_get_algorithm_Empty(self):\n searched_id = 'xyz1'\n index = search.Index(name=search_algorithm._INDEX_STRING)\n result = index.get_range(ids_only=True)\n self.assertEqual(0, len(result.results), msg='The database is not empty')\n algorithm = search_algorithm.get_algorithm(index, searched_id)\n self.assertEqual(1, algorithm, msg='Non existent Algorithm was found in empty database')","def test_fake_job( self ):\n hda = MockHda( job=UNDEFINED_JOB )\n self.history.active_datasets.append( hda )\n job_dict, warnings = extract.summarize( trans=self.trans )\n assert not warnings\n assert len( job_dict ) == 1\n fake_job = job_dict.keys()[ 0 ]\n assert fake_job.id.startswith( \"fake_\" )\n datasets = job_dict.values()[ 0 ]\n assert datasets == [ ( None, hda ) ]","def test_context_data_with_valid_search_and_no_results(self):\n response = self.client.get(self.get_url(self.study.pk), {'description': 'test'})\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceDatasetTableFull)","def test_workflows_find_one_get(self):\n pass","def test_db_is_created(test_teardown):\n try:\n applications = Application.query.first()\n inhouse_postings = Inhouse.query.first()\n external_postings = External.query.first()\n except Exception:\n assert False\n assert True","def check_dataset(self):\n url = self.metadata.metadata_url\n document = Document.objects.get(\n metadata=self.metadata,\n document_type=DocumentEnum.METADATA.value,\n is_original=True,\n )\n original_document = document.content\n self.check_document(url, original_document)","async def test_24() -> None:\n LOG.debug(\"Test query for targeting one existing and one non-existing PUBLIC datasets, using ALL. (expect only PUBLIC)\")\n payload = {\n \"referenceName\": \"MT\",\n \"start\": 9,\n \"referenceBases\": \"T\",\n \"alternateBases\": \"C\",\n \"assemblyId\": \"GRCh38\",\n \"datasetIds\": [\"urn:hg:1111genome\", \"urn:hg:1000genome\"],\n \"includeDatasetResponses\": \"ALL\",\n }\n headers = {\"Authorization\": f\"Bearer {TOKEN}\"}\n async with aiohttp.ClientSession(headers=headers) as session:\n async with session.post(\"http://localhost:5050/query\", data=json.dumps(payload)) as resp:\n data = await resp.json()\n assert data[\"exists\"] is True, sys.exit(\"Query POST Endpoint Error!\")\n assert len(data[\"datasetAlleleResponses\"]) == 1, sys.exit(\"Should be able to retrieve only public.\")","def test_dataset_found_when_querying_number_in_name(self):\n models.Study.objects.all().delete()\n # Use a different study to ensure that one of the pre-created datasets doesn't match.\n study_name = 'unlikely_24601_dataset'\n # Use an accession that won't match for one dataset but not the other\n name_match = factories.StudyFactory.create(i_study_name=study_name, i_accession=123456)\n phs_match = factories.StudyFactory.create(i_study_name='other_name', i_accession=24601)\n url = self.get_url()\n response = self.client.get(url, {'q': 246})\n returned_pks = get_autocomplete_view_ids(response)\n self.assertEqual(sorted(returned_pks),\n sorted([name_match.i_accession, phs_match.i_accession]))","def test_get_algorithm_Found(self):\n searched_id = 'xyz1'\n searched_algorithm = {}\n searched_algorithm['algorithmId'] = searched_id\n searched_algorithm['algorithmSummary'] = 'algorithmSummary' + searched_id\n searched_algorithm['displayName'] = 'displayName' + searched_id\n searched_algorithm['linkURL'] = 'linkURL' + searched_id\n right_list = []\n create_test_algorithm_list(right_list, 101)\n right_list.append(searched_algorithm)\n documents = []\n create_test_documents_list(right_list, documents, 102)\n index = search.Index(name=search_algorithm._INDEX_STRING)\n index.put(documents)\n # end of preparing data\n result = index.get_range(ids_only=True)\n self.assertLess(0, len(result.results), msg='The database is empty')\n algorithm = search_algorithm.get_algorithm(index, searched_id)\n self.assertDictEqual(searched_algorithm, algorithm, msg='Algorithm was not found in 102 algorithms database')","def test_success(database):\n\n det_award_1 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\"00FORGN\",\n place_of_perform_country_c=\"UKR\")\n det_award_2 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\"00FoRGN\",\n place_of_perform_country_c=\"uKr\")\n det_award_3 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\"ny**987\",\n place_of_perform_country_c=\"USA\")\n det_award_4 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\"NY**987\",\n place_of_perform_country_c=\"UsA\")\n errors = number_of_errors(_FILE, database, models=[det_award_1, det_award_2, det_award_3, det_award_4])\n assert errors == 0","def check_analysis(self, analysis, ecosystem, package, version):\n try:\n assert analysis is not None, \"Analysis not available\"\n assert \"result\" in analysis, \"Can not find the 'result' node.\"\n result = analysis[\"result\"]\n self.check_recommendation_part(result)\n self.check_data_part(result, ecosystem, package, version)\n return \"OK\"\n except Exception as e:\n return \"Failed: \" + str(e)","def setUp(self):\n self.database = Mock()\n self.database.reports_overviews.find_one.return_value = dict(_id=\"id\")","def test_get_occurrence(self):\n pass","def test_context_data_with_valid_search_and_some_results(self):\n dataset = factories.SourceDatasetFactory.create(\n i_dbgap_description='lorem ipsum',\n source_study_version__study=self.study)\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceDatasetTableFull)\n self.assertQuerysetEqual(context['results_table'].data, [repr(dataset)])","def test_exists_false(self):\n self.assertFalse(PrepSample.exists('Not_a_Sample', self.prep_template))","def test_get_activity_occurrence_details(self):\n pass","def test_graph_load_query_exec(self):\n provider = QueryProvider(data_environment=\"SecurityGraph\", driver=self.provider)\n df = provider.all_queries.get_alert(\"help\")\n self.assertIsNone(df)\n\n with self.assertRaises(ValueError) as cm:\n df = provider.all_queries.get_alert()\n self.assertIn(\"alert_id\", str(cm.exception))\n\n df = provider.all_queries.get_alert(alert_id=\"foo\")\n self.assertEqual(len(df), 1)\n self.assertIn(\"/foo\", df[\"query\"].iloc[0])","def test_check_database_exists_invalid(self):\n query_result = None\n self.client.athena_client = MockAthenaClient(results=query_result)\n\n assert_false(self.client.check_database_exists())","def test_success(database):\n\n det_award_1 = DetachedAwardFinancialAssistanceFactory(place_of_performance_forei=\"description\",\n place_of_perform_country_c=\"UK\",\n record_type=2)\n det_award_2 = DetachedAwardFinancialAssistanceFactory(place_of_performance_forei=\"description\",\n place_of_perform_country_c=\"USA\",\n record_type=2\n )\n det_award_3 = DetachedAwardFinancialAssistanceFactory(place_of_performance_forei=None,\n place_of_perform_country_c=\"USA\",\n record_type=2)\n det_award_4 = DetachedAwardFinancialAssistanceFactory(place_of_performance_forei=\"\",\n place_of_perform_country_c=\"UsA\",\n record_type=2)\n det_award_5 = DetachedAwardFinancialAssistanceFactory(place_of_performance_forei=\"\",\n place_of_perform_country_c=\"UK\",\n record_type=1)\n det_award_6 = DetachedAwardFinancialAssistanceFactory(place_of_performance_forei=None,\n place_of_perform_country_c=\"UK\",\n record_type=1)\n\n errors = number_of_errors(_FILE, database, models=[det_award_1, det_award_2, det_award_3, det_award_4,\n det_award_5, det_award_6])\n assert errors == 0","def test_success(database):\n\n det_award_1 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\"00FORGN\",\n place_of_perform_country_c=\"UKR\", record_type=1)\n det_award_2 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\"00FoRGN\",\n place_of_perform_country_c=\"uKr\", record_type=1)\n det_award_3 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\"ny**987\",\n place_of_perform_country_c=\"USA\", record_type=2)\n det_award_4 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\"NY**987\",\n place_of_perform_country_c=\"UsA\", record_type=2)\n det_award_5 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\"NY**987\",\n place_of_perform_country_c=\"UKR\", record_type=3)\n errors = number_of_errors(_FILE, database, models=[det_award_1, det_award_2, det_award_3, det_award_4, det_award_5])\n assert errors == 0","def test_db_missing_read(env_setup, env_table, db_insert_test_data, db_read_test_data, response_test_data):\n test_string = DbManager(SqLiteHelper, {\"db_path\": env_setup, \"master_table\": env_table}) \\\n .processor(db_read_test_data.get(\"invalid2\")) # testing\n assert test_string == response_test_data.get(\"invalid_read2\")","def test_analysis_result_num(self):\n self.assertIsNotNone(analysis.analysis_interaction(\"Datasets/Wine.csv\", \"Class\"))","def test_table_has_no_rows(self):\n models.SourceDataset.objects.all().delete()\n response = self.client.get(self.get_url(self.study.pk))\n context = response.context\n table = context['source_dataset_table']\n self.assertEqual(len(table.rows), 0)","def check_dataset_exists(dataset):\n result = subprocess.call(['das_client.py', '--query', 'dataset dataset=%s' % dataset])\n return result == 0","def test_get_algorithm_NotFound(self):\n searched_id = 'xyz1'\n right_list = []\n create_test_algorithm_list(right_list, 101)\n documents = []\n create_test_documents_list(right_list, documents, 101)\n index = search.Index(name=search_algorithm._INDEX_STRING)\n index.put(documents)\n # end of preparing data\n result = index.get_range(ids_only=True)\n self.assertLess(0, len(result.results), msg='The database is empty')\n algorithm = search_algorithm.get_algorithm(index, searched_id)\n self.assertEqual(1, algorithm, msg='Nonexistent Algorithm was found in 101 algorithms database')","def exist(self):","def update_analysis(pk):\n\n track = Track.query.get(pk)\n if track is None:\n # TODO: Log This\n return False\n\n # Call Echo Nest\n try:\n analysis = get_track_analysis(track.spotify_uri)\n except EchoNestError:\n # TODO: Log This\n return False\n\n # commit analysis data to Track model\n track.audio_summary = analysis\n\n db.session.add(track)\n db.session.commit()\n\n return True","def test_context_data_with_valid_search_and_a_specified_study(self):\n trait = factories.SourceTraitFactory.create(i_description='lorem ipsum')\n study = trait.source_dataset.source_study_version.study\n factories.SourceTraitFactory.create(i_description='lorem other')\n get = {'description': 'lorem', 'studies': [study.pk]}\n response = self.client.get(self.get_url(), get)\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)\n self.assertQuerysetEqual(context['results_table'].data, [repr(trait)])","def test_success(database):\n\n office = OfficeFactory(office_code='12345a', financial_assistance_awards_office=True)\n det_award_1 = DetachedAwardFinancialAssistanceFactory(awarding_office_code='12345a')\n # test ignore case\n det_award_2 = DetachedAwardFinancialAssistanceFactory(awarding_office_code='12345A')\n det_award_3 = DetachedAwardFinancialAssistanceFactory(awarding_office_code='')\n det_award_4 = DetachedAwardFinancialAssistanceFactory(awarding_office_code=None)\n errors = number_of_errors(_FILE, database, models=[office, det_award_1, det_award_2, det_award_3, det_award_4])\n assert errors == 0","def checkIfAntennaExists(table, name, fk):\n\ttry:\n\t\tcon = sqlite3.connect('PampDb.db')\n\t\tcur = con.cursor()\n\t\tcur.execute(\"SELECT * FROM \" + table + \" WHERE name='\" + name + \"'\")\n\t\tob = cur.fetchall()\n\t\tbo = False\n\t\tif not ob:\n\t\t\tcur.execute(\"INSERT INTO '\" + table + \"' (name, measuringObjectId) VALUES ('\" + name + \"', '\" + str(fk) + \"')\")\n\t\t\tcon.commit()\n\t\t\tcur.execute(\"SELECT * FROM \" + table + \" WHERE name='\" + name + \"'\")\n\t\t\tobj = cur.fetchall()\n\t\t\tcorObj = obj[0]\n\t\t\treturn corObj\n\t\telse:\n\t\t\tfor row in ob:\n\t\t\t\tif row[2] == fk:\n\t\t\t\t\tbo = True\n\t\t\t\t\treturn row\n\t\t\tif not bo:\n\t\t\t\tcur.execute(\"INSERT INTO '\" + table + \"' (name, measuringObjectId) VALUES ('\" + name + \"', '\" + str(fk) + \"')\")\n\t\t\t\tcon.commit()\n\t\t\t\tcur.execute(\"SELECT * FROM \" + table + \" WHERE name='\" + name + \"' AND measuringObjectId='\" + str(fk) + \"'\")\n\t\t\t\tobj = cur.fetchall()\n\t\t\t\tcorObj = obj[0]\n\t\t\t\treturn corObj\n\t\tcon.commit()\n\t\tcon.close()\n\texcept:\n\t\tprint('Could not run function checkIfAntennaExists from DbController')","def test_AlgorithmsIdHandler_GET_Found(self):\n searched_id = 'xyz1'\n searched_algorithm = {}\n searched_algorithm['algorithmId'] = searched_id\n searched_algorithm['algorithmSummary'] = 'algorithmSummary' + searched_id\n searched_algorithm['displayName'] = 'displayName' + searched_id\n searched_algorithm['linkURL'] = 'linkURL' + searched_id\n right_list = []\n create_test_algorithm_list(right_list, 101)\n right_list.append(searched_algorithm)\n documents = []\n create_test_documents_list(right_list, documents, 102)\n index = search.Index(name=search_algorithm._INDEX_STRING)\n index.put(documents)\n # end of preparing data\n result = index.get_range(ids_only=True)\n self.assertLess(0, len(result.results), msg='The database is empty')\n response = self.testapp.get('/algorithms/' + searched_id)\n self.assertEqual(200, response.status_int, msg=\"Existent Algorithm wasn't found in empty database\")\n self.assertEqual('application/json', response.content_type)\n self.assertNotIn('Algorithm Not Found', response.normal_body.decode(encoding='UTF-8'))\n self.assertEqual(4, len(json.loads(response.normal_body.decode(encoding='UTF-8'))), msg='There returned algorithm has more keys then 4')\n self.assertDictEqual(searched_algorithm, json.loads(response.normal_body.decode(encoding='UTF-8')), msg='Returned data was not searched algorithm')","def check_assertions(self,result):\n print \"checking result\",result\n if self.db.old.find_one({\"pdb_code\": result.pdb_code}) is None:\n self.insert(result)\n else:\n result_db = self.db.old.find_one({\"pdb_code\": result.pdb_code})\n assert result_db['chunk'] == result.clusters\n assert result_db['chunks'] == result.chunks\n assert result_db['chunk_sizes'] == result.chunk_sizes","def id_exists(test_name):\n result_json = None\n try:\n with open(robot_dir + \"/output/results/{}.json\".format(test_name.replace(' ', ''))) as result_file:\n result_json = json.load(result_file)\n except:\n print(\"Failed to open the result json\")\n return False\n #look for values NEW_ASSOC, NEW_PROP1, NEW_PROP2\n print(result_json)\n if 6 == 6:\n return True\n return \"Length is not 6\"","def has_result(self):\n return len(self.__analysis_items) > 0","def test_dataset_found_when_querying_number_in_name(self):\n models.SourceTrait.objects.all().delete()\n # Use a different study to ensure that one of the pre-created datasets doesn't match.\n dataset_name = 'unlikely_24601_dataset'\n # Use an accession that won't match for one dataset but not the other\n dataset_name_match = factories.SourceDatasetFactory.create(dataset_name=dataset_name, i_accession=123456)\n dataset_accession_match = factories.SourceDatasetFactory.create(dataset_name='other_name', i_accession=24601)\n url = self.get_url()\n response = self.client.get(url, {'q': 246})\n returned_pks = get_autocomplete_view_ids(response)\n self.assertEqual(sorted(returned_pks), sorted([dataset_name_match.i_id, dataset_accession_match.i_id]))","def test_context_data_with_valid_search_and_no_results(self):\n response = self.client.get(self.get_url(self.study.pk), {'description': 'test'})\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)","def test_correct_dataset_found_by_name(self):\n dataset_name = 'my_unlikely_dataset_name'\n dataset = factories.SourceDatasetFactory.create(\n dataset_name=dataset_name,\n source_study_version=self.source_study_version\n )\n url = self.get_url(self.study.pk)\n response = self.client.get(url, {'q': dataset_name})\n returned_pks = get_autocomplete_view_ids(response)\n self.assertEqual(returned_pks, [dataset.i_id])","def test_correct_dataset_found_by_name(self):\n dataset_name = 'my_unlikely_dataset_name'\n dataset = factories.SourceDatasetFactory.create(\n dataset_name=dataset_name,\n source_study_version=self.source_study_version\n )\n url = self.get_url(self.study.pk)\n response = self.client.get(url, {'q': dataset_name})\n returned_pks = get_autocomplete_view_ids(response)\n self.assertEqual(returned_pks, [dataset.i_id])","def test_get_success_case(self):\r\n m = self.table.objects.get(test_id=0, attempt_id=0)\r\n assert isinstance(m, ResultObject)\r\n assert m.test_id == 0\r\n assert m.attempt_id == 0\r\n\r\n q = self.table.objects(test_id=0, attempt_id=0)\r\n m = q.get()\r\n assert isinstance(m, ResultObject)\r\n assert m.test_id == 0\r\n assert m.attempt_id == 0\r\n\r\n q = self.table.objects(test_id=0)\r\n m = q.get(attempt_id=0)\r\n assert isinstance(m, ResultObject)\r\n assert m.test_id == 0\r\n assert m.attempt_id == 0","def test_AlgorithmsIdHandler_GET_NotFound(self):\n searchedId='xyz1'\n right_list = []\n create_test_algorithm_list(right_list, 101)\n documents = []\n create_test_documents_list(right_list, documents, 101)\n index = search.Index(name=search_algorithm._INDEX_STRING)\n index.put(documents)\n # end of preparing data\n result = index.get_range(ids_only=True)\n self.assertLess(0, len(result.results), msg='The database is empty')\n response = self.testapp.get('/algorithms/' + searchedId, expect_errors=True)\n self.assertEqual(404, response.status_int, msg='Non existent Algorithm was found in empty database')\n self.assertEqual('application/json', response.content_type)\n self.assertIn('Algorithm Not Found', response.normal_body.decode(encoding='UTF-8'))","def test_get_record(self):\n pass","def test_context_data_info_message_for_one_result(self):\n factories.SourceTraitFactory.create(\n i_description='lorem ipsum',\n source_dataset__source_study_version__study=self.study)\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\n messages = list(response.wsgi_request._messages)\n self.assertEqual(len(messages), 1)\n self.assertEqual(str(messages[0]), '1 result found.')","def test_AlgorithmsIdHandler_GET_Empty(self):\n searchedId='xyz1'\n response = self.testapp.get('/algorithms/' + searchedId, expect_errors=True)\n self.assertEqual(404, response.status_int, msg='Non existent Algorithm was found in empty database')\n self.assertEqual('application/json', response.content_type)\n self.assertIn('Algorithm Not Found', response.normal_body.decode(encoding='UTF-8'))","def test_query_inserted_data(self):\n with app.app_context():\n data_github = {\n \"version_control\": \"github\",\n \"scm_repo\": \"B\",\n \"scm_branch\": \"B\",\n \"scm_commit\": \"B\",\n \"repo\": \"B1\",\n \"branch\": \"B1\",\n \"enabled\": False\n }\n\n data_git = {\n \"version_control\": \"git\",\n \"scm_repo\": \"B\",\n \"scm_branch\": \"B\",\n \"scm_commit\": \"B\",\n \"repo\": \"B2\",\n \"branch\": \"B2\",\n \"enabled\": False\n }\n\n for data_insert in [data_github, data_git]:\n create_tracking(data_insert)\n\n resp = self.client.get(\"/tracking?repo={}&branch={}\".format(data_insert[\"repo\"], data_insert[\"branch\"]))\n\n resp_dict = json.loads(resp.data)\n self.assertIn(\"code\", resp_dict, msg=\"Error in data format return\")\n self.assertEqual(ResponseCode.SUCCESS, resp_dict.get(\"code\"), msg=\"Error in status code return\")\n\n self.assertIn(\"msg\", resp_dict, msg=\"Error in data format return\")\n self.assertEqual(\n ResponseCode.CODE_MSG_MAP.get(ResponseCode.SUCCESS),\n resp_dict.get(\"msg\"),\n msg=\"Error in status code return\"\n )\n\n self.assertIn(\"data\", resp_dict, msg=\"Error in data format return\")\n self.assertIsNotNone(resp_dict.get(\"data\"), msg=\"Error in data information return\")\n self.assertIn(data_insert, resp_dict.get(\"data\"), msg=\"Error in data information return\")","def checkExistence(idMeta):\n # XXX add for diaries\n sqlq = \"\"\"\n SELECT dt\n FROM Electricity_10min\n WHERE `Meta_idMeta` = {}\n LIMIT 1;\n \"\"\".format(idMeta)\n try:\n result = mdb.getSQL(sqlq)[0]\n if (result):\n return True\n except:\n return False","def test_no_updated_datasets(self):\n response = self.client.get(self.get_url(self.study.pk))\n context = response.context\n table = context['source_dataset_table']\n for dataset in self.datasets_v3:\n self.assertNotIn(dataset, table.data)","def test_create_occurrence(self):\n pass","async def test_9() -> None:\n LOG.debug(\"Test get query (good query, empty response)\")\n params = {\"assemblyId\": \"GRCh99\", \"referenceName\": \"MT\", \"start\": 63, \"referenceBases\": \"CT\", \"alternateBases\": \"NN\", \"includeDatasetResponses\": \"HIT\"}\n async with aiohttp.ClientSession() as session:\n async with session.get(\"http://localhost:5050/query\", params=params) as resp:\n data = await resp.json()\n assert data[\"exists\"] is False, sys.exit(\"Query GET Endpoint Error!\")","def test_context_data_info_message_for_no_results(self):\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\n messages = list(response.wsgi_request._messages)\n self.assertEqual(len(messages), 1)\n self.assertEqual(str(messages[0]), '0 results found.')","def test_context_data_info_message_for_no_results(self):\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\n messages = list(response.wsgi_request._messages)\n self.assertEqual(len(messages), 1)\n self.assertEqual(str(messages[0]), '0 results found.')","def test_sample_is_attached_to_patient(self):\r\n self.assertEqual(self.test_patient.sample_set.all()[0], self.test_sample)","def test_get_records(self):\n pass","def test_exists(self, mock_current_session):\n added = datetime.now(UTC)\n mock_store = mock.MagicMock()\n mock_store.get_metadata.return_value = \\\n Metadata(added=added, checksum='foopdfchex==', size_bytes=1_234)\n mock_current_session.return_value = mock_store\n\n data, code, headers = \\\n controllers.get_preview_metadata(self.source_id, self.checksum)\n self.assertEqual(code, status.OK, 'Returns 200 OK')\n self.assertEqual(headers['ETag'], 'foopdfchex==',\n 'ETag is set to the preview checksum')\n self.assertDictEqual(data, {'checksum': 'foopdfchex==',\n 'added': added,\n 'size_bytes': 1234},\n 'Returns metadata about the preview')","def test_analysis_result_cat(self):\n self.assertIsNotNone(analysis.analysis_interaction(\"Datasets/Crime1.csv\", \"Category\"))","def db_exists(self, db):\n raise NotImplementedError()","def test_check_table_exists_invalid(self, mock_logging):\n query_result = None\n self.client.athena_client = MockAthenaClient(results=query_result)\n\n result = self.client.check_table_exists('unit-test')\n assert_false(result)\n assert_true(mock_logging.info.called)","def test_top_archive_view_has_metadata_iff_idea_exists(self):\n self.ideas[2].voter.display_name = 'George Washington'\n self.ideas[2].voter.save()\n\n self.ideas[2].category.name = 'Environmental Issues'\n self.ideas[2].category.save()\n\n TopSubmissionForm(data={'category': self.categories[0].id,\n 'submission': self.ideas[2].id,\n 'rank': 2},\n debate=self.debate).save()\n rsp = self.client.get(self.url(self.categories[0].slug))\n self.assertContains(rsp, self.ideas[2].voter.user_display_name())\n self.assertContains(rsp, self.ideas[2].category.name)\n self.assertContains(rsp, date_format(localtime(self.ideas[2].created_at)))\n\n self.ideas[2].delete()\n rsp = self.client.get(self.url(self.categories[0].slug))\n self.assertNotContains(rsp, self.ideas[2].voter.user_display_name())\n self.assertNotContains(rsp, self.ideas[2].category.name)\n self.assertNotContains(rsp, date_format(localtime(self.ideas[2].created_at)))\n self.assertContains(rsp, self.ideas[2].headline)","def test_finding_datasets_doesnt_query_database_excessively(\n access_type, client, django_assert_num_queries\n):\n expected_num_queries = 13\n source_tags = [factories.SourceTagFactory() for _ in range(10)]\n topic_tags = [factories.TopicTagFactory() for _ in range(10)]\n\n masters = [\n factories.DataSetFactory(\n type=DataSetType.MASTER,\n published=True,\n user_access_type=access_type,\n )\n for _ in range(random.randint(10, 50))\n ]\n for master in masters:\n master.tags.set(\n random.sample(source_tags, random.randint(1, 3))\n + random.sample(topic_tags, random.randint(1, 3))\n )\n\n datacuts = [\n factories.DataSetFactory(\n type=DataSetType.DATACUT,\n published=True,\n user_access_type=access_type,\n )\n for _ in range(random.randint(10, 50))\n ]\n for datacut in datacuts:\n datacut.tags.set(random.sample(source_tags, 1) + random.sample(topic_tags, 1))\n\n references = [factories.ReferenceDatasetFactory.create(published=True) for _ in range(10)]\n for reference in references:\n reference.tags.set(\n random.sample(source_tags, random.randint(1, 3))\n + random.sample(topic_tags, random.randint(1, 3))\n )\n\n visualisations = [\n factories.VisualisationCatalogueItemFactory.create(published=True)\n for _ in range(random.randint(10, 50))\n ]\n\n for visualisation in visualisations:\n factories.DataSetApplicationTemplatePermissionFactory(\n application_template=visualisation.visualisation_template,\n dataset=random.choice(masters),\n )\n\n # Log into site (triggers the queries related to setting up the user).\n client.get(reverse(\"root\"))\n\n with django_assert_num_queries(expected_num_queries, exact=False):\n response = client.get(reverse(\"datasets:find_datasets\"), follow=True)\n assert response.status_code == 200\n\n with django_assert_num_queries(expected_num_queries, exact=False):\n response = client.get(reverse(\"datasets:find_datasets\"), {\"q\": \"potato\"})\n assert response.status_code == 200\n\n with django_assert_num_queries(expected_num_queries + 1, exact=False):\n response = client.get(\n reverse(\"datasets:find_datasets\"),\n {\"source\": [str(tag.id) for tag in random.sample(source_tags, random.randint(1, 5))]},\n )\n assert response.status_code == 200\n\n with django_assert_num_queries(expected_num_queries + 1, exact=False):\n response = client.get(\n reverse(\"datasets:find_datasets\"),\n {\"topic\": [str(tag.id) for tag in random.sample(topic_tags, random.randint(1, 5))]},\n )\n assert response.status_code == 200\n\n with django_assert_num_queries(expected_num_queries, exact=False):\n response = client.get(\n reverse(\"datasets:find_datasets\"),\n {\"data_type\": str(DataSetType.MASTER)},\n )\n assert response.status_code == 200\n\n with django_assert_num_queries(expected_num_queries, exact=False):\n response = client.get(reverse(\"datasets:find_datasets\"), {\"access\": \"yes\"})\n assert response.status_code == 200","def test_retrieve(self):\n stats_data = self.stats_data\n facility = self.facility\n\n obj = FacilityPatientStatsHistory.objects.create(\n facility=facility, entry_date=datetime.date(2020, 4, 1), **stats_data\n )\n\n response = self.client.get(self.get_url(entry_id=obj.external_id), format=\"json\")\n self.assertDictEqual(\n response.json(), self.get_detail_representation(stats_data, facility=facility),\n )"],"string":"[\n \"def test_get_analysis_with_id_when_missing(analysis_store: MockStore):\\n # GIVEN an id that doesn't exist\\n missing_analysis_id = 12312423534\\n\\n # WHEN accessing the analysis\\n analysis: Analysis = analysis_store.get_analysis_with_id(analysis_id=missing_analysis_id)\\n\\n # THEN it should return None\\n assert not analysis\",\n \"def test_data_source_soaps_id_exists_get(self):\\n pass\",\n \"def test_exist(self):\\n with self.assertRaises(IncompetentQiitaDeveloperError):\\n MetadataTemplate.exists(self.study)\",\n \"def test_analysis_match(self):\\n self.api.observable_add('test.com')\\n results = self.api.analysis_match(['test.com', 'unknown.com'])\\n known = [o['value'] for o in results['known']]\\n self.assertIn('test.com', known)\\n self.assertIn('unknown.com', results['unknown'])\",\n \"def test_get_study_missing(self):\\n self.assertIsNone(self.storage.get_study('missing'))\",\n \"def test_no_one_in_db(self):\\n q = self.generate_query('view_manager_report', ())\\n res = self.execute_query(q)\\n expected = []\\n assert len(res) == 0, f'There is suppose to be an empty summary {res}'\\n assert res == expected, f'The result is suppose to be empty {res}'\",\n \"def test_data_source_soaps_find_one_get(self):\\n pass\",\n \"def test_exists_true(self):\\n self.assertTrue(SampleTemplate.exists(self.test_study.id))\",\n \"def test_exists_true(self):\\n self.assertTrue(Sample.exists(self.sample_id, self.sample_template))\",\n \"def testDatabase(self):\\n con = self.getMetadataDatabaseConnection()\\n if con:\\n return True\",\n \"def test_check_database_exists(self):\\n query_result = [{'streamalert': True}]\\n self.client.athena_client = MockAthenaClient(results=query_result)\\n\\n assert_true(self.client.check_database_exists())\",\n \"def test_get(self, init_db, audit):\\n assert Audit.get(audit.id) == audit\",\n \"def test_workflows_id_exists_get(self):\\n pass\",\n \"def test_query_1(self):\\n with app.test_request_context():\\n agency_none = db.session.query(\\n Agency).filter_by(name=\\\"not here\\\").first()\\n self.assertTrue(agency_none is None)\",\n \"def test_article_exist(self):\\n\\n article = Article.objects.get(title='Test title')\\n self.assertEqual(article.author, 'Roman')\",\n \"def test_if_the_view_for_the_first_exists(self): \\n test_song = Song.objects.get(title=\\\"fake\\\")\\n response = self.client.get('/songs/'+str(test_song.pk)+'/')\\n self.assertEqual(response.status_code, 200)\",\n \"def checkIfMeasuringObjectExists(table, name, fk):\\n\\ttry:\\n\\t\\tcon = sqlite3.connect('PampDb.db')\\n\\t\\tcur = con.cursor()\\n\\t\\tcur.execute(\\\"SELECT * FROM \\\" + table + \\\" WHERE name='\\\" + name + \\\"'\\\")\\n\\t\\tob = cur.fetchall()\\n\\t\\tbo = False\\n\\t\\tif not ob:\\n\\t\\t\\tcur.execute(\\\"INSERT INTO '\\\" + table + \\\"' (name, organisationId) VALUES ('\\\" + name + \\\"', '\\\" + str(fk) + \\\"')\\\")\\n\\t\\t\\tcon.commit()\\n\\t\\t\\tcur.execute(\\\"SELECT * FROM \\\" + table + \\\" WHERE name='\\\" + name + \\\"'\\\")\\n\\t\\t\\tobj = cur.fetchall()\\n\\t\\t\\tcorObj = obj[0]\\n\\t\\t\\treturn corObj\\n\\t\\telse:\\n\\t\\t\\tfor row in ob:\\n\\t\\t\\t\\tif row[2] == fk:\\n\\t\\t\\t\\t\\tbo = True\\n\\t\\t\\t\\t\\treturn row\\n\\t\\t\\tif not bo:\\n\\t\\t\\t\\tcur.execute(\\\"INSERT INTO '\\\" + table + \\\"' (name, organisationId) VALUES ('\\\" + name + \\\"', '\\\" + str(fk) + \\\"')\\\")\\n\\t\\t\\t\\tcon.commit()\\n\\t\\t\\t\\tcur.execute(\\\"SELECT * FROM \\\" + table + \\\" WHERE name='\\\" + name + \\\"' AND organisationId='\\\" + str(fk) + \\\"'\\\")\\n\\t\\t\\t\\tobj = cur.fetchall()\\n\\t\\t\\t\\tcorObj = obj[0]\\n\\t\\t\\t\\treturn corObj\\n\\t\\tcon.commit()\\n\\t\\tcon.close()\\n\\texcept:\\n\\t\\tprint('Could not run function checkIfMeasuringObjectExists from DbController')\",\n \"def test_import(self):\\n self.import_report(self.report_json)\\n self.database.reports.insert_one.assert_called_once()\",\n \"def test_includes_one_new_dataset(self):\\n new_dataset = factories.SourceDatasetFactory.create(source_study_version=self.study_version_3)\\n response = self.client.get(self.get_url(self.study.pk))\\n context = response.context\\n table = context['source_dataset_table']\\n self.assertIn(new_dataset, table.data)\",\n \"def createAnalysis(self, study_id):\\n try:\\n con = self.getSFFDatabaseConnection()\\n analysis_id=0\\n db_output=con.cursor().callproc('create_analysis',\\n [study_id,analysis_id])\\n return db_output[1]\\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), str(e))\\n return False\",\n \"def test_add():\\n\\n conn = psycopg2.connect(host=\\\"sculptor.stat.cmu.edu\\\", database=c.DB_USER,\\n user=c.DB_USER, password=c.DB_PASSWORD)\\n cur = conn.cursor()\\n cur.execute(\\\"\\\"\\\" SELECT COUNT(*) FROM songs WHERE song_title = SHERlocked\\n artist_name = unknown\\\"\\\"\\\")\\n count = cur.fetchone()[0]\\n assert count != 0\",\n \"async def test_get_empty(subject: AnalysisStore, protocol_store: ProtocolStore) -> None:\\n protocol_store.insert(make_dummy_protocol_resource(\\\"protocol-id\\\"))\\n\\n full_result = await subject.get_by_protocol(\\\"protocol-id\\\")\\n summaries_result = subject.get_summaries_by_protocol(\\\"protocol-id\\\")\\n\\n assert full_result == []\\n assert summaries_result == []\\n\\n with pytest.raises(AnalysisNotFoundError, match=\\\"analysis-id\\\"):\\n await subject.get(\\\"analysis-id\\\")\",\n \"def test_finds_no_traits_if_dataset_search_doesnt_match(self):\\n dataset = factories.SourceDatasetFactory.create(i_dbgap_description='a dataset about demographic measurements')\\n trait = factories.SourceTraitFactory.create(i_description='lorem ipsum', source_dataset=dataset)\\n response = self.client.get(self.get_url(), {'description': 'lorem', 'dataset_description': 'something'})\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)\\n self.assertEqual(len(context['results_table'].rows), 0)\",\n \"def test_exists(self):\\n d = self._examineOrSelect()\\n self._response(b'* 3 EXISTS')\\n self.assertEqual(\\n self.successResultOf(d),\\n {'READ-WRITE': False, 'EXISTS': 3})\",\n \"def test_exists_false(self):\\n self.assertFalse(SampleTemplate.exists(self.new_study.id))\",\n \"def test_exists(self):\\n with self.assertRaises(IncompetentQiitaDeveloperError):\\n BaseSample.exists('SKM7.640188', SampleTemplate(1))\",\n \"def test_func(self):\\n return (Student.objects.filter(user=self.request.user).exists())\",\n \"def test_exists_true(self):\\n self.assertTrue(PrepSample.exists(self.sample_id, self.prep_template))\",\n \"def test_context_data_with_valid_search_and_a_specified_study(self):\\n dataset = factories.SourceDatasetFactory.create(i_dbgap_description='lorem ipsum')\\n study = dataset.source_study_version.study\\n factories.SourceDatasetFactory.create(i_dbgap_description='lorem other')\\n get = {'description': 'lorem', 'studies': [study.pk]}\\n response = self.client.get(self.get_url(), get)\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceDatasetTableFull)\\n self.assertQuerysetEqual(context['results_table'].data, [repr(dataset)])\",\n \"def test_exists_false(self):\\n self.assertFalse(Sample.exists('Not_a_Sample', self.sample_template))\",\n \"def test_check_table_exists(self):\\n query_result = [{'alerts': True}]\\n self.client.athena_client = MockAthenaClient(results=query_result)\\n\\n result = self.client.check_table_exists('unit-test')\\n assert_true(result)\\n\\n generated_results_key = 'unit-testing/{}'.format(datetime.now().strftime('%Y/%m/%d'))\\n assert_equal(self.client.athena_results_key, generated_results_key)\",\n \"def test_stats_get(self):\\n stats_store = StatsStore()\\n\\n gen_stats = stats_store.general_stats_get(\\\"inexisting_stats\\\")\\n assert not gen_stats\",\n \"def test_c_get_existing_records(self):\\n\\n success = True\\n records = get_existing_records(location, database)\\n\\n if records['variable'].values[0] != value:\\n success = False\\n\\n for function in records['function'].values:\\n if function not in outcome_methods:\\n success = False\\n\\n if records[records['function'] == 'nanmean']['value'].values != 2.143:\\n success = False\\n\\n if records[records['function'] == 'nanpercentile_25']['value'].values != 1.0:\\n success = False\\n\\n if records[records['function'] == 'nanpercentile_75']['value'].values != 2.5:\\n success = False\\n\\n if not np.isnan(records[records['function'] == 'std']['value'].values[0]):\\n success = False\\n\\n assert(success)\",\n \"def test_context_data_info_message_for_one_result(self):\\n factories.SourceDatasetFactory.create(\\n i_dbgap_description='lorem ipsum',\\n source_study_version__study=self.study)\\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\\n messages = list(response.wsgi_request._messages)\\n self.assertEqual(len(messages), 1)\\n self.assertEqual(str(messages[0]), '1 result found.')\",\n \"def dataset_exists(es_url, id, es_index=\\\"grq\\\"):\\n\\n total, id = check_dataset(es_url, id, es_index)\\n if total > 0:\\n return True\\n return False\",\n \"def test_context_data_only_finds_results_in_requested_study(self):\\n dataset = factories.SourceDatasetFactory.create(\\n i_dbgap_description='lorem ipsum',\\n source_study_version__study=self.study)\\n factories.SourceDatasetFactory.create(i_dbgap_description='lorem ipsum')\\n get = {'description': 'lorem'}\\n response = self.client.get(self.get_url(self.study.pk), get)\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceDatasetTableFull)\\n self.assertQuerysetEqual(context['results_table'].data, [repr(dataset)])\",\n \"async def test_26() -> None:\\n LOG.debug(\\\"Test query for non-existing query targeting three datasets, using MISS. (expect data shown)\\\")\\n payload = {\\n \\\"referenceName\\\": \\\"MT\\\",\\n \\\"start\\\": 10,\\n \\\"referenceBases\\\": \\\"T\\\",\\n \\\"alternateBases\\\": \\\"C\\\",\\n \\\"assemblyId\\\": \\\"GRCh38\\\",\\n \\\"datasetIds\\\": [\\\"urn:hg:1000genome\\\", \\\"urn:hg:1000genome:controlled\\\", \\\"urn:hg:1000genome:registered\\\"],\\n \\\"includeDatasetResponses\\\": \\\"MISS\\\",\\n }\\n headers = {\\\"Authorization\\\": f\\\"Bearer {TOKEN}\\\"}\\n async with aiohttp.ClientSession(headers=headers) as session:\\n async with session.post(\\\"http://localhost:5050/query\\\", data=json.dumps(payload)) as resp:\\n data = await resp.json()\\n assert data[\\\"exists\\\"] is False, sys.exit(\\\"Query POST Endpoint Error!\\\")\\n assert len(data[\\\"datasetAlleleResponses\\\"]) == 3, sys.exit(\\\"Should be able to retrieve missing datasets.\\\")\",\n \"def test_case18(self):\\n\\n result = self.graph1.studentExists(\\\"student1\\\")\\n\\n self.assertTrue(result)\",\n \"def test_dataset_found_when_querying_number_in_name(self):\\n models.SourceTrait.objects.all().delete()\\n # Use a different study to ensure that one of the pre-created datasets doesn't match.\\n dataset_name = 'unlikely_24601_dataset'\\n # Use an accession that won't match for one dataset but not the other\\n dataset_name_match = factories.SourceDatasetFactory.create(\\n dataset_name=dataset_name,\\n i_accession=123456,\\n source_study_version=self.source_study_version\\n )\\n dataset_accession_match = factories.SourceDatasetFactory.create(\\n dataset_name='other_name',\\n i_accession=24601,\\n source_study_version=self.source_study_version\\n )\\n url = self.get_url(self.study.pk)\\n response = self.client.get(url, {'q': 246})\\n returned_pks = get_autocomplete_view_ids(response)\\n self.assertEqual(sorted(returned_pks), sorted([dataset_name_match.i_id, dataset_accession_match.i_id]))\",\n \"async def test_23() -> None:\\n LOG.debug(\\\"Test query for targeting a non-existing PUBLIC datasets, using ALL. (expect no data shown)\\\")\\n payload = {\\n \\\"referenceName\\\": \\\"MT\\\",\\n \\\"start\\\": 9,\\n \\\"referenceBases\\\": \\\"T\\\",\\n \\\"alternateBases\\\": \\\"C\\\",\\n \\\"assemblyId\\\": \\\"GRCh38\\\",\\n \\\"datasetIds\\\": [\\\"urn:hg:1111genome\\\"],\\n \\\"includeDatasetResponses\\\": \\\"ALL\\\",\\n }\\n headers = {\\\"Authorization\\\": f\\\"Bearer {TOKEN}\\\"}\\n async with aiohttp.ClientSession(headers=headers) as session:\\n async with session.post(\\\"http://localhost:5050/query\\\", data=json.dumps(payload)) as resp:\\n data = await resp.json()\\n assert data[\\\"exists\\\"] is False, sys.exit(\\\"Query POST Endpoint Error!\\\")\\n assert len(data[\\\"datasetAlleleResponses\\\"]) == 0, sys.exit(\\\"Should be able to retrieve only public.\\\")\",\n \"def testQuery(self):\\n # Clear anything first\\n for i in range(10):\\n row_name = \\\"aff4:/row:%s\\\" % i\\n data_store.DB.Set(row_name, \\\"metadata:%s\\\" % i, str(i), timestamp=5,\\n token=self.token)\\n data_store.DB.Set(row_name, \\\"aff4:type\\\", \\\"test\\\", token=self.token)\\n\\n # Retrieve all subjects with metadata:5 set:\\n rows = [row for row in data_store.DB.Query(\\n [\\\"metadata:5\\\"], data_store.DB.filter.HasPredicateFilter(\\\"metadata:5\\\"),\\n subject_prefix=\\\"aff4:/row:\\\", token=self.token)]\\n\\n self.assertEqual(len(rows), 1)\\n self.assertEqual(rows[0][\\\"subject\\\"][0][0], \\\"aff4:/row:5\\\")\\n self.assertEqual(rows[0][\\\"metadata:5\\\"][0][0], \\\"5\\\")\\n self.assertEqual(rows[0][\\\"metadata:5\\\"][0][1], 5)\",\n \"def test_get_algorithm_Empty(self):\\n searched_id = 'xyz1'\\n index = search.Index(name=search_algorithm._INDEX_STRING)\\n result = index.get_range(ids_only=True)\\n self.assertEqual(0, len(result.results), msg='The database is not empty')\\n algorithm = search_algorithm.get_algorithm(index, searched_id)\\n self.assertEqual(1, algorithm, msg='Non existent Algorithm was found in empty database')\",\n \"def test_fake_job( self ):\\n hda = MockHda( job=UNDEFINED_JOB )\\n self.history.active_datasets.append( hda )\\n job_dict, warnings = extract.summarize( trans=self.trans )\\n assert not warnings\\n assert len( job_dict ) == 1\\n fake_job = job_dict.keys()[ 0 ]\\n assert fake_job.id.startswith( \\\"fake_\\\" )\\n datasets = job_dict.values()[ 0 ]\\n assert datasets == [ ( None, hda ) ]\",\n \"def test_context_data_with_valid_search_and_no_results(self):\\n response = self.client.get(self.get_url(self.study.pk), {'description': 'test'})\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceDatasetTableFull)\",\n \"def test_workflows_find_one_get(self):\\n pass\",\n \"def test_db_is_created(test_teardown):\\n try:\\n applications = Application.query.first()\\n inhouse_postings = Inhouse.query.first()\\n external_postings = External.query.first()\\n except Exception:\\n assert False\\n assert True\",\n \"def check_dataset(self):\\n url = self.metadata.metadata_url\\n document = Document.objects.get(\\n metadata=self.metadata,\\n document_type=DocumentEnum.METADATA.value,\\n is_original=True,\\n )\\n original_document = document.content\\n self.check_document(url, original_document)\",\n \"async def test_24() -> None:\\n LOG.debug(\\\"Test query for targeting one existing and one non-existing PUBLIC datasets, using ALL. (expect only PUBLIC)\\\")\\n payload = {\\n \\\"referenceName\\\": \\\"MT\\\",\\n \\\"start\\\": 9,\\n \\\"referenceBases\\\": \\\"T\\\",\\n \\\"alternateBases\\\": \\\"C\\\",\\n \\\"assemblyId\\\": \\\"GRCh38\\\",\\n \\\"datasetIds\\\": [\\\"urn:hg:1111genome\\\", \\\"urn:hg:1000genome\\\"],\\n \\\"includeDatasetResponses\\\": \\\"ALL\\\",\\n }\\n headers = {\\\"Authorization\\\": f\\\"Bearer {TOKEN}\\\"}\\n async with aiohttp.ClientSession(headers=headers) as session:\\n async with session.post(\\\"http://localhost:5050/query\\\", data=json.dumps(payload)) as resp:\\n data = await resp.json()\\n assert data[\\\"exists\\\"] is True, sys.exit(\\\"Query POST Endpoint Error!\\\")\\n assert len(data[\\\"datasetAlleleResponses\\\"]) == 1, sys.exit(\\\"Should be able to retrieve only public.\\\")\",\n \"def test_dataset_found_when_querying_number_in_name(self):\\n models.Study.objects.all().delete()\\n # Use a different study to ensure that one of the pre-created datasets doesn't match.\\n study_name = 'unlikely_24601_dataset'\\n # Use an accession that won't match for one dataset but not the other\\n name_match = factories.StudyFactory.create(i_study_name=study_name, i_accession=123456)\\n phs_match = factories.StudyFactory.create(i_study_name='other_name', i_accession=24601)\\n url = self.get_url()\\n response = self.client.get(url, {'q': 246})\\n returned_pks = get_autocomplete_view_ids(response)\\n self.assertEqual(sorted(returned_pks),\\n sorted([name_match.i_accession, phs_match.i_accession]))\",\n \"def test_get_algorithm_Found(self):\\n searched_id = 'xyz1'\\n searched_algorithm = {}\\n searched_algorithm['algorithmId'] = searched_id\\n searched_algorithm['algorithmSummary'] = 'algorithmSummary' + searched_id\\n searched_algorithm['displayName'] = 'displayName' + searched_id\\n searched_algorithm['linkURL'] = 'linkURL' + searched_id\\n right_list = []\\n create_test_algorithm_list(right_list, 101)\\n right_list.append(searched_algorithm)\\n documents = []\\n create_test_documents_list(right_list, documents, 102)\\n index = search.Index(name=search_algorithm._INDEX_STRING)\\n index.put(documents)\\n # end of preparing data\\n result = index.get_range(ids_only=True)\\n self.assertLess(0, len(result.results), msg='The database is empty')\\n algorithm = search_algorithm.get_algorithm(index, searched_id)\\n self.assertDictEqual(searched_algorithm, algorithm, msg='Algorithm was not found in 102 algorithms database')\",\n \"def test_success(database):\\n\\n det_award_1 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\\\"00FORGN\\\",\\n place_of_perform_country_c=\\\"UKR\\\")\\n det_award_2 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\\\"00FoRGN\\\",\\n place_of_perform_country_c=\\\"uKr\\\")\\n det_award_3 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\\\"ny**987\\\",\\n place_of_perform_country_c=\\\"USA\\\")\\n det_award_4 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\\\"NY**987\\\",\\n place_of_perform_country_c=\\\"UsA\\\")\\n errors = number_of_errors(_FILE, database, models=[det_award_1, det_award_2, det_award_3, det_award_4])\\n assert errors == 0\",\n \"def check_analysis(self, analysis, ecosystem, package, version):\\n try:\\n assert analysis is not None, \\\"Analysis not available\\\"\\n assert \\\"result\\\" in analysis, \\\"Can not find the 'result' node.\\\"\\n result = analysis[\\\"result\\\"]\\n self.check_recommendation_part(result)\\n self.check_data_part(result, ecosystem, package, version)\\n return \\\"OK\\\"\\n except Exception as e:\\n return \\\"Failed: \\\" + str(e)\",\n \"def setUp(self):\\n self.database = Mock()\\n self.database.reports_overviews.find_one.return_value = dict(_id=\\\"id\\\")\",\n \"def test_get_occurrence(self):\\n pass\",\n \"def test_context_data_with_valid_search_and_some_results(self):\\n dataset = factories.SourceDatasetFactory.create(\\n i_dbgap_description='lorem ipsum',\\n source_study_version__study=self.study)\\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceDatasetTableFull)\\n self.assertQuerysetEqual(context['results_table'].data, [repr(dataset)])\",\n \"def test_exists_false(self):\\n self.assertFalse(PrepSample.exists('Not_a_Sample', self.prep_template))\",\n \"def test_get_activity_occurrence_details(self):\\n pass\",\n \"def test_graph_load_query_exec(self):\\n provider = QueryProvider(data_environment=\\\"SecurityGraph\\\", driver=self.provider)\\n df = provider.all_queries.get_alert(\\\"help\\\")\\n self.assertIsNone(df)\\n\\n with self.assertRaises(ValueError) as cm:\\n df = provider.all_queries.get_alert()\\n self.assertIn(\\\"alert_id\\\", str(cm.exception))\\n\\n df = provider.all_queries.get_alert(alert_id=\\\"foo\\\")\\n self.assertEqual(len(df), 1)\\n self.assertIn(\\\"/foo\\\", df[\\\"query\\\"].iloc[0])\",\n \"def test_check_database_exists_invalid(self):\\n query_result = None\\n self.client.athena_client = MockAthenaClient(results=query_result)\\n\\n assert_false(self.client.check_database_exists())\",\n \"def test_success(database):\\n\\n det_award_1 = DetachedAwardFinancialAssistanceFactory(place_of_performance_forei=\\\"description\\\",\\n place_of_perform_country_c=\\\"UK\\\",\\n record_type=2)\\n det_award_2 = DetachedAwardFinancialAssistanceFactory(place_of_performance_forei=\\\"description\\\",\\n place_of_perform_country_c=\\\"USA\\\",\\n record_type=2\\n )\\n det_award_3 = DetachedAwardFinancialAssistanceFactory(place_of_performance_forei=None,\\n place_of_perform_country_c=\\\"USA\\\",\\n record_type=2)\\n det_award_4 = DetachedAwardFinancialAssistanceFactory(place_of_performance_forei=\\\"\\\",\\n place_of_perform_country_c=\\\"UsA\\\",\\n record_type=2)\\n det_award_5 = DetachedAwardFinancialAssistanceFactory(place_of_performance_forei=\\\"\\\",\\n place_of_perform_country_c=\\\"UK\\\",\\n record_type=1)\\n det_award_6 = DetachedAwardFinancialAssistanceFactory(place_of_performance_forei=None,\\n place_of_perform_country_c=\\\"UK\\\",\\n record_type=1)\\n\\n errors = number_of_errors(_FILE, database, models=[det_award_1, det_award_2, det_award_3, det_award_4,\\n det_award_5, det_award_6])\\n assert errors == 0\",\n \"def test_success(database):\\n\\n det_award_1 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\\\"00FORGN\\\",\\n place_of_perform_country_c=\\\"UKR\\\", record_type=1)\\n det_award_2 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\\\"00FoRGN\\\",\\n place_of_perform_country_c=\\\"uKr\\\", record_type=1)\\n det_award_3 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\\\"ny**987\\\",\\n place_of_perform_country_c=\\\"USA\\\", record_type=2)\\n det_award_4 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\\\"NY**987\\\",\\n place_of_perform_country_c=\\\"UsA\\\", record_type=2)\\n det_award_5 = DetachedAwardFinancialAssistanceFactory(place_of_performance_code=\\\"NY**987\\\",\\n place_of_perform_country_c=\\\"UKR\\\", record_type=3)\\n errors = number_of_errors(_FILE, database, models=[det_award_1, det_award_2, det_award_3, det_award_4, det_award_5])\\n assert errors == 0\",\n \"def test_db_missing_read(env_setup, env_table, db_insert_test_data, db_read_test_data, response_test_data):\\n test_string = DbManager(SqLiteHelper, {\\\"db_path\\\": env_setup, \\\"master_table\\\": env_table}) \\\\\\n .processor(db_read_test_data.get(\\\"invalid2\\\")) # testing\\n assert test_string == response_test_data.get(\\\"invalid_read2\\\")\",\n \"def test_analysis_result_num(self):\\n self.assertIsNotNone(analysis.analysis_interaction(\\\"Datasets/Wine.csv\\\", \\\"Class\\\"))\",\n \"def test_table_has_no_rows(self):\\n models.SourceDataset.objects.all().delete()\\n response = self.client.get(self.get_url(self.study.pk))\\n context = response.context\\n table = context['source_dataset_table']\\n self.assertEqual(len(table.rows), 0)\",\n \"def check_dataset_exists(dataset):\\n result = subprocess.call(['das_client.py', '--query', 'dataset dataset=%s' % dataset])\\n return result == 0\",\n \"def test_get_algorithm_NotFound(self):\\n searched_id = 'xyz1'\\n right_list = []\\n create_test_algorithm_list(right_list, 101)\\n documents = []\\n create_test_documents_list(right_list, documents, 101)\\n index = search.Index(name=search_algorithm._INDEX_STRING)\\n index.put(documents)\\n # end of preparing data\\n result = index.get_range(ids_only=True)\\n self.assertLess(0, len(result.results), msg='The database is empty')\\n algorithm = search_algorithm.get_algorithm(index, searched_id)\\n self.assertEqual(1, algorithm, msg='Nonexistent Algorithm was found in 101 algorithms database')\",\n \"def exist(self):\",\n \"def update_analysis(pk):\\n\\n track = Track.query.get(pk)\\n if track is None:\\n # TODO: Log This\\n return False\\n\\n # Call Echo Nest\\n try:\\n analysis = get_track_analysis(track.spotify_uri)\\n except EchoNestError:\\n # TODO: Log This\\n return False\\n\\n # commit analysis data to Track model\\n track.audio_summary = analysis\\n\\n db.session.add(track)\\n db.session.commit()\\n\\n return True\",\n \"def test_context_data_with_valid_search_and_a_specified_study(self):\\n trait = factories.SourceTraitFactory.create(i_description='lorem ipsum')\\n study = trait.source_dataset.source_study_version.study\\n factories.SourceTraitFactory.create(i_description='lorem other')\\n get = {'description': 'lorem', 'studies': [study.pk]}\\n response = self.client.get(self.get_url(), get)\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)\\n self.assertQuerysetEqual(context['results_table'].data, [repr(trait)])\",\n \"def test_success(database):\\n\\n office = OfficeFactory(office_code='12345a', financial_assistance_awards_office=True)\\n det_award_1 = DetachedAwardFinancialAssistanceFactory(awarding_office_code='12345a')\\n # test ignore case\\n det_award_2 = DetachedAwardFinancialAssistanceFactory(awarding_office_code='12345A')\\n det_award_3 = DetachedAwardFinancialAssistanceFactory(awarding_office_code='')\\n det_award_4 = DetachedAwardFinancialAssistanceFactory(awarding_office_code=None)\\n errors = number_of_errors(_FILE, database, models=[office, det_award_1, det_award_2, det_award_3, det_award_4])\\n assert errors == 0\",\n \"def checkIfAntennaExists(table, name, fk):\\n\\ttry:\\n\\t\\tcon = sqlite3.connect('PampDb.db')\\n\\t\\tcur = con.cursor()\\n\\t\\tcur.execute(\\\"SELECT * FROM \\\" + table + \\\" WHERE name='\\\" + name + \\\"'\\\")\\n\\t\\tob = cur.fetchall()\\n\\t\\tbo = False\\n\\t\\tif not ob:\\n\\t\\t\\tcur.execute(\\\"INSERT INTO '\\\" + table + \\\"' (name, measuringObjectId) VALUES ('\\\" + name + \\\"', '\\\" + str(fk) + \\\"')\\\")\\n\\t\\t\\tcon.commit()\\n\\t\\t\\tcur.execute(\\\"SELECT * FROM \\\" + table + \\\" WHERE name='\\\" + name + \\\"'\\\")\\n\\t\\t\\tobj = cur.fetchall()\\n\\t\\t\\tcorObj = obj[0]\\n\\t\\t\\treturn corObj\\n\\t\\telse:\\n\\t\\t\\tfor row in ob:\\n\\t\\t\\t\\tif row[2] == fk:\\n\\t\\t\\t\\t\\tbo = True\\n\\t\\t\\t\\t\\treturn row\\n\\t\\t\\tif not bo:\\n\\t\\t\\t\\tcur.execute(\\\"INSERT INTO '\\\" + table + \\\"' (name, measuringObjectId) VALUES ('\\\" + name + \\\"', '\\\" + str(fk) + \\\"')\\\")\\n\\t\\t\\t\\tcon.commit()\\n\\t\\t\\t\\tcur.execute(\\\"SELECT * FROM \\\" + table + \\\" WHERE name='\\\" + name + \\\"' AND measuringObjectId='\\\" + str(fk) + \\\"'\\\")\\n\\t\\t\\t\\tobj = cur.fetchall()\\n\\t\\t\\t\\tcorObj = obj[0]\\n\\t\\t\\t\\treturn corObj\\n\\t\\tcon.commit()\\n\\t\\tcon.close()\\n\\texcept:\\n\\t\\tprint('Could not run function checkIfAntennaExists from DbController')\",\n \"def test_AlgorithmsIdHandler_GET_Found(self):\\n searched_id = 'xyz1'\\n searched_algorithm = {}\\n searched_algorithm['algorithmId'] = searched_id\\n searched_algorithm['algorithmSummary'] = 'algorithmSummary' + searched_id\\n searched_algorithm['displayName'] = 'displayName' + searched_id\\n searched_algorithm['linkURL'] = 'linkURL' + searched_id\\n right_list = []\\n create_test_algorithm_list(right_list, 101)\\n right_list.append(searched_algorithm)\\n documents = []\\n create_test_documents_list(right_list, documents, 102)\\n index = search.Index(name=search_algorithm._INDEX_STRING)\\n index.put(documents)\\n # end of preparing data\\n result = index.get_range(ids_only=True)\\n self.assertLess(0, len(result.results), msg='The database is empty')\\n response = self.testapp.get('/algorithms/' + searched_id)\\n self.assertEqual(200, response.status_int, msg=\\\"Existent Algorithm wasn't found in empty database\\\")\\n self.assertEqual('application/json', response.content_type)\\n self.assertNotIn('Algorithm Not Found', response.normal_body.decode(encoding='UTF-8'))\\n self.assertEqual(4, len(json.loads(response.normal_body.decode(encoding='UTF-8'))), msg='There returned algorithm has more keys then 4')\\n self.assertDictEqual(searched_algorithm, json.loads(response.normal_body.decode(encoding='UTF-8')), msg='Returned data was not searched algorithm')\",\n \"def check_assertions(self,result):\\n print \\\"checking result\\\",result\\n if self.db.old.find_one({\\\"pdb_code\\\": result.pdb_code}) is None:\\n self.insert(result)\\n else:\\n result_db = self.db.old.find_one({\\\"pdb_code\\\": result.pdb_code})\\n assert result_db['chunk'] == result.clusters\\n assert result_db['chunks'] == result.chunks\\n assert result_db['chunk_sizes'] == result.chunk_sizes\",\n \"def id_exists(test_name):\\n result_json = None\\n try:\\n with open(robot_dir + \\\"/output/results/{}.json\\\".format(test_name.replace(' ', ''))) as result_file:\\n result_json = json.load(result_file)\\n except:\\n print(\\\"Failed to open the result json\\\")\\n return False\\n #look for values NEW_ASSOC, NEW_PROP1, NEW_PROP2\\n print(result_json)\\n if 6 == 6:\\n return True\\n return \\\"Length is not 6\\\"\",\n \"def has_result(self):\\n return len(self.__analysis_items) > 0\",\n \"def test_dataset_found_when_querying_number_in_name(self):\\n models.SourceTrait.objects.all().delete()\\n # Use a different study to ensure that one of the pre-created datasets doesn't match.\\n dataset_name = 'unlikely_24601_dataset'\\n # Use an accession that won't match for one dataset but not the other\\n dataset_name_match = factories.SourceDatasetFactory.create(dataset_name=dataset_name, i_accession=123456)\\n dataset_accession_match = factories.SourceDatasetFactory.create(dataset_name='other_name', i_accession=24601)\\n url = self.get_url()\\n response = self.client.get(url, {'q': 246})\\n returned_pks = get_autocomplete_view_ids(response)\\n self.assertEqual(sorted(returned_pks), sorted([dataset_name_match.i_id, dataset_accession_match.i_id]))\",\n \"def test_context_data_with_valid_search_and_no_results(self):\\n response = self.client.get(self.get_url(self.study.pk), {'description': 'test'})\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)\",\n \"def test_correct_dataset_found_by_name(self):\\n dataset_name = 'my_unlikely_dataset_name'\\n dataset = factories.SourceDatasetFactory.create(\\n dataset_name=dataset_name,\\n source_study_version=self.source_study_version\\n )\\n url = self.get_url(self.study.pk)\\n response = self.client.get(url, {'q': dataset_name})\\n returned_pks = get_autocomplete_view_ids(response)\\n self.assertEqual(returned_pks, [dataset.i_id])\",\n \"def test_correct_dataset_found_by_name(self):\\n dataset_name = 'my_unlikely_dataset_name'\\n dataset = factories.SourceDatasetFactory.create(\\n dataset_name=dataset_name,\\n source_study_version=self.source_study_version\\n )\\n url = self.get_url(self.study.pk)\\n response = self.client.get(url, {'q': dataset_name})\\n returned_pks = get_autocomplete_view_ids(response)\\n self.assertEqual(returned_pks, [dataset.i_id])\",\n \"def test_get_success_case(self):\\r\\n m = self.table.objects.get(test_id=0, attempt_id=0)\\r\\n assert isinstance(m, ResultObject)\\r\\n assert m.test_id == 0\\r\\n assert m.attempt_id == 0\\r\\n\\r\\n q = self.table.objects(test_id=0, attempt_id=0)\\r\\n m = q.get()\\r\\n assert isinstance(m, ResultObject)\\r\\n assert m.test_id == 0\\r\\n assert m.attempt_id == 0\\r\\n\\r\\n q = self.table.objects(test_id=0)\\r\\n m = q.get(attempt_id=0)\\r\\n assert isinstance(m, ResultObject)\\r\\n assert m.test_id == 0\\r\\n assert m.attempt_id == 0\",\n \"def test_AlgorithmsIdHandler_GET_NotFound(self):\\n searchedId='xyz1'\\n right_list = []\\n create_test_algorithm_list(right_list, 101)\\n documents = []\\n create_test_documents_list(right_list, documents, 101)\\n index = search.Index(name=search_algorithm._INDEX_STRING)\\n index.put(documents)\\n # end of preparing data\\n result = index.get_range(ids_only=True)\\n self.assertLess(0, len(result.results), msg='The database is empty')\\n response = self.testapp.get('/algorithms/' + searchedId, expect_errors=True)\\n self.assertEqual(404, response.status_int, msg='Non existent Algorithm was found in empty database')\\n self.assertEqual('application/json', response.content_type)\\n self.assertIn('Algorithm Not Found', response.normal_body.decode(encoding='UTF-8'))\",\n \"def test_get_record(self):\\n pass\",\n \"def test_context_data_info_message_for_one_result(self):\\n factories.SourceTraitFactory.create(\\n i_description='lorem ipsum',\\n source_dataset__source_study_version__study=self.study)\\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\\n messages = list(response.wsgi_request._messages)\\n self.assertEqual(len(messages), 1)\\n self.assertEqual(str(messages[0]), '1 result found.')\",\n \"def test_AlgorithmsIdHandler_GET_Empty(self):\\n searchedId='xyz1'\\n response = self.testapp.get('/algorithms/' + searchedId, expect_errors=True)\\n self.assertEqual(404, response.status_int, msg='Non existent Algorithm was found in empty database')\\n self.assertEqual('application/json', response.content_type)\\n self.assertIn('Algorithm Not Found', response.normal_body.decode(encoding='UTF-8'))\",\n \"def test_query_inserted_data(self):\\n with app.app_context():\\n data_github = {\\n \\\"version_control\\\": \\\"github\\\",\\n \\\"scm_repo\\\": \\\"B\\\",\\n \\\"scm_branch\\\": \\\"B\\\",\\n \\\"scm_commit\\\": \\\"B\\\",\\n \\\"repo\\\": \\\"B1\\\",\\n \\\"branch\\\": \\\"B1\\\",\\n \\\"enabled\\\": False\\n }\\n\\n data_git = {\\n \\\"version_control\\\": \\\"git\\\",\\n \\\"scm_repo\\\": \\\"B\\\",\\n \\\"scm_branch\\\": \\\"B\\\",\\n \\\"scm_commit\\\": \\\"B\\\",\\n \\\"repo\\\": \\\"B2\\\",\\n \\\"branch\\\": \\\"B2\\\",\\n \\\"enabled\\\": False\\n }\\n\\n for data_insert in [data_github, data_git]:\\n create_tracking(data_insert)\\n\\n resp = self.client.get(\\\"/tracking?repo={}&branch={}\\\".format(data_insert[\\\"repo\\\"], data_insert[\\\"branch\\\"]))\\n\\n resp_dict = json.loads(resp.data)\\n self.assertIn(\\\"code\\\", resp_dict, msg=\\\"Error in data format return\\\")\\n self.assertEqual(ResponseCode.SUCCESS, resp_dict.get(\\\"code\\\"), msg=\\\"Error in status code return\\\")\\n\\n self.assertIn(\\\"msg\\\", resp_dict, msg=\\\"Error in data format return\\\")\\n self.assertEqual(\\n ResponseCode.CODE_MSG_MAP.get(ResponseCode.SUCCESS),\\n resp_dict.get(\\\"msg\\\"),\\n msg=\\\"Error in status code return\\\"\\n )\\n\\n self.assertIn(\\\"data\\\", resp_dict, msg=\\\"Error in data format return\\\")\\n self.assertIsNotNone(resp_dict.get(\\\"data\\\"), msg=\\\"Error in data information return\\\")\\n self.assertIn(data_insert, resp_dict.get(\\\"data\\\"), msg=\\\"Error in data information return\\\")\",\n \"def checkExistence(idMeta):\\n # XXX add for diaries\\n sqlq = \\\"\\\"\\\"\\n SELECT dt\\n FROM Electricity_10min\\n WHERE `Meta_idMeta` = {}\\n LIMIT 1;\\n \\\"\\\"\\\".format(idMeta)\\n try:\\n result = mdb.getSQL(sqlq)[0]\\n if (result):\\n return True\\n except:\\n return False\",\n \"def test_no_updated_datasets(self):\\n response = self.client.get(self.get_url(self.study.pk))\\n context = response.context\\n table = context['source_dataset_table']\\n for dataset in self.datasets_v3:\\n self.assertNotIn(dataset, table.data)\",\n \"def test_create_occurrence(self):\\n pass\",\n \"async def test_9() -> None:\\n LOG.debug(\\\"Test get query (good query, empty response)\\\")\\n params = {\\\"assemblyId\\\": \\\"GRCh99\\\", \\\"referenceName\\\": \\\"MT\\\", \\\"start\\\": 63, \\\"referenceBases\\\": \\\"CT\\\", \\\"alternateBases\\\": \\\"NN\\\", \\\"includeDatasetResponses\\\": \\\"HIT\\\"}\\n async with aiohttp.ClientSession() as session:\\n async with session.get(\\\"http://localhost:5050/query\\\", params=params) as resp:\\n data = await resp.json()\\n assert data[\\\"exists\\\"] is False, sys.exit(\\\"Query GET Endpoint Error!\\\")\",\n \"def test_context_data_info_message_for_no_results(self):\\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\\n messages = list(response.wsgi_request._messages)\\n self.assertEqual(len(messages), 1)\\n self.assertEqual(str(messages[0]), '0 results found.')\",\n \"def test_context_data_info_message_for_no_results(self):\\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\\n messages = list(response.wsgi_request._messages)\\n self.assertEqual(len(messages), 1)\\n self.assertEqual(str(messages[0]), '0 results found.')\",\n \"def test_sample_is_attached_to_patient(self):\\r\\n self.assertEqual(self.test_patient.sample_set.all()[0], self.test_sample)\",\n \"def test_get_records(self):\\n pass\",\n \"def test_exists(self, mock_current_session):\\n added = datetime.now(UTC)\\n mock_store = mock.MagicMock()\\n mock_store.get_metadata.return_value = \\\\\\n Metadata(added=added, checksum='foopdfchex==', size_bytes=1_234)\\n mock_current_session.return_value = mock_store\\n\\n data, code, headers = \\\\\\n controllers.get_preview_metadata(self.source_id, self.checksum)\\n self.assertEqual(code, status.OK, 'Returns 200 OK')\\n self.assertEqual(headers['ETag'], 'foopdfchex==',\\n 'ETag is set to the preview checksum')\\n self.assertDictEqual(data, {'checksum': 'foopdfchex==',\\n 'added': added,\\n 'size_bytes': 1234},\\n 'Returns metadata about the preview')\",\n \"def test_analysis_result_cat(self):\\n self.assertIsNotNone(analysis.analysis_interaction(\\\"Datasets/Crime1.csv\\\", \\\"Category\\\"))\",\n \"def db_exists(self, db):\\n raise NotImplementedError()\",\n \"def test_check_table_exists_invalid(self, mock_logging):\\n query_result = None\\n self.client.athena_client = MockAthenaClient(results=query_result)\\n\\n result = self.client.check_table_exists('unit-test')\\n assert_false(result)\\n assert_true(mock_logging.info.called)\",\n \"def test_top_archive_view_has_metadata_iff_idea_exists(self):\\n self.ideas[2].voter.display_name = 'George Washington'\\n self.ideas[2].voter.save()\\n\\n self.ideas[2].category.name = 'Environmental Issues'\\n self.ideas[2].category.save()\\n\\n TopSubmissionForm(data={'category': self.categories[0].id,\\n 'submission': self.ideas[2].id,\\n 'rank': 2},\\n debate=self.debate).save()\\n rsp = self.client.get(self.url(self.categories[0].slug))\\n self.assertContains(rsp, self.ideas[2].voter.user_display_name())\\n self.assertContains(rsp, self.ideas[2].category.name)\\n self.assertContains(rsp, date_format(localtime(self.ideas[2].created_at)))\\n\\n self.ideas[2].delete()\\n rsp = self.client.get(self.url(self.categories[0].slug))\\n self.assertNotContains(rsp, self.ideas[2].voter.user_display_name())\\n self.assertNotContains(rsp, self.ideas[2].category.name)\\n self.assertNotContains(rsp, date_format(localtime(self.ideas[2].created_at)))\\n self.assertContains(rsp, self.ideas[2].headline)\",\n \"def test_finding_datasets_doesnt_query_database_excessively(\\n access_type, client, django_assert_num_queries\\n):\\n expected_num_queries = 13\\n source_tags = [factories.SourceTagFactory() for _ in range(10)]\\n topic_tags = [factories.TopicTagFactory() for _ in range(10)]\\n\\n masters = [\\n factories.DataSetFactory(\\n type=DataSetType.MASTER,\\n published=True,\\n user_access_type=access_type,\\n )\\n for _ in range(random.randint(10, 50))\\n ]\\n for master in masters:\\n master.tags.set(\\n random.sample(source_tags, random.randint(1, 3))\\n + random.sample(topic_tags, random.randint(1, 3))\\n )\\n\\n datacuts = [\\n factories.DataSetFactory(\\n type=DataSetType.DATACUT,\\n published=True,\\n user_access_type=access_type,\\n )\\n for _ in range(random.randint(10, 50))\\n ]\\n for datacut in datacuts:\\n datacut.tags.set(random.sample(source_tags, 1) + random.sample(topic_tags, 1))\\n\\n references = [factories.ReferenceDatasetFactory.create(published=True) for _ in range(10)]\\n for reference in references:\\n reference.tags.set(\\n random.sample(source_tags, random.randint(1, 3))\\n + random.sample(topic_tags, random.randint(1, 3))\\n )\\n\\n visualisations = [\\n factories.VisualisationCatalogueItemFactory.create(published=True)\\n for _ in range(random.randint(10, 50))\\n ]\\n\\n for visualisation in visualisations:\\n factories.DataSetApplicationTemplatePermissionFactory(\\n application_template=visualisation.visualisation_template,\\n dataset=random.choice(masters),\\n )\\n\\n # Log into site (triggers the queries related to setting up the user).\\n client.get(reverse(\\\"root\\\"))\\n\\n with django_assert_num_queries(expected_num_queries, exact=False):\\n response = client.get(reverse(\\\"datasets:find_datasets\\\"), follow=True)\\n assert response.status_code == 200\\n\\n with django_assert_num_queries(expected_num_queries, exact=False):\\n response = client.get(reverse(\\\"datasets:find_datasets\\\"), {\\\"q\\\": \\\"potato\\\"})\\n assert response.status_code == 200\\n\\n with django_assert_num_queries(expected_num_queries + 1, exact=False):\\n response = client.get(\\n reverse(\\\"datasets:find_datasets\\\"),\\n {\\\"source\\\": [str(tag.id) for tag in random.sample(source_tags, random.randint(1, 5))]},\\n )\\n assert response.status_code == 200\\n\\n with django_assert_num_queries(expected_num_queries + 1, exact=False):\\n response = client.get(\\n reverse(\\\"datasets:find_datasets\\\"),\\n {\\\"topic\\\": [str(tag.id) for tag in random.sample(topic_tags, random.randint(1, 5))]},\\n )\\n assert response.status_code == 200\\n\\n with django_assert_num_queries(expected_num_queries, exact=False):\\n response = client.get(\\n reverse(\\\"datasets:find_datasets\\\"),\\n {\\\"data_type\\\": str(DataSetType.MASTER)},\\n )\\n assert response.status_code == 200\\n\\n with django_assert_num_queries(expected_num_queries, exact=False):\\n response = client.get(reverse(\\\"datasets:find_datasets\\\"), {\\\"access\\\": \\\"yes\\\"})\\n assert response.status_code == 200\",\n \"def test_retrieve(self):\\n stats_data = self.stats_data\\n facility = self.facility\\n\\n obj = FacilityPatientStatsHistory.objects.create(\\n facility=facility, entry_date=datetime.date(2020, 4, 1), **stats_data\\n )\\n\\n response = self.client.get(self.get_url(entry_id=obj.external_id), format=\\\"json\\\")\\n self.assertDictEqual(\\n response.json(), self.get_detail_representation(stats_data, facility=facility),\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67521673","0.64993656","0.6392804","0.6276373","0.62410223","0.62198424","0.61320305","0.6044973","0.60429484","0.6037851","0.60214347","0.600699","0.59700125","0.5969135","0.593259","0.5906568","0.5866727","0.5863172","0.5861047","0.5857293","0.584378","0.5838553","0.58186275","0.5813475","0.5810965","0.579262","0.57862514","0.5781008","0.5779888","0.5761946","0.574462","0.5740754","0.5736686","0.57287604","0.57237417","0.57122886","0.5671642","0.5664183","0.56521666","0.5638795","0.5628406","0.56226134","0.5617123","0.5604342","0.5597625","0.559357","0.5592517","0.55824065","0.5575365","0.5575002","0.55592734","0.5558491","0.55576086","0.5557572","0.5556679","0.55378366","0.5537214","0.55349135","0.55347025","0.55324095","0.5531295","0.55210966","0.5519781","0.55169433","0.5512076","0.5511335","0.55051637","0.5478382","0.5471927","0.5468975","0.54661006","0.54647475","0.5457949","0.5457179","0.5456896","0.5452834","0.5438161","0.54357666","0.54357666","0.5434994","0.54325765","0.5427334","0.5425808","0.54209703","0.5420194","0.54201","0.54199696","0.5418647","0.5416836","0.54157","0.54157","0.5414083","0.540972","0.5409069","0.5407914","0.54057056","0.53997153","0.53971976","0.5396009","0.53885543"],"string":"[\n \"0.67521673\",\n \"0.64993656\",\n \"0.6392804\",\n \"0.6276373\",\n \"0.62410223\",\n \"0.62198424\",\n \"0.61320305\",\n \"0.6044973\",\n \"0.60429484\",\n \"0.6037851\",\n \"0.60214347\",\n \"0.600699\",\n \"0.59700125\",\n \"0.5969135\",\n \"0.593259\",\n \"0.5906568\",\n \"0.5866727\",\n \"0.5863172\",\n \"0.5861047\",\n \"0.5857293\",\n \"0.584378\",\n \"0.5838553\",\n \"0.58186275\",\n \"0.5813475\",\n \"0.5810965\",\n \"0.579262\",\n \"0.57862514\",\n \"0.5781008\",\n \"0.5779888\",\n \"0.5761946\",\n \"0.574462\",\n \"0.5740754\",\n \"0.5736686\",\n \"0.57287604\",\n \"0.57237417\",\n \"0.57122886\",\n \"0.5671642\",\n \"0.5664183\",\n \"0.56521666\",\n \"0.5638795\",\n \"0.5628406\",\n \"0.56226134\",\n \"0.5617123\",\n \"0.5604342\",\n \"0.5597625\",\n \"0.559357\",\n \"0.5592517\",\n \"0.55824065\",\n \"0.5575365\",\n \"0.5575002\",\n \"0.55592734\",\n \"0.5558491\",\n \"0.55576086\",\n \"0.5557572\",\n \"0.5556679\",\n \"0.55378366\",\n \"0.5537214\",\n \"0.55349135\",\n \"0.55347025\",\n \"0.55324095\",\n \"0.5531295\",\n \"0.55210966\",\n \"0.5519781\",\n \"0.55169433\",\n \"0.5512076\",\n \"0.5511335\",\n \"0.55051637\",\n \"0.5478382\",\n \"0.5471927\",\n \"0.5468975\",\n \"0.54661006\",\n \"0.54647475\",\n \"0.5457949\",\n \"0.5457179\",\n \"0.5456896\",\n \"0.5452834\",\n \"0.5438161\",\n \"0.54357666\",\n \"0.54357666\",\n \"0.5434994\",\n \"0.54325765\",\n \"0.5427334\",\n \"0.5425808\",\n \"0.54209703\",\n \"0.5420194\",\n \"0.54201\",\n \"0.54199696\",\n \"0.5418647\",\n \"0.5416836\",\n \"0.54157\",\n \"0.54157\",\n \"0.5414083\",\n \"0.540972\",\n \"0.5409069\",\n \"0.5407914\",\n \"0.54057056\",\n \"0.53997153\",\n \"0.53971976\",\n \"0.5396009\",\n \"0.53885543\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6659734"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":83693,"cells":{"query":{"kind":"string","value":"Test getting an analysis when it does not exist in the database."},"document":{"kind":"string","value":"def test_get_analysis_with_id_when_missing(analysis_store: MockStore):\n # GIVEN an id that doesn't exist\n missing_analysis_id = 12312423534\n\n # WHEN accessing the analysis\n analysis: Analysis = analysis_store.get_analysis_with_id(analysis_id=missing_analysis_id)\n\n # THEN it should return None\n assert not analysis"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_no_one_in_db(self):\n q = self.generate_query('view_manager_report', ())\n res = self.execute_query(q)\n expected = []\n assert len(res) == 0, f'There is suppose to be an empty summary {res}'\n assert res == expected, f'The result is suppose to be empty {res}'","def test_get_study_missing(self):\n self.assertIsNone(self.storage.get_study('missing'))","async def test_get_empty(subject: AnalysisStore, protocol_store: ProtocolStore) -> None:\n protocol_store.insert(make_dummy_protocol_resource(\"protocol-id\"))\n\n full_result = await subject.get_by_protocol(\"protocol-id\")\n summaries_result = subject.get_summaries_by_protocol(\"protocol-id\")\n\n assert full_result == []\n assert summaries_result == []\n\n with pytest.raises(AnalysisNotFoundError, match=\"analysis-id\"):\n await subject.get(\"analysis-id\")","def test_query_1(self):\n with app.test_request_context():\n agency_none = db.session.query(\n Agency).filter_by(name=\"not here\").first()\n self.assertTrue(agency_none is None)","def test_finds_no_traits_if_dataset_search_doesnt_match(self):\n dataset = factories.SourceDatasetFactory.create(i_dbgap_description='a dataset about demographic measurements')\n trait = factories.SourceTraitFactory.create(i_description='lorem ipsum', source_dataset=dataset)\n response = self.client.get(self.get_url(), {'description': 'lorem', 'dataset_description': 'something'})\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)\n self.assertEqual(len(context['results_table'].rows), 0)","def test_exist(self):\n with self.assertRaises(IncompetentQiitaDeveloperError):\n MetadataTemplate.exists(self.study)","def test_no_updated_datasets(self):\n response = self.client.get(self.get_url(self.study.pk))\n context = response.context\n table = context['source_dataset_table']\n for dataset in self.datasets_v3:\n self.assertNotIn(dataset, table.data)","def test_table_has_no_rows(self):\n models.SourceDataset.objects.all().delete()\n response = self.client.get(self.get_url(self.study.pk))\n context = response.context\n table = context['source_dataset_table']\n self.assertEqual(len(table.rows), 0)","def test_exists_false(self):\n self.assertFalse(Sample.exists('Not_a_Sample', self.sample_template))","def test_context_data_info_message_for_no_results(self):\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\n messages = list(response.wsgi_request._messages)\n self.assertEqual(len(messages), 1)\n self.assertEqual(str(messages[0]), '0 results found.')","def test_context_data_info_message_for_no_results(self):\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\n messages = list(response.wsgi_request._messages)\n self.assertEqual(len(messages), 1)\n self.assertEqual(str(messages[0]), '0 results found.')","def test_import_is_skipped(self):\n self.database.reports.distinct.return_value = [\"id\"]\n self.import_report(self.report_json)\n self.database.reports.insert_one.assert_not_called()","def test_not_found(self):\n self.library.get.when.called_with('dummy!!!')\\\n .should.throw(ViolationDoesNotExists)","def test_db_missing_read(env_setup, env_table, db_insert_test_data, db_read_test_data, response_test_data):\n test_string = DbManager(SqLiteHelper, {\"db_path\": env_setup, \"master_table\": env_table}) \\\n .processor(db_read_test_data.get(\"invalid2\")) # testing\n assert test_string == response_test_data.get(\"invalid_read2\")","def test_exists_false(self):\n self.assertFalse(SampleTemplate.exists(self.new_study.id))","def test_get_algorithm_NotFound(self):\n searched_id = 'xyz1'\n right_list = []\n create_test_algorithm_list(right_list, 101)\n documents = []\n create_test_documents_list(right_list, documents, 101)\n index = search.Index(name=search_algorithm._INDEX_STRING)\n index.put(documents)\n # end of preparing data\n result = index.get_range(ids_only=True)\n self.assertLess(0, len(result.results), msg='The database is empty')\n algorithm = search_algorithm.get_algorithm(index, searched_id)\n self.assertEqual(1, algorithm, msg='Nonexistent Algorithm was found in 101 algorithms database')","def test_report_of_article_does_not_exist(self):\n from rest_framework.test import APIClient\n client = APIClient()\n response = client.post('/api/report/spoon/', self.report,\n HTTP_AUTHORIZATION='Token ' + self.token_1,\n format='json')\n result = json.loads(response.content)\n\n self.assertEqual(result[\"error_message\"], \"The article you are reporting does not exist\")\n self.assertEqual(response.status_code, status.HTTP_200_OK)","def test_get_non_existing_sale_record(self):\n\t\tself.register_user()\n\t\tresult = self.login_user()\n\t\taccess_token = json.loads(result.data.decode())['token']\n\n\t\tresponse = self.client.get('/api/v1/sale/100',\n\t\t\theaders=dict(Authorization=\"Bearer \" + access_token))\n\t\tself.assertEqual(response.status_code, 404)\n\n\t\tresult = json.loads(response.data.decode())\n\t\tself.assertEqual(result[\"message\"], \"sale record unavailable\")\n\t\tself.assertEqual(result[\"status\"], \"not found\")","def test_data_source_soaps_id_exists_get(self):\n pass","def test_no_track_data_error():\n try:\n bad_arm = survey.get_spiral_slice(track = \"fakeSpiral\")\n except KeyError:\n assert True\n else:\n assert False","def test_does_not_exist(self, mock_current_session):\n mock_store = mock.MagicMock()\n mock_store.get_metadata.side_effect = store.DoesNotExist\n mock_current_session.return_value = mock_store\n\n with self.assertRaises(NotFound):\n controllers.get_preview_metadata(self.source_id, self.checksum)","def test_experiment_do_not_exist(self):\n with pytest.raises(NoConfigurationError) as exception:\n get_experiment(\"a\")\n assert (\n \"No experiment with given name 'a' and version '*' inside database, \"\n \"no view can be created.\" == str(exception.value)\n )","def test_no_skill_aggregate(self):\n actions.login(ADMIN_EMAIL)\n\n get_url = '%s?%s' % (self.URL, urllib.urlencode({\n 'ids': [1]}, True))\n response = self.get(get_url)\n self.assertEqual(200, response.status_int)\n payload = transforms.loads(response.body)['payload']\n result = transforms.loads(payload)\n\n self.assertEqual(['Date'], result['column_headers'])\n self.assertEqual([], result['data'])","def test_ai_undefined(self, mock_get, mock_get_categories):\n\n # We mock ai_list\n mock_get.return_value = {\n 'ai_list': [\n factory.build(\n dict,\n FACTORY_CLASS=AiFactory,\n ai_status='ai_undefined'\n )\n ]\n }\n response = self.client.get(reverse('studio:summary'))\n self.assertContains(response, 'Not Started')","def test_get_algorithm_Empty(self):\n searched_id = 'xyz1'\n index = search.Index(name=search_algorithm._INDEX_STRING)\n result = index.get_range(ids_only=True)\n self.assertEqual(0, len(result.results), msg='The database is not empty')\n algorithm = search_algorithm.get_algorithm(index, searched_id)\n self.assertEqual(1, algorithm, msg='Non existent Algorithm was found in empty database')","def test_get_document_inexistent(empty_index):\n with pytest.raises(Exception):\n empty_index().get_document(\"123\")","def test_missing_data_sources(self):","def test_no_removed_datasets(self):\n removed_dataset_1 = factories.SourceDatasetFactory.create(source_study_version=self.study_version_1)\n removed_dataset_2 = factories.SourceDatasetFactory.create(\n source_study_version=self.study_version_2, i_accession=removed_dataset_1.i_accession)\n response = self.client.get(self.get_url(self.study.pk))\n context = response.context\n table = context['source_dataset_table']\n self.assertNotIn(removed_dataset_1, table.data)\n self.assertNotIn(removed_dataset_2, table.data)\n self.assertEqual(len(table.data), 0)","def test_exists_false(self):\n self.assertFalse(PrepSample.exists('Not_a_Sample', self.prep_template))","def test_id_missing(self) -> None:\n with pytest.raises(NotFound):\n ObservationType.from_id(-1)","def test_context_data_with_valid_search_and_no_results(self):\n response = self.client.get(self.get_url(self.study.pk), {'description': 'test'})\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceDatasetTableFull)","def test_get_analysis_with_id(analysis_store: MockStore):\n # GIVEN a store with an analysis\n existing_analysis: Analysis = analysis_store.get_query(table=Analysis).first()\n\n # WHEN accessing it by ID\n analysis: Analysis = analysis_store.get_analysis_with_id(analysis_id=existing_analysis.id)\n\n # THEN it should return the same analysis\n assert analysis == existing_analysis","def test_stats_get(self):\n stats_store = StatsStore()\n\n gen_stats = stats_store.general_stats_get(\"inexisting_stats\")\n assert not gen_stats","def test_no_match(add_doc, add_institution):\n\n doc = add_doc(log={\n 'url': 'http://yale.edu/syllabus.pdf'\n })\n\n harvard = add_institution(\n name='Harvard University',\n domain='harvard.edu',\n )\n\n doc_to_inst(doc.id)\n\n # Shouldn't write a link.\n assert Institution_Document.select().count() == 0","def test_check_database_exists_invalid(self):\n query_result = None\n self.client.athena_client = MockAthenaClient(results=query_result)\n\n assert_false(self.client.check_database_exists())","def test_missing_model():\n\n with pytest.raises(KeyError):\n Instafilter(\"xxx\")","def test_AlgorithmsIdHandler_GET_NotFound(self):\n searchedId='xyz1'\n right_list = []\n create_test_algorithm_list(right_list, 101)\n documents = []\n create_test_documents_list(right_list, documents, 101)\n index = search.Index(name=search_algorithm._INDEX_STRING)\n index.put(documents)\n # end of preparing data\n result = index.get_range(ids_only=True)\n self.assertLess(0, len(result.results), msg='The database is empty')\n response = self.testapp.get('/algorithms/' + searchedId, expect_errors=True)\n self.assertEqual(404, response.status_int, msg='Non existent Algorithm was found in empty database')\n self.assertEqual('application/json', response.content_type)\n self.assertIn('Algorithm Not Found', response.normal_body.decode(encoding='UTF-8'))","def test_table_has_no_rows(self):\n models.Study.objects.all().delete()\n response = self.client.get(self.get_url())\n context = response.context\n table = context['study_table']\n self.assertEqual(len(table.rows), 0)","def test_neg_exists_with_non_existent_data(self, key, ex, ex_code):\n try:\n key, meta = self.as_connection.exists(key)\n assert meta is None\n \"\"\"\n We are making the api backward compatible. In case of RecordNotFound an\n exception will not be raised. Instead Ok response is returned withe the\n meta as None. This might change with further releases.\n \"\"\"\n except ex as exception:\n assert exception.code == ex_code","def test_table_has_no_rows(self):\n models.SourceDataset.objects.all().delete()\n response = self.client.get(self.get_url())\n context = response.context\n table = context['source_dataset_table']\n self.assertEqual(len(table.rows), 0)","def test_get_doesnotexist_exception(self):\r\n with self.assertRaises(self.table.DoesNotExist):\r\n self.table.objects.get(test_id=100)","def test_handle_non_existed_assignment_properly(user_client):\n response = user_client.get(\"/api/v1/assignments/999/\")\n assert response.data == {\"detail\": \"Not found.\"}","def test_query_with_no_matches_returns_nothing(test_store):\n items = list(test_store.get_by(name=\"Sugar\"))\n\n assert len(items) == 0","def test_no_data():\n test = [{}, ['keys']]\n t_result = fetch_data_by_keys(*test)\n assert not is_successful(t_result)\n assert 'keys' in str(t_result.failure())","def test_get_report_wrong_object_id(self):\n vt_analyses = VirusTotalAPIAnalyses('test_api_key')\n vt_analyses.get_report('test_object_id')\n http_err = vt_analyses.get_last_http_error()\n self.assertEqual(http_err, vt_analyses.HTTP_NOT_FOUND_ERROR)","def test_no_such_key():\n test = [{'key': 'val1'}, ['missing']]\n t_result = fetch_data_by_keys(*test)\n assert not is_successful(t_result)\n assert 'missing' in str(t_result.failure())","def test_context_data_with_valid_search_and_no_results(self):\n response = self.client.get(self.get_url(self.study.pk), {'description': 'test'})\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)","def test_get_doesnotexist_exception(self):\r\n with self.assertRaises(TestModel.DoesNotExist):\r\n TestModel.objects.get(test_id=100)","async def test_26() -> None:\n LOG.debug(\"Test query for non-existing query targeting three datasets, using MISS. (expect data shown)\")\n payload = {\n \"referenceName\": \"MT\",\n \"start\": 10,\n \"referenceBases\": \"T\",\n \"alternateBases\": \"C\",\n \"assemblyId\": \"GRCh38\",\n \"datasetIds\": [\"urn:hg:1000genome\", \"urn:hg:1000genome:controlled\", \"urn:hg:1000genome:registered\"],\n \"includeDatasetResponses\": \"MISS\",\n }\n headers = {\"Authorization\": f\"Bearer {TOKEN}\"}\n async with aiohttp.ClientSession(headers=headers) as session:\n async with session.post(\"http://localhost:5050/query\", data=json.dumps(payload)) as resp:\n data = await resp.json()\n assert data[\"exists\"] is False, sys.exit(\"Query POST Endpoint Error!\")\n assert len(data[\"datasetAlleleResponses\"]) == 3, sys.exit(\"Should be able to retrieve missing datasets.\")","def test_empty_db(client, test_db):\n rv = client.get(\"/\")\n assert b\"No entries yet. Add some!\" in rv.data","async def test_nr_of_missing_metrics_without_correct_report(self):\n self.reports[\"reports\"] = []\n response = await self.collect(get_request_json_side_effect=[self.data_model, self.reports])\n self.assert_measurement(response, parse_error=\"No reports found with title or id\")","def test_no_results(self, setup_data):\n term = 'there-should-be-no-match'\n\n url = reverse('api-v3:search:basic')\n response = self.api_client.get(\n url,\n data={\n 'term': term,\n 'entity': 'company',\n },\n )\n\n assert response.data['count'] == 0","def test_c_get_existing_records(self):\n\n success = True\n records = get_existing_records(location, database)\n\n if records['variable'].values[0] != value:\n success = False\n\n for function in records['function'].values:\n if function not in outcome_methods:\n success = False\n\n if records[records['function'] == 'nanmean']['value'].values != 2.143:\n success = False\n\n if records[records['function'] == 'nanpercentile_25']['value'].values != 1.0:\n success = False\n\n if records[records['function'] == 'nanpercentile_75']['value'].values != 2.5:\n success = False\n\n if not np.isnan(records[records['function'] == 'std']['value'].values[0]):\n success = False\n\n assert(success)","def test_narrative_data_missing(self, config_handler):\n spec = Spec.from_dict(\n {\"name\": \"homogeneity_coefficient\", \"unit\": \"percentage\", \"dtype\": \"float\"}\n )\n with raises(SmifDataNotFoundError):\n config_handler.read_narrative_variant_data(\"does not exist\", spec)","def test_table_has_no_rows(self):\n models.SourceTrait.objects.all().delete()\n response = self.client.get(self.get_url(self.study.pk))\n context = response.context\n table = context['source_trait_table']\n self.assertEqual(len(table.rows), 0)","def test_analysis_match(self):\n self.api.observable_add('test.com')\n results = self.api.analysis_match(['test.com', 'unknown.com'])\n known = [o['value'] for o in results['known']]\n self.assertIn('test.com', known)\n self.assertIn('unknown.com', results['unknown'])","def test_status_missing(self):\n measurement = Measurement(self.metric())\n self.assertEqual(None, measurement.status())","def test_returns_all_datasets_with_no_query(self):\n url = self.get_url(self.study.pk)\n response = self.client.get(url)\n pks = get_autocomplete_view_ids(response)\n self.assertEqual(sorted([dataset.pk for dataset in self.source_datasets]), sorted(pks))","def test_returns_all_datasets_with_no_query(self):\n url = self.get_url(self.study.pk)\n response = self.client.get(url)\n pks = get_autocomplete_view_ids(response)\n self.assertEqual(sorted([dataset.pk for dataset in self.source_datasets]), sorted(pks))","def test_returns_all_datasets_with_no_query(self):\n url = self.get_url(self.study.pk)\n response = self.client.get(url)\n pks = get_autocomplete_view_ids(response)\n self.assertEqual(sorted([dataset.pk for dataset in self.source_datasets]), sorted(pks))","def test_view_with_invalid_pk(self):\n response = self.client.get(self.get_url(self.dataset.pk + 1))\n self.assertEqual(response.status_code, 404)","def test_returns_all_studies_with_no_query(self):\n url = self.get_url()\n response = self.client.get(url)\n pks = get_autocomplete_view_ids(response)\n self.assertEqual(sorted([study.pk for study in self.studies]), sorted(pks))","def test_returns_all_studies_with_no_query(self):\n url = self.get_url()\n response = self.client.get(url)\n pks = get_autocomplete_view_ids(response)\n self.assertEqual(sorted([study.pk for study in self.studies]), sorted(pks))","def test_does_not_exist(self, mock_current_session):\n mock_store = mock.MagicMock()\n mock_store.get_preview_checksum.side_effect = store.DoesNotExist\n mock_current_session.return_value = mock_store\n\n with self.assertRaises(NotFound):\n controllers.check_preview_exists(self.source_id, self.checksum)","def test_obtain_issues_no_query(self, mock_url_read):\n mock_url_read.side_effect = \\\n [LAST_SCAN, '{\"reportId\": 22}', '{\"status\": {\"value\": \"Created\"}}', '<CxXMLResults />']\n self.__report.obtain_issues(['id'], 'high')\n issues = self.__report.issues()\n self.assertIsInstance(issues, List)\n self.assertEqual(len(issues), 0)","def test_no_results(self):\n self.factory.create()\n response = self._get(get_kwargs={'search': 'hello'})\n self.assertEquals(response.status_code, 200)\n self.assertTemplateUsed(response, self.template_name)\n self.assertEquals(response.context['object_list'].count(), 0)","def test_missing(server):\n\n assert \"non_existing_database\" not in server\n with pytest.raises(excepts.DBNotExists):\n server[\"non_existing_database\"]","def test_data_source_soaps_find_one_get(self):\n pass","def test_no_source_measurements(self):\n measurement = self.measurement(self.metric())\n self.assertEqual(None, measurement[\"count\"][\"value\"])","def test_check_table_exists_invalid(self, mock_logging):\n query_result = None\n self.client.athena_client = MockAthenaClient(results=query_result)\n\n result = self.client.check_table_exists('unit-test')\n assert_false(result)\n assert_true(mock_logging.info.called)","def test_9_incorrect_database(self):\n fitness = Fitness(None, self.user_id_1)\n s = fitness.insert_in_database(self.fitness_dict, date_time=self.dt1)\n self.assertFalse(s)","def test_fetch_no_results():\n url = (\n \"https://gliders.ioos.us/erddap/search/index.csv?page=1&itemsPerPage=100000&searchFor\"\n '=\"incredibly_long_string_that_should_never_match_a_real_dataset\" '\n )\n key = \"ioos\"\n data = fetch_results(url, key)\n assert data is None","def test_graph_load_query_exec(self):\n provider = QueryProvider(data_environment=\"SecurityGraph\", driver=self.provider)\n df = provider.all_queries.get_alert(\"help\")\n self.assertIsNone(df)\n\n with self.assertRaises(ValueError) as cm:\n df = provider.all_queries.get_alert()\n self.assertIn(\"alert_id\", str(cm.exception))\n\n df = provider.all_queries.get_alert(alert_id=\"foo\")\n self.assertEqual(len(df), 1)\n self.assertIn(\"/foo\", df[\"query\"].iloc[0])","def test_exists(self):\n with self.assertRaises(IncompetentQiitaDeveloperError):\n BaseSample.exists('SKM7.640188', SampleTemplate(1))","def test_ensure_data_no_totaltracks(self):\n album = Album(artist='Artist', album='Album', totalseconds=120)\n with self.assertRaises(Exception):\n album.ensure_data()","def test_410_000_non_existant_db(self):\n with TDC() as temp_dir:\n file = Path(temp_dir) / 'database.db'\n self.assertFalse(file.exists(),'Database file exists pre test')\n eng = Engine(file)\n con = eng.connect()\n self.assertTrue(file.exists(), 'Database file does not exists post test')","def test_search_table_fail_if_no_query(self) -> None:\n with local_app.test_client() as test:\n response = test.get('/api/search/v0/table', query_string=dict(page_index='0'))\n self.assertEqual(response.status_code, HTTPStatus.INTERNAL_SERVER_ERROR)","def test_does_not_exist(self, mock_current_session):\n mock_store = mock.MagicMock()\n mock_store.get_preview.side_effect = store.DoesNotExist\n mock_current_session.return_value = mock_store\n\n with self.assertRaises(NotFound):\n controllers.get_preview_content(self.source_id, self.checksum)","def test_get_data_fail(self):\n self.assertIsNone(get_data('this_must_fail', 5, 0))","def test_AlgorithmsIdHandler_GET_Empty(self):\n searchedId='xyz1'\n response = self.testapp.get('/algorithms/' + searchedId, expect_errors=True)\n self.assertEqual(404, response.status_int, msg='Non existent Algorithm was found in empty database')\n self.assertEqual('application/json', response.content_type)\n self.assertIn('Algorithm Not Found', response.normal_body.decode(encoding='UTF-8'))","def test_assessment_full_no_warnings(self):\n response = self.import_file(\"assessment_full_no_warnings.csv\")\n self._check_csv_response(response, {})\n\n # Test first Assessment line in the CSV file\n asmt_1 = models.Assessment.query.filter_by(slug=\"Assessment 1\").first()\n users = {\n \"user 1\": {\"Assessor\"},\n \"user 2\": {\"Assessor\", \"Creator\"}\n }\n self._test_assessment_users(asmt_1, users)\n self.assertEqual(asmt_1.status, models.Assessment.START_STATE)\n\n # Test second Assessment line in the CSV file\n asmt_2 = models.Assessment.query.filter_by(slug=\"Assessment 2\").first()\n users = {\n \"user 1\": {\"Assessor\"},\n \"user 2\": {\"Creator\"},\n \"user 3\": {},\n \"user 4\": {},\n \"user 5\": {},\n }\n self._test_assessment_users(asmt_2, users)\n self.assertEqual(asmt_2.status, models.Assessment.PROGRESS_STATE)\n\n audit = [obj for obj in asmt_1.related_objects() if obj.type == \"Audit\"][0]\n self.assertEqual(audit.context, asmt_1.context)\n\n evidence = models.Document.query.filter_by(title=\"some title 2\").first()\n self.assertEqual(audit.context, evidence.context)","def test_get_star__no_existing(self):\n email = 'user1@example.com'\n feature_id = self.feature_1.key.integer_id()\n actual = notifier.FeatureStar.get_star(email, feature_id)\n self.assertEqual(None, actual)","def test_030_query_nothing(self):\n\n testflow.step(\"Querying for nothing\")\n assert not self.query_cli.run()[0], \"Invalid arguments of query passed\"","def test_get_session_missing(self):\n study_id = self.storage.create_study(sample_study_spec())\n self.assertIsNone(self.storage.get_session(study_id, 'missing'))\n\n session = sample_session(study_id)\n self.storage.create_session(session)\n self.assertIsNone(self.storage.get_session('missing', session.id))","def test_other_study_not_in_queryset(self):\n # Delete all but five source traits, so that there are 5 from each study.\n study2 = factories.StudyFactory.create()\n datasets2 = factories.SourceDatasetFactory.create_batch(\n 5, source_study_version__study=study2)\n # Get results from the autocomplete view and make sure only datasets from the correct study are found.\n url = self.get_url(self.study.pk)\n response = self.client.get(url)\n returned_pks = get_autocomplete_view_ids(response)\n # Make sure that the other study's datasets do not show up.\n self.assertEqual(len(returned_pks), len(self.source_datasets))\n for dataset in datasets2:\n self.assertNotIn(dataset.i_id, returned_pks)\n for dataset in self.source_datasets:\n self.assertIn(dataset.i_id, returned_pks)","def test_other_study_not_in_queryset(self):\n # Delete all but five source traits, so that there are 5 from each study.\n study2 = factories.StudyFactory.create()\n datasets2 = factories.SourceDatasetFactory.create_batch(\n 5, source_study_version__study=study2)\n # Get results from the autocomplete view and make sure only datasets from the correct study are found.\n url = self.get_url(self.study.pk)\n response = self.client.get(url)\n returned_pks = get_autocomplete_view_ids(response)\n # Make sure that the other study's datasets do not show up.\n self.assertEqual(len(returned_pks), len(self.source_datasets))\n for dataset in datasets2:\n self.assertNotIn(dataset.i_id, returned_pks)\n for dataset in self.source_datasets:\n self.assertIn(dataset.i_id, returned_pks)","def test_running_lookup_uncertainties(self):\n if os.name != \"nt\":\n return\n\n model = LookupTestModel(r\"../models/\", \"lookupTestModel\")\n\n # model.step = 4 #reduce data to be stored\n perform_experiments(model, 10)","def test_find_nonexistent_data(self):\n with app.app_context():\n\n resp = self.client.get(\"/tracking?repo=aa&branch=aa\")\n\n resp_dict = json.loads(resp.data)\n\n self.assertIn(\"code\", resp_dict, msg=\"Error in data format return\")\n self.assertEqual(ResponseCode.SUCCESS, resp_dict.get(\"code\"), msg=\"Error in status code return\")\n\n self.assertIn(\"msg\", resp_dict, msg=\"Error in data format return\")\n self.assertEqual(\n ResponseCode.CODE_MSG_MAP.get(ResponseCode.SUCCESS),\n resp_dict.get(\"msg\"),\n msg=\"Error in status code return\"\n )\n\n self.assertIn(\"data\", resp_dict, msg=\"Error in data format return\")\n self.assertIsNotNone(resp_dict.get(\"data\"), msg=\"Error in data information return\")\n self.assertEqual(resp_dict.get(\"data\"), [], msg=\"Error in data information return\")","def test_get_empty_rare(self):\r\n self.assertRaises(TableException, get_rare_data, self.otu_table,\r\n 50, include_small_samples=False)","def test_error(self):\n metric = self.metric()\n measurement = self.measurement(metric, sources=[self.source(metric, parse_error=\"error\")])\n self.assertEqual(None, measurement[\"count\"][\"value\"])","def test_other_study_not_in_queryset(self):\n # Delete all but five source datasets, so that there are 5 from each study.\n study2 = factories.StudyFactory.create()\n datasets2 = factories.SourceDatasetFactory.create_batch(\n 5, source_study_version__study=study2)\n # Get results from the autocomplete view and make sure only datasets from the correct study are found.\n url = self.get_url(self.study.pk)\n response = self.client.get(url)\n returned_pks = get_autocomplete_view_ids(response)\n # Make sure that the other study's datasets do not show up.\n self.assertEqual(len(returned_pks), len(self.source_datasets))\n for dataset in datasets2:\n self.assertNotIn(dataset.i_id, returned_pks)\n for dataset in self.source_datasets:\n self.assertIn(dataset.i_id, returned_pks)","def test_get_non_existent_skill_progress(self):\n self._build_sample_graph()\n student = models.Student(user_id='1')\n tracker = SkillCompletionTracker()\n result = tracker.get_skills_progress(student, [self.sc.id])\n self.assertEqual(SkillCompletionTracker.NOT_ATTEMPTED,\n result[self.sc.id][0])","async def test_fetch_one_returning_no_results(database_url):\n async with Database(database_url) as database:\n async with database.transaction(force_rollback=True):\n # fetch_all()\n query = notes.select()\n result = await database.fetch_one(query=query)\n assert result is None","def test_export_data_on_nonexistent_user(self) -> None:\n user_data = user_models.LearnerGoalsModel.export_data(\n self.NONEXISTENT_USER_ID)\n self.assertEqual({}, user_data)","def test_get_json_data_no_test(self, mock_test):\n from mod_test.controllers import get_json_data\n\n mock_test.query.filter.return_value.first.return_value = None\n expected = b'{\"error\":\"Test not found\",\"status\":\"failure\"}\\n'\n\n result = get_json_data(1)\n\n self.assertEqual(result.data, expected)\n mock_test.query.filter.assert_called_once_with(mock_test.id == 1)","def test_invalid_type(self):\n self.call_command(filename='power_plant_import/tests/data/invalid_type.csv')\n\n # No PowerPlants or Projects were created during the test\n self.assertEqual(PowerPlant.objects.count(), 0)\n self.assertEqual(Project.objects.count(), 0)","def test_no_data(self):\n response = self.client.get(reverse('education:states'))\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response.context.get(\"states\").count(), 0)\n self.assertContains(response, \"No Data Available\")\n self.assertNotContains(response, \"Number of Public High Schools\")","def test_user_with_no_explorations_has_no_impact(self):\n user_a_id = self._sign_up_user(\n self.USER_A_EMAIL, self.USER_A_USERNAME)\n self._run_computation()\n user_stats_model = user_models.UserStatsModel.get(\n user_a_id, strict=False)\n self.assertIsNone(user_stats_model)","def test_get_nonexistant_data(self):\n response = self.client.get(\"/api/elections/1\",\n headers=[(\"Accept\", \"application/json\")])\n\n self.assertEqual(response.status_code, 404)\n self.assertEqual(response.mimetype, \"application/json\")\n\n data = json.loads(response.data.decode(\"ascii\"))\n self.assertEqual(data[\"message\"], \"Could not find election with id 1\")","def testPluginNoError(self):\n schema = self.dataset.makeMinimalSchema()\n task = lsst.meas.base.SingleFrameMeasurementTask(schema=schema, config=self.config)\n exposure, cat = self.dataset.realize(noise=100.0, schema=schema, randomSeed=0)\n task.run(cat, exposure)\n source = cat[0]\n self.assertFalse(source.get(self.algName + \"_flag\"))\n self.assertFalse(source.get(self.algName + \"_flag_containsNan\"))\n self.assertFalse(source.get(self.algName + \"_flag_edge\"))"],"string":"[\n \"def test_no_one_in_db(self):\\n q = self.generate_query('view_manager_report', ())\\n res = self.execute_query(q)\\n expected = []\\n assert len(res) == 0, f'There is suppose to be an empty summary {res}'\\n assert res == expected, f'The result is suppose to be empty {res}'\",\n \"def test_get_study_missing(self):\\n self.assertIsNone(self.storage.get_study('missing'))\",\n \"async def test_get_empty(subject: AnalysisStore, protocol_store: ProtocolStore) -> None:\\n protocol_store.insert(make_dummy_protocol_resource(\\\"protocol-id\\\"))\\n\\n full_result = await subject.get_by_protocol(\\\"protocol-id\\\")\\n summaries_result = subject.get_summaries_by_protocol(\\\"protocol-id\\\")\\n\\n assert full_result == []\\n assert summaries_result == []\\n\\n with pytest.raises(AnalysisNotFoundError, match=\\\"analysis-id\\\"):\\n await subject.get(\\\"analysis-id\\\")\",\n \"def test_query_1(self):\\n with app.test_request_context():\\n agency_none = db.session.query(\\n Agency).filter_by(name=\\\"not here\\\").first()\\n self.assertTrue(agency_none is None)\",\n \"def test_finds_no_traits_if_dataset_search_doesnt_match(self):\\n dataset = factories.SourceDatasetFactory.create(i_dbgap_description='a dataset about demographic measurements')\\n trait = factories.SourceTraitFactory.create(i_description='lorem ipsum', source_dataset=dataset)\\n response = self.client.get(self.get_url(), {'description': 'lorem', 'dataset_description': 'something'})\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)\\n self.assertEqual(len(context['results_table'].rows), 0)\",\n \"def test_exist(self):\\n with self.assertRaises(IncompetentQiitaDeveloperError):\\n MetadataTemplate.exists(self.study)\",\n \"def test_no_updated_datasets(self):\\n response = self.client.get(self.get_url(self.study.pk))\\n context = response.context\\n table = context['source_dataset_table']\\n for dataset in self.datasets_v3:\\n self.assertNotIn(dataset, table.data)\",\n \"def test_table_has_no_rows(self):\\n models.SourceDataset.objects.all().delete()\\n response = self.client.get(self.get_url(self.study.pk))\\n context = response.context\\n table = context['source_dataset_table']\\n self.assertEqual(len(table.rows), 0)\",\n \"def test_exists_false(self):\\n self.assertFalse(Sample.exists('Not_a_Sample', self.sample_template))\",\n \"def test_context_data_info_message_for_no_results(self):\\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\\n messages = list(response.wsgi_request._messages)\\n self.assertEqual(len(messages), 1)\\n self.assertEqual(str(messages[0]), '0 results found.')\",\n \"def test_context_data_info_message_for_no_results(self):\\n response = self.client.get(self.get_url(self.study.pk), {'description': 'lorem'})\\n messages = list(response.wsgi_request._messages)\\n self.assertEqual(len(messages), 1)\\n self.assertEqual(str(messages[0]), '0 results found.')\",\n \"def test_import_is_skipped(self):\\n self.database.reports.distinct.return_value = [\\\"id\\\"]\\n self.import_report(self.report_json)\\n self.database.reports.insert_one.assert_not_called()\",\n \"def test_not_found(self):\\n self.library.get.when.called_with('dummy!!!')\\\\\\n .should.throw(ViolationDoesNotExists)\",\n \"def test_db_missing_read(env_setup, env_table, db_insert_test_data, db_read_test_data, response_test_data):\\n test_string = DbManager(SqLiteHelper, {\\\"db_path\\\": env_setup, \\\"master_table\\\": env_table}) \\\\\\n .processor(db_read_test_data.get(\\\"invalid2\\\")) # testing\\n assert test_string == response_test_data.get(\\\"invalid_read2\\\")\",\n \"def test_exists_false(self):\\n self.assertFalse(SampleTemplate.exists(self.new_study.id))\",\n \"def test_get_algorithm_NotFound(self):\\n searched_id = 'xyz1'\\n right_list = []\\n create_test_algorithm_list(right_list, 101)\\n documents = []\\n create_test_documents_list(right_list, documents, 101)\\n index = search.Index(name=search_algorithm._INDEX_STRING)\\n index.put(documents)\\n # end of preparing data\\n result = index.get_range(ids_only=True)\\n self.assertLess(0, len(result.results), msg='The database is empty')\\n algorithm = search_algorithm.get_algorithm(index, searched_id)\\n self.assertEqual(1, algorithm, msg='Nonexistent Algorithm was found in 101 algorithms database')\",\n \"def test_report_of_article_does_not_exist(self):\\n from rest_framework.test import APIClient\\n client = APIClient()\\n response = client.post('/api/report/spoon/', self.report,\\n HTTP_AUTHORIZATION='Token ' + self.token_1,\\n format='json')\\n result = json.loads(response.content)\\n\\n self.assertEqual(result[\\\"error_message\\\"], \\\"The article you are reporting does not exist\\\")\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\",\n \"def test_get_non_existing_sale_record(self):\\n\\t\\tself.register_user()\\n\\t\\tresult = self.login_user()\\n\\t\\taccess_token = json.loads(result.data.decode())['token']\\n\\n\\t\\tresponse = self.client.get('/api/v1/sale/100',\\n\\t\\t\\theaders=dict(Authorization=\\\"Bearer \\\" + access_token))\\n\\t\\tself.assertEqual(response.status_code, 404)\\n\\n\\t\\tresult = json.loads(response.data.decode())\\n\\t\\tself.assertEqual(result[\\\"message\\\"], \\\"sale record unavailable\\\")\\n\\t\\tself.assertEqual(result[\\\"status\\\"], \\\"not found\\\")\",\n \"def test_data_source_soaps_id_exists_get(self):\\n pass\",\n \"def test_no_track_data_error():\\n try:\\n bad_arm = survey.get_spiral_slice(track = \\\"fakeSpiral\\\")\\n except KeyError:\\n assert True\\n else:\\n assert False\",\n \"def test_does_not_exist(self, mock_current_session):\\n mock_store = mock.MagicMock()\\n mock_store.get_metadata.side_effect = store.DoesNotExist\\n mock_current_session.return_value = mock_store\\n\\n with self.assertRaises(NotFound):\\n controllers.get_preview_metadata(self.source_id, self.checksum)\",\n \"def test_experiment_do_not_exist(self):\\n with pytest.raises(NoConfigurationError) as exception:\\n get_experiment(\\\"a\\\")\\n assert (\\n \\\"No experiment with given name 'a' and version '*' inside database, \\\"\\n \\\"no view can be created.\\\" == str(exception.value)\\n )\",\n \"def test_no_skill_aggregate(self):\\n actions.login(ADMIN_EMAIL)\\n\\n get_url = '%s?%s' % (self.URL, urllib.urlencode({\\n 'ids': [1]}, True))\\n response = self.get(get_url)\\n self.assertEqual(200, response.status_int)\\n payload = transforms.loads(response.body)['payload']\\n result = transforms.loads(payload)\\n\\n self.assertEqual(['Date'], result['column_headers'])\\n self.assertEqual([], result['data'])\",\n \"def test_ai_undefined(self, mock_get, mock_get_categories):\\n\\n # We mock ai_list\\n mock_get.return_value = {\\n 'ai_list': [\\n factory.build(\\n dict,\\n FACTORY_CLASS=AiFactory,\\n ai_status='ai_undefined'\\n )\\n ]\\n }\\n response = self.client.get(reverse('studio:summary'))\\n self.assertContains(response, 'Not Started')\",\n \"def test_get_algorithm_Empty(self):\\n searched_id = 'xyz1'\\n index = search.Index(name=search_algorithm._INDEX_STRING)\\n result = index.get_range(ids_only=True)\\n self.assertEqual(0, len(result.results), msg='The database is not empty')\\n algorithm = search_algorithm.get_algorithm(index, searched_id)\\n self.assertEqual(1, algorithm, msg='Non existent Algorithm was found in empty database')\",\n \"def test_get_document_inexistent(empty_index):\\n with pytest.raises(Exception):\\n empty_index().get_document(\\\"123\\\")\",\n \"def test_missing_data_sources(self):\",\n \"def test_no_removed_datasets(self):\\n removed_dataset_1 = factories.SourceDatasetFactory.create(source_study_version=self.study_version_1)\\n removed_dataset_2 = factories.SourceDatasetFactory.create(\\n source_study_version=self.study_version_2, i_accession=removed_dataset_1.i_accession)\\n response = self.client.get(self.get_url(self.study.pk))\\n context = response.context\\n table = context['source_dataset_table']\\n self.assertNotIn(removed_dataset_1, table.data)\\n self.assertNotIn(removed_dataset_2, table.data)\\n self.assertEqual(len(table.data), 0)\",\n \"def test_exists_false(self):\\n self.assertFalse(PrepSample.exists('Not_a_Sample', self.prep_template))\",\n \"def test_id_missing(self) -> None:\\n with pytest.raises(NotFound):\\n ObservationType.from_id(-1)\",\n \"def test_context_data_with_valid_search_and_no_results(self):\\n response = self.client.get(self.get_url(self.study.pk), {'description': 'test'})\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceDatasetTableFull)\",\n \"def test_get_analysis_with_id(analysis_store: MockStore):\\n # GIVEN a store with an analysis\\n existing_analysis: Analysis = analysis_store.get_query(table=Analysis).first()\\n\\n # WHEN accessing it by ID\\n analysis: Analysis = analysis_store.get_analysis_with_id(analysis_id=existing_analysis.id)\\n\\n # THEN it should return the same analysis\\n assert analysis == existing_analysis\",\n \"def test_stats_get(self):\\n stats_store = StatsStore()\\n\\n gen_stats = stats_store.general_stats_get(\\\"inexisting_stats\\\")\\n assert not gen_stats\",\n \"def test_no_match(add_doc, add_institution):\\n\\n doc = add_doc(log={\\n 'url': 'http://yale.edu/syllabus.pdf'\\n })\\n\\n harvard = add_institution(\\n name='Harvard University',\\n domain='harvard.edu',\\n )\\n\\n doc_to_inst(doc.id)\\n\\n # Shouldn't write a link.\\n assert Institution_Document.select().count() == 0\",\n \"def test_check_database_exists_invalid(self):\\n query_result = None\\n self.client.athena_client = MockAthenaClient(results=query_result)\\n\\n assert_false(self.client.check_database_exists())\",\n \"def test_missing_model():\\n\\n with pytest.raises(KeyError):\\n Instafilter(\\\"xxx\\\")\",\n \"def test_AlgorithmsIdHandler_GET_NotFound(self):\\n searchedId='xyz1'\\n right_list = []\\n create_test_algorithm_list(right_list, 101)\\n documents = []\\n create_test_documents_list(right_list, documents, 101)\\n index = search.Index(name=search_algorithm._INDEX_STRING)\\n index.put(documents)\\n # end of preparing data\\n result = index.get_range(ids_only=True)\\n self.assertLess(0, len(result.results), msg='The database is empty')\\n response = self.testapp.get('/algorithms/' + searchedId, expect_errors=True)\\n self.assertEqual(404, response.status_int, msg='Non existent Algorithm was found in empty database')\\n self.assertEqual('application/json', response.content_type)\\n self.assertIn('Algorithm Not Found', response.normal_body.decode(encoding='UTF-8'))\",\n \"def test_table_has_no_rows(self):\\n models.Study.objects.all().delete()\\n response = self.client.get(self.get_url())\\n context = response.context\\n table = context['study_table']\\n self.assertEqual(len(table.rows), 0)\",\n \"def test_neg_exists_with_non_existent_data(self, key, ex, ex_code):\\n try:\\n key, meta = self.as_connection.exists(key)\\n assert meta is None\\n \\\"\\\"\\\"\\n We are making the api backward compatible. In case of RecordNotFound an\\n exception will not be raised. Instead Ok response is returned withe the\\n meta as None. This might change with further releases.\\n \\\"\\\"\\\"\\n except ex as exception:\\n assert exception.code == ex_code\",\n \"def test_table_has_no_rows(self):\\n models.SourceDataset.objects.all().delete()\\n response = self.client.get(self.get_url())\\n context = response.context\\n table = context['source_dataset_table']\\n self.assertEqual(len(table.rows), 0)\",\n \"def test_get_doesnotexist_exception(self):\\r\\n with self.assertRaises(self.table.DoesNotExist):\\r\\n self.table.objects.get(test_id=100)\",\n \"def test_handle_non_existed_assignment_properly(user_client):\\n response = user_client.get(\\\"/api/v1/assignments/999/\\\")\\n assert response.data == {\\\"detail\\\": \\\"Not found.\\\"}\",\n \"def test_query_with_no_matches_returns_nothing(test_store):\\n items = list(test_store.get_by(name=\\\"Sugar\\\"))\\n\\n assert len(items) == 0\",\n \"def test_no_data():\\n test = [{}, ['keys']]\\n t_result = fetch_data_by_keys(*test)\\n assert not is_successful(t_result)\\n assert 'keys' in str(t_result.failure())\",\n \"def test_get_report_wrong_object_id(self):\\n vt_analyses = VirusTotalAPIAnalyses('test_api_key')\\n vt_analyses.get_report('test_object_id')\\n http_err = vt_analyses.get_last_http_error()\\n self.assertEqual(http_err, vt_analyses.HTTP_NOT_FOUND_ERROR)\",\n \"def test_no_such_key():\\n test = [{'key': 'val1'}, ['missing']]\\n t_result = fetch_data_by_keys(*test)\\n assert not is_successful(t_result)\\n assert 'missing' in str(t_result.failure())\",\n \"def test_context_data_with_valid_search_and_no_results(self):\\n response = self.client.get(self.get_url(self.study.pk), {'description': 'test'})\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)\",\n \"def test_get_doesnotexist_exception(self):\\r\\n with self.assertRaises(TestModel.DoesNotExist):\\r\\n TestModel.objects.get(test_id=100)\",\n \"async def test_26() -> None:\\n LOG.debug(\\\"Test query for non-existing query targeting three datasets, using MISS. (expect data shown)\\\")\\n payload = {\\n \\\"referenceName\\\": \\\"MT\\\",\\n \\\"start\\\": 10,\\n \\\"referenceBases\\\": \\\"T\\\",\\n \\\"alternateBases\\\": \\\"C\\\",\\n \\\"assemblyId\\\": \\\"GRCh38\\\",\\n \\\"datasetIds\\\": [\\\"urn:hg:1000genome\\\", \\\"urn:hg:1000genome:controlled\\\", \\\"urn:hg:1000genome:registered\\\"],\\n \\\"includeDatasetResponses\\\": \\\"MISS\\\",\\n }\\n headers = {\\\"Authorization\\\": f\\\"Bearer {TOKEN}\\\"}\\n async with aiohttp.ClientSession(headers=headers) as session:\\n async with session.post(\\\"http://localhost:5050/query\\\", data=json.dumps(payload)) as resp:\\n data = await resp.json()\\n assert data[\\\"exists\\\"] is False, sys.exit(\\\"Query POST Endpoint Error!\\\")\\n assert len(data[\\\"datasetAlleleResponses\\\"]) == 3, sys.exit(\\\"Should be able to retrieve missing datasets.\\\")\",\n \"def test_empty_db(client, test_db):\\n rv = client.get(\\\"/\\\")\\n assert b\\\"No entries yet. Add some!\\\" in rv.data\",\n \"async def test_nr_of_missing_metrics_without_correct_report(self):\\n self.reports[\\\"reports\\\"] = []\\n response = await self.collect(get_request_json_side_effect=[self.data_model, self.reports])\\n self.assert_measurement(response, parse_error=\\\"No reports found with title or id\\\")\",\n \"def test_no_results(self, setup_data):\\n term = 'there-should-be-no-match'\\n\\n url = reverse('api-v3:search:basic')\\n response = self.api_client.get(\\n url,\\n data={\\n 'term': term,\\n 'entity': 'company',\\n },\\n )\\n\\n assert response.data['count'] == 0\",\n \"def test_c_get_existing_records(self):\\n\\n success = True\\n records = get_existing_records(location, database)\\n\\n if records['variable'].values[0] != value:\\n success = False\\n\\n for function in records['function'].values:\\n if function not in outcome_methods:\\n success = False\\n\\n if records[records['function'] == 'nanmean']['value'].values != 2.143:\\n success = False\\n\\n if records[records['function'] == 'nanpercentile_25']['value'].values != 1.0:\\n success = False\\n\\n if records[records['function'] == 'nanpercentile_75']['value'].values != 2.5:\\n success = False\\n\\n if not np.isnan(records[records['function'] == 'std']['value'].values[0]):\\n success = False\\n\\n assert(success)\",\n \"def test_narrative_data_missing(self, config_handler):\\n spec = Spec.from_dict(\\n {\\\"name\\\": \\\"homogeneity_coefficient\\\", \\\"unit\\\": \\\"percentage\\\", \\\"dtype\\\": \\\"float\\\"}\\n )\\n with raises(SmifDataNotFoundError):\\n config_handler.read_narrative_variant_data(\\\"does not exist\\\", spec)\",\n \"def test_table_has_no_rows(self):\\n models.SourceTrait.objects.all().delete()\\n response = self.client.get(self.get_url(self.study.pk))\\n context = response.context\\n table = context['source_trait_table']\\n self.assertEqual(len(table.rows), 0)\",\n \"def test_analysis_match(self):\\n self.api.observable_add('test.com')\\n results = self.api.analysis_match(['test.com', 'unknown.com'])\\n known = [o['value'] for o in results['known']]\\n self.assertIn('test.com', known)\\n self.assertIn('unknown.com', results['unknown'])\",\n \"def test_status_missing(self):\\n measurement = Measurement(self.metric())\\n self.assertEqual(None, measurement.status())\",\n \"def test_returns_all_datasets_with_no_query(self):\\n url = self.get_url(self.study.pk)\\n response = self.client.get(url)\\n pks = get_autocomplete_view_ids(response)\\n self.assertEqual(sorted([dataset.pk for dataset in self.source_datasets]), sorted(pks))\",\n \"def test_returns_all_datasets_with_no_query(self):\\n url = self.get_url(self.study.pk)\\n response = self.client.get(url)\\n pks = get_autocomplete_view_ids(response)\\n self.assertEqual(sorted([dataset.pk for dataset in self.source_datasets]), sorted(pks))\",\n \"def test_returns_all_datasets_with_no_query(self):\\n url = self.get_url(self.study.pk)\\n response = self.client.get(url)\\n pks = get_autocomplete_view_ids(response)\\n self.assertEqual(sorted([dataset.pk for dataset in self.source_datasets]), sorted(pks))\",\n \"def test_view_with_invalid_pk(self):\\n response = self.client.get(self.get_url(self.dataset.pk + 1))\\n self.assertEqual(response.status_code, 404)\",\n \"def test_returns_all_studies_with_no_query(self):\\n url = self.get_url()\\n response = self.client.get(url)\\n pks = get_autocomplete_view_ids(response)\\n self.assertEqual(sorted([study.pk for study in self.studies]), sorted(pks))\",\n \"def test_returns_all_studies_with_no_query(self):\\n url = self.get_url()\\n response = self.client.get(url)\\n pks = get_autocomplete_view_ids(response)\\n self.assertEqual(sorted([study.pk for study in self.studies]), sorted(pks))\",\n \"def test_does_not_exist(self, mock_current_session):\\n mock_store = mock.MagicMock()\\n mock_store.get_preview_checksum.side_effect = store.DoesNotExist\\n mock_current_session.return_value = mock_store\\n\\n with self.assertRaises(NotFound):\\n controllers.check_preview_exists(self.source_id, self.checksum)\",\n \"def test_obtain_issues_no_query(self, mock_url_read):\\n mock_url_read.side_effect = \\\\\\n [LAST_SCAN, '{\\\"reportId\\\": 22}', '{\\\"status\\\": {\\\"value\\\": \\\"Created\\\"}}', '<CxXMLResults />']\\n self.__report.obtain_issues(['id'], 'high')\\n issues = self.__report.issues()\\n self.assertIsInstance(issues, List)\\n self.assertEqual(len(issues), 0)\",\n \"def test_no_results(self):\\n self.factory.create()\\n response = self._get(get_kwargs={'search': 'hello'})\\n self.assertEquals(response.status_code, 200)\\n self.assertTemplateUsed(response, self.template_name)\\n self.assertEquals(response.context['object_list'].count(), 0)\",\n \"def test_missing(server):\\n\\n assert \\\"non_existing_database\\\" not in server\\n with pytest.raises(excepts.DBNotExists):\\n server[\\\"non_existing_database\\\"]\",\n \"def test_data_source_soaps_find_one_get(self):\\n pass\",\n \"def test_no_source_measurements(self):\\n measurement = self.measurement(self.metric())\\n self.assertEqual(None, measurement[\\\"count\\\"][\\\"value\\\"])\",\n \"def test_check_table_exists_invalid(self, mock_logging):\\n query_result = None\\n self.client.athena_client = MockAthenaClient(results=query_result)\\n\\n result = self.client.check_table_exists('unit-test')\\n assert_false(result)\\n assert_true(mock_logging.info.called)\",\n \"def test_9_incorrect_database(self):\\n fitness = Fitness(None, self.user_id_1)\\n s = fitness.insert_in_database(self.fitness_dict, date_time=self.dt1)\\n self.assertFalse(s)\",\n \"def test_fetch_no_results():\\n url = (\\n \\\"https://gliders.ioos.us/erddap/search/index.csv?page=1&itemsPerPage=100000&searchFor\\\"\\n '=\\\"incredibly_long_string_that_should_never_match_a_real_dataset\\\" '\\n )\\n key = \\\"ioos\\\"\\n data = fetch_results(url, key)\\n assert data is None\",\n \"def test_graph_load_query_exec(self):\\n provider = QueryProvider(data_environment=\\\"SecurityGraph\\\", driver=self.provider)\\n df = provider.all_queries.get_alert(\\\"help\\\")\\n self.assertIsNone(df)\\n\\n with self.assertRaises(ValueError) as cm:\\n df = provider.all_queries.get_alert()\\n self.assertIn(\\\"alert_id\\\", str(cm.exception))\\n\\n df = provider.all_queries.get_alert(alert_id=\\\"foo\\\")\\n self.assertEqual(len(df), 1)\\n self.assertIn(\\\"/foo\\\", df[\\\"query\\\"].iloc[0])\",\n \"def test_exists(self):\\n with self.assertRaises(IncompetentQiitaDeveloperError):\\n BaseSample.exists('SKM7.640188', SampleTemplate(1))\",\n \"def test_ensure_data_no_totaltracks(self):\\n album = Album(artist='Artist', album='Album', totalseconds=120)\\n with self.assertRaises(Exception):\\n album.ensure_data()\",\n \"def test_410_000_non_existant_db(self):\\n with TDC() as temp_dir:\\n file = Path(temp_dir) / 'database.db'\\n self.assertFalse(file.exists(),'Database file exists pre test')\\n eng = Engine(file)\\n con = eng.connect()\\n self.assertTrue(file.exists(), 'Database file does not exists post test')\",\n \"def test_search_table_fail_if_no_query(self) -> None:\\n with local_app.test_client() as test:\\n response = test.get('/api/search/v0/table', query_string=dict(page_index='0'))\\n self.assertEqual(response.status_code, HTTPStatus.INTERNAL_SERVER_ERROR)\",\n \"def test_does_not_exist(self, mock_current_session):\\n mock_store = mock.MagicMock()\\n mock_store.get_preview.side_effect = store.DoesNotExist\\n mock_current_session.return_value = mock_store\\n\\n with self.assertRaises(NotFound):\\n controllers.get_preview_content(self.source_id, self.checksum)\",\n \"def test_get_data_fail(self):\\n self.assertIsNone(get_data('this_must_fail', 5, 0))\",\n \"def test_AlgorithmsIdHandler_GET_Empty(self):\\n searchedId='xyz1'\\n response = self.testapp.get('/algorithms/' + searchedId, expect_errors=True)\\n self.assertEqual(404, response.status_int, msg='Non existent Algorithm was found in empty database')\\n self.assertEqual('application/json', response.content_type)\\n self.assertIn('Algorithm Not Found', response.normal_body.decode(encoding='UTF-8'))\",\n \"def test_assessment_full_no_warnings(self):\\n response = self.import_file(\\\"assessment_full_no_warnings.csv\\\")\\n self._check_csv_response(response, {})\\n\\n # Test first Assessment line in the CSV file\\n asmt_1 = models.Assessment.query.filter_by(slug=\\\"Assessment 1\\\").first()\\n users = {\\n \\\"user 1\\\": {\\\"Assessor\\\"},\\n \\\"user 2\\\": {\\\"Assessor\\\", \\\"Creator\\\"}\\n }\\n self._test_assessment_users(asmt_1, users)\\n self.assertEqual(asmt_1.status, models.Assessment.START_STATE)\\n\\n # Test second Assessment line in the CSV file\\n asmt_2 = models.Assessment.query.filter_by(slug=\\\"Assessment 2\\\").first()\\n users = {\\n \\\"user 1\\\": {\\\"Assessor\\\"},\\n \\\"user 2\\\": {\\\"Creator\\\"},\\n \\\"user 3\\\": {},\\n \\\"user 4\\\": {},\\n \\\"user 5\\\": {},\\n }\\n self._test_assessment_users(asmt_2, users)\\n self.assertEqual(asmt_2.status, models.Assessment.PROGRESS_STATE)\\n\\n audit = [obj for obj in asmt_1.related_objects() if obj.type == \\\"Audit\\\"][0]\\n self.assertEqual(audit.context, asmt_1.context)\\n\\n evidence = models.Document.query.filter_by(title=\\\"some title 2\\\").first()\\n self.assertEqual(audit.context, evidence.context)\",\n \"def test_get_star__no_existing(self):\\n email = 'user1@example.com'\\n feature_id = self.feature_1.key.integer_id()\\n actual = notifier.FeatureStar.get_star(email, feature_id)\\n self.assertEqual(None, actual)\",\n \"def test_030_query_nothing(self):\\n\\n testflow.step(\\\"Querying for nothing\\\")\\n assert not self.query_cli.run()[0], \\\"Invalid arguments of query passed\\\"\",\n \"def test_get_session_missing(self):\\n study_id = self.storage.create_study(sample_study_spec())\\n self.assertIsNone(self.storage.get_session(study_id, 'missing'))\\n\\n session = sample_session(study_id)\\n self.storage.create_session(session)\\n self.assertIsNone(self.storage.get_session('missing', session.id))\",\n \"def test_other_study_not_in_queryset(self):\\n # Delete all but five source traits, so that there are 5 from each study.\\n study2 = factories.StudyFactory.create()\\n datasets2 = factories.SourceDatasetFactory.create_batch(\\n 5, source_study_version__study=study2)\\n # Get results from the autocomplete view and make sure only datasets from the correct study are found.\\n url = self.get_url(self.study.pk)\\n response = self.client.get(url)\\n returned_pks = get_autocomplete_view_ids(response)\\n # Make sure that the other study's datasets do not show up.\\n self.assertEqual(len(returned_pks), len(self.source_datasets))\\n for dataset in datasets2:\\n self.assertNotIn(dataset.i_id, returned_pks)\\n for dataset in self.source_datasets:\\n self.assertIn(dataset.i_id, returned_pks)\",\n \"def test_other_study_not_in_queryset(self):\\n # Delete all but five source traits, so that there are 5 from each study.\\n study2 = factories.StudyFactory.create()\\n datasets2 = factories.SourceDatasetFactory.create_batch(\\n 5, source_study_version__study=study2)\\n # Get results from the autocomplete view and make sure only datasets from the correct study are found.\\n url = self.get_url(self.study.pk)\\n response = self.client.get(url)\\n returned_pks = get_autocomplete_view_ids(response)\\n # Make sure that the other study's datasets do not show up.\\n self.assertEqual(len(returned_pks), len(self.source_datasets))\\n for dataset in datasets2:\\n self.assertNotIn(dataset.i_id, returned_pks)\\n for dataset in self.source_datasets:\\n self.assertIn(dataset.i_id, returned_pks)\",\n \"def test_running_lookup_uncertainties(self):\\n if os.name != \\\"nt\\\":\\n return\\n\\n model = LookupTestModel(r\\\"../models/\\\", \\\"lookupTestModel\\\")\\n\\n # model.step = 4 #reduce data to be stored\\n perform_experiments(model, 10)\",\n \"def test_find_nonexistent_data(self):\\n with app.app_context():\\n\\n resp = self.client.get(\\\"/tracking?repo=aa&branch=aa\\\")\\n\\n resp_dict = json.loads(resp.data)\\n\\n self.assertIn(\\\"code\\\", resp_dict, msg=\\\"Error in data format return\\\")\\n self.assertEqual(ResponseCode.SUCCESS, resp_dict.get(\\\"code\\\"), msg=\\\"Error in status code return\\\")\\n\\n self.assertIn(\\\"msg\\\", resp_dict, msg=\\\"Error in data format return\\\")\\n self.assertEqual(\\n ResponseCode.CODE_MSG_MAP.get(ResponseCode.SUCCESS),\\n resp_dict.get(\\\"msg\\\"),\\n msg=\\\"Error in status code return\\\"\\n )\\n\\n self.assertIn(\\\"data\\\", resp_dict, msg=\\\"Error in data format return\\\")\\n self.assertIsNotNone(resp_dict.get(\\\"data\\\"), msg=\\\"Error in data information return\\\")\\n self.assertEqual(resp_dict.get(\\\"data\\\"), [], msg=\\\"Error in data information return\\\")\",\n \"def test_get_empty_rare(self):\\r\\n self.assertRaises(TableException, get_rare_data, self.otu_table,\\r\\n 50, include_small_samples=False)\",\n \"def test_error(self):\\n metric = self.metric()\\n measurement = self.measurement(metric, sources=[self.source(metric, parse_error=\\\"error\\\")])\\n self.assertEqual(None, measurement[\\\"count\\\"][\\\"value\\\"])\",\n \"def test_other_study_not_in_queryset(self):\\n # Delete all but five source datasets, so that there are 5 from each study.\\n study2 = factories.StudyFactory.create()\\n datasets2 = factories.SourceDatasetFactory.create_batch(\\n 5, source_study_version__study=study2)\\n # Get results from the autocomplete view and make sure only datasets from the correct study are found.\\n url = self.get_url(self.study.pk)\\n response = self.client.get(url)\\n returned_pks = get_autocomplete_view_ids(response)\\n # Make sure that the other study's datasets do not show up.\\n self.assertEqual(len(returned_pks), len(self.source_datasets))\\n for dataset in datasets2:\\n self.assertNotIn(dataset.i_id, returned_pks)\\n for dataset in self.source_datasets:\\n self.assertIn(dataset.i_id, returned_pks)\",\n \"def test_get_non_existent_skill_progress(self):\\n self._build_sample_graph()\\n student = models.Student(user_id='1')\\n tracker = SkillCompletionTracker()\\n result = tracker.get_skills_progress(student, [self.sc.id])\\n self.assertEqual(SkillCompletionTracker.NOT_ATTEMPTED,\\n result[self.sc.id][0])\",\n \"async def test_fetch_one_returning_no_results(database_url):\\n async with Database(database_url) as database:\\n async with database.transaction(force_rollback=True):\\n # fetch_all()\\n query = notes.select()\\n result = await database.fetch_one(query=query)\\n assert result is None\",\n \"def test_export_data_on_nonexistent_user(self) -> None:\\n user_data = user_models.LearnerGoalsModel.export_data(\\n self.NONEXISTENT_USER_ID)\\n self.assertEqual({}, user_data)\",\n \"def test_get_json_data_no_test(self, mock_test):\\n from mod_test.controllers import get_json_data\\n\\n mock_test.query.filter.return_value.first.return_value = None\\n expected = b'{\\\"error\\\":\\\"Test not found\\\",\\\"status\\\":\\\"failure\\\"}\\\\n'\\n\\n result = get_json_data(1)\\n\\n self.assertEqual(result.data, expected)\\n mock_test.query.filter.assert_called_once_with(mock_test.id == 1)\",\n \"def test_invalid_type(self):\\n self.call_command(filename='power_plant_import/tests/data/invalid_type.csv')\\n\\n # No PowerPlants or Projects were created during the test\\n self.assertEqual(PowerPlant.objects.count(), 0)\\n self.assertEqual(Project.objects.count(), 0)\",\n \"def test_no_data(self):\\n response = self.client.get(reverse('education:states'))\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response.context.get(\\\"states\\\").count(), 0)\\n self.assertContains(response, \\\"No Data Available\\\")\\n self.assertNotContains(response, \\\"Number of Public High Schools\\\")\",\n \"def test_user_with_no_explorations_has_no_impact(self):\\n user_a_id = self._sign_up_user(\\n self.USER_A_EMAIL, self.USER_A_USERNAME)\\n self._run_computation()\\n user_stats_model = user_models.UserStatsModel.get(\\n user_a_id, strict=False)\\n self.assertIsNone(user_stats_model)\",\n \"def test_get_nonexistant_data(self):\\n response = self.client.get(\\\"/api/elections/1\\\",\\n headers=[(\\\"Accept\\\", \\\"application/json\\\")])\\n\\n self.assertEqual(response.status_code, 404)\\n self.assertEqual(response.mimetype, \\\"application/json\\\")\\n\\n data = json.loads(response.data.decode(\\\"ascii\\\"))\\n self.assertEqual(data[\\\"message\\\"], \\\"Could not find election with id 1\\\")\",\n \"def testPluginNoError(self):\\n schema = self.dataset.makeMinimalSchema()\\n task = lsst.meas.base.SingleFrameMeasurementTask(schema=schema, config=self.config)\\n exposure, cat = self.dataset.realize(noise=100.0, schema=schema, randomSeed=0)\\n task.run(cat, exposure)\\n source = cat[0]\\n self.assertFalse(source.get(self.algName + \\\"_flag\\\"))\\n self.assertFalse(source.get(self.algName + \\\"_flag_containsNan\\\"))\\n self.assertFalse(source.get(self.algName + \\\"_flag_edge\\\"))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6867313","0.6787145","0.64357316","0.6329981","0.62323785","0.6220911","0.6134222","0.6128569","0.6122037","0.60938495","0.60938495","0.6075478","0.60506773","0.6032781","0.6021422","0.6012929","0.60125285","0.60118175","0.60108805","0.6007062","0.59906363","0.59866434","0.5978294","0.5959229","0.59586984","0.5950741","0.59231466","0.5922015","0.5919598","0.5907387","0.5888685","0.58835125","0.5844173","0.58285344","0.58107024","0.58101207","0.5789504","0.57852113","0.5775079","0.5769849","0.576669","0.576347","0.57604367","0.57563734","0.5738955","0.5722213","0.57070047","0.56999844","0.5697313","0.5692532","0.5676103","0.5666059","0.5659841","0.56442755","0.5644192","0.5643372","0.5635116","0.5626114","0.5626114","0.5626114","0.5625228","0.5623874","0.5623874","0.5622299","0.5621626","0.5613626","0.56035286","0.5602922","0.56014967","0.559638","0.5589295","0.5584103","0.5581754","0.55772024","0.55680627","0.55626065","0.556116","0.55603224","0.55600923","0.55580664","0.5555619","0.554861","0.55401826","0.5540056","0.5536912","0.5536912","0.5534271","0.55274636","0.55238134","0.55227965","0.5522206","0.5516149","0.5514974","0.5512383","0.550823","0.5502993","0.5501366","0.5494892","0.54947656","0.5488299"],"string":"[\n \"0.6867313\",\n \"0.6787145\",\n \"0.64357316\",\n \"0.6329981\",\n \"0.62323785\",\n \"0.6220911\",\n \"0.6134222\",\n \"0.6128569\",\n \"0.6122037\",\n \"0.60938495\",\n \"0.60938495\",\n \"0.6075478\",\n \"0.60506773\",\n \"0.6032781\",\n \"0.6021422\",\n \"0.6012929\",\n \"0.60125285\",\n \"0.60118175\",\n \"0.60108805\",\n \"0.6007062\",\n \"0.59906363\",\n \"0.59866434\",\n \"0.5978294\",\n \"0.5959229\",\n \"0.59586984\",\n \"0.5950741\",\n \"0.59231466\",\n \"0.5922015\",\n \"0.5919598\",\n \"0.5907387\",\n \"0.5888685\",\n \"0.58835125\",\n \"0.5844173\",\n \"0.58285344\",\n \"0.58107024\",\n \"0.58101207\",\n \"0.5789504\",\n \"0.57852113\",\n \"0.5775079\",\n \"0.5769849\",\n \"0.576669\",\n \"0.576347\",\n \"0.57604367\",\n \"0.57563734\",\n \"0.5738955\",\n \"0.5722213\",\n \"0.57070047\",\n \"0.56999844\",\n \"0.5697313\",\n \"0.5692532\",\n \"0.5676103\",\n \"0.5666059\",\n \"0.5659841\",\n \"0.56442755\",\n \"0.5644192\",\n \"0.5643372\",\n \"0.5635116\",\n \"0.5626114\",\n \"0.5626114\",\n \"0.5626114\",\n \"0.5625228\",\n \"0.5623874\",\n \"0.5623874\",\n \"0.5622299\",\n \"0.5621626\",\n \"0.5613626\",\n \"0.56035286\",\n \"0.5602922\",\n \"0.56014967\",\n \"0.559638\",\n \"0.5589295\",\n \"0.5584103\",\n \"0.5581754\",\n \"0.55772024\",\n \"0.55680627\",\n \"0.55626065\",\n \"0.556116\",\n \"0.55603224\",\n \"0.55600923\",\n \"0.55580664\",\n \"0.5555619\",\n \"0.554861\",\n \"0.55401826\",\n \"0.5540056\",\n \"0.5536912\",\n \"0.5536912\",\n \"0.5534271\",\n \"0.55274636\",\n \"0.55238134\",\n \"0.55227965\",\n \"0.5522206\",\n \"0.5516149\",\n \"0.5514974\",\n \"0.5512383\",\n \"0.550823\",\n \"0.5502993\",\n \"0.5501366\",\n \"0.5494892\",\n \"0.54947656\",\n \"0.5488299\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7349075"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83694,"cells":{"query":{"kind":"string","value":"Test getting the number of failed jobs per category since a supplied date from the database."},"document":{"kind":"string","value":"def test_get_nr_jobs_with_status_per_category(job_store: MockStore, timestamp_yesterday: datetime):\n # GIVEN a database with jobs\n\n # WHEN querying for failed users\n failed_jobs: List[Dict[str, Union[str, int]]] = job_store.get_nr_jobs_with_status_per_category(\n since_when=timestamp_yesterday, status=TrailblazerStatus.FAILED\n )\n\n # THEN failed jobs should be returned\n assert failed_jobs\n\n # THEN one job should be returned\n assert len(failed_jobs) == 1\n\n # THEN name and count should be defined\n assert failed_jobs[0].get(\"name\") == \"1\"\n assert failed_jobs[0].get(\"count\") == 1"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_error_category(self):\n\n error = error_test_utils.create_error(category='DATA')\n job = job_test_utils.create_job(error=error)\n\n url = '/%s/jobs/?error_category=%s' % (self.api, error.category)\n response = self.client.generic('GET', url)\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n\n result = json.loads(response.content)\n self.assertEqual(len(result['results']), 1)\n self.assertEqual(result['results'][0]['id'], job.id)\n self.assertEqual(result['results'][0]['error']['category'], error.category)","async def test_job_lookback_days(self):\n self.set_source_parameter(\"lookback_days\", \"3\")\n\n now_dt = now()\n now_timestamp = int(datetime.timestamp(now_dt) * 1000)\n last_week_timestamp = int(datetime.timestamp(now_dt - timedelta(weeks=1)) * 1000)\n self.builds.extend(\n [\n {\"result\": \"SUCCESS\", \"timestamp\": now_timestamp},\n {\"result\": \"SUCCESS\", \"timestamp\": last_week_timestamp},\n ],\n )\n\n jenkins_json = {\n \"jobs\": [{\"name\": \"job\", \"url\": self.job_url, \"buildable\": True, \"color\": \"blue\", \"builds\": self.builds}],\n }\n response = await self.collect(get_request_json_return_value=jenkins_json)\n\n expected_entities = [{\"build_count\": 1, \"key\": \"job\", \"name\": \"job\", \"url\": self.job_url}]\n self.assert_measurement(response, value=\"1\", entities=expected_entities)","def test_failed_job(self):\n failed_job = json.loads(BASE_JSON % (FAILURE, 1433166610, 1, 1433166609))[0]\n self.assertEquals(self.query_api.get_job_status(failed_job), FAILURE)","def _failed_tests(self, metric_source_id: str) -> int:\n return self.__test_count(metric_source_id, 'failed')","def no_new_cases_count(day: int, month: int, year: int = 2020) -> int:\r\n \r\n # Your code goes here (remove pass)\r","def test_query_train_jobs_with_wrong_offse(self, client):\n params = dict(offse=0, limit=10)\n url = get_url(BASE_URL, params)\n response = client.get(url)\n result = response.get_json()\n assert result.get('total') == SUMMARY_DIR_NUM\n assert len(result.get('train_jobs')) == min(10, SUMMARY_DIR_NUM)","def test_results_errors(self, affiliate_items):\n updater = mock.Mock(side_effect=ValueError())\n batch_job = BatchJob(affiliate_items, updater)\n\n error_count = 0\n for result in batch_job.run():\n error_count += int(result.is_error)\n\n assert error_count == 4","def test_date_range(self):\n\n url = '/%s/job-types/status/?started=%s&ended=%s' % ( self.api,\n '2015-01-01T00:00:00Z',\n '2015-01-02T00:00:00Z')\n response = self.client.generic('GET', url)\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n\n result = json.loads(response.content)\n self.assertEqual(len(result['results']), 4)","def test_failed_job(self):\n\n failed_job = json.loads(TREEHERDER_JOB % (\"testfailed\", \"completed\"))\n self.assertEquals(self.query_api.get_job_status(failed_job), FAILURE)","def test_active_and_date_range(self):\n\n url = '/%s/job-types/status/?is_active=true&started=%s&ended=%s' % ( self.api,\n '2016-01-01T00:00:00Z',\n '2016-01-02T00:00:00Z')\n response = self.client.generic('GET', url)\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n\n result = json.loads(response.content)\n self.assertEqual(len(result['results']), 3)\n self.assertEqual(result['results'][0]['job_type']['name'], self.job1.job_type.name)\n self.assertEqual(len(result['results'][0]['job_counts']), 0)","def fetch_testing(df, testing_start, curr_date_set, duration=1):\n dt_testing_start = dt.datetime.strptime(testing_start, '%Y-%m-%d')\n for _ in range(200):\n if testing_start in curr_date_set:\n dt_testing_end = dt_testing_start + dt.timedelta(days=duration)\n break\n else:\n dt_testing_start = next_weekday(dt_testing_start)\n try:\n return df.loc[(df.date < dt_testing_end) & (df.date >= dt_testing_start)]\n\n except:\n print('Error fectch_testing')\n return False","def test_results(self, affiliate_items):\n processed_count = 0\n error_count = 0\n\n updater = mock.Mock()\n batch_job = BatchJob(affiliate_items, updater)\n\n for result in batch_job.run():\n processed_count += 1\n error_count += int(result.is_error)\n\n assert updater.call_count == 4\n assert processed_count == 4\n assert error_count == 0","def test_questions_by_category_failure(self):\n\n response = self.client().get('/categories/10/questions')\n body = json.loads(response.data)\n\n self.assertEqual(response.status_code, 404)\n self.assertEqual(body['success'], False)\n self.assertNotEqual(len(body['message']), 'resource not found')","def test_run_date(self):\n Historical_ROAs_Parsed_Table(clear=True)\n\n date = '2019-08-01'\n \n with Historical_ROAs_Table(clear=True) as t:\n Historical_ROAs_Parser().run(datetime.strptime(date, '%Y-%m-%d'))\n sql = f\"SELECT COUNT(*) FROM {t.name} WHERE date_added = '{date}'\"\n \n # unless ROAs are retroactively added, this should be constant\n assert t.get_count(sql) == 95743","def getByDay(self, date=None, num=False):\n if date is None:\n date = self.date\n\n tdate = datetime.datetime.strptime(\n date, \"%Y%m%d\") - datetime.timedelta(180)\n ldate = tdate.strftime(\"%Y%m%d\")\n ddict = {\"$or\": [{\"task_day\": {\"$gt\": ldate}, \"status\": \"waiting\"}, {\n \"task_day\": date, \"status\": \"failure\", \"retry\": {\"$lte\": 3}}]}\n if num:\n return self.mgdb.task_history.find(ddict).count()\n else:\n l = []\n for doc in self.mgdb.task_history.find(ddict).sort('level', pymongo.DESCENDING):\n l.append(doc)\n return l","def cluster_count_failure_report(self, node_id: str) -> ResponseT:\n return self.execute_command(\"CLUSTER COUNT-FAILURE-REPORTS\", node_id)","def test_07_dataset_counts_unpublished(self):\n print (self.test_07_dataset_counts_unpublished.__doc__)\n\n stats_maker = StatsMakerDatasets()\n\n r = stats_maker.get_dataset_counts_by_create_date_unpublished()\n\n # check number of months\n self.assertEqual(len(r.result_data['records']), 16)\n\n # check 1st month\n first_month = {'count': 15,\n 'month_name': 'April',\n 'month_name_short': 'Apr',\n 'month_num': 4,\n 'running_total': 15,\n 'year_num': 2015,\n 'yyyy_mm': '2015-04'}\n self.assertEqual(dict(r.result_data['records'][0]), first_month)\n\n # check last month\n last_month = {'count': 94,\n 'month_name': 'July',\n 'month_name_short': 'Jul',\n 'month_num': 7,\n 'running_total': 343,\n 'year_num': 2016,\n 'yyyy_mm': '2016-07'}\n self.assertEqual(dict(r.result_data['records'][-1]), last_month)","def test_results_success(self, affiliate_items):\n success_count = 0\n\n updater = mock.Mock()\n batch_job = BatchJob(affiliate_items, updater)\n\n for result in batch_job.run():\n success_count += int(not result.is_error)\n\n assert success_count == 4","def test_created_date_invalid(self):\n thread1 = ThreadFactory()\n PostFactory(thread=thread1)\n\n self.refresh()\n\n qs = {'a': 1, 'w': 4, 'format': 'json',\n 'created': constants.INTERVAL_AFTER,\n 'created_date': 'invalid'}\n response = self.client.get(reverse('search.advanced'), qs)\n eq_(1, json.loads(response.content)['total'])","def find_error_days():\n query = \"\"\"\n SELECT all_requests.day,\n (ROUND((error_requests.bad * 1000)/all_requests.good)/10)\n AS percent\n FROM all_requests\n JOIN error_requests\n ON all_requests.day = error_requests.day\n WHERE ROUND((error_requests.bad * 1000)/all_requests.good) > 10\n \"\"\"\n results = psql_connection(query)\n\n print(\"Days with more than 1% errors\")\n for result in results:\n print '{date} - {errors} % errors'.format(\n date=result[0].strftime('%B %d, %Y'), errors=result[1])","def getnoofjobs(self):\n select_noofjobs = (\n \"select count(*) from public.jobs where latestjobversion=True \"\n \"and insertdate between Date(%s) and Date(%s) \"\n \"and (username not in (%s))\"\n )\n\n\n\n self.pgcursor.execute(select_noofjobs, (self.startdate, self.enddate, self.adminusers))\n\n noofjobs = 0\n count = self.pgcursor.fetchone()\n if count is not None:\n noofjobs = count[0]\n\n # print(str.format(\"total no of jobs: {0}\", noofjobs))\n return noofjobs","def getFailedJobs(self):\n return self.__failedJobs","def test_category_invalid(self):\n # wiki and questions\n ques = QuestionFactory(title=u'q1 audio')\n ques.tags.add(u'desktop')\n ans = AnswerFactory(question=ques)\n AnswerVoteFactory(answer=ans, helpful=True)\n\n d1 = DocumentFactory(\n title=u'd1 audio',\n locale=u'en-US',\n category=10,\n is_archived=False,\n tags=[u'desktop'])\n ApprovedRevisionFactory(document=d1)\n\n self.refresh()\n\n qs = {'a': 1, 'w': 3, 'format': 'json', 'category': 'invalid'}\n response = self.client.get(reverse('search.advanced'), qs)\n eq_(2, json.loads(response.content)['total'])","def test_validate_njobs():\n with pytest.raises(ValueError):\n validate_njobs(0.1)\n with pytest.raises(ValueError):\n validate_njobs(0)\n\n assert validate_njobs(1) == 1\n assert validate_njobs(2) == 2","def test_query_params_date(session, params, expected_number_of_hits):\n result = get_search(session, params)\n compare(result['total']['value'], expected_number_of_hits)","def searched_per_day(df):\n return df.groupby([pd.TimeGrouper('D')]).apply(lambda row: \n len(row[row['action'] == 'searchResultPage']))","def test_past_category(self):\n create_category(category_name=\"Past category.\", days=-30)\n response = self.client.get(reverse('closetclient:index'))\n self.assertQuerysetEqual(response.context['latest_category_list'],['<Category: Past category.>']\n )","def test_query_train_jobs_with_exceeded_limit(self, client):\n params = dict(offset=0, limit=1000)\n url = get_url(BASE_URL, params)\n response = client.get(url)\n result = response.get_json()\n assert result.get('error_code') == '50540002'","def fetch_training(df, training_start, duration):\n # if not dt.datetime.strptime(training_start, '%Y-%m-%d').weekday() < 5:\n # print('Start date should be weekday!')\n # return False\n\n dt_training_start = dt.datetime.strptime(training_start, '%Y-%m-%d')\n dt_training_end = dt_training_start + dt.timedelta(days=duration)\n try:\n return df.loc[(df.date < dt_training_end) & (df.date >= dt_training_start)]\n\n except:\n print('Error fetch_training')\n return False","def test_two_past_categorys(self):\n create_category(category_name=\"Past Category 1.\", days=-30)\n create_category(category_name=\"Past Category 2.\", days=-5)\n response = self.client.get(reverse('closetclient:index'))\n self.assertQuerysetEqual(\n response.context['latest_category_list'],\n ['<Category: Past Category 2.>', '<Category: Past Category 1.>']\n )","def n_count(category):\r\n sql = text('''\r\n WITH uniq AS (\r\n SELECT COUNT(app.id) FROM task, app\r\n LEFT OUTER JOIN category ON app.category_id=category.id\r\n WHERE\r\n category.short_name=:category\r\n AND app.hidden=0\r\n AND app.info LIKE('%task_presenter%')\r\n AND task.app_id=app.id\r\n GROUP BY app.id)\r\n SELECT COUNT(*) FROM uniq\r\n ''')\r\n\r\n results = db.engine.execute(sql, category=category)\r\n count = 0\r\n for row in results:\r\n count = row[0]\r\n return count","def days_with_error() :\n query = \"\"\"SELECT errorlogs.date,round(100.0*errorcount/logcount,2) As Percent FROM logs,errorlogs\n WHERE logs.date=errorlogs.date AND errorcount>logcount/100\"\"\"\n result = get_data(query)\n print(\" 3. Days with more than 1% of error:\")\n print(\"\")\n for record in result :\n print(' ' + str(record[0]) + ' '+ '-' + \" \" + str(record[1]) + '%'+ ' '+ 'errors')\n print(\"\\t\")","def counter(self) -> int:\n return self._fail_counter","def question_3():\n cursor.execute(mostErrorDays)\n output = cursor.fetchall()\n return output","def total_suspicious(cc): # pragma: no cover\n cc.execute(\"\"\"SELECT DISTINCT DATE_FORMAT(git_commit.timestamp, '%Y-%m')\n FROM git_commit\"\"\")\n months = cc.fetchall()\n results = []\n for month in months:\n month = month[0]\n cc.execute(\"\"\"SELECT COUNT(*)\n FROM review\n INNER JOIN git_commit\n ON review.review_url = git_commit.review_url\n INNER JOIN commit_people\n ON commit_people.git_commit_hash = git_commit.hash\n LEFT JOIN (\n SELECT review_url, COUNT(*) AS c\n FROM review_people\n WHERE type = 'lgtm'\n GROUP BY review_url) lgtm_count\n ON review.review_url = lgtm_count.review_url\n WHERE lgtm_count.c = 0 OR lgtm_count.c IS NULL\n AND commit_people.type = 'tbr'\n AND YEAR(git_commit.timestamp) = %s\n AND MONTH(git_commit.timestamp) = %s\"\"\" % (month[:4], month[5:]))\n no_lgtm = cc.fetchone()\n cc.execute(\"\"\"SELECT COUNT(*)\n FROM git_commit\n WHERE review_url IS NULL\n AND YEAR(git_commit.timestamp) = %s\n AND MONTH(git_commit.timestamp) = %s\"\"\" % (month[:4], month[5:]))\n no_review = cc.fetchone()\n result = int(no_lgtm[0]) + int(no_review[0])\n results.append([month, result])\n return results","def test_get_job_executions(self):\n url = '/%s/jobs/%d/executions/' % (self.api, self.job_1.id)\n response = self.client.generic('GET', url)\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n\n results = json.loads(response.content)\n job_exe_count = results['count']\n self.assertEqual(job_exe_count, 4)\n #check that we order by descending exe_num\n self.assertEqual(results['results'][0]['exe_num'], 4)","def count(self):\n # no auth?\n return self.app.db.jobs.count()","def test_400_if_questions_by_category_fails(self):\n\n # send request with category id 100\n response = self.client().get('/categories/100/questions')\n\n # load response data\n data = json.loads(response.data)\n\n # check response status code and message\n self.assertEqual(response.status_code, 400)\n self.assertEqual(data['success'], False)\n self.assertEqual(data['message'], 'bad request')","def test_polljobs_callcount(mock_status):\n\n jobs = {\n \"jobone\": {\n \"laststatus\": \"Running\",\n \"scheduler\": \"LSF\",\n \"jobid\": \"123456\"\n },\n \"jobtwo\": {\n \"laststatus\": \"Queued\",\n \"scheduler\": \"LSF\",\n \"jobid\": \"123456\"\n },\n \"jobthree\": {\n \"laststatus\": \"Submit Error\",\n \"scheduler\": \"LSF\",\n \"jobid\": \"123456\"\n },\n \"jobfour\": {\n \"laststatus\": \"Waiting Submission\",\n \"scheduler\": \"LSF\",\n \"jobid\": \"123456\"\n },\n \"jobfive\": {\n \"laststatus\": \"Finished\",\n \"scheduler\": \"LSF\",\n \"jobid\": \"123456\"\n },\n \"jobsix\": {\n \"laststatus\": \"Complete\",\n \"scheduler\": \"LSF\",\n \"jobid\": \"123456\"\n }\n }\n\n mock_status.return_value = \"Running\"\n returnval = _polljobs(jobs, False)\n\n assert mock_status.call_count == 2, \\\n \"Should only be polling running and queued jobs\"\n assert jobs[\"jobtwo\"][\"laststatus\"] == \"Running\"\n assert returnval is True","def test_past_category(self):\n past_category = create_category(category_name='Past Category.', days=-5)\n url = reverse('closetclient:detail', args=(past_category.id,))\n response = self.client.get(url)\n self.assertContains(response, past_category.category_name)","def test_ehr_submission_data_cutoff(self, mock_get_affected_tables):\n # mocks the return value of get_affected_tables as we only want to loop through the\n # visit_occurrence not all of the CDM tables\n mock_get_affected_tables.return_value = [common.VISIT_OCCURRENCE]\n\n queries = []\n visit_occurrence_tmpl = self.jinja_env.from_string(\"\"\"\n INSERT INTO `{{fq_dataset_name}}.{{cdm_table}}`\n (visit_occurrence_id, person_id, visit_concept_id, visit_start_date, \n visit_start_datetime, visit_end_date, visit_end_datetime, visit_type_concept_id)\n VALUES\n (111, 222, 3, date('2018-03-06'), timestamp('2018-03-06 11:00:00'), \n date('2018-03-07'), timestamp('2018-03-07 11:00:00'), 4),\n (222, 333, 3, date('2019-03-06'), timestamp('2019-03-06 11:00:00'), \n date('2019-03-07'), timestamp('2019-03-07 11:00:00'), 4),\n (333, 444, 3, date('2020-03-06'), timestamp('2020-03-06 11:00:00'), \n date('2020-03-07'), timestamp('2020-03-07 11:00:00'), 4),\n (444, 555, 3, date('2021-03-06'), timestamp('2021-03-06 11:00:00'), \n date('2021-03-07'), timestamp('2021-03-07 11:00:00'), 4),\n (555, 666, 3, date('2022-03-06'), timestamp('2022-03-06 11:00:00'), \n date('2022-03-07'), timestamp('2022-03-07 11:00:00'), 4)\n \"\"\").render(fq_dataset_name=self.fq_dataset_name,\n cdm_table=common.VISIT_OCCURRENCE)\n queries.append(visit_occurrence_tmpl)\n\n self.load_test_data(queries)\n\n table_and_counts = [{\n 'fq_table_name':\n '.'.join([self.fq_dataset_name, 'visit_occurrence']),\n 'fq_sandbox_table_name':\n f'{self.fq_sandbox_name}.{self.rule_instance.sandbox_table_for(common.VISIT_OCCURRENCE)}',\n 'loaded_ids': [111, 222, 333, 444, 555],\n 'sandboxed_ids': [444, 555],\n 'fields': [\n 'visit_occurrence_id', 'person_id', 'visit_concept_id',\n 'visit_start_date', 'visit_start_datetime', 'visit_end_date',\n 'visit_end_datetime', 'visit_type_concept_id'\n ],\n 'cleaned_values': [\n (111, 222, 3, parse('2018-03-06').date(),\n parse('2018-03-06 11:00:00 UTC'), parse('2018-03-07').date(),\n parse('2018-03-07 11:00:00 UTC'), 4),\n (222, 333, 3, parse('2019-03-06').date(),\n parse('2019-03-06 11:00:00 UTC'), parse('2019-03-07').date(),\n parse('2019-03-07 11:00:00 UTC'), 4),\n (333, 444, 3, parse('2020-03-06').date(),\n parse('2020-03-06 11:00:00 UTC'), parse('2020-03-07').date(),\n parse('2020-03-07 11:00:00 UTC'), 4)\n ]\n }]\n\n self.default_test(table_and_counts)","def get_fail_count(self):\n return sum(1 for outcome in (r.outcome for r in self.values()) if outcome == Result.FAIL)","def test_results_for_repo_with_weeks_ago(self):\n result = self.simulate_get('/results/TEST/jenkinsfile-test', query_string='weeks_ago=1')\n self.assertEqual(result.status_code, 200)\n self.assertEqual(len(result.json['results']), 2)","def run_tests():\n passed_tests = 0\n failed_tests = 0\n for case in TEST_CASES:\n start_date, end_date = [datetime.strptime(x, \"%d/%m/%Y\") for x in case[0]]\n experiment = Experiment(start_date, end_date)\n if experiment.duration() == case[1]:\n result = \"passed\"\n passed_tests += 1\n else:\n result = \"failed\"\n failed_tests += 1\n print(f\"\"\"{\"-\".join(case[0])}, {case[1]} days: Test {result}\"\"\")\n\n print(\n f\"All tests completed\\n\"\n f\"Number of tests passed: {passed_tests}\\n\"\n f\"Number of tests failed: {failed_tests}\"\n )","def searched_per_day_by_group(df):\n return df.groupby([pd.TimeGrouper('D'),\n 'group']).apply(lambda row:\n len(row[row['action'] == 'searchResultPage']))","def test_course_unexpired_runs():\n course = CourseFactory.create()\n now = now_in_utc()\n start_dates = [now, now + timedelta(days=-3)]\n end_dates = [now + timedelta(hours=1), now + timedelta(days=-2)]\n CourseRunFactory.create_batch(\n 2,\n course=course,\n start_date=factory.Iterator(start_dates),\n end_date=factory.Iterator(end_dates),\n live=True,\n )\n\n # Add a run that is not live and shouldn't show up in unexpired list\n CourseRunFactory.create(\n course=course, start_date=start_dates[0], end_date=end_dates[0], live=False\n )\n\n assert len(course.unexpired_runs) == 1\n course_run = course.unexpired_runs[0]\n assert course_run.start_date == start_dates[0]\n assert course_run.end_date == end_dates[0]","def test_400_if_questions_by_category_fails(self):\n # send request with category id 2020\n category_id = 2020\n res = self.client().get(f'/categories/{category_id}/questions')\n data = json.loads(res.data)\n # check response status code and message\n self.assertEqual(res.status_code, 400)\n self.assertEqual(data['success'], False)\n self.assertEqual(data['message'], 'bad request')","def days_with_request():\n\n # To print information\n information_string = '3. Days with more than ' \\\n '1% of request that lead to an error:\\n'\n\n # Query string\n query = \"\"\"select * from (select date(time),\n round(100.0*sum(case log.status\n when '200 OK' then 0 else 1 end)/count(log.status),3)\n as error from log group by date(time)\n order by error desc) as subq where error > 1;\"\"\"\n\n print(information_string)\n for result in query_db(query):\n print('\\t{0:%B %d, %Y} - {1}%'.format(result[0], result[1]))\n\n print(\"\\n\")","def test_can_create_job_category(self):\n\t\tself.job_category.save()\n\t\tjob_category_instance = JobCategory.objects.get(pk=1)\n\t\tself.assertEqual(\n\t\t\tself.category,\n\t\t\tjob_category_instance.category,\n\t\t\t\"Job categories don't match.\"\n\t\t)","def test(self):\n advisories = self.list_advisories(\"2016-10-1\")\n self.after = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n self.include_cvrf = True\n\n for a in advisories:\n return self.process_advisory(a)","def test_dates_and_Datetimes(self):\n if self.skip_tests:\n return\n recipe = (\n self.recipe()\n .dimensions(\"year_by_format\")\n .metrics(\"count\")\n .order_by(\"year_by_format\")\n )\n self.assertRecipeCSV(\n recipe,\n \"\"\"\n year_by_format,count,year_by_format_id\n 2005-01-01 00:00:00,1,2005-01-01 00:00:00\n 2013-01-01 00:00:00,1,2013-01-01 00:00:00\n \"\"\",\n )\n recipe = (\n self.recipe()\n .dimensions(\"year_by_format\")\n .metrics(\"count\")\n .order_by(\"-year_by_format\")\n )\n self.assertRecipeCSV(\n recipe,\n \"\"\"\n year_by_format,count,year_by_format_id\n 2013-01-01 00:00:00,1,2013-01-01 00:00:00\n 2005-01-01 00:00:00,1,2005-01-01 00:00:00\n \"\"\",\n )\n\n # Test a month() conversion\n recipe = (\n self.recipe()\n .dimensions(\"test_month\")\n .metrics(\"age\", \"count\")\n .order_by(\"-test_month\")\n )\n self.assertRecipeCSV(\n recipe,\n \"\"\"\n test_month,age,count,test_month_id\n 2015-05-01,10,1,2015-05-01\n 2015-01-01,5,1,2015-01-01\n \"\"\",\n )","def compare_tool_results_count(tool_results, check, issue_type, known_count):\n # logging.info(\"known_count=%s, check key=%s, tool_results=%s, issue_type=%s\",\n # str(known_count), str(check), str(tool_results), str(issue_type))\n return tool_results[check][issue_type] > known_count","def test_unqualified_by_date(self):\n to_date = datetime.today() - timedelta(days=2)\n from_date = to_date.date() - timedelta(days=2)\n consumer = Consumer.objects.get(id=103)\n consumer.is_emailable = True\n consumer.consumer_create_datetime = to_date - timedelta(days=1)\n consumer.save()\n result = UnqualifiedConsumerEmailTask().qry_unqualified_consumers(\n from_date, to_date.date())\n self.assertEqual(result.filter(id=103).count(), 1)","def test_get_food_most_calories_smaller_population():\n df_breakfast = df[df['Category'] == 'Breakfast']\n\n actual = get_food_most_calories(df_breakfast)\n expected = 'Big Breakfast with Hotcakes (Large Biscuit)'\n assert actual == expected","def test_successful(self):\n\n url = '/%s/job-types/running/' % self.api\n response = self.client.generic('GET', url)\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n\n result = json.loads(response.content)\n self.assertEqual(len(result['results']), 1)\n self.assertEqual(result['results'][0]['job_type']['name'], self.job.job_type.name)\n self.assertEqual(result['results'][0]['count'], 1)\n self.assertIsNotNone(result['results'][0]['longest_running'])","def test_query_train_jobs(self, client):\n params = dict(offset=0, limit=10)\n url = get_url(BASE_URL, params)\n response = client.get(url)\n result = response.get_json()\n assert result.get('total') == SUMMARY_DIR_NUM\n assert len(result.get('train_jobs')) == min(10, SUMMARY_DIR_NUM)","def test_slack_notifier_on_failed_circle_ci_jobs():\n from circle_ci_slack_notifier import (\n CircleCIClient,\n CircleCiFailedJobsParser,\n construct_failed_jobs_slack_message,\n )\n\n parser = CircleCiFailedJobsParser(\n circle_client=CircleCIClient(), workflow_id=WORKFLOW_ID\n )\n assert construct_failed_jobs_slack_message(parser) == [\n {\n \"fallback\": \"Demisto SDK Master-Failure\",\n \"color\": \"danger\",\n \"title\": \"Demisto SDK Master-Failure\",\n \"title_link\": \"https://app.circleci.com/pipelines/github/demisto/demisto-sdk//workflows/1\",\n \"fields\": [\n {\n \"title\": \"Failed Circle-CI jobs - (3)\",\n \"value\": \"run-unit-tests-3.9.10[pytest]\\nrun-integration-tests-3.9.10[pytest]\"\n \"\\nvalidate-files[Test validate files and yaml]\",\n \"short\": False,\n },\n {\n \"title\": \"Failed unit-tests - (1)\",\n \"value\": \"demisto_sdk.commands.common.content.tests.objects.pack_objects.abstract_pack_\"\n \"objects.json_content_object_test.test_to_version_no_from_version\",\n \"short\": False,\n },\n {\n \"title\": \"Failed integration-tests - (1)\",\n \"value\": \"demisto_sdk.tests.integration_tests.create_id_set_integration_test.\"\n \"TestCreateIdSet.test_excluded_items_contain_aliased_field\",\n \"short\": False,\n },\n {\n \"title\": \"Failed files on validations - (2)\",\n \"value\": \"Packs/ARIAPacketIntelligence/Integrations/ARIAPacketIntelligence/\"\n \"ARIAPacketIntelligence.yml - [IN153]\\nPacks/AccentureCTI/Playbooks/\"\n \"playbook-ACTI_Create_Report-Indicator_Associations.yml - [PB110]\",\n \"short\": False,\n },\n ],\n }\n ]","def test_404_total_categories_not_equals_seven(self):\n res = self.client().get('/categories/7')\n data = json.loads(res.data)\n self.assertEqual(res.status_code, 404)\n self.assertEqual(data['success'], False)\n self.assertEqual(data['message'], 'Resource Not Found')","def errors(job_name, jenkins_username, jenkins_token):\n global server\n# job_name = 'enterprise_pe-acceptance-tests_integration-system_pe_full-upgrade_weekend_2016.4.x' # 'enterprise_pe-orchestrator_intn-van-sys-pez-multi_2016.4.x-2016.4.x' # 'enterprise_pe-modules-vanagon-suite_intn-van-sys-pez-multi_daily-pe-modules-2016.4.x'\n server = Jenkins('https://cinext-jenkinsmaster-enterprise-prod-1.delivery.puppetlabs.net', username=jenkins_username, password=jenkins_token)\n info = server.get_job_info(job_name)\n builds = [server.get_build_info(job_name, build['number']) for build in info['builds']]\n failed_build_numbers = [b for b in builds if b['result'] == 'FAILURE']\n last_job_errors = None\n\n counts = defaultdict(int)\n similar = set()\n for build in failed_build_numbers:\n output = server.get_build_console_output(job_name, build['number'])\n finder = get_strategy(output)\n errors = finder(output)\n print \"Errors: {}\".format(errors)\n if last_job_errors:\n seq = difflib.SequenceMatcher(a=last_job_errors, b=errors)\n if seq.ratio() == 1.0:\n counts['exact'] += 1\n if seq.ratio() >= 0.7 and seq.ratio() < 1.0:\n counts['similar'] += 1\n similar.append(errors)\n else:\n last_job_errors = errors\n\n if last_job_errors:\n click.echo('Last job errors were:')\n click.echo('\\t{}'.format('\\n\\t'.join(last_job_errors)))\n\n if last_job_errors and 'exact' in counts:\n click.echo('There were {} jobs that failed with errors exactly the same as the last failed job:'.format(counts['exact']))\n click.echo('\\t{}'.format('\\n\\t'.join(last_job_errors)))\n\n if last_job_errors and 'similar' in counts:\n click.echo('There were {} jobs that failed with experienced similar errors as the last failed job:'.format(counts['exact']))\n click.echo('\\t{}'.format('\\n\\t'.join(last_job_errors)))\n for s in similar:\n click.echo('Additional Failed Job:')\n click.echo('\\t{}'.format('\\n\\t'.join(s)))","def _log_failed(cls, count):\n MetricLogger.log_metric(FUNCTION_NAME, MetricLogger.SQS_FAILED_RECORDS, count)","def test_categoryQuery(self) -> None:\n result = self.entries.filter(category__iexact='suncare')\n self.assertGreater(len(result), 0)\n\n result = self.entries.filter(category__iexact='xxxxxx')\n self.assertEqual(len(result), 0)","def test_get_questions_by_category(self):\n\n res = self.client().get('/categories/1/questions')\n\n data = json.loads(res.data)\n\n self.assertEqual(res.status_code, 200)\n self.assertEqual(data['success'], True)\n self.assertEqual(len(data['questions']), 3)\n self.assertEqual(len(data['categories']), 6)\n self.assertTrue(data['total_questions'])\n self.assertTrue(data['current_category'])","def test_get_refresh_job_status(self):\n pass","def problem_days(cursor):\n days = 'None found'\n try:\n logs = \"\"\"select daily.day,\n daily_total::integer/100,\n daily_errors::integer,\n daily_total\n from daily_logs as daily, error_logs as errors\n where (daily_total::integer/100.0) <\n daily_errors::integer\n and daily.day = errors.day\n order by daily.day\n \"\"\"\n\n cursor.execute(logs)\n report = cursor.fetchall()\n # If no days were found, return\n if len(report) <= 0:\n return days\n\n except psycopg2.Error as e:\n print('Fetching summary of days with >1% error statuses: \\r\\n{}'\n .format(e.pgerror))\n\n # If the query returns any days, return the results.\n else:\n day_str = ' {0} - {1}% of {2} were errors\\r\\n'\n days = 'Days when over 1% of requests lead to errors: \\r\\n'\n for date in report:\n percentage_error = round((date[2]/date[1]), 2)\n days += day_str.format(date[0].strftime('%d of %B %Y'),\n percentage_error,\n date[3])\n return days","def test_06_dataset_counts_published(self):\n print (self.test_06_dataset_counts_published.__doc__)\n\n stats_maker = StatsMakerDatasets()\n\n r = stats_maker.get_dataset_counts_by_create_date_published()\n\n # check number of months\n self.assertEqual(len(r.result_data['records']), 16)\n\n # check 1st month\n first_month = {'count': 21,\n 'month_name': 'April',\n 'month_name_short': 'Apr',\n 'month_num': 4,\n 'running_total': 21,\n 'year_num': 2015,\n 'yyyy_mm': '2015-04'}\n self.assertEqual(dict(r.result_data['records'][0]), first_month)\n\n # check last month\n last_month = {'count': 4,\n 'month_name': 'July',\n 'month_name_short': 'Jul',\n 'month_num': 7,\n 'running_total': 227,\n 'year_num': 2016,\n 'yyyy_mm': '2016-07'}\n self.assertEqual(dict(r.result_data['records'][-1]), last_month)","def test_get_jobs_status(\n globals, urls, client, mock_test_responses, context_fixture):\n\n context = context_fixture('Healthy')\n mock_test_responses(task='upload', status=CoreStatus.DONE)\n responses.add(\n responses.GET, urls('task', 'upload'),\n json={\n '_id': globals['upload'],\n 'status': CoreStatus.FAIL\n },\n status=200,\n content_type='application/json')\n\n for i in range(2):\n client.upload(file=globals['test_csv_file'], name=str(i))\n\n context.run()\n job_fail = context.get_jobs_status(status=['fail'])\n\n assert job_fail.iloc[0]['status'] == 'fail'\n assert job_fail.iloc[0]['Job'] == '1'","def test_workflows_count_get(self):\n pass","def test_since(self):\n self.create_logs(self.user1, num=50, start=self.year2000)\n self.create_logs(self.user1, num=50, start=self.year2001)\n\n response = self.client.get(telemetry_url, {\n 'since': self.year2001.isoformat(),\n })\n self.assertEqual(200, response.status_code)\n\n data = json.loads(response.content)\n\n # since is non-inclusive, so the first entry is not included\n self.assertEqual(49, len(data))\n\n for entry in data:\n time = iso8601.parse_date(entry['timestamp'])\n self.assertGreater(time, self.year2001)","def jobHealthy(self, count):\n job = self.tester.submission_result.job\n for idx in range(count - 1):\n if (job.health == 'healthy'):\n return True\n print(\"health check fail : %d\" % idx )\n time.sleep(1)\n job.refresh()\n self.assertEqual('healthy', job.health)\n return False","def test_was_published_recently_with_old_category(self):\n time = timezone.now() - datetime.timedelta(days=1)\n old_category = Category(pub_date=time)\n self.assertIs(old_category.was_published_recently(), False)","def test_results_with_weeks_ago(self):\n result = self.simulate_get('/results/', query_string='weeks_ago=1')\n self.assertEqual(result.status_code, 200)\n self.assertEqual(len(result.json['results']), 2)","def test_one_date(self):\n result = beautiful_days_at_the_movies(10, 10, 6)\n self.assertEquals(result, 0)","def test_get_questions_by_category(self):\n res = self.client().get('/api/categories/1/questions')\n self.assertEqual(res.status_code, 200)\n data = json.loads(res.data)\n self.assertTrue(data[\"success\"])\n self.assertTrue(data[\"questions\"])\n self.assertTrue(data[\"total_questions\"])","def test_course_available_runs():\n user = UserFactory.create()\n course = CourseFactory.create()\n runs = CourseRunFactory.create_batch(2, course=course, live=True)\n runs.sort(key=lambda run: run.start_date)\n CourseRunEnrollmentFactory.create(run=runs[0], user=user)\n assert course.available_runs(user) == [runs[1]]\n assert course.available_runs(UserFactory.create()) == runs","def test_nested_friendly_date_criteria(self):\n # Add topic - future items\n topic = self._ATCT\n date_crit = topic.addCriterion('start', 'ATFriendlyDateCriteria')\n date_crit.setValue(0)\n date_crit.setDateRange('+') # This is irrelevant when the date is now\n date_crit.setOperation('more')\n # Add subtopic - past items\n self.setRoles(['Manager', 'Member'])\n topic.addSubtopic('qux')\n self.setRoles(['Member'])\n subtopic = topic.qux\n date_crit = subtopic.addCriterion('end', 'ATFriendlyDateCriteria')\n date_crit.setValue(0)\n date_crit.setDateRange('-') # This is irrelevant when the date is now\n date_crit.setOperation('less')\n subtopic.setAcquireCriteria(True)\n # fetch the query\n query = subtopic.buildQuery()\n self.assertTrue(query['end'])\n # query shouldn't have a start key\n # https://dev.plone.org/plone/ticket/8827\n self.assertFalse('start' in query)","def date_diagnostic(scenario, dates):\n running = 0\n with open(\"scenario%s_dates.txt\" % (scenario,), \"w\") as fp:\n fp.write(\"date,total\\n\")\n for date in pd.date_range(APR15, MAY30):\n hits = [d for d in dates if d == date]\n running += len(hits)\n fp.write(\"%s,%s\\n\" % (date, running))","def fail_counter(self) -> int:\n return self._state_storage.counter","def count_risk_categories_by_month(data, month, year):\n return count_risk_categories(\n filter_inspection_type(\n filter_month(data, month, year), 'Routine - Unscheduled'))","def test_08_dataset_counts_all(self):\n print (self.test_08_dataset_counts_all.__doc__)\n\n stats_maker = StatsMakerDatasets()\n\n r = stats_maker.get_dataset_counts_by_create_date()\n\n # check number of months\n self.assertEqual(len(r.result_data['records']), 16)\n\n # check 1st month\n first_month = {'count': 36,\n 'month_name': 'April',\n 'month_name_short': 'Apr',\n 'month_num': 4,\n 'running_total': 36,\n 'year_num': 2015,\n 'yyyy_mm': '2015-04'}\n self.assertEqual(dict(r.result_data['records'][0]), first_month)\n\n # check last month\n last_month = {'count': 98,\n 'month_name': 'July',\n 'month_name_short': 'Jul',\n 'month_num': 7,\n 'running_total': 570,\n 'year_num': 2016,\n 'yyyy_mm': '2016-07'}\n self.assertEqual(dict(r.result_data['records'][-1]), last_month)","def test_list_activity_occurrences(self):\n pass","def error_report():\n db, c = connect(DBNAME)\n c.execute(\"select to_char(time,'FMMonth DD, YYYY') as date, \"\n \"round((sum(case when status = '200 OK' \"\n \"then 0 else 1 end)::decimal / count(*)) * 100,2) \"\n \"as percent_error from log group by date \"\n \"having (sum(case when status = '200 OK' \"\n \"then 0 else 1 end)::decimal / count(*)) * 100 > 1\")\n error_table = c.fetchall()\n db.close()\n print \"\\nDates on Which Over 1% of Requests Led to Errors:\"\n for error in error_table:\n if __name__ == '__main__':\n print str(error[0]) + \" - \" + str(error[1]) + \"%\"","def test_job_fail(self):\n with self.settings(JOBS_ROOT=os.path.join(settings.BASE_DIR, \"extras/tests/dummy_jobs\")):\n\n module = \"test_fail\"\n name = \"TestFail\"\n job_class = get_job(f\"local/{module}/{name}\")\n job_result = JobResult.objects.create(\n name=job_class.class_path,\n obj_type=self.job_content_type,\n user=None,\n job_id=uuid.uuid4(),\n )\n run_job(data={}, request=None, commit=False, job_result_pk=job_result.pk)\n job_result.refresh_from_db()\n self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_ERRORED)","def test_questions_by_category(self):\n\n response = self.client().get('/categories/1/questions')\n body = json.loads(response.data)\n\n self.assertEqual(response.status_code, 200)\n self.assertEqual(body['success'], True)\n self.assertNotEqual(len(body['questions']), 0)\n self.assertNotEqual(len(body['category']), 'Science')","def _first_good_date(self, day):\n count = 0\n while True:\n try:\n self.data.loc[day - timedelta(count)]\n return day - timedelta(count)\n except KeyError:\n count += 1","def test_successful(self):\n\n url = '/%s/jobs/' % self.api\n response = self.client.generic('GET', url)\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n\n result = json.loads(response.content)\n self.assertEqual(len(result['results']), 3)\n for entry in result['results']:\n expected = None\n if entry['id'] == self.job1.id:\n expected = self.job1\n elif entry['id'] == self.job2.id:\n expected = self.job2\n elif entry['id'] == self.job3.id:\n expected = self.job3\n else:\n self.fail('Found unexpected result: %s' % entry['id'])\n self.assertEqual(entry['job_type']['name'], expected.job_type.name)\n self.assertEqual(entry['job_type_rev']['job_type']['id'], expected.job_type.id)\n self.assertEqual(entry['is_superseded'], expected.is_superseded)","def test_results_for_project_with_weeks_ago(self):\n result = self.simulate_get('/results/TEST', query_string='weeks_ago=1')\n self.assertEqual(result.status_code, 200)\n self.assertEqual(len(result.json['results']), 2)","def testreportFailureToDashboard(self):\n self.assertEqual(0, reportFailureToDashboard(0, None))\n # parseAd is called by reportFailureToDashboard, but if we would\n # call it from reportFailureToDashboard error will be suppressed\n # and it will return same exit code\n # So lets call it directly\n if '_CONDOR_JOB_AD' in os.environ:\n del os.environ[\"_CONDOR_JOB_AD\"]\n self.assertRaises(KeyError, parseAd)\n self.assertEqual(0, reportFailureToDashboard(0))\n os.environ[\"_CONDOR_JOB_AD\"] = \"testFile\"\n # if this environment variable is set, it will check this file\n # if file is not present, it will raise IOError\n self.assertRaises(IOError, parseAd)\n # Test real job_ad file and check if it returns dict.\n os.environ[\"_CONDOR_JOB_AD\"] = os.path.join(getTestBase(), '..', 'data', 'WMCore', 'Services', 'Dashboard', 'job_ad_file')\n out = parseAd()\n self.assertTrue(isinstance(out, dict))\n # Also test it sending directly parsed job ad\n self.assertEqual(0, reportFailureToDashboard(0, out))","def test_calculate_working_days():\n assert (\n calculate_working_days(parse('2020-01-01'), parse('2020-03-31')) == 64\n )","def totaled_total_suspicious(cc, sql_time_specification): # pragma: no cover\n cc.execute(\"\"\"SELECT COUNT(*)\n FROM review\n INNER JOIN git_commit\n ON review.review_url = git_commit.review_url\n INNER JOIN commit_people\n ON commit_people.git_commit_hash = git_commit.hash\n LEFT JOIN (\n SELECT review_url, COUNT(*) AS c\n FROM review_people\n WHERE type = 'lgtm'\n GROUP BY review_url) lgtm_count\n ON review.review_url = lgtm_count.review_url\n WHERE lgtm_count.c = 0 OR lgtm_count.c IS NULL\n AND commit_people.type = 'tbr' AND %s\"\"\" % sql_time_specification)\n no_lgtm = cc.fetchone()\n cc.execute(\"\"\"SELECT COUNT(*)\n FROM git_commit\n WHERE review_url IS NULL AND %s\"\"\" % sql_time_specification)\n no_review = cc.fetchone()\n result = int(no_lgtm[0]) + int(no_review[0])\n return result","def test_get_certification_deadline(database):\n sess = database.session\n quart_sub = SubmissionFactory(submission_id=1, reporting_fiscal_year=2020, reporting_fiscal_period=6,\n is_fabs=False, is_quarter_format=True)\n month_sub = SubmissionFactory(submission_id=2, reporting_fiscal_year=2020, reporting_fiscal_period=10,\n is_fabs=False, is_quarter_format=False)\n fail_sub = SubmissionFactory(submission_id=3, reporting_fiscal_year=2020, reporting_fiscal_period=9,\n is_fabs=False, is_quarter_format=False)\n fabs_sub = SubmissionFactory(submission_id=4, reporting_fiscal_year=2020, reporting_fiscal_period=6,\n is_fabs=True, is_quarter_format=False)\n q2 = SubmissionWindowScheduleFactory(period=6, year=2020)\n p10 = SubmissionWindowScheduleFactory(period=10, year=2020)\n sess.add_all([quart_sub, month_sub, fail_sub, fabs_sub, q2, p10])\n\n # Pass cases\n assert get_certification_deadline(quart_sub) == q2.certification_deadline.date()\n assert get_certification_deadline(month_sub) == p10.certification_deadline.date()\n # Fail cases\n assert get_certification_deadline(fail_sub) is None\n assert get_certification_deadline(fabs_sub) is None","def test_valid_n_jobs(n_jobs: Any) -> None:\n check_n_jobs(n_jobs)","def test_check_freq_crashed(self):\n self.assertEqual(check_freq(self.jobset2), 'fcrashed')","def test_batch_create_occurrences(self):\n pass","def test_01_stats_dates(self):\r\n today = unicode(datetime.date.today())\r\n with self.flask_app.test_request_context('/'):\r\n dates, dates_n_tasks, dates_anon, dates_auth = stats.stats_dates(1)\r\n err_msg = \"There should be 10 answers today\"\r\n assert dates[today] == 10, err_msg\r\n err_msg = \"There should be 100 answers per day\"\r\n assert dates_n_tasks[today] == 100, err_msg\r\n err_msg = \"The SUM of answers from anon and auth users should be 10\"\r\n assert (dates_anon[today] + dates_auth[today]) == 10, err_msg","def test_set_activity_occurrence_results(self):\n pass","def failure_rate_for_test_suite(self, test_suite_name):\n bot_response = \"\"\n\n log.info(f\"Fetching feature name from codeceptjs script: {test_suite_name}\")\n # converting label to test script path + file name\n test_label = test_suite_name.split(\"-\")\n test_script = \"suites/\" + test_label[1] + \"/\" + test_label[2] + \".js\"\n\n try:\n # try to find the test script that corresponds to the test suite name\n test_script_source = self._get_test_script_source(test_script)\n except Exception as err:\n log.error(str(err))\n return str(err)\n\n log.debug(f\"Looking for the name of the feature in: {test_script}\")\n try:\n feature_name = self._get_feature_name_from_source(test_script_source)\n except Exception as err:\n log.error(str(err))\n return str(err)\n\n influxlib = self.get_influxlib()\n data_points = influxlib.query_ci_metrics(\n \"fail_count\", {\"suite_name\": feature_name}\n )\n if data_points:\n # crunch numbers here\n test_suite_failures = {}\n\n # iterate through influxdb's data points obtained from query response\n for point in data_points:\n # initialize nested-dictionary of PRs inside the repo_name key if it is not yet created\n if point[\"repo_name\"] not in test_suite_failures:\n test_suite_failures[point[\"repo_name\"]] = {}\n\n # Count failed PRs per repo_name\n repo_key = test_suite_failures[point[\"repo_name\"]]\n repo_key.__setitem__(\n point[\"pr_num\"], int(repo_key[point[\"pr_num\"]]) + 1\n ) if point[\"pr_num\"] in repo_key else repo_key.__setitem__(\n point[\"pr_num\"], 1\n )\n\n log.debug(f\"### ## FINAL test_suite_failures: {test_suite_failures}\")\n\n # prepare bot response\n bot_response += (\n f\":information_source: The test suite {test_suite_name} failed:\\n\"\n )\n bot_response += \"```\"\n # each row of the report should print a msg similar to:\n # - 1 time(s) on PR-123 from repo myRepo\n for repo_name, prs in test_suite_failures.items():\n for pr_num, failure_count in prs.items():\n bot_response += f\"- {failure_count} time(s) on PR-{pr_num} from repo {repo_name}\\n\"\n bot_response += \"```\"\n else:\n bot_response += (\n \"could not find any `fail_count` metrics for this test suite :shrug:\"\n )\n\n return bot_response","def test_metrics_since_history(self):\n\n slug = \"test-slug\"\n years = 5\n link_type = \"history\"\n now = datetime(2014, 7, 4)\n\n module = 'redis_metrics.templatetags.redis_metric_tags.datetime'\n with patch(module) as mock_datetime:\n mock_datetime.utcnow.return_value = now\n\n result = taglib.metrics_since(slug, years, link_type)\n self.assertIn('link_type', result.keys())\n self.assertIn('slug_values', result.keys())\n self.assertEqual(result['link_type'], link_type)\n\n # Verify contents of `slug_values`\n # There should be entries for each year + 5 additional periods.\n expected = [\n (slug, now - timedelta(days=1), \"Today\", 'daily'),\n (slug, now - timedelta(days=7), \"1 Week\", 'daily'),\n (slug, now - timedelta(days=30), \"30 Days\", 'daily'),\n (slug, now - timedelta(days=60), \"60 Days\", 'daily'),\n (slug, now - timedelta(days=90), \"90 Days\", 'daily'),\n (slug, now - timedelta(days=365), \"1 Years\", 'daily'),\n (slug, now - timedelta(days=365 * 2), \"2 Years\", 'daily'),\n (slug, now - timedelta(days=365 * 3), \"3 Years\", 'daily'),\n (slug, now - timedelta(days=365 * 4), \"4 Years\", 'daily'),\n (slug, now - timedelta(days=365 * 5), \"5 Years\", 'daily'),\n ]\n self.assertEqual(expected, result['slug_values'])","def count_risk_categories(data):\n results = Counter([row['risk_category'] for row in data])\n if '' in results:\n results['No Violations'] = results['']\n del results['']\n return results","def __calculate_emptiness (self, scheduling_unit):\n difference = 0\n \n for date in self.workers.get_dates ( ):\n for person in self.mapper.get_all_people ( ):\n for turnus in self.mapper.get_turnuses (scheduling_unit, person):\n if person.is_scheduled_exact (scheduling_unit, turnus, date):\n difference += 1\n \n needed = self.workers.get_workers_by_type (date, scheduling_unit, turnus)\n \n difference -= needed\n return difference","def test_successful(self):\n\n url = '/%s/job-types/' % self.api\n response = self.client.get(url)\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n\n result = json.loads(response.content)\n self.assertEqual(len(result['results']), 6)\n for entry in result['results']:\n expected = None\n if entry['name'] == self.job_type1.name:\n expected = self.job_type1\n elif entry['name'] == self.job_type2.name:\n expected = self.job_type2\n elif entry['name'] == self.job_type3.name:\n expected = self.job_type3\n elif entry['name'] == self.job_type6.name:\n if entry['version'] == self.job_type4.version:\n expected = self.job_type4\n elif entry['version'] == self.job_type5.version:\n expected = self.job_type5\n elif entry['version'] == self.job_type6.version:\n expected = self.job_type6\n else:\n self.assertTrue(False, 'unexpected job type!')\n else:\n self.fail('Found unexpected result: %s' % entry['id'])\n\n self.assertEqual(entry['name'], expected.name)\n self.assertEqual(entry['title'], expected.get_title())\n self.assertEqual(entry['description'], expected.get_description())\n self.assertEqual(entry['icon_code'], expected.icon_code)\n self.assertEqual(entry['is_published'], expected.is_published)\n self.assertEqual(entry['is_active'], expected.is_active)\n self.assertEqual(entry['is_paused'], expected.is_paused)\n self.assertEqual(entry['is_system'], expected.is_system)\n self.assertEqual(entry['max_scheduled'], expected.max_scheduled)\n self.assertEqual(entry['revision_num'], expected.revision_num)\n self.assertEqual(entry['docker_image'], expected.docker_image)"],"string":"[\n \"def test_error_category(self):\\n\\n error = error_test_utils.create_error(category='DATA')\\n job = job_test_utils.create_job(error=error)\\n\\n url = '/%s/jobs/?error_category=%s' % (self.api, error.category)\\n response = self.client.generic('GET', url)\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n\\n result = json.loads(response.content)\\n self.assertEqual(len(result['results']), 1)\\n self.assertEqual(result['results'][0]['id'], job.id)\\n self.assertEqual(result['results'][0]['error']['category'], error.category)\",\n \"async def test_job_lookback_days(self):\\n self.set_source_parameter(\\\"lookback_days\\\", \\\"3\\\")\\n\\n now_dt = now()\\n now_timestamp = int(datetime.timestamp(now_dt) * 1000)\\n last_week_timestamp = int(datetime.timestamp(now_dt - timedelta(weeks=1)) * 1000)\\n self.builds.extend(\\n [\\n {\\\"result\\\": \\\"SUCCESS\\\", \\\"timestamp\\\": now_timestamp},\\n {\\\"result\\\": \\\"SUCCESS\\\", \\\"timestamp\\\": last_week_timestamp},\\n ],\\n )\\n\\n jenkins_json = {\\n \\\"jobs\\\": [{\\\"name\\\": \\\"job\\\", \\\"url\\\": self.job_url, \\\"buildable\\\": True, \\\"color\\\": \\\"blue\\\", \\\"builds\\\": self.builds}],\\n }\\n response = await self.collect(get_request_json_return_value=jenkins_json)\\n\\n expected_entities = [{\\\"build_count\\\": 1, \\\"key\\\": \\\"job\\\", \\\"name\\\": \\\"job\\\", \\\"url\\\": self.job_url}]\\n self.assert_measurement(response, value=\\\"1\\\", entities=expected_entities)\",\n \"def test_failed_job(self):\\n failed_job = json.loads(BASE_JSON % (FAILURE, 1433166610, 1, 1433166609))[0]\\n self.assertEquals(self.query_api.get_job_status(failed_job), FAILURE)\",\n \"def _failed_tests(self, metric_source_id: str) -> int:\\n return self.__test_count(metric_source_id, 'failed')\",\n \"def no_new_cases_count(day: int, month: int, year: int = 2020) -> int:\\r\\n \\r\\n # Your code goes here (remove pass)\\r\",\n \"def test_query_train_jobs_with_wrong_offse(self, client):\\n params = dict(offse=0, limit=10)\\n url = get_url(BASE_URL, params)\\n response = client.get(url)\\n result = response.get_json()\\n assert result.get('total') == SUMMARY_DIR_NUM\\n assert len(result.get('train_jobs')) == min(10, SUMMARY_DIR_NUM)\",\n \"def test_results_errors(self, affiliate_items):\\n updater = mock.Mock(side_effect=ValueError())\\n batch_job = BatchJob(affiliate_items, updater)\\n\\n error_count = 0\\n for result in batch_job.run():\\n error_count += int(result.is_error)\\n\\n assert error_count == 4\",\n \"def test_date_range(self):\\n\\n url = '/%s/job-types/status/?started=%s&ended=%s' % ( self.api,\\n '2015-01-01T00:00:00Z',\\n '2015-01-02T00:00:00Z')\\n response = self.client.generic('GET', url)\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n\\n result = json.loads(response.content)\\n self.assertEqual(len(result['results']), 4)\",\n \"def test_failed_job(self):\\n\\n failed_job = json.loads(TREEHERDER_JOB % (\\\"testfailed\\\", \\\"completed\\\"))\\n self.assertEquals(self.query_api.get_job_status(failed_job), FAILURE)\",\n \"def test_active_and_date_range(self):\\n\\n url = '/%s/job-types/status/?is_active=true&started=%s&ended=%s' % ( self.api,\\n '2016-01-01T00:00:00Z',\\n '2016-01-02T00:00:00Z')\\n response = self.client.generic('GET', url)\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n\\n result = json.loads(response.content)\\n self.assertEqual(len(result['results']), 3)\\n self.assertEqual(result['results'][0]['job_type']['name'], self.job1.job_type.name)\\n self.assertEqual(len(result['results'][0]['job_counts']), 0)\",\n \"def fetch_testing(df, testing_start, curr_date_set, duration=1):\\n dt_testing_start = dt.datetime.strptime(testing_start, '%Y-%m-%d')\\n for _ in range(200):\\n if testing_start in curr_date_set:\\n dt_testing_end = dt_testing_start + dt.timedelta(days=duration)\\n break\\n else:\\n dt_testing_start = next_weekday(dt_testing_start)\\n try:\\n return df.loc[(df.date < dt_testing_end) & (df.date >= dt_testing_start)]\\n\\n except:\\n print('Error fectch_testing')\\n return False\",\n \"def test_results(self, affiliate_items):\\n processed_count = 0\\n error_count = 0\\n\\n updater = mock.Mock()\\n batch_job = BatchJob(affiliate_items, updater)\\n\\n for result in batch_job.run():\\n processed_count += 1\\n error_count += int(result.is_error)\\n\\n assert updater.call_count == 4\\n assert processed_count == 4\\n assert error_count == 0\",\n \"def test_questions_by_category_failure(self):\\n\\n response = self.client().get('/categories/10/questions')\\n body = json.loads(response.data)\\n\\n self.assertEqual(response.status_code, 404)\\n self.assertEqual(body['success'], False)\\n self.assertNotEqual(len(body['message']), 'resource not found')\",\n \"def test_run_date(self):\\n Historical_ROAs_Parsed_Table(clear=True)\\n\\n date = '2019-08-01'\\n \\n with Historical_ROAs_Table(clear=True) as t:\\n Historical_ROAs_Parser().run(datetime.strptime(date, '%Y-%m-%d'))\\n sql = f\\\"SELECT COUNT(*) FROM {t.name} WHERE date_added = '{date}'\\\"\\n \\n # unless ROAs are retroactively added, this should be constant\\n assert t.get_count(sql) == 95743\",\n \"def getByDay(self, date=None, num=False):\\n if date is None:\\n date = self.date\\n\\n tdate = datetime.datetime.strptime(\\n date, \\\"%Y%m%d\\\") - datetime.timedelta(180)\\n ldate = tdate.strftime(\\\"%Y%m%d\\\")\\n ddict = {\\\"$or\\\": [{\\\"task_day\\\": {\\\"$gt\\\": ldate}, \\\"status\\\": \\\"waiting\\\"}, {\\n \\\"task_day\\\": date, \\\"status\\\": \\\"failure\\\", \\\"retry\\\": {\\\"$lte\\\": 3}}]}\\n if num:\\n return self.mgdb.task_history.find(ddict).count()\\n else:\\n l = []\\n for doc in self.mgdb.task_history.find(ddict).sort('level', pymongo.DESCENDING):\\n l.append(doc)\\n return l\",\n \"def cluster_count_failure_report(self, node_id: str) -> ResponseT:\\n return self.execute_command(\\\"CLUSTER COUNT-FAILURE-REPORTS\\\", node_id)\",\n \"def test_07_dataset_counts_unpublished(self):\\n print (self.test_07_dataset_counts_unpublished.__doc__)\\n\\n stats_maker = StatsMakerDatasets()\\n\\n r = stats_maker.get_dataset_counts_by_create_date_unpublished()\\n\\n # check number of months\\n self.assertEqual(len(r.result_data['records']), 16)\\n\\n # check 1st month\\n first_month = {'count': 15,\\n 'month_name': 'April',\\n 'month_name_short': 'Apr',\\n 'month_num': 4,\\n 'running_total': 15,\\n 'year_num': 2015,\\n 'yyyy_mm': '2015-04'}\\n self.assertEqual(dict(r.result_data['records'][0]), first_month)\\n\\n # check last month\\n last_month = {'count': 94,\\n 'month_name': 'July',\\n 'month_name_short': 'Jul',\\n 'month_num': 7,\\n 'running_total': 343,\\n 'year_num': 2016,\\n 'yyyy_mm': '2016-07'}\\n self.assertEqual(dict(r.result_data['records'][-1]), last_month)\",\n \"def test_results_success(self, affiliate_items):\\n success_count = 0\\n\\n updater = mock.Mock()\\n batch_job = BatchJob(affiliate_items, updater)\\n\\n for result in batch_job.run():\\n success_count += int(not result.is_error)\\n\\n assert success_count == 4\",\n \"def test_created_date_invalid(self):\\n thread1 = ThreadFactory()\\n PostFactory(thread=thread1)\\n\\n self.refresh()\\n\\n qs = {'a': 1, 'w': 4, 'format': 'json',\\n 'created': constants.INTERVAL_AFTER,\\n 'created_date': 'invalid'}\\n response = self.client.get(reverse('search.advanced'), qs)\\n eq_(1, json.loads(response.content)['total'])\",\n \"def find_error_days():\\n query = \\\"\\\"\\\"\\n SELECT all_requests.day,\\n (ROUND((error_requests.bad * 1000)/all_requests.good)/10)\\n AS percent\\n FROM all_requests\\n JOIN error_requests\\n ON all_requests.day = error_requests.day\\n WHERE ROUND((error_requests.bad * 1000)/all_requests.good) > 10\\n \\\"\\\"\\\"\\n results = psql_connection(query)\\n\\n print(\\\"Days with more than 1% errors\\\")\\n for result in results:\\n print '{date} - {errors} % errors'.format(\\n date=result[0].strftime('%B %d, %Y'), errors=result[1])\",\n \"def getnoofjobs(self):\\n select_noofjobs = (\\n \\\"select count(*) from public.jobs where latestjobversion=True \\\"\\n \\\"and insertdate between Date(%s) and Date(%s) \\\"\\n \\\"and (username not in (%s))\\\"\\n )\\n\\n\\n\\n self.pgcursor.execute(select_noofjobs, (self.startdate, self.enddate, self.adminusers))\\n\\n noofjobs = 0\\n count = self.pgcursor.fetchone()\\n if count is not None:\\n noofjobs = count[0]\\n\\n # print(str.format(\\\"total no of jobs: {0}\\\", noofjobs))\\n return noofjobs\",\n \"def getFailedJobs(self):\\n return self.__failedJobs\",\n \"def test_category_invalid(self):\\n # wiki and questions\\n ques = QuestionFactory(title=u'q1 audio')\\n ques.tags.add(u'desktop')\\n ans = AnswerFactory(question=ques)\\n AnswerVoteFactory(answer=ans, helpful=True)\\n\\n d1 = DocumentFactory(\\n title=u'd1 audio',\\n locale=u'en-US',\\n category=10,\\n is_archived=False,\\n tags=[u'desktop'])\\n ApprovedRevisionFactory(document=d1)\\n\\n self.refresh()\\n\\n qs = {'a': 1, 'w': 3, 'format': 'json', 'category': 'invalid'}\\n response = self.client.get(reverse('search.advanced'), qs)\\n eq_(2, json.loads(response.content)['total'])\",\n \"def test_validate_njobs():\\n with pytest.raises(ValueError):\\n validate_njobs(0.1)\\n with pytest.raises(ValueError):\\n validate_njobs(0)\\n\\n assert validate_njobs(1) == 1\\n assert validate_njobs(2) == 2\",\n \"def test_query_params_date(session, params, expected_number_of_hits):\\n result = get_search(session, params)\\n compare(result['total']['value'], expected_number_of_hits)\",\n \"def searched_per_day(df):\\n return df.groupby([pd.TimeGrouper('D')]).apply(lambda row: \\n len(row[row['action'] == 'searchResultPage']))\",\n \"def test_past_category(self):\\n create_category(category_name=\\\"Past category.\\\", days=-30)\\n response = self.client.get(reverse('closetclient:index'))\\n self.assertQuerysetEqual(response.context['latest_category_list'],['<Category: Past category.>']\\n )\",\n \"def test_query_train_jobs_with_exceeded_limit(self, client):\\n params = dict(offset=0, limit=1000)\\n url = get_url(BASE_URL, params)\\n response = client.get(url)\\n result = response.get_json()\\n assert result.get('error_code') == '50540002'\",\n \"def fetch_training(df, training_start, duration):\\n # if not dt.datetime.strptime(training_start, '%Y-%m-%d').weekday() < 5:\\n # print('Start date should be weekday!')\\n # return False\\n\\n dt_training_start = dt.datetime.strptime(training_start, '%Y-%m-%d')\\n dt_training_end = dt_training_start + dt.timedelta(days=duration)\\n try:\\n return df.loc[(df.date < dt_training_end) & (df.date >= dt_training_start)]\\n\\n except:\\n print('Error fetch_training')\\n return False\",\n \"def test_two_past_categorys(self):\\n create_category(category_name=\\\"Past Category 1.\\\", days=-30)\\n create_category(category_name=\\\"Past Category 2.\\\", days=-5)\\n response = self.client.get(reverse('closetclient:index'))\\n self.assertQuerysetEqual(\\n response.context['latest_category_list'],\\n ['<Category: Past Category 2.>', '<Category: Past Category 1.>']\\n )\",\n \"def n_count(category):\\r\\n sql = text('''\\r\\n WITH uniq AS (\\r\\n SELECT COUNT(app.id) FROM task, app\\r\\n LEFT OUTER JOIN category ON app.category_id=category.id\\r\\n WHERE\\r\\n category.short_name=:category\\r\\n AND app.hidden=0\\r\\n AND app.info LIKE('%task_presenter%')\\r\\n AND task.app_id=app.id\\r\\n GROUP BY app.id)\\r\\n SELECT COUNT(*) FROM uniq\\r\\n ''')\\r\\n\\r\\n results = db.engine.execute(sql, category=category)\\r\\n count = 0\\r\\n for row in results:\\r\\n count = row[0]\\r\\n return count\",\n \"def days_with_error() :\\n query = \\\"\\\"\\\"SELECT errorlogs.date,round(100.0*errorcount/logcount,2) As Percent FROM logs,errorlogs\\n WHERE logs.date=errorlogs.date AND errorcount>logcount/100\\\"\\\"\\\"\\n result = get_data(query)\\n print(\\\" 3. Days with more than 1% of error:\\\")\\n print(\\\"\\\")\\n for record in result :\\n print(' ' + str(record[0]) + ' '+ '-' + \\\" \\\" + str(record[1]) + '%'+ ' '+ 'errors')\\n print(\\\"\\\\t\\\")\",\n \"def counter(self) -> int:\\n return self._fail_counter\",\n \"def question_3():\\n cursor.execute(mostErrorDays)\\n output = cursor.fetchall()\\n return output\",\n \"def total_suspicious(cc): # pragma: no cover\\n cc.execute(\\\"\\\"\\\"SELECT DISTINCT DATE_FORMAT(git_commit.timestamp, '%Y-%m')\\n FROM git_commit\\\"\\\"\\\")\\n months = cc.fetchall()\\n results = []\\n for month in months:\\n month = month[0]\\n cc.execute(\\\"\\\"\\\"SELECT COUNT(*)\\n FROM review\\n INNER JOIN git_commit\\n ON review.review_url = git_commit.review_url\\n INNER JOIN commit_people\\n ON commit_people.git_commit_hash = git_commit.hash\\n LEFT JOIN (\\n SELECT review_url, COUNT(*) AS c\\n FROM review_people\\n WHERE type = 'lgtm'\\n GROUP BY review_url) lgtm_count\\n ON review.review_url = lgtm_count.review_url\\n WHERE lgtm_count.c = 0 OR lgtm_count.c IS NULL\\n AND commit_people.type = 'tbr'\\n AND YEAR(git_commit.timestamp) = %s\\n AND MONTH(git_commit.timestamp) = %s\\\"\\\"\\\" % (month[:4], month[5:]))\\n no_lgtm = cc.fetchone()\\n cc.execute(\\\"\\\"\\\"SELECT COUNT(*)\\n FROM git_commit\\n WHERE review_url IS NULL\\n AND YEAR(git_commit.timestamp) = %s\\n AND MONTH(git_commit.timestamp) = %s\\\"\\\"\\\" % (month[:4], month[5:]))\\n no_review = cc.fetchone()\\n result = int(no_lgtm[0]) + int(no_review[0])\\n results.append([month, result])\\n return results\",\n \"def test_get_job_executions(self):\\n url = '/%s/jobs/%d/executions/' % (self.api, self.job_1.id)\\n response = self.client.generic('GET', url)\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n\\n results = json.loads(response.content)\\n job_exe_count = results['count']\\n self.assertEqual(job_exe_count, 4)\\n #check that we order by descending exe_num\\n self.assertEqual(results['results'][0]['exe_num'], 4)\",\n \"def count(self):\\n # no auth?\\n return self.app.db.jobs.count()\",\n \"def test_400_if_questions_by_category_fails(self):\\n\\n # send request with category id 100\\n response = self.client().get('/categories/100/questions')\\n\\n # load response data\\n data = json.loads(response.data)\\n\\n # check response status code and message\\n self.assertEqual(response.status_code, 400)\\n self.assertEqual(data['success'], False)\\n self.assertEqual(data['message'], 'bad request')\",\n \"def test_polljobs_callcount(mock_status):\\n\\n jobs = {\\n \\\"jobone\\\": {\\n \\\"laststatus\\\": \\\"Running\\\",\\n \\\"scheduler\\\": \\\"LSF\\\",\\n \\\"jobid\\\": \\\"123456\\\"\\n },\\n \\\"jobtwo\\\": {\\n \\\"laststatus\\\": \\\"Queued\\\",\\n \\\"scheduler\\\": \\\"LSF\\\",\\n \\\"jobid\\\": \\\"123456\\\"\\n },\\n \\\"jobthree\\\": {\\n \\\"laststatus\\\": \\\"Submit Error\\\",\\n \\\"scheduler\\\": \\\"LSF\\\",\\n \\\"jobid\\\": \\\"123456\\\"\\n },\\n \\\"jobfour\\\": {\\n \\\"laststatus\\\": \\\"Waiting Submission\\\",\\n \\\"scheduler\\\": \\\"LSF\\\",\\n \\\"jobid\\\": \\\"123456\\\"\\n },\\n \\\"jobfive\\\": {\\n \\\"laststatus\\\": \\\"Finished\\\",\\n \\\"scheduler\\\": \\\"LSF\\\",\\n \\\"jobid\\\": \\\"123456\\\"\\n },\\n \\\"jobsix\\\": {\\n \\\"laststatus\\\": \\\"Complete\\\",\\n \\\"scheduler\\\": \\\"LSF\\\",\\n \\\"jobid\\\": \\\"123456\\\"\\n }\\n }\\n\\n mock_status.return_value = \\\"Running\\\"\\n returnval = _polljobs(jobs, False)\\n\\n assert mock_status.call_count == 2, \\\\\\n \\\"Should only be polling running and queued jobs\\\"\\n assert jobs[\\\"jobtwo\\\"][\\\"laststatus\\\"] == \\\"Running\\\"\\n assert returnval is True\",\n \"def test_past_category(self):\\n past_category = create_category(category_name='Past Category.', days=-5)\\n url = reverse('closetclient:detail', args=(past_category.id,))\\n response = self.client.get(url)\\n self.assertContains(response, past_category.category_name)\",\n \"def test_ehr_submission_data_cutoff(self, mock_get_affected_tables):\\n # mocks the return value of get_affected_tables as we only want to loop through the\\n # visit_occurrence not all of the CDM tables\\n mock_get_affected_tables.return_value = [common.VISIT_OCCURRENCE]\\n\\n queries = []\\n visit_occurrence_tmpl = self.jinja_env.from_string(\\\"\\\"\\\"\\n INSERT INTO `{{fq_dataset_name}}.{{cdm_table}}`\\n (visit_occurrence_id, person_id, visit_concept_id, visit_start_date, \\n visit_start_datetime, visit_end_date, visit_end_datetime, visit_type_concept_id)\\n VALUES\\n (111, 222, 3, date('2018-03-06'), timestamp('2018-03-06 11:00:00'), \\n date('2018-03-07'), timestamp('2018-03-07 11:00:00'), 4),\\n (222, 333, 3, date('2019-03-06'), timestamp('2019-03-06 11:00:00'), \\n date('2019-03-07'), timestamp('2019-03-07 11:00:00'), 4),\\n (333, 444, 3, date('2020-03-06'), timestamp('2020-03-06 11:00:00'), \\n date('2020-03-07'), timestamp('2020-03-07 11:00:00'), 4),\\n (444, 555, 3, date('2021-03-06'), timestamp('2021-03-06 11:00:00'), \\n date('2021-03-07'), timestamp('2021-03-07 11:00:00'), 4),\\n (555, 666, 3, date('2022-03-06'), timestamp('2022-03-06 11:00:00'), \\n date('2022-03-07'), timestamp('2022-03-07 11:00:00'), 4)\\n \\\"\\\"\\\").render(fq_dataset_name=self.fq_dataset_name,\\n cdm_table=common.VISIT_OCCURRENCE)\\n queries.append(visit_occurrence_tmpl)\\n\\n self.load_test_data(queries)\\n\\n table_and_counts = [{\\n 'fq_table_name':\\n '.'.join([self.fq_dataset_name, 'visit_occurrence']),\\n 'fq_sandbox_table_name':\\n f'{self.fq_sandbox_name}.{self.rule_instance.sandbox_table_for(common.VISIT_OCCURRENCE)}',\\n 'loaded_ids': [111, 222, 333, 444, 555],\\n 'sandboxed_ids': [444, 555],\\n 'fields': [\\n 'visit_occurrence_id', 'person_id', 'visit_concept_id',\\n 'visit_start_date', 'visit_start_datetime', 'visit_end_date',\\n 'visit_end_datetime', 'visit_type_concept_id'\\n ],\\n 'cleaned_values': [\\n (111, 222, 3, parse('2018-03-06').date(),\\n parse('2018-03-06 11:00:00 UTC'), parse('2018-03-07').date(),\\n parse('2018-03-07 11:00:00 UTC'), 4),\\n (222, 333, 3, parse('2019-03-06').date(),\\n parse('2019-03-06 11:00:00 UTC'), parse('2019-03-07').date(),\\n parse('2019-03-07 11:00:00 UTC'), 4),\\n (333, 444, 3, parse('2020-03-06').date(),\\n parse('2020-03-06 11:00:00 UTC'), parse('2020-03-07').date(),\\n parse('2020-03-07 11:00:00 UTC'), 4)\\n ]\\n }]\\n\\n self.default_test(table_and_counts)\",\n \"def get_fail_count(self):\\n return sum(1 for outcome in (r.outcome for r in self.values()) if outcome == Result.FAIL)\",\n \"def test_results_for_repo_with_weeks_ago(self):\\n result = self.simulate_get('/results/TEST/jenkinsfile-test', query_string='weeks_ago=1')\\n self.assertEqual(result.status_code, 200)\\n self.assertEqual(len(result.json['results']), 2)\",\n \"def run_tests():\\n passed_tests = 0\\n failed_tests = 0\\n for case in TEST_CASES:\\n start_date, end_date = [datetime.strptime(x, \\\"%d/%m/%Y\\\") for x in case[0]]\\n experiment = Experiment(start_date, end_date)\\n if experiment.duration() == case[1]:\\n result = \\\"passed\\\"\\n passed_tests += 1\\n else:\\n result = \\\"failed\\\"\\n failed_tests += 1\\n print(f\\\"\\\"\\\"{\\\"-\\\".join(case[0])}, {case[1]} days: Test {result}\\\"\\\"\\\")\\n\\n print(\\n f\\\"All tests completed\\\\n\\\"\\n f\\\"Number of tests passed: {passed_tests}\\\\n\\\"\\n f\\\"Number of tests failed: {failed_tests}\\\"\\n )\",\n \"def searched_per_day_by_group(df):\\n return df.groupby([pd.TimeGrouper('D'),\\n 'group']).apply(lambda row:\\n len(row[row['action'] == 'searchResultPage']))\",\n \"def test_course_unexpired_runs():\\n course = CourseFactory.create()\\n now = now_in_utc()\\n start_dates = [now, now + timedelta(days=-3)]\\n end_dates = [now + timedelta(hours=1), now + timedelta(days=-2)]\\n CourseRunFactory.create_batch(\\n 2,\\n course=course,\\n start_date=factory.Iterator(start_dates),\\n end_date=factory.Iterator(end_dates),\\n live=True,\\n )\\n\\n # Add a run that is not live and shouldn't show up in unexpired list\\n CourseRunFactory.create(\\n course=course, start_date=start_dates[0], end_date=end_dates[0], live=False\\n )\\n\\n assert len(course.unexpired_runs) == 1\\n course_run = course.unexpired_runs[0]\\n assert course_run.start_date == start_dates[0]\\n assert course_run.end_date == end_dates[0]\",\n \"def test_400_if_questions_by_category_fails(self):\\n # send request with category id 2020\\n category_id = 2020\\n res = self.client().get(f'/categories/{category_id}/questions')\\n data = json.loads(res.data)\\n # check response status code and message\\n self.assertEqual(res.status_code, 400)\\n self.assertEqual(data['success'], False)\\n self.assertEqual(data['message'], 'bad request')\",\n \"def days_with_request():\\n\\n # To print information\\n information_string = '3. Days with more than ' \\\\\\n '1% of request that lead to an error:\\\\n'\\n\\n # Query string\\n query = \\\"\\\"\\\"select * from (select date(time),\\n round(100.0*sum(case log.status\\n when '200 OK' then 0 else 1 end)/count(log.status),3)\\n as error from log group by date(time)\\n order by error desc) as subq where error > 1;\\\"\\\"\\\"\\n\\n print(information_string)\\n for result in query_db(query):\\n print('\\\\t{0:%B %d, %Y} - {1}%'.format(result[0], result[1]))\\n\\n print(\\\"\\\\n\\\")\",\n \"def test_can_create_job_category(self):\\n\\t\\tself.job_category.save()\\n\\t\\tjob_category_instance = JobCategory.objects.get(pk=1)\\n\\t\\tself.assertEqual(\\n\\t\\t\\tself.category,\\n\\t\\t\\tjob_category_instance.category,\\n\\t\\t\\t\\\"Job categories don't match.\\\"\\n\\t\\t)\",\n \"def test(self):\\n advisories = self.list_advisories(\\\"2016-10-1\\\")\\n self.after = datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n self.include_cvrf = True\\n\\n for a in advisories:\\n return self.process_advisory(a)\",\n \"def test_dates_and_Datetimes(self):\\n if self.skip_tests:\\n return\\n recipe = (\\n self.recipe()\\n .dimensions(\\\"year_by_format\\\")\\n .metrics(\\\"count\\\")\\n .order_by(\\\"year_by_format\\\")\\n )\\n self.assertRecipeCSV(\\n recipe,\\n \\\"\\\"\\\"\\n year_by_format,count,year_by_format_id\\n 2005-01-01 00:00:00,1,2005-01-01 00:00:00\\n 2013-01-01 00:00:00,1,2013-01-01 00:00:00\\n \\\"\\\"\\\",\\n )\\n recipe = (\\n self.recipe()\\n .dimensions(\\\"year_by_format\\\")\\n .metrics(\\\"count\\\")\\n .order_by(\\\"-year_by_format\\\")\\n )\\n self.assertRecipeCSV(\\n recipe,\\n \\\"\\\"\\\"\\n year_by_format,count,year_by_format_id\\n 2013-01-01 00:00:00,1,2013-01-01 00:00:00\\n 2005-01-01 00:00:00,1,2005-01-01 00:00:00\\n \\\"\\\"\\\",\\n )\\n\\n # Test a month() conversion\\n recipe = (\\n self.recipe()\\n .dimensions(\\\"test_month\\\")\\n .metrics(\\\"age\\\", \\\"count\\\")\\n .order_by(\\\"-test_month\\\")\\n )\\n self.assertRecipeCSV(\\n recipe,\\n \\\"\\\"\\\"\\n test_month,age,count,test_month_id\\n 2015-05-01,10,1,2015-05-01\\n 2015-01-01,5,1,2015-01-01\\n \\\"\\\"\\\",\\n )\",\n \"def compare_tool_results_count(tool_results, check, issue_type, known_count):\\n # logging.info(\\\"known_count=%s, check key=%s, tool_results=%s, issue_type=%s\\\",\\n # str(known_count), str(check), str(tool_results), str(issue_type))\\n return tool_results[check][issue_type] > known_count\",\n \"def test_unqualified_by_date(self):\\n to_date = datetime.today() - timedelta(days=2)\\n from_date = to_date.date() - timedelta(days=2)\\n consumer = Consumer.objects.get(id=103)\\n consumer.is_emailable = True\\n consumer.consumer_create_datetime = to_date - timedelta(days=1)\\n consumer.save()\\n result = UnqualifiedConsumerEmailTask().qry_unqualified_consumers(\\n from_date, to_date.date())\\n self.assertEqual(result.filter(id=103).count(), 1)\",\n \"def test_get_food_most_calories_smaller_population():\\n df_breakfast = df[df['Category'] == 'Breakfast']\\n\\n actual = get_food_most_calories(df_breakfast)\\n expected = 'Big Breakfast with Hotcakes (Large Biscuit)'\\n assert actual == expected\",\n \"def test_successful(self):\\n\\n url = '/%s/job-types/running/' % self.api\\n response = self.client.generic('GET', url)\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n\\n result = json.loads(response.content)\\n self.assertEqual(len(result['results']), 1)\\n self.assertEqual(result['results'][0]['job_type']['name'], self.job.job_type.name)\\n self.assertEqual(result['results'][0]['count'], 1)\\n self.assertIsNotNone(result['results'][0]['longest_running'])\",\n \"def test_query_train_jobs(self, client):\\n params = dict(offset=0, limit=10)\\n url = get_url(BASE_URL, params)\\n response = client.get(url)\\n result = response.get_json()\\n assert result.get('total') == SUMMARY_DIR_NUM\\n assert len(result.get('train_jobs')) == min(10, SUMMARY_DIR_NUM)\",\n \"def test_slack_notifier_on_failed_circle_ci_jobs():\\n from circle_ci_slack_notifier import (\\n CircleCIClient,\\n CircleCiFailedJobsParser,\\n construct_failed_jobs_slack_message,\\n )\\n\\n parser = CircleCiFailedJobsParser(\\n circle_client=CircleCIClient(), workflow_id=WORKFLOW_ID\\n )\\n assert construct_failed_jobs_slack_message(parser) == [\\n {\\n \\\"fallback\\\": \\\"Demisto SDK Master-Failure\\\",\\n \\\"color\\\": \\\"danger\\\",\\n \\\"title\\\": \\\"Demisto SDK Master-Failure\\\",\\n \\\"title_link\\\": \\\"https://app.circleci.com/pipelines/github/demisto/demisto-sdk//workflows/1\\\",\\n \\\"fields\\\": [\\n {\\n \\\"title\\\": \\\"Failed Circle-CI jobs - (3)\\\",\\n \\\"value\\\": \\\"run-unit-tests-3.9.10[pytest]\\\\nrun-integration-tests-3.9.10[pytest]\\\"\\n \\\"\\\\nvalidate-files[Test validate files and yaml]\\\",\\n \\\"short\\\": False,\\n },\\n {\\n \\\"title\\\": \\\"Failed unit-tests - (1)\\\",\\n \\\"value\\\": \\\"demisto_sdk.commands.common.content.tests.objects.pack_objects.abstract_pack_\\\"\\n \\\"objects.json_content_object_test.test_to_version_no_from_version\\\",\\n \\\"short\\\": False,\\n },\\n {\\n \\\"title\\\": \\\"Failed integration-tests - (1)\\\",\\n \\\"value\\\": \\\"demisto_sdk.tests.integration_tests.create_id_set_integration_test.\\\"\\n \\\"TestCreateIdSet.test_excluded_items_contain_aliased_field\\\",\\n \\\"short\\\": False,\\n },\\n {\\n \\\"title\\\": \\\"Failed files on validations - (2)\\\",\\n \\\"value\\\": \\\"Packs/ARIAPacketIntelligence/Integrations/ARIAPacketIntelligence/\\\"\\n \\\"ARIAPacketIntelligence.yml - [IN153]\\\\nPacks/AccentureCTI/Playbooks/\\\"\\n \\\"playbook-ACTI_Create_Report-Indicator_Associations.yml - [PB110]\\\",\\n \\\"short\\\": False,\\n },\\n ],\\n }\\n ]\",\n \"def test_404_total_categories_not_equals_seven(self):\\n res = self.client().get('/categories/7')\\n data = json.loads(res.data)\\n self.assertEqual(res.status_code, 404)\\n self.assertEqual(data['success'], False)\\n self.assertEqual(data['message'], 'Resource Not Found')\",\n \"def errors(job_name, jenkins_username, jenkins_token):\\n global server\\n# job_name = 'enterprise_pe-acceptance-tests_integration-system_pe_full-upgrade_weekend_2016.4.x' # 'enterprise_pe-orchestrator_intn-van-sys-pez-multi_2016.4.x-2016.4.x' # 'enterprise_pe-modules-vanagon-suite_intn-van-sys-pez-multi_daily-pe-modules-2016.4.x'\\n server = Jenkins('https://cinext-jenkinsmaster-enterprise-prod-1.delivery.puppetlabs.net', username=jenkins_username, password=jenkins_token)\\n info = server.get_job_info(job_name)\\n builds = [server.get_build_info(job_name, build['number']) for build in info['builds']]\\n failed_build_numbers = [b for b in builds if b['result'] == 'FAILURE']\\n last_job_errors = None\\n\\n counts = defaultdict(int)\\n similar = set()\\n for build in failed_build_numbers:\\n output = server.get_build_console_output(job_name, build['number'])\\n finder = get_strategy(output)\\n errors = finder(output)\\n print \\\"Errors: {}\\\".format(errors)\\n if last_job_errors:\\n seq = difflib.SequenceMatcher(a=last_job_errors, b=errors)\\n if seq.ratio() == 1.0:\\n counts['exact'] += 1\\n if seq.ratio() >= 0.7 and seq.ratio() < 1.0:\\n counts['similar'] += 1\\n similar.append(errors)\\n else:\\n last_job_errors = errors\\n\\n if last_job_errors:\\n click.echo('Last job errors were:')\\n click.echo('\\\\t{}'.format('\\\\n\\\\t'.join(last_job_errors)))\\n\\n if last_job_errors and 'exact' in counts:\\n click.echo('There were {} jobs that failed with errors exactly the same as the last failed job:'.format(counts['exact']))\\n click.echo('\\\\t{}'.format('\\\\n\\\\t'.join(last_job_errors)))\\n\\n if last_job_errors and 'similar' in counts:\\n click.echo('There were {} jobs that failed with experienced similar errors as the last failed job:'.format(counts['exact']))\\n click.echo('\\\\t{}'.format('\\\\n\\\\t'.join(last_job_errors)))\\n for s in similar:\\n click.echo('Additional Failed Job:')\\n click.echo('\\\\t{}'.format('\\\\n\\\\t'.join(s)))\",\n \"def _log_failed(cls, count):\\n MetricLogger.log_metric(FUNCTION_NAME, MetricLogger.SQS_FAILED_RECORDS, count)\",\n \"def test_categoryQuery(self) -> None:\\n result = self.entries.filter(category__iexact='suncare')\\n self.assertGreater(len(result), 0)\\n\\n result = self.entries.filter(category__iexact='xxxxxx')\\n self.assertEqual(len(result), 0)\",\n \"def test_get_questions_by_category(self):\\n\\n res = self.client().get('/categories/1/questions')\\n\\n data = json.loads(res.data)\\n\\n self.assertEqual(res.status_code, 200)\\n self.assertEqual(data['success'], True)\\n self.assertEqual(len(data['questions']), 3)\\n self.assertEqual(len(data['categories']), 6)\\n self.assertTrue(data['total_questions'])\\n self.assertTrue(data['current_category'])\",\n \"def test_get_refresh_job_status(self):\\n pass\",\n \"def problem_days(cursor):\\n days = 'None found'\\n try:\\n logs = \\\"\\\"\\\"select daily.day,\\n daily_total::integer/100,\\n daily_errors::integer,\\n daily_total\\n from daily_logs as daily, error_logs as errors\\n where (daily_total::integer/100.0) <\\n daily_errors::integer\\n and daily.day = errors.day\\n order by daily.day\\n \\\"\\\"\\\"\\n\\n cursor.execute(logs)\\n report = cursor.fetchall()\\n # If no days were found, return\\n if len(report) <= 0:\\n return days\\n\\n except psycopg2.Error as e:\\n print('Fetching summary of days with >1% error statuses: \\\\r\\\\n{}'\\n .format(e.pgerror))\\n\\n # If the query returns any days, return the results.\\n else:\\n day_str = ' {0} - {1}% of {2} were errors\\\\r\\\\n'\\n days = 'Days when over 1% of requests lead to errors: \\\\r\\\\n'\\n for date in report:\\n percentage_error = round((date[2]/date[1]), 2)\\n days += day_str.format(date[0].strftime('%d of %B %Y'),\\n percentage_error,\\n date[3])\\n return days\",\n \"def test_06_dataset_counts_published(self):\\n print (self.test_06_dataset_counts_published.__doc__)\\n\\n stats_maker = StatsMakerDatasets()\\n\\n r = stats_maker.get_dataset_counts_by_create_date_published()\\n\\n # check number of months\\n self.assertEqual(len(r.result_data['records']), 16)\\n\\n # check 1st month\\n first_month = {'count': 21,\\n 'month_name': 'April',\\n 'month_name_short': 'Apr',\\n 'month_num': 4,\\n 'running_total': 21,\\n 'year_num': 2015,\\n 'yyyy_mm': '2015-04'}\\n self.assertEqual(dict(r.result_data['records'][0]), first_month)\\n\\n # check last month\\n last_month = {'count': 4,\\n 'month_name': 'July',\\n 'month_name_short': 'Jul',\\n 'month_num': 7,\\n 'running_total': 227,\\n 'year_num': 2016,\\n 'yyyy_mm': '2016-07'}\\n self.assertEqual(dict(r.result_data['records'][-1]), last_month)\",\n \"def test_get_jobs_status(\\n globals, urls, client, mock_test_responses, context_fixture):\\n\\n context = context_fixture('Healthy')\\n mock_test_responses(task='upload', status=CoreStatus.DONE)\\n responses.add(\\n responses.GET, urls('task', 'upload'),\\n json={\\n '_id': globals['upload'],\\n 'status': CoreStatus.FAIL\\n },\\n status=200,\\n content_type='application/json')\\n\\n for i in range(2):\\n client.upload(file=globals['test_csv_file'], name=str(i))\\n\\n context.run()\\n job_fail = context.get_jobs_status(status=['fail'])\\n\\n assert job_fail.iloc[0]['status'] == 'fail'\\n assert job_fail.iloc[0]['Job'] == '1'\",\n \"def test_workflows_count_get(self):\\n pass\",\n \"def test_since(self):\\n self.create_logs(self.user1, num=50, start=self.year2000)\\n self.create_logs(self.user1, num=50, start=self.year2001)\\n\\n response = self.client.get(telemetry_url, {\\n 'since': self.year2001.isoformat(),\\n })\\n self.assertEqual(200, response.status_code)\\n\\n data = json.loads(response.content)\\n\\n # since is non-inclusive, so the first entry is not included\\n self.assertEqual(49, len(data))\\n\\n for entry in data:\\n time = iso8601.parse_date(entry['timestamp'])\\n self.assertGreater(time, self.year2001)\",\n \"def jobHealthy(self, count):\\n job = self.tester.submission_result.job\\n for idx in range(count - 1):\\n if (job.health == 'healthy'):\\n return True\\n print(\\\"health check fail : %d\\\" % idx )\\n time.sleep(1)\\n job.refresh()\\n self.assertEqual('healthy', job.health)\\n return False\",\n \"def test_was_published_recently_with_old_category(self):\\n time = timezone.now() - datetime.timedelta(days=1)\\n old_category = Category(pub_date=time)\\n self.assertIs(old_category.was_published_recently(), False)\",\n \"def test_results_with_weeks_ago(self):\\n result = self.simulate_get('/results/', query_string='weeks_ago=1')\\n self.assertEqual(result.status_code, 200)\\n self.assertEqual(len(result.json['results']), 2)\",\n \"def test_one_date(self):\\n result = beautiful_days_at_the_movies(10, 10, 6)\\n self.assertEquals(result, 0)\",\n \"def test_get_questions_by_category(self):\\n res = self.client().get('/api/categories/1/questions')\\n self.assertEqual(res.status_code, 200)\\n data = json.loads(res.data)\\n self.assertTrue(data[\\\"success\\\"])\\n self.assertTrue(data[\\\"questions\\\"])\\n self.assertTrue(data[\\\"total_questions\\\"])\",\n \"def test_course_available_runs():\\n user = UserFactory.create()\\n course = CourseFactory.create()\\n runs = CourseRunFactory.create_batch(2, course=course, live=True)\\n runs.sort(key=lambda run: run.start_date)\\n CourseRunEnrollmentFactory.create(run=runs[0], user=user)\\n assert course.available_runs(user) == [runs[1]]\\n assert course.available_runs(UserFactory.create()) == runs\",\n \"def test_nested_friendly_date_criteria(self):\\n # Add topic - future items\\n topic = self._ATCT\\n date_crit = topic.addCriterion('start', 'ATFriendlyDateCriteria')\\n date_crit.setValue(0)\\n date_crit.setDateRange('+') # This is irrelevant when the date is now\\n date_crit.setOperation('more')\\n # Add subtopic - past items\\n self.setRoles(['Manager', 'Member'])\\n topic.addSubtopic('qux')\\n self.setRoles(['Member'])\\n subtopic = topic.qux\\n date_crit = subtopic.addCriterion('end', 'ATFriendlyDateCriteria')\\n date_crit.setValue(0)\\n date_crit.setDateRange('-') # This is irrelevant when the date is now\\n date_crit.setOperation('less')\\n subtopic.setAcquireCriteria(True)\\n # fetch the query\\n query = subtopic.buildQuery()\\n self.assertTrue(query['end'])\\n # query shouldn't have a start key\\n # https://dev.plone.org/plone/ticket/8827\\n self.assertFalse('start' in query)\",\n \"def date_diagnostic(scenario, dates):\\n running = 0\\n with open(\\\"scenario%s_dates.txt\\\" % (scenario,), \\\"w\\\") as fp:\\n fp.write(\\\"date,total\\\\n\\\")\\n for date in pd.date_range(APR15, MAY30):\\n hits = [d for d in dates if d == date]\\n running += len(hits)\\n fp.write(\\\"%s,%s\\\\n\\\" % (date, running))\",\n \"def fail_counter(self) -> int:\\n return self._state_storage.counter\",\n \"def count_risk_categories_by_month(data, month, year):\\n return count_risk_categories(\\n filter_inspection_type(\\n filter_month(data, month, year), 'Routine - Unscheduled'))\",\n \"def test_08_dataset_counts_all(self):\\n print (self.test_08_dataset_counts_all.__doc__)\\n\\n stats_maker = StatsMakerDatasets()\\n\\n r = stats_maker.get_dataset_counts_by_create_date()\\n\\n # check number of months\\n self.assertEqual(len(r.result_data['records']), 16)\\n\\n # check 1st month\\n first_month = {'count': 36,\\n 'month_name': 'April',\\n 'month_name_short': 'Apr',\\n 'month_num': 4,\\n 'running_total': 36,\\n 'year_num': 2015,\\n 'yyyy_mm': '2015-04'}\\n self.assertEqual(dict(r.result_data['records'][0]), first_month)\\n\\n # check last month\\n last_month = {'count': 98,\\n 'month_name': 'July',\\n 'month_name_short': 'Jul',\\n 'month_num': 7,\\n 'running_total': 570,\\n 'year_num': 2016,\\n 'yyyy_mm': '2016-07'}\\n self.assertEqual(dict(r.result_data['records'][-1]), last_month)\",\n \"def test_list_activity_occurrences(self):\\n pass\",\n \"def error_report():\\n db, c = connect(DBNAME)\\n c.execute(\\\"select to_char(time,'FMMonth DD, YYYY') as date, \\\"\\n \\\"round((sum(case when status = '200 OK' \\\"\\n \\\"then 0 else 1 end)::decimal / count(*)) * 100,2) \\\"\\n \\\"as percent_error from log group by date \\\"\\n \\\"having (sum(case when status = '200 OK' \\\"\\n \\\"then 0 else 1 end)::decimal / count(*)) * 100 > 1\\\")\\n error_table = c.fetchall()\\n db.close()\\n print \\\"\\\\nDates on Which Over 1% of Requests Led to Errors:\\\"\\n for error in error_table:\\n if __name__ == '__main__':\\n print str(error[0]) + \\\" - \\\" + str(error[1]) + \\\"%\\\"\",\n \"def test_job_fail(self):\\n with self.settings(JOBS_ROOT=os.path.join(settings.BASE_DIR, \\\"extras/tests/dummy_jobs\\\")):\\n\\n module = \\\"test_fail\\\"\\n name = \\\"TestFail\\\"\\n job_class = get_job(f\\\"local/{module}/{name}\\\")\\n job_result = JobResult.objects.create(\\n name=job_class.class_path,\\n obj_type=self.job_content_type,\\n user=None,\\n job_id=uuid.uuid4(),\\n )\\n run_job(data={}, request=None, commit=False, job_result_pk=job_result.pk)\\n job_result.refresh_from_db()\\n self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_ERRORED)\",\n \"def test_questions_by_category(self):\\n\\n response = self.client().get('/categories/1/questions')\\n body = json.loads(response.data)\\n\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(body['success'], True)\\n self.assertNotEqual(len(body['questions']), 0)\\n self.assertNotEqual(len(body['category']), 'Science')\",\n \"def _first_good_date(self, day):\\n count = 0\\n while True:\\n try:\\n self.data.loc[day - timedelta(count)]\\n return day - timedelta(count)\\n except KeyError:\\n count += 1\",\n \"def test_successful(self):\\n\\n url = '/%s/jobs/' % self.api\\n response = self.client.generic('GET', url)\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n\\n result = json.loads(response.content)\\n self.assertEqual(len(result['results']), 3)\\n for entry in result['results']:\\n expected = None\\n if entry['id'] == self.job1.id:\\n expected = self.job1\\n elif entry['id'] == self.job2.id:\\n expected = self.job2\\n elif entry['id'] == self.job3.id:\\n expected = self.job3\\n else:\\n self.fail('Found unexpected result: %s' % entry['id'])\\n self.assertEqual(entry['job_type']['name'], expected.job_type.name)\\n self.assertEqual(entry['job_type_rev']['job_type']['id'], expected.job_type.id)\\n self.assertEqual(entry['is_superseded'], expected.is_superseded)\",\n \"def test_results_for_project_with_weeks_ago(self):\\n result = self.simulate_get('/results/TEST', query_string='weeks_ago=1')\\n self.assertEqual(result.status_code, 200)\\n self.assertEqual(len(result.json['results']), 2)\",\n \"def testreportFailureToDashboard(self):\\n self.assertEqual(0, reportFailureToDashboard(0, None))\\n # parseAd is called by reportFailureToDashboard, but if we would\\n # call it from reportFailureToDashboard error will be suppressed\\n # and it will return same exit code\\n # So lets call it directly\\n if '_CONDOR_JOB_AD' in os.environ:\\n del os.environ[\\\"_CONDOR_JOB_AD\\\"]\\n self.assertRaises(KeyError, parseAd)\\n self.assertEqual(0, reportFailureToDashboard(0))\\n os.environ[\\\"_CONDOR_JOB_AD\\\"] = \\\"testFile\\\"\\n # if this environment variable is set, it will check this file\\n # if file is not present, it will raise IOError\\n self.assertRaises(IOError, parseAd)\\n # Test real job_ad file and check if it returns dict.\\n os.environ[\\\"_CONDOR_JOB_AD\\\"] = os.path.join(getTestBase(), '..', 'data', 'WMCore', 'Services', 'Dashboard', 'job_ad_file')\\n out = parseAd()\\n self.assertTrue(isinstance(out, dict))\\n # Also test it sending directly parsed job ad\\n self.assertEqual(0, reportFailureToDashboard(0, out))\",\n \"def test_calculate_working_days():\\n assert (\\n calculate_working_days(parse('2020-01-01'), parse('2020-03-31')) == 64\\n )\",\n \"def totaled_total_suspicious(cc, sql_time_specification): # pragma: no cover\\n cc.execute(\\\"\\\"\\\"SELECT COUNT(*)\\n FROM review\\n INNER JOIN git_commit\\n ON review.review_url = git_commit.review_url\\n INNER JOIN commit_people\\n ON commit_people.git_commit_hash = git_commit.hash\\n LEFT JOIN (\\n SELECT review_url, COUNT(*) AS c\\n FROM review_people\\n WHERE type = 'lgtm'\\n GROUP BY review_url) lgtm_count\\n ON review.review_url = lgtm_count.review_url\\n WHERE lgtm_count.c = 0 OR lgtm_count.c IS NULL\\n AND commit_people.type = 'tbr' AND %s\\\"\\\"\\\" % sql_time_specification)\\n no_lgtm = cc.fetchone()\\n cc.execute(\\\"\\\"\\\"SELECT COUNT(*)\\n FROM git_commit\\n WHERE review_url IS NULL AND %s\\\"\\\"\\\" % sql_time_specification)\\n no_review = cc.fetchone()\\n result = int(no_lgtm[0]) + int(no_review[0])\\n return result\",\n \"def test_get_certification_deadline(database):\\n sess = database.session\\n quart_sub = SubmissionFactory(submission_id=1, reporting_fiscal_year=2020, reporting_fiscal_period=6,\\n is_fabs=False, is_quarter_format=True)\\n month_sub = SubmissionFactory(submission_id=2, reporting_fiscal_year=2020, reporting_fiscal_period=10,\\n is_fabs=False, is_quarter_format=False)\\n fail_sub = SubmissionFactory(submission_id=3, reporting_fiscal_year=2020, reporting_fiscal_period=9,\\n is_fabs=False, is_quarter_format=False)\\n fabs_sub = SubmissionFactory(submission_id=4, reporting_fiscal_year=2020, reporting_fiscal_period=6,\\n is_fabs=True, is_quarter_format=False)\\n q2 = SubmissionWindowScheduleFactory(period=6, year=2020)\\n p10 = SubmissionWindowScheduleFactory(period=10, year=2020)\\n sess.add_all([quart_sub, month_sub, fail_sub, fabs_sub, q2, p10])\\n\\n # Pass cases\\n assert get_certification_deadline(quart_sub) == q2.certification_deadline.date()\\n assert get_certification_deadline(month_sub) == p10.certification_deadline.date()\\n # Fail cases\\n assert get_certification_deadline(fail_sub) is None\\n assert get_certification_deadline(fabs_sub) is None\",\n \"def test_valid_n_jobs(n_jobs: Any) -> None:\\n check_n_jobs(n_jobs)\",\n \"def test_check_freq_crashed(self):\\n self.assertEqual(check_freq(self.jobset2), 'fcrashed')\",\n \"def test_batch_create_occurrences(self):\\n pass\",\n \"def test_01_stats_dates(self):\\r\\n today = unicode(datetime.date.today())\\r\\n with self.flask_app.test_request_context('/'):\\r\\n dates, dates_n_tasks, dates_anon, dates_auth = stats.stats_dates(1)\\r\\n err_msg = \\\"There should be 10 answers today\\\"\\r\\n assert dates[today] == 10, err_msg\\r\\n err_msg = \\\"There should be 100 answers per day\\\"\\r\\n assert dates_n_tasks[today] == 100, err_msg\\r\\n err_msg = \\\"The SUM of answers from anon and auth users should be 10\\\"\\r\\n assert (dates_anon[today] + dates_auth[today]) == 10, err_msg\",\n \"def test_set_activity_occurrence_results(self):\\n pass\",\n \"def failure_rate_for_test_suite(self, test_suite_name):\\n bot_response = \\\"\\\"\\n\\n log.info(f\\\"Fetching feature name from codeceptjs script: {test_suite_name}\\\")\\n # converting label to test script path + file name\\n test_label = test_suite_name.split(\\\"-\\\")\\n test_script = \\\"suites/\\\" + test_label[1] + \\\"/\\\" + test_label[2] + \\\".js\\\"\\n\\n try:\\n # try to find the test script that corresponds to the test suite name\\n test_script_source = self._get_test_script_source(test_script)\\n except Exception as err:\\n log.error(str(err))\\n return str(err)\\n\\n log.debug(f\\\"Looking for the name of the feature in: {test_script}\\\")\\n try:\\n feature_name = self._get_feature_name_from_source(test_script_source)\\n except Exception as err:\\n log.error(str(err))\\n return str(err)\\n\\n influxlib = self.get_influxlib()\\n data_points = influxlib.query_ci_metrics(\\n \\\"fail_count\\\", {\\\"suite_name\\\": feature_name}\\n )\\n if data_points:\\n # crunch numbers here\\n test_suite_failures = {}\\n\\n # iterate through influxdb's data points obtained from query response\\n for point in data_points:\\n # initialize nested-dictionary of PRs inside the repo_name key if it is not yet created\\n if point[\\\"repo_name\\\"] not in test_suite_failures:\\n test_suite_failures[point[\\\"repo_name\\\"]] = {}\\n\\n # Count failed PRs per repo_name\\n repo_key = test_suite_failures[point[\\\"repo_name\\\"]]\\n repo_key.__setitem__(\\n point[\\\"pr_num\\\"], int(repo_key[point[\\\"pr_num\\\"]]) + 1\\n ) if point[\\\"pr_num\\\"] in repo_key else repo_key.__setitem__(\\n point[\\\"pr_num\\\"], 1\\n )\\n\\n log.debug(f\\\"### ## FINAL test_suite_failures: {test_suite_failures}\\\")\\n\\n # prepare bot response\\n bot_response += (\\n f\\\":information_source: The test suite {test_suite_name} failed:\\\\n\\\"\\n )\\n bot_response += \\\"```\\\"\\n # each row of the report should print a msg similar to:\\n # - 1 time(s) on PR-123 from repo myRepo\\n for repo_name, prs in test_suite_failures.items():\\n for pr_num, failure_count in prs.items():\\n bot_response += f\\\"- {failure_count} time(s) on PR-{pr_num} from repo {repo_name}\\\\n\\\"\\n bot_response += \\\"```\\\"\\n else:\\n bot_response += (\\n \\\"could not find any `fail_count` metrics for this test suite :shrug:\\\"\\n )\\n\\n return bot_response\",\n \"def test_metrics_since_history(self):\\n\\n slug = \\\"test-slug\\\"\\n years = 5\\n link_type = \\\"history\\\"\\n now = datetime(2014, 7, 4)\\n\\n module = 'redis_metrics.templatetags.redis_metric_tags.datetime'\\n with patch(module) as mock_datetime:\\n mock_datetime.utcnow.return_value = now\\n\\n result = taglib.metrics_since(slug, years, link_type)\\n self.assertIn('link_type', result.keys())\\n self.assertIn('slug_values', result.keys())\\n self.assertEqual(result['link_type'], link_type)\\n\\n # Verify contents of `slug_values`\\n # There should be entries for each year + 5 additional periods.\\n expected = [\\n (slug, now - timedelta(days=1), \\\"Today\\\", 'daily'),\\n (slug, now - timedelta(days=7), \\\"1 Week\\\", 'daily'),\\n (slug, now - timedelta(days=30), \\\"30 Days\\\", 'daily'),\\n (slug, now - timedelta(days=60), \\\"60 Days\\\", 'daily'),\\n (slug, now - timedelta(days=90), \\\"90 Days\\\", 'daily'),\\n (slug, now - timedelta(days=365), \\\"1 Years\\\", 'daily'),\\n (slug, now - timedelta(days=365 * 2), \\\"2 Years\\\", 'daily'),\\n (slug, now - timedelta(days=365 * 3), \\\"3 Years\\\", 'daily'),\\n (slug, now - timedelta(days=365 * 4), \\\"4 Years\\\", 'daily'),\\n (slug, now - timedelta(days=365 * 5), \\\"5 Years\\\", 'daily'),\\n ]\\n self.assertEqual(expected, result['slug_values'])\",\n \"def count_risk_categories(data):\\n results = Counter([row['risk_category'] for row in data])\\n if '' in results:\\n results['No Violations'] = results['']\\n del results['']\\n return results\",\n \"def __calculate_emptiness (self, scheduling_unit):\\n difference = 0\\n \\n for date in self.workers.get_dates ( ):\\n for person in self.mapper.get_all_people ( ):\\n for turnus in self.mapper.get_turnuses (scheduling_unit, person):\\n if person.is_scheduled_exact (scheduling_unit, turnus, date):\\n difference += 1\\n \\n needed = self.workers.get_workers_by_type (date, scheduling_unit, turnus)\\n \\n difference -= needed\\n return difference\",\n \"def test_successful(self):\\n\\n url = '/%s/job-types/' % self.api\\n response = self.client.get(url)\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n\\n result = json.loads(response.content)\\n self.assertEqual(len(result['results']), 6)\\n for entry in result['results']:\\n expected = None\\n if entry['name'] == self.job_type1.name:\\n expected = self.job_type1\\n elif entry['name'] == self.job_type2.name:\\n expected = self.job_type2\\n elif entry['name'] == self.job_type3.name:\\n expected = self.job_type3\\n elif entry['name'] == self.job_type6.name:\\n if entry['version'] == self.job_type4.version:\\n expected = self.job_type4\\n elif entry['version'] == self.job_type5.version:\\n expected = self.job_type5\\n elif entry['version'] == self.job_type6.version:\\n expected = self.job_type6\\n else:\\n self.assertTrue(False, 'unexpected job type!')\\n else:\\n self.fail('Found unexpected result: %s' % entry['id'])\\n\\n self.assertEqual(entry['name'], expected.name)\\n self.assertEqual(entry['title'], expected.get_title())\\n self.assertEqual(entry['description'], expected.get_description())\\n self.assertEqual(entry['icon_code'], expected.icon_code)\\n self.assertEqual(entry['is_published'], expected.is_published)\\n self.assertEqual(entry['is_active'], expected.is_active)\\n self.assertEqual(entry['is_paused'], expected.is_paused)\\n self.assertEqual(entry['is_system'], expected.is_system)\\n self.assertEqual(entry['max_scheduled'], expected.max_scheduled)\\n self.assertEqual(entry['revision_num'], expected.revision_num)\\n self.assertEqual(entry['docker_image'], expected.docker_image)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5813953","0.5470477","0.5436561","0.5431106","0.5430519","0.5358405","0.5351436","0.5340761","0.5265007","0.52533865","0.52142894","0.51785016","0.512772","0.50592387","0.50564986","0.5048593","0.50406694","0.5030915","0.5024704","0.5023085","0.50163347","0.500575","0.5004526","0.49818915","0.49803784","0.4965496","0.49607524","0.495687","0.49560797","0.49470124","0.4942441","0.4937785","0.49305353","0.49304283","0.49304104","0.49181506","0.49027586","0.49021935","0.48998353","0.48909748","0.48887694","0.48715886","0.4859976","0.48551846","0.4839348","0.48299727","0.48150465","0.4811772","0.48071107","0.47869924","0.4779023","0.47764823","0.47758836","0.47707945","0.47694394","0.47652027","0.47630888","0.47519782","0.47363827","0.47340074","0.4729618","0.47242036","0.4721359","0.47201616","0.47147506","0.4712637","0.4711244","0.4710903","0.47084606","0.47068426","0.47040254","0.47006544","0.46994558","0.46986693","0.46967688","0.46966186","0.46947226","0.46903172","0.46891716","0.46773493","0.46762145","0.4673549","0.46708673","0.46702194","0.46644816","0.46642262","0.46616158","0.4660519","0.46564177","0.4651805","0.4649352","0.464405","0.46418026","0.4640433","0.46397445","0.46367717","0.4635261","0.46276775","0.46245924","0.46227536"],"string":"[\n \"0.5813953\",\n \"0.5470477\",\n \"0.5436561\",\n \"0.5431106\",\n \"0.5430519\",\n \"0.5358405\",\n \"0.5351436\",\n \"0.5340761\",\n \"0.5265007\",\n \"0.52533865\",\n \"0.52142894\",\n \"0.51785016\",\n \"0.512772\",\n \"0.50592387\",\n \"0.50564986\",\n \"0.5048593\",\n \"0.50406694\",\n \"0.5030915\",\n \"0.5024704\",\n \"0.5023085\",\n \"0.50163347\",\n \"0.500575\",\n \"0.5004526\",\n \"0.49818915\",\n \"0.49803784\",\n \"0.4965496\",\n \"0.49607524\",\n \"0.495687\",\n \"0.49560797\",\n \"0.49470124\",\n \"0.4942441\",\n \"0.4937785\",\n \"0.49305353\",\n \"0.49304283\",\n \"0.49304104\",\n \"0.49181506\",\n \"0.49027586\",\n \"0.49021935\",\n \"0.48998353\",\n \"0.48909748\",\n \"0.48887694\",\n \"0.48715886\",\n \"0.4859976\",\n \"0.48551846\",\n \"0.4839348\",\n \"0.48299727\",\n \"0.48150465\",\n \"0.4811772\",\n \"0.48071107\",\n \"0.47869924\",\n \"0.4779023\",\n \"0.47764823\",\n \"0.47758836\",\n \"0.47707945\",\n \"0.47694394\",\n \"0.47652027\",\n \"0.47630888\",\n \"0.47519782\",\n \"0.47363827\",\n \"0.47340074\",\n \"0.4729618\",\n \"0.47242036\",\n \"0.4721359\",\n \"0.47201616\",\n \"0.47147506\",\n \"0.4712637\",\n \"0.4711244\",\n \"0.4710903\",\n \"0.47084606\",\n \"0.47068426\",\n \"0.47040254\",\n \"0.47006544\",\n \"0.46994558\",\n \"0.46986693\",\n \"0.46967688\",\n \"0.46966186\",\n \"0.46947226\",\n \"0.46903172\",\n \"0.46891716\",\n \"0.46773493\",\n \"0.46762145\",\n \"0.4673549\",\n \"0.46708673\",\n \"0.46702194\",\n \"0.46644816\",\n \"0.46642262\",\n \"0.46616158\",\n \"0.4660519\",\n \"0.46564177\",\n \"0.4651805\",\n \"0.4649352\",\n \"0.464405\",\n \"0.46418026\",\n \"0.4640433\",\n \"0.46397445\",\n \"0.46367717\",\n \"0.4635261\",\n \"0.46276775\",\n \"0.46245924\",\n \"0.46227536\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7530706"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83695,"cells":{"query":{"kind":"string","value":"Test getting a user from the database."},"document":{"kind":"string","value":"def test_get_user(user_store: MockStore, user_email: str):\n # GIVEN a database with a user\n\n # WHEN querying for a user\n user: User = user_store.get_user(email=user_email)\n\n # THEN it should be returned\n assert user.email == user_email"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def testGetUser(self):\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\n user = getUser(u'user')\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n result = yield self.facade.getUser(session, u'user')\n self.assertEqual(u'user', result.username)\n self.assertEqual(str(user.objectID), result.objectId)\n self.assertEqual(u'User', result.name)\n self.assertEqual(u'USER', result.role)","def test_get(self):\n user = api.user.create(\n username='chuck',\n email='chuck@norris.org',\n password='secret',\n )\n\n self.assertEqual(api.user.get('chuck'), user)","def test_get_user_by_username(self):\n\t\tusername_in_db = server.get_user_by_username('Natasha')\n\t\tself.assertTrue(username_in_db, 'Query did not fetch user object.')\n\t\tusername_not_in_db = server.get_user_by_username('xyz')\n\t\tself.assertFalse(username_not_in_db, 'Query fetched user that did not exist (xyz).')","def test_get_user(self):\n user = User(self.client, \"test-user\", {})\n\n self.assertEqual(user.username, \"test-user\")\n self.assertEqual(user.email, \"test-user@linode.com\")\n self.assertTrue(user.restricted)\n self.assertTrue(user.tfa_enabled)\n self.assertIsNotNone(user.ssh_keys)","def test_user(self):\n u = self.d.user('example')\n self.assertEqual(u.username, 'example')\n self.assertEqual(u.name, 'Example Sampleman')","def test_003_get_user(self, mock_db_query):\n mock_db_query.get.return_value = seller1\n\n response = self.app.get('/v1/users/' + str(seller1.identity), headers={'accept': 'application/json'})\n\n print(response.get_data().decode())\n\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response.json['first_name'], 'Lisa')","def test_get_user(self):\n print('(' + self.test_get_user.__name__+')', self.test_get_user.__doc__)\n # test for patient\n self.assertDictContainsSubset(\n self.connection.get_user(PATIENT_USERNAME), PATIENT)\n # test for doctor\n self.assertDictContainsSubset(\n self.connection.get_user(DOCTOR_USERNAME), DOCTOR)","def test_retrive_user(self):\n res = self.client.get(ME_URL)\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(res.data['email'], self.user.email)\n self.assertEqual(res.data['name'], self.user.name)\n self.assertNotIn('password', res.data)","def test_get_user(sample_user):\n\n client = auth_client(APIClient(), sample_user.email, \"testpassword\")\n\n response = client.get(reverse(\"user-detail\"), format=\"json\")\n assert response.status_code == status.HTTP_200_OK\n assert json.dumps(response.data) == json.dumps(\n {\"id\": sample_user.pk, \"email\": sample_user.email}\n )","def test_api_user_get(self):\n pass","def test_getUser(self):\n\t\turl = \"/users/2/\"\n\t\tresponse = self.client.get(url, format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\tself.assertEqual(response.data[\"id\"], 2)\n\t\tself.assertEqual(response.data[\"username\"], \"testUser2\")","def test_user(app, client, session, models, tokens):\n response = client.get(\n \"/user\", headers={\"Authorization\": f\"Bearer {tokens['read']}\"}\n )\n assert response.status_code == 200\n\n # Verify returned data against the database\n user_id = jwt.decode(\n tokens[\"read\"], app.config[\"RSA_PUBLIC_KEY\"], app.config[\"ALGORITHM\"],\n )[\"usr\"]\n user = User.query.filter(User.id == user_id).one()\n assert user.first_name == response.json[\"first_name\"]\n assert user.last_name == response.json[\"last_name\"]\n assert user.email == response.json[\"email\"]","def test_get(self, db_session: Session, get_user: Callable, attribute: str, db_column: Column) -> None:\n user_service = get_user_service(db_session)\n user = get_user(db_session)\n assert db_session.query(Users).filter(db_column == getattr(user, attribute)).one()\n\n response = user_service.get_user_info({\"id\": user.id})\n\n assert response == {\n \"status\": \"success\",\n \"code\": 200,\n \"data\": {\n \"user_id\": user.id,\n },\n }","def test_get_single_user(self):\n user = add_user(\"neilb\", \"neilb14@mailinator.com\")\n with self.client:\n response = self.client.get(f'/users/{user.id}')\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 200)\n self.assertTrue('created_at' in data['data'])\n self.assertIn('neilb', data['data']['username'])\n self.assertIn('neilb14@mailinator.com', data['data']['email'])\n self.assertIn('success', data['status'])","def test_user(self):\n\n user = User.query.filter(User.user_fname == \"Smokey\").first()\n self.assertEqual(user.user_fname, \"Smokey\")","def test_user_get(self):\r\n expected_user = UserFactory.create()\r\n # Test GET all users\r\n res = self.app.get('/api/user')\r\n data = json.loads(res.data)\r\n user = data[0]\r\n assert len(data) == 1, data\r\n assert user['name'] == expected_user.name, data\r\n\r\n # The output should have a mime-type: application/json\r\n assert res.mimetype == 'application/json', res\r\n\r\n # Test GETting a specific user by ID\r\n res = self.app.get('/api/user/1')\r\n data = json.loads(res.data)\r\n user = data\r\n assert user['name'] == expected_user.name, data\r\n\r\n # Test a non-existant ID\r\n res = self.app.get('/api/user/3434209')\r\n err = json.loads(res.data)\r\n assert res.status_code == 404, err\r\n assert err['status'] == 'failed', err\r\n assert err['target'] == 'user', err\r\n assert err['exception_cls'] == 'NotFound', err\r\n assert err['action'] == 'GET', err","def test_fetch_user(self):\n\n self.register_user()\n\n self.assertEqual(self.fetch_user_details().status_code, 200)\n\n self.assertTrue(self.fetch_user_details(\n ).json[\"data\"][0][\"username\"] == 'Bjorn')","def test_user(self):\n user = User.objects.get(username=\"test01\")\n print(user.username)\n print(user.email)\n self.assertEqual(user.email,\"test01@email.com\")\n # cat = Animal.objects.get(name=\"cat\")\n # self.assertEqual(lion.speak(), 'The lion says \"roar\"')\n # self.assertEqual(cat.speak(), 'The cat says \"meow\"')","def test_login(self):\n username = \"user1\"\n password = \"pw1\"\n userID = 1\n data = db.session.query(User.id).filter_by(username = username, password = password).first()\n self.assertTrue(data is not None)","def test_user_id_get(self):\n pass","def test_get_website_user_returns_user(self):\n user = get_website_user()\n self.assertTrue(user)","def test_get_user(\n self,\n mixin,\n mdb,\n muser_query,\n get_user,\n mrequest,\n mdecoded_jwt,\n ):\n mquery = muser_query.return_value\n\n assert get_user(\n mixin, dbsession=mdb) == mquery.get_by_id.return_value\n mquery.get_by_id.assert_called_once_with(sentinel.user_id)","def test_users_get(self):\n pass","def test_users_get(self):\n pass","def test_UserFromDB():\n assert UserFromDB(\"DIANE\").email == \"d@gmail.com\"\n assert UserFromDB(\"DIANE\").username == \"DIANE\"","def test_user_retrieve(self):\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.get_token())\n response = self.client.get(reverse(\"account:user-profile\"))\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data.get('user').get('email'), \"testuser@gmail.com\")","def test_get_users(user_store: MockStore, user_email: str, username: str):\n # GIVEN a database with a user\n\n # WHEN getting users\n users: List[User] = user_store.get_users(name=username, email=user_email)\n\n # THEN the user should be returned\n assert users[0].email == user_email","def test_get_username(self):\r\n user = UserMgr.get(username=u'admin')\r\n self.assertEqual(\r\n user.id,\r\n 1,\r\n \"Should have a user id of 1: \" + str(user.id))\r\n self.assertEqual(\r\n user.username,\r\n 'admin',\r\n \"Should have a username of admin: \" + user.username)","def test_get_user_by_name(self):\n\n # Select on empty set\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\n self.assertFalse(selected.success)\n self.assertIsNone(selected.documents)\n\n # Insert user\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertTrue(inserted.success)\n\n # Select user by username\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\n self.assertTrue(selected.success)\n self.assertEqual(selected.documents, MAGEN_USER)","def test_user_instance(self):\n db.session.add(self.user)\n db.session.commit()\n\n user = User.query.filter_by(user_name = \"john_doe\").first()\n users = User.query.all()\n\n self.assertTrue(len(users) > 0)\n self.assertEqual(user.user_name, \"john_doe\")\n self.assertEqual(user.email, \"johndoe@example.com\")\n self.assertEqual(user.profile_pic_path, \"app/static/images\")\n self.assertEqual(user.first_name, \"John\")\n self.assertEqual(user.last_name, \"Doe\")\n self.assertEqual(user.headline, \"Food Blogger\")\n self.assertEqual(user.bio, \"Mainly writes on Chinese cuisine\")","def test_get_user_info_returns_user(self, db_mock):\n repo = Repository()\n db_instance = db_mock.return_value\n db_instance.get_user_info.return_value = (1, {\"name\": \"Kari\"})\n self.assertEquals(repo.get_user_info(\"123\"), (1, {\"name\": \"Kari\"}))","def test_get_by_id(self):\n\n user = CustomUser.get_by_id(2)\n expected_user = CustomUser.objects.get(id=2)\n self.assertEqual(user, expected_user)","def getTestUser():\n allUsers = User.objects.all()\n if len(allUsers) > 0 :\n return allUsers[0]\n else :\n return User.objects.create_user(username='profiletester',\n email='profiletester@mapstorytests.com',\n password='superduperpassword2000')","def test_users_username_get(self):\n pass","def test_get_user_by_uuiduser_uuid_get(self):\n pass","def user_for_test(db_setup):\n db_setup.cur.execute(\n \"\"\"\n SELECT row_to_json(u) \n FROM( SELECT id, first_name, last_name, username FROM users WHERE username = %s LIMIT 1)\n u\n \"\"\", (\"test123\",))\n test_user = db_setup.cur.fetchone()[0]\n return test_user","def test_insert_get_user(self):\n\n # Select a user on an empty set\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\n self.assertFalse(selected.success)\n self.assertIsNone(selected.documents)\n\n # Inserting user into Database\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertTrue(inserted.success)\n\n # Verify that document was inserted\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\n self.assertTrue(selected.success)\n self.assertEqual(selected.documents, MAGEN_USER)\n\n # Inserting same user again (uuid and e-mail should be unique)\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertFalse(inserted.success)\n self.assertIn('user_uuid', inserted.message)","def test_get_user_by_id_non_admin(client: FlaskClient, db_session) -> None:\n username = create_random_username()\n populate_database_with_users(db_session, username)\n # Users with matching username in auth token are allowed to make\n # the request\n user = GifSyncUser.get_by_username(username)\n assert user is not None\n auth_token = create_auth_token(username)\n response = get_user(client, username, auth_token.signed)\n assert response.status_code == HTTPStatus.OK\n assert_user_in_response(response)\n # User retrieved matches the user in database\n json_data: dict = response.get_json()\n user_data = json_data.get(\"user\")\n assert isinstance(user_data, dict)\n assert user_data.get(\"id\") == user.id\n assert user_data.get(\"username\") == user.username\n assert isinstance(user_data.get(\"gifs\"), list)\n assert len(user_data[\"gifs\"]) == len(user.gifs)","def test_get_user_id(self):\n print('(' + self.test_get_user_id.__name__+')',\n self.test_get_user_id.__doc__)\n # for patient\n self.assertEqual(\n PATIENT_ID, self.connection.get_user_id(PATIENT_USERNAME))\n # for doctor\n self.assertEqual(\n DOCTOR_ID, self.connection.get_user_id(DOCTOR_USERNAME))","def test_get_users(self):\n pass","def test_resource_user_resource_get_user_get(self):\n pass","def test_get_user_by_id_admin(client: FlaskClient, db_session) -> None:\n username = create_random_username()\n admin_username = create_random_username()\n populate_database_with_users(db_session, username)\n user = GifSyncUser.get_by_username(username)\n assert user is not None\n # Admin users are allowed to make the request\n auth_token = create_auth_token(admin_username, admin=True)\n response = get_user(client, username, auth_token.signed)\n assert response.status_code == HTTPStatus.OK\n assert_user_in_response(response)\n # User retrieved matches the user in database\n json_data: dict = response.get_json()\n user_data = json_data.get(\"user\")\n assert isinstance(user_data, dict)\n assert user_data.get(\"id\") == user.id\n assert user_data.get(\"username\") == user.username\n assert isinstance(user_data.get(\"gifs\"), list)\n assert len(user_data[\"gifs\"]) == len(user.gifs)","def test_good_user(self):\n user = self.datautils.create_user()\n self.request.user = user\n self.request.matchdict = {'user_id': int(user.id)}\n result = user_id_get_view(self.request)['d']\n expected = {\n 'id': user.id,\n 'username': user.username,\n 'created': user.created,\n 'email': user.email,\n }\n self.assertEqual(result, expected)","def test_get_id(self):\r\n # the migration adds an initial admin user to the system\r\n user = UserMgr.get(user_id=1)\r\n self.assertEqual(\r\n user.id,\r\n 1,\r\n \"Should have a user id of 1: \" + str(user.id))\r\n self.assertEqual(\r\n user.username,\r\n 'admin',\r\n \"Should have a username of admin: \" + user.username)","def test_create_user(self):\n User.objects.create_user(username='abc', password='abcpass', email='abc@example.com')\n user_obj = User.objects.get(username='abc')\n self.assertTrue(user_obj.email, \"abc@example.com\")\n self.assertEqual(str(user_obj), \"abc\")","def test_get_bad_user(self):\r\n user = UserMgr.get(username=u'noexist')\r\n\r\n self.assertEqual(\r\n user,\r\n None,\r\n \"Should not find a non-existant user: \" + str(user))","def test_read_user(self):\n pass","def test_correct_user(self):\n\n self.create_user('Henrik', 1)\n self.create_user('Henrik2', 2)\n self.create_user('Test', 3)\n\n resp = self.client.get('/api/users/Henrik/')\n self.assertEquals(resp.json['total-users'], 2)","def get_user(id):\n pass","def test_logged_user_data(self, test_client, init_database, insert_user_db):\n login_url = '/api/v1/auth/login'\n login_data = {\n 'email': insert_user_db.email,\n 'password': 'password'\n }\n login_response = test_client.post(login_url, json=login_data)\n\n url = '/api/v1/auth/me'\n headers = {\n 'Authorization': 'Bearer {}'.format(login_response.json['access'])\n }\n response = test_client.get(url, headers=headers)\n\n assert response.status_code == 200\n assert response.json['id'] is not None\n assert response.json['name'] == insert_user_db.name\n assert response.json['email'] == insert_user_db.email","def test_010_query_users(self):\n\n testflow.step(\"Querying for users\")\n assert self.query_cli.run(what='user')[0], \"Failed to search for users\"","def test_get_user_exists(self):\n # First make the user\n resp = self.app.post('/users', data=json.dumps(self.test_user1_data))\n assert resp.status_code == 200\n\n # Now get the user data and verify it is correct\n resp = self.app.get('/users/{}'.format(self.test_user1_userid))\n assert resp.status_code == 200\n data = json.loads(resp.data)\n for key in ['first_name', 'last_name', 'userid', 'groups']:\n assert key in data\n assert data['first_name'] == self.test_user1_first\n assert data['last_name'] == self.test_user1_last\n assert data['userid'] == self.test_user1_userid\n for groupid in self.test_user1_groups:\n assert groupid in data['groups']","def test_get_users_no_username(user_store: MockStore, user_email: str):\n # GIVEN a database with a user\n\n # WHEN getting users\n users: List[User] = user_store.get_users(email=user_email)\n\n # THEN the user should be returned\n assert users[0].email == user_email","def test_get_for_user_no_user(self):\n self.assertIsNone(Tour.objects.get_for_user(User()))","def testGetUserIgnoresCase(self):\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n result = yield self.facade.getUser(session, u'uSeR')\n self.assertEqual(u'user', result.username)","def test_detail(self, client, users):\n user = users[0]\n url = reverse('users:detail', args=(user.pk,))\n response = client.get(url)\n assert response.status_code == 200\n assert user.username in str(response.content)","def test_user_by_username(self):\n username = make_user(self.client)['username']\n resp = self.client.get('/user/'+username,\n headers=api_headers())\n json_resp = json.loads(resp.data.decode('utf-8'))\n self.assertEqual(json_resp['status'], 'user found')\n self.assertEqual(json_resp['user']['username'], username)","def test_get_user_by_emailuser_email_get(self):\n pass","def test_gets_user_by_email(self):\r\n User.objects.create(email='another_user@example.com')\r\n desired_user = User.objects.create(email='edith@example.com')\r\n found_user = PasswordlessAuthenticationBackend().get_user('edith@example.com')\r\n self.assertEqual(desired_user, found_user)","def test_resource_user_resource_get_current_user_get(self):\n pass","def test_user(self):\n return True","def test_known_user(self):\n self.sign_in()\n u = User.objects.create(first_name = \"David\",\n last_name = 'Smith',\n password='******',\n email='david.smith@mom.com',\n phone_number='012-345-6789')\n response = self.client.get(reverse('backend:user_details', args=(u.pk,)))\n self.assertEqual(response.status_code, 200)\n self.assertDictEqual(response.json(), u.json_detail())","def test_check_user(self):\n self.new_user.save_user()\n test_user = User(\"Test\", \"user\", \"test\", \"walIas15\")\n test_user.save_user()\n test_user.check_user(\"test\", \"walIas15\")","def test_find_user_by_username(self):\n self.new_user.save_user()\n test_user = User(\"Test\", \"user\", \"test\", \"walIas15\")\n test_user.save_user()\n user_exists = User.user_exist(\"test\")\n self.assertTrue(user_exists)","def test_user_username_get(self):\n response = self.client.open('//user/{username}'.format(username='username_example'),\n method='GET')\n self.assert200(response, \"Response body is : \" + response.data.decode('utf-8'))","def testGet(self):\n userdict = {'id': 1,\n 'objectID': u'04585bec-28cf-4a21-bc3e-081f3ed62680',\n 'username': u'testuser',\n 'passwordHash': 'hash',\n 'fullname': u'Test User',\n 'email': u'test@example.com',\n 'role': Role.ANONYMOUS.id}\n self.cache.set('user:testuser', json.dumps(userdict))\n result = self.userCache.get(u'testuser')\n user = result.results\n self.assertEqual(1, user.id)\n self.assertEqual('04585bec-28cf-4a21-bc3e-081f3ed62680',\n str(user.objectID))\n self.assertEqual(u'testuser', user.username)\n self.assertEqual('hash', user.passwordHash)\n self.assertEqual(u'Test User', user.fullname)\n self.assertEqual(u'test@example.com', user.email)\n self.assertEqual(Role.ANONYMOUS, user.role)","def test_show(self):\n\n with self.client as c:\n response = c.get(f\"/users/{self.testuser.id}\")\n\n self.assertEqual(response.status_code, 200)\n self.assertIn(\"@alice\", str(response.data))","def test_get_users(self):\n print('(' + self.test_get_users.__name__+')',\n self.test_get_users.__doc__)\n users = self.connection.get_users()\n # Check we get right size of users table\n self.assertEqual(len(users), INITIAL_USERS_COUNT)\n # check PATIENT and DOCTOR data with users object we got\n for user in users:\n if user['username'] == PATIENT_USERNAME:\n self.assertDictContainsSubset(user, PATIENT['public_profile'])\n elif user['username'] == DOCTOR_USERNAME:\n self.assertDictContainsSubset(user, DOCTOR['public_profile'])","def testCreateIsAllowed(self):\n self.users.create([(u'user', u'secret', u'User', u'user@example.com')])\n user = getUser(u'user')\n self.assertEqual(u'user', user.username)","def test_get_by_id(self):\n with self.client:\n self.client.post('/users/login', data=dict(\n username=\"eschoppik\", password='secret'\n ), follow_redirects=True)\n self.assertTrue(current_user.id == 1)\n self.assertFalse(current_user.id == 20)","def test_resource_user_resource_get_user_by_email_address_get(self):\n pass","def test_retrieve_profile(self):\n\n response = self.client.get(URL_ME)\n\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n\n # Check that the user object returns as expected. There is no need\n # (and it is not secure) to return a password to client side.\n self.assertEqual(response.data, {\n 'name': self.user.name,\n 'email': self.user.email\n })","def test_create_user(self):\n data = {\n \"firstname\": \"John\",\n \"lastname\": \"Doe\",\n \"password\": \"supersecret\",\n \"password_repeat\": \"supersecret\",\n }\n res = self.post(url=\"/users\", data=data)\n self.assertEqual(res.status_code, 200)\n self.assertIn(b\"Created user.\", res.data)\n\n user = User.query.filter_by(id=6).first()\n self.assertTrue(user)\n self.assertEqual(user.firstname, \"John\")\n self.assertEqual(user.lastname, \"Doe\")\n self.assertFalse(user.is_verified)","def test_get_single_user_no_id(self):\n add_user(\"neilb\", \"neilb14@mailinator.com\")\n with self.client:\n response = self.client.get('/users/blah')\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 404)\n self.assertIn('User does not exist', data['message'])\n self.assertIn('fail', data['status'])","def test_get_user_info(self):\n \n name = app.get_user_info(\"skullphish\", name=True)\n vocab_count = app.get_user_info(\"skullphish\", vocab_count=True)\n userId = app.get_user_info(\"skullphish\", userId=True)\n \n self.assertTrue(name == \"damian rodbari\")\n self.assertEqual(vocab_count,0)\n self.assertTrue(userId == ObjectId(\"5bb8a0c006f1f8105bc3bb23\"))","def test_user_info(self):\n fake_fetchall = MagicMock()\n fake_fetchall.return_value = [(1234, 5678)]\n db = database.Database()\n db._cursor.fetchall = fake_fetchall\n\n info = db.user_info('sally')\n expected = (1234, 5678)\n\n self.assertEqual(info, expected)","def test_get_users(self):\n users = app.get_users()\n self.assertEqual(len(users), 1)","def test_create_and_retrieve_user(client):\n new_user_name = TEST_USER_NAME\n new_user_pass = TEST_USER_PASS\n post_response = create_user(\n client,\n new_user_name,\n new_user_pass)\n assert post_response.status_code == HttpStatus.created_201.value\n assert User.query.count() == 1\n\n post_response_data = json.loads(post_response.get_data(as_text=True))\n assert post_response_data['name'] == new_user_name\n\n new_user_url = post_response_data['url']\n get_response = client.get(\n new_user_url,\n headers=get_authentication_headers(new_user_name, new_user_pass))\n assert get_response.status_code == HttpStatus.ok_200.value\n\n get_response_data = json.loads(get_response.get_data(as_text=True))\n assert get_response_data['name'] == new_user_name","def test_getuser(self):\n # scenario 1: with @ starting in name and extid\n crusoe = self.fixtures.crusoe\n service_twitter = 'twitter'\n oauth_token = environ.get('TWITTER_OAUTH_TOKEN')\n oauth_token_type = 'Bearer' # NOQA: S105\n externalid = models.UserExternalId(\n service=service_twitter,\n user=crusoe,\n userid=crusoe.email.email,\n username=crusoe.username,\n oauth_token=oauth_token,\n oauth_token_type=oauth_token_type,\n )\n db.session.add(externalid)\n db.session.commit()\n result1 = models.getuser('@crusoe')\n self.assertIsInstance(result1, models.User)\n self.assertEqual(result1, crusoe)\n\n # scenario 2: with @ in name and not extid\n d_email = 'd@dothraki.vly'\n daenerys = models.User(\n username='daenerys', fullname=\"Daenerys Targaryen\", email=d_email\n )\n daenerys_email = models.UserEmail(email=d_email, user=daenerys)\n db.session.add_all([daenerys, daenerys_email])\n db.session.commit()\n result2 = models.getuser(d_email)\n self.assertIsInstance(result2, models.User)\n self.assertEqual(result2, daenerys)\n result3 = models.getuser('@daenerys')\n self.assertIsNone(result3)\n\n # scenario 3: with no @ starting in name, check by UserEmailClaim\n j_email = 'jonsnow@nightswatch.co.uk'\n jonsnow = models.User(username='jonsnow', fullname=\"Jon Snow\")\n jonsnow_email_claimed = models.UserEmailClaim(email=j_email, user=jonsnow)\n db.session.add_all([jonsnow, jonsnow_email_claimed])\n db.session.commit()\n result4 = models.getuser(j_email)\n self.assertIsInstance(result4, models.User)\n self.assertEqual(result4, jonsnow)\n\n # scenario 5: with no @ anywhere in name, fetch username\n arya = models.User(username='arya', fullname=\"Arya Stark\")\n db.session.add(arya)\n db.session.commit()\n result5 = models.getuser('arya')\n self.assertEqual(result5, arya)\n\n # scenario 6: with no starting with @ name and no UserEmailClaim or UserEmail\n cersei = models.User(username='cersei', fullname=\"Cersei Lannister\")\n db.session.add(cersei)\n db.session.commit()\n result6 = models.getuser('cersei@thelannisters.co.uk')\n self.assertIsNone(result6)","def testGetUserWithoutData(self):\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n deferred = self.facade.getUser(session, u'unknown')\n error = yield self.assertFailure(deferred, TNoSuchUser)\n self.assertEqual(u'unknown', error.name)","def test_resource_user_resource_find_users_get(self):\n pass","def test_get_user_if_exists(self):\n user = User.objects.create(username=self.username)\n actual = get_user_if_exists(None, self.details, user=user)\n self.assertDictEqual(actual, {'is_new': False})","def test_api_can_get_users_by_id(self):\n rv = self.client().post('/api/v1/user/', \n data = self.req)\n\n res = self.client().get('/api/v1/user/3')\n self.assertEquals(res.status_code, 200)","def test_get_user_when_non_existing(user_store: MockStore):\n # GIVEN a database with a user\n\n # WHEN querying for a user that doesn't exist\n user: User = user_store.get_user(email=\"this_is_a_made_up_email@fake_example.com\")\n\n # THEN it should return as None\n assert user is None","def test_user_auth(self):\n self.new_user.save_login()\n test_user=User(\"trinity\",\"trinity@gmail.com\",\"123\")\n test_user.save_login()\n self.assertTrue(self.new_user.users_auth(\"trinity\",\"123\"))","def test_create_simple_user(self):\n payload = {\n 'email': 'test@mail.com',\n 'password': 'password231',\n 'name': 'vasia'\n }\n\n res = self.client.post(CREATE_USER_URL, payload)\n\n u = get_user_model().objects.get(**res.data)\n\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\n self.assertTrue(u.check_password(self.payload['password']))\n self.assertEqual(u.email, self.payload['email'])","def test_user_view(self):\n with self.app.app_context():\n u = user(save=True)\n\n response = self.client.get('/user/%s' % u.slug)\n eq_(response.status_code, 200)\n\n response = self.client.get('/user/not-a-real-user')\n eq_(response.status_code, 404)","def test_get_website_user_returns_same_user(self):\n user = get_website_user()\n self.assertEqual(get_website_user(), user)","def test_user_get_profile():\n app = create_ctfd()\n with app.app_context():\n register_user(app)\n client = login_as_user(app)\n r = client.get('/profile')\n assert r.status_code == 200\n destroy_ctfd(app)","def test_set_up(self):\n try:\n user = User.objects.get(username = USERNAME)\n except:\n self.assertFalse(True, 'Error retrieving %s from database' %USERNAME)\n\n self.assertEquals(user.first_name, FIRST_NAME)\n self.assertEquals(user.last_name, LAST_NAME)\n self.assertEquals(user.email, EMAIL)","def test_database():\n User = get_user_model()\n assert User.objects.count() == 0\n User.objects.create(username='dummy', email='dummy@example.com')\n assert User.objects.count() == 1","def setUp(self):\n user = Users.query.first()","def user(email):\r\n return User.objects.get(email=email)","def get_one_user():","def get(self, no):\n user = get_a_user(no)\n if not user:\n api.abort(404)\n else:\n return user","def test_get_by_id_false(self):\n\n user = CustomUser.get_by_id(44444)\n\n self.assertIsNone(user)","def get_user_details():\n rv = query_db('select * from user')\n return rv[0] if rv else None","def test_create_user(self):\n user = User(\"Gideon Bamuleseyo\", \"gideon@mail.com\", \"secret\")\n self.assertEqual(user.name, \"Gideon Bamuleseyo\")\n self.assertEqual(user.email, \"gideon@mail.com\")\n self.assertEqual(user.password, \"secret\")","def get_user(self, user_id):\n uri = 'users/' + user_id\n return self.make_request(uri)","def test_createUser_single(self):\n #TODO: this and other tests"],"string":"[\n \"def testGetUser(self):\\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\\n user = getUser(u'user')\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n result = yield self.facade.getUser(session, u'user')\\n self.assertEqual(u'user', result.username)\\n self.assertEqual(str(user.objectID), result.objectId)\\n self.assertEqual(u'User', result.name)\\n self.assertEqual(u'USER', result.role)\",\n \"def test_get(self):\\n user = api.user.create(\\n username='chuck',\\n email='chuck@norris.org',\\n password='secret',\\n )\\n\\n self.assertEqual(api.user.get('chuck'), user)\",\n \"def test_get_user_by_username(self):\\n\\t\\tusername_in_db = server.get_user_by_username('Natasha')\\n\\t\\tself.assertTrue(username_in_db, 'Query did not fetch user object.')\\n\\t\\tusername_not_in_db = server.get_user_by_username('xyz')\\n\\t\\tself.assertFalse(username_not_in_db, 'Query fetched user that did not exist (xyz).')\",\n \"def test_get_user(self):\\n user = User(self.client, \\\"test-user\\\", {})\\n\\n self.assertEqual(user.username, \\\"test-user\\\")\\n self.assertEqual(user.email, \\\"test-user@linode.com\\\")\\n self.assertTrue(user.restricted)\\n self.assertTrue(user.tfa_enabled)\\n self.assertIsNotNone(user.ssh_keys)\",\n \"def test_user(self):\\n u = self.d.user('example')\\n self.assertEqual(u.username, 'example')\\n self.assertEqual(u.name, 'Example Sampleman')\",\n \"def test_003_get_user(self, mock_db_query):\\n mock_db_query.get.return_value = seller1\\n\\n response = self.app.get('/v1/users/' + str(seller1.identity), headers={'accept': 'application/json'})\\n\\n print(response.get_data().decode())\\n\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response.json['first_name'], 'Lisa')\",\n \"def test_get_user(self):\\n print('(' + self.test_get_user.__name__+')', self.test_get_user.__doc__)\\n # test for patient\\n self.assertDictContainsSubset(\\n self.connection.get_user(PATIENT_USERNAME), PATIENT)\\n # test for doctor\\n self.assertDictContainsSubset(\\n self.connection.get_user(DOCTOR_USERNAME), DOCTOR)\",\n \"def test_retrive_user(self):\\n res = self.client.get(ME_URL)\\n\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(res.data['email'], self.user.email)\\n self.assertEqual(res.data['name'], self.user.name)\\n self.assertNotIn('password', res.data)\",\n \"def test_get_user(sample_user):\\n\\n client = auth_client(APIClient(), sample_user.email, \\\"testpassword\\\")\\n\\n response = client.get(reverse(\\\"user-detail\\\"), format=\\\"json\\\")\\n assert response.status_code == status.HTTP_200_OK\\n assert json.dumps(response.data) == json.dumps(\\n {\\\"id\\\": sample_user.pk, \\\"email\\\": sample_user.email}\\n )\",\n \"def test_api_user_get(self):\\n pass\",\n \"def test_getUser(self):\\n\\t\\turl = \\\"/users/2/\\\"\\n\\t\\tresponse = self.client.get(url, format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\tself.assertEqual(response.data[\\\"id\\\"], 2)\\n\\t\\tself.assertEqual(response.data[\\\"username\\\"], \\\"testUser2\\\")\",\n \"def test_user(app, client, session, models, tokens):\\n response = client.get(\\n \\\"/user\\\", headers={\\\"Authorization\\\": f\\\"Bearer {tokens['read']}\\\"}\\n )\\n assert response.status_code == 200\\n\\n # Verify returned data against the database\\n user_id = jwt.decode(\\n tokens[\\\"read\\\"], app.config[\\\"RSA_PUBLIC_KEY\\\"], app.config[\\\"ALGORITHM\\\"],\\n )[\\\"usr\\\"]\\n user = User.query.filter(User.id == user_id).one()\\n assert user.first_name == response.json[\\\"first_name\\\"]\\n assert user.last_name == response.json[\\\"last_name\\\"]\\n assert user.email == response.json[\\\"email\\\"]\",\n \"def test_get(self, db_session: Session, get_user: Callable, attribute: str, db_column: Column) -> None:\\n user_service = get_user_service(db_session)\\n user = get_user(db_session)\\n assert db_session.query(Users).filter(db_column == getattr(user, attribute)).one()\\n\\n response = user_service.get_user_info({\\\"id\\\": user.id})\\n\\n assert response == {\\n \\\"status\\\": \\\"success\\\",\\n \\\"code\\\": 200,\\n \\\"data\\\": {\\n \\\"user_id\\\": user.id,\\n },\\n }\",\n \"def test_get_single_user(self):\\n user = add_user(\\\"neilb\\\", \\\"neilb14@mailinator.com\\\")\\n with self.client:\\n response = self.client.get(f'/users/{user.id}')\\n data = json.loads(response.data.decode())\\n self.assertEqual(response.status_code, 200)\\n self.assertTrue('created_at' in data['data'])\\n self.assertIn('neilb', data['data']['username'])\\n self.assertIn('neilb14@mailinator.com', data['data']['email'])\\n self.assertIn('success', data['status'])\",\n \"def test_user(self):\\n\\n user = User.query.filter(User.user_fname == \\\"Smokey\\\").first()\\n self.assertEqual(user.user_fname, \\\"Smokey\\\")\",\n \"def test_user_get(self):\\r\\n expected_user = UserFactory.create()\\r\\n # Test GET all users\\r\\n res = self.app.get('/api/user')\\r\\n data = json.loads(res.data)\\r\\n user = data[0]\\r\\n assert len(data) == 1, data\\r\\n assert user['name'] == expected_user.name, data\\r\\n\\r\\n # The output should have a mime-type: application/json\\r\\n assert res.mimetype == 'application/json', res\\r\\n\\r\\n # Test GETting a specific user by ID\\r\\n res = self.app.get('/api/user/1')\\r\\n data = json.loads(res.data)\\r\\n user = data\\r\\n assert user['name'] == expected_user.name, data\\r\\n\\r\\n # Test a non-existant ID\\r\\n res = self.app.get('/api/user/3434209')\\r\\n err = json.loads(res.data)\\r\\n assert res.status_code == 404, err\\r\\n assert err['status'] == 'failed', err\\r\\n assert err['target'] == 'user', err\\r\\n assert err['exception_cls'] == 'NotFound', err\\r\\n assert err['action'] == 'GET', err\",\n \"def test_fetch_user(self):\\n\\n self.register_user()\\n\\n self.assertEqual(self.fetch_user_details().status_code, 200)\\n\\n self.assertTrue(self.fetch_user_details(\\n ).json[\\\"data\\\"][0][\\\"username\\\"] == 'Bjorn')\",\n \"def test_user(self):\\n user = User.objects.get(username=\\\"test01\\\")\\n print(user.username)\\n print(user.email)\\n self.assertEqual(user.email,\\\"test01@email.com\\\")\\n # cat = Animal.objects.get(name=\\\"cat\\\")\\n # self.assertEqual(lion.speak(), 'The lion says \\\"roar\\\"')\\n # self.assertEqual(cat.speak(), 'The cat says \\\"meow\\\"')\",\n \"def test_login(self):\\n username = \\\"user1\\\"\\n password = \\\"pw1\\\"\\n userID = 1\\n data = db.session.query(User.id).filter_by(username = username, password = password).first()\\n self.assertTrue(data is not None)\",\n \"def test_user_id_get(self):\\n pass\",\n \"def test_get_website_user_returns_user(self):\\n user = get_website_user()\\n self.assertTrue(user)\",\n \"def test_get_user(\\n self,\\n mixin,\\n mdb,\\n muser_query,\\n get_user,\\n mrequest,\\n mdecoded_jwt,\\n ):\\n mquery = muser_query.return_value\\n\\n assert get_user(\\n mixin, dbsession=mdb) == mquery.get_by_id.return_value\\n mquery.get_by_id.assert_called_once_with(sentinel.user_id)\",\n \"def test_users_get(self):\\n pass\",\n \"def test_users_get(self):\\n pass\",\n \"def test_UserFromDB():\\n assert UserFromDB(\\\"DIANE\\\").email == \\\"d@gmail.com\\\"\\n assert UserFromDB(\\\"DIANE\\\").username == \\\"DIANE\\\"\",\n \"def test_user_retrieve(self):\\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.get_token())\\n response = self.client.get(reverse(\\\"account:user-profile\\\"))\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data.get('user').get('email'), \\\"testuser@gmail.com\\\")\",\n \"def test_get_users(user_store: MockStore, user_email: str, username: str):\\n # GIVEN a database with a user\\n\\n # WHEN getting users\\n users: List[User] = user_store.get_users(name=username, email=user_email)\\n\\n # THEN the user should be returned\\n assert users[0].email == user_email\",\n \"def test_get_username(self):\\r\\n user = UserMgr.get(username=u'admin')\\r\\n self.assertEqual(\\r\\n user.id,\\r\\n 1,\\r\\n \\\"Should have a user id of 1: \\\" + str(user.id))\\r\\n self.assertEqual(\\r\\n user.username,\\r\\n 'admin',\\r\\n \\\"Should have a username of admin: \\\" + user.username)\",\n \"def test_get_user_by_name(self):\\n\\n # Select on empty set\\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\\n self.assertFalse(selected.success)\\n self.assertIsNone(selected.documents)\\n\\n # Insert user\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertTrue(inserted.success)\\n\\n # Select user by username\\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\\n self.assertTrue(selected.success)\\n self.assertEqual(selected.documents, MAGEN_USER)\",\n \"def test_user_instance(self):\\n db.session.add(self.user)\\n db.session.commit()\\n\\n user = User.query.filter_by(user_name = \\\"john_doe\\\").first()\\n users = User.query.all()\\n\\n self.assertTrue(len(users) > 0)\\n self.assertEqual(user.user_name, \\\"john_doe\\\")\\n self.assertEqual(user.email, \\\"johndoe@example.com\\\")\\n self.assertEqual(user.profile_pic_path, \\\"app/static/images\\\")\\n self.assertEqual(user.first_name, \\\"John\\\")\\n self.assertEqual(user.last_name, \\\"Doe\\\")\\n self.assertEqual(user.headline, \\\"Food Blogger\\\")\\n self.assertEqual(user.bio, \\\"Mainly writes on Chinese cuisine\\\")\",\n \"def test_get_user_info_returns_user(self, db_mock):\\n repo = Repository()\\n db_instance = db_mock.return_value\\n db_instance.get_user_info.return_value = (1, {\\\"name\\\": \\\"Kari\\\"})\\n self.assertEquals(repo.get_user_info(\\\"123\\\"), (1, {\\\"name\\\": \\\"Kari\\\"}))\",\n \"def test_get_by_id(self):\\n\\n user = CustomUser.get_by_id(2)\\n expected_user = CustomUser.objects.get(id=2)\\n self.assertEqual(user, expected_user)\",\n \"def getTestUser():\\n allUsers = User.objects.all()\\n if len(allUsers) > 0 :\\n return allUsers[0]\\n else :\\n return User.objects.create_user(username='profiletester',\\n email='profiletester@mapstorytests.com',\\n password='superduperpassword2000')\",\n \"def test_users_username_get(self):\\n pass\",\n \"def test_get_user_by_uuiduser_uuid_get(self):\\n pass\",\n \"def user_for_test(db_setup):\\n db_setup.cur.execute(\\n \\\"\\\"\\\"\\n SELECT row_to_json(u) \\n FROM( SELECT id, first_name, last_name, username FROM users WHERE username = %s LIMIT 1)\\n u\\n \\\"\\\"\\\", (\\\"test123\\\",))\\n test_user = db_setup.cur.fetchone()[0]\\n return test_user\",\n \"def test_insert_get_user(self):\\n\\n # Select a user on an empty set\\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\\n self.assertFalse(selected.success)\\n self.assertIsNone(selected.documents)\\n\\n # Inserting user into Database\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertTrue(inserted.success)\\n\\n # Verify that document was inserted\\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\\n self.assertTrue(selected.success)\\n self.assertEqual(selected.documents, MAGEN_USER)\\n\\n # Inserting same user again (uuid and e-mail should be unique)\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertFalse(inserted.success)\\n self.assertIn('user_uuid', inserted.message)\",\n \"def test_get_user_by_id_non_admin(client: FlaskClient, db_session) -> None:\\n username = create_random_username()\\n populate_database_with_users(db_session, username)\\n # Users with matching username in auth token are allowed to make\\n # the request\\n user = GifSyncUser.get_by_username(username)\\n assert user is not None\\n auth_token = create_auth_token(username)\\n response = get_user(client, username, auth_token.signed)\\n assert response.status_code == HTTPStatus.OK\\n assert_user_in_response(response)\\n # User retrieved matches the user in database\\n json_data: dict = response.get_json()\\n user_data = json_data.get(\\\"user\\\")\\n assert isinstance(user_data, dict)\\n assert user_data.get(\\\"id\\\") == user.id\\n assert user_data.get(\\\"username\\\") == user.username\\n assert isinstance(user_data.get(\\\"gifs\\\"), list)\\n assert len(user_data[\\\"gifs\\\"]) == len(user.gifs)\",\n \"def test_get_user_id(self):\\n print('(' + self.test_get_user_id.__name__+')',\\n self.test_get_user_id.__doc__)\\n # for patient\\n self.assertEqual(\\n PATIENT_ID, self.connection.get_user_id(PATIENT_USERNAME))\\n # for doctor\\n self.assertEqual(\\n DOCTOR_ID, self.connection.get_user_id(DOCTOR_USERNAME))\",\n \"def test_get_users(self):\\n pass\",\n \"def test_resource_user_resource_get_user_get(self):\\n pass\",\n \"def test_get_user_by_id_admin(client: FlaskClient, db_session) -> None:\\n username = create_random_username()\\n admin_username = create_random_username()\\n populate_database_with_users(db_session, username)\\n user = GifSyncUser.get_by_username(username)\\n assert user is not None\\n # Admin users are allowed to make the request\\n auth_token = create_auth_token(admin_username, admin=True)\\n response = get_user(client, username, auth_token.signed)\\n assert response.status_code == HTTPStatus.OK\\n assert_user_in_response(response)\\n # User retrieved matches the user in database\\n json_data: dict = response.get_json()\\n user_data = json_data.get(\\\"user\\\")\\n assert isinstance(user_data, dict)\\n assert user_data.get(\\\"id\\\") == user.id\\n assert user_data.get(\\\"username\\\") == user.username\\n assert isinstance(user_data.get(\\\"gifs\\\"), list)\\n assert len(user_data[\\\"gifs\\\"]) == len(user.gifs)\",\n \"def test_good_user(self):\\n user = self.datautils.create_user()\\n self.request.user = user\\n self.request.matchdict = {'user_id': int(user.id)}\\n result = user_id_get_view(self.request)['d']\\n expected = {\\n 'id': user.id,\\n 'username': user.username,\\n 'created': user.created,\\n 'email': user.email,\\n }\\n self.assertEqual(result, expected)\",\n \"def test_get_id(self):\\r\\n # the migration adds an initial admin user to the system\\r\\n user = UserMgr.get(user_id=1)\\r\\n self.assertEqual(\\r\\n user.id,\\r\\n 1,\\r\\n \\\"Should have a user id of 1: \\\" + str(user.id))\\r\\n self.assertEqual(\\r\\n user.username,\\r\\n 'admin',\\r\\n \\\"Should have a username of admin: \\\" + user.username)\",\n \"def test_create_user(self):\\n User.objects.create_user(username='abc', password='abcpass', email='abc@example.com')\\n user_obj = User.objects.get(username='abc')\\n self.assertTrue(user_obj.email, \\\"abc@example.com\\\")\\n self.assertEqual(str(user_obj), \\\"abc\\\")\",\n \"def test_get_bad_user(self):\\r\\n user = UserMgr.get(username=u'noexist')\\r\\n\\r\\n self.assertEqual(\\r\\n user,\\r\\n None,\\r\\n \\\"Should not find a non-existant user: \\\" + str(user))\",\n \"def test_read_user(self):\\n pass\",\n \"def test_correct_user(self):\\n\\n self.create_user('Henrik', 1)\\n self.create_user('Henrik2', 2)\\n self.create_user('Test', 3)\\n\\n resp = self.client.get('/api/users/Henrik/')\\n self.assertEquals(resp.json['total-users'], 2)\",\n \"def get_user(id):\\n pass\",\n \"def test_logged_user_data(self, test_client, init_database, insert_user_db):\\n login_url = '/api/v1/auth/login'\\n login_data = {\\n 'email': insert_user_db.email,\\n 'password': 'password'\\n }\\n login_response = test_client.post(login_url, json=login_data)\\n\\n url = '/api/v1/auth/me'\\n headers = {\\n 'Authorization': 'Bearer {}'.format(login_response.json['access'])\\n }\\n response = test_client.get(url, headers=headers)\\n\\n assert response.status_code == 200\\n assert response.json['id'] is not None\\n assert response.json['name'] == insert_user_db.name\\n assert response.json['email'] == insert_user_db.email\",\n \"def test_010_query_users(self):\\n\\n testflow.step(\\\"Querying for users\\\")\\n assert self.query_cli.run(what='user')[0], \\\"Failed to search for users\\\"\",\n \"def test_get_user_exists(self):\\n # First make the user\\n resp = self.app.post('/users', data=json.dumps(self.test_user1_data))\\n assert resp.status_code == 200\\n\\n # Now get the user data and verify it is correct\\n resp = self.app.get('/users/{}'.format(self.test_user1_userid))\\n assert resp.status_code == 200\\n data = json.loads(resp.data)\\n for key in ['first_name', 'last_name', 'userid', 'groups']:\\n assert key in data\\n assert data['first_name'] == self.test_user1_first\\n assert data['last_name'] == self.test_user1_last\\n assert data['userid'] == self.test_user1_userid\\n for groupid in self.test_user1_groups:\\n assert groupid in data['groups']\",\n \"def test_get_users_no_username(user_store: MockStore, user_email: str):\\n # GIVEN a database with a user\\n\\n # WHEN getting users\\n users: List[User] = user_store.get_users(email=user_email)\\n\\n # THEN the user should be returned\\n assert users[0].email == user_email\",\n \"def test_get_for_user_no_user(self):\\n self.assertIsNone(Tour.objects.get_for_user(User()))\",\n \"def testGetUserIgnoresCase(self):\\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n result = yield self.facade.getUser(session, u'uSeR')\\n self.assertEqual(u'user', result.username)\",\n \"def test_detail(self, client, users):\\n user = users[0]\\n url = reverse('users:detail', args=(user.pk,))\\n response = client.get(url)\\n assert response.status_code == 200\\n assert user.username in str(response.content)\",\n \"def test_user_by_username(self):\\n username = make_user(self.client)['username']\\n resp = self.client.get('/user/'+username,\\n headers=api_headers())\\n json_resp = json.loads(resp.data.decode('utf-8'))\\n self.assertEqual(json_resp['status'], 'user found')\\n self.assertEqual(json_resp['user']['username'], username)\",\n \"def test_get_user_by_emailuser_email_get(self):\\n pass\",\n \"def test_gets_user_by_email(self):\\r\\n User.objects.create(email='another_user@example.com')\\r\\n desired_user = User.objects.create(email='edith@example.com')\\r\\n found_user = PasswordlessAuthenticationBackend().get_user('edith@example.com')\\r\\n self.assertEqual(desired_user, found_user)\",\n \"def test_resource_user_resource_get_current_user_get(self):\\n pass\",\n \"def test_user(self):\\n return True\",\n \"def test_known_user(self):\\n self.sign_in()\\n u = User.objects.create(first_name = \\\"David\\\",\\n last_name = 'Smith',\\n password='******',\\n email='david.smith@mom.com',\\n phone_number='012-345-6789')\\n response = self.client.get(reverse('backend:user_details', args=(u.pk,)))\\n self.assertEqual(response.status_code, 200)\\n self.assertDictEqual(response.json(), u.json_detail())\",\n \"def test_check_user(self):\\n self.new_user.save_user()\\n test_user = User(\\\"Test\\\", \\\"user\\\", \\\"test\\\", \\\"walIas15\\\")\\n test_user.save_user()\\n test_user.check_user(\\\"test\\\", \\\"walIas15\\\")\",\n \"def test_find_user_by_username(self):\\n self.new_user.save_user()\\n test_user = User(\\\"Test\\\", \\\"user\\\", \\\"test\\\", \\\"walIas15\\\")\\n test_user.save_user()\\n user_exists = User.user_exist(\\\"test\\\")\\n self.assertTrue(user_exists)\",\n \"def test_user_username_get(self):\\n response = self.client.open('//user/{username}'.format(username='username_example'),\\n method='GET')\\n self.assert200(response, \\\"Response body is : \\\" + response.data.decode('utf-8'))\",\n \"def testGet(self):\\n userdict = {'id': 1,\\n 'objectID': u'04585bec-28cf-4a21-bc3e-081f3ed62680',\\n 'username': u'testuser',\\n 'passwordHash': 'hash',\\n 'fullname': u'Test User',\\n 'email': u'test@example.com',\\n 'role': Role.ANONYMOUS.id}\\n self.cache.set('user:testuser', json.dumps(userdict))\\n result = self.userCache.get(u'testuser')\\n user = result.results\\n self.assertEqual(1, user.id)\\n self.assertEqual('04585bec-28cf-4a21-bc3e-081f3ed62680',\\n str(user.objectID))\\n self.assertEqual(u'testuser', user.username)\\n self.assertEqual('hash', user.passwordHash)\\n self.assertEqual(u'Test User', user.fullname)\\n self.assertEqual(u'test@example.com', user.email)\\n self.assertEqual(Role.ANONYMOUS, user.role)\",\n \"def test_show(self):\\n\\n with self.client as c:\\n response = c.get(f\\\"/users/{self.testuser.id}\\\")\\n\\n self.assertEqual(response.status_code, 200)\\n self.assertIn(\\\"@alice\\\", str(response.data))\",\n \"def test_get_users(self):\\n print('(' + self.test_get_users.__name__+')',\\n self.test_get_users.__doc__)\\n users = self.connection.get_users()\\n # Check we get right size of users table\\n self.assertEqual(len(users), INITIAL_USERS_COUNT)\\n # check PATIENT and DOCTOR data with users object we got\\n for user in users:\\n if user['username'] == PATIENT_USERNAME:\\n self.assertDictContainsSubset(user, PATIENT['public_profile'])\\n elif user['username'] == DOCTOR_USERNAME:\\n self.assertDictContainsSubset(user, DOCTOR['public_profile'])\",\n \"def testCreateIsAllowed(self):\\n self.users.create([(u'user', u'secret', u'User', u'user@example.com')])\\n user = getUser(u'user')\\n self.assertEqual(u'user', user.username)\",\n \"def test_get_by_id(self):\\n with self.client:\\n self.client.post('/users/login', data=dict(\\n username=\\\"eschoppik\\\", password='secret'\\n ), follow_redirects=True)\\n self.assertTrue(current_user.id == 1)\\n self.assertFalse(current_user.id == 20)\",\n \"def test_resource_user_resource_get_user_by_email_address_get(self):\\n pass\",\n \"def test_retrieve_profile(self):\\n\\n response = self.client.get(URL_ME)\\n\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\n # Check that the user object returns as expected. There is no need\\n # (and it is not secure) to return a password to client side.\\n self.assertEqual(response.data, {\\n 'name': self.user.name,\\n 'email': self.user.email\\n })\",\n \"def test_create_user(self):\\n data = {\\n \\\"firstname\\\": \\\"John\\\",\\n \\\"lastname\\\": \\\"Doe\\\",\\n \\\"password\\\": \\\"supersecret\\\",\\n \\\"password_repeat\\\": \\\"supersecret\\\",\\n }\\n res = self.post(url=\\\"/users\\\", data=data)\\n self.assertEqual(res.status_code, 200)\\n self.assertIn(b\\\"Created user.\\\", res.data)\\n\\n user = User.query.filter_by(id=6).first()\\n self.assertTrue(user)\\n self.assertEqual(user.firstname, \\\"John\\\")\\n self.assertEqual(user.lastname, \\\"Doe\\\")\\n self.assertFalse(user.is_verified)\",\n \"def test_get_single_user_no_id(self):\\n add_user(\\\"neilb\\\", \\\"neilb14@mailinator.com\\\")\\n with self.client:\\n response = self.client.get('/users/blah')\\n data = json.loads(response.data.decode())\\n self.assertEqual(response.status_code, 404)\\n self.assertIn('User does not exist', data['message'])\\n self.assertIn('fail', data['status'])\",\n \"def test_get_user_info(self):\\n \\n name = app.get_user_info(\\\"skullphish\\\", name=True)\\n vocab_count = app.get_user_info(\\\"skullphish\\\", vocab_count=True)\\n userId = app.get_user_info(\\\"skullphish\\\", userId=True)\\n \\n self.assertTrue(name == \\\"damian rodbari\\\")\\n self.assertEqual(vocab_count,0)\\n self.assertTrue(userId == ObjectId(\\\"5bb8a0c006f1f8105bc3bb23\\\"))\",\n \"def test_user_info(self):\\n fake_fetchall = MagicMock()\\n fake_fetchall.return_value = [(1234, 5678)]\\n db = database.Database()\\n db._cursor.fetchall = fake_fetchall\\n\\n info = db.user_info('sally')\\n expected = (1234, 5678)\\n\\n self.assertEqual(info, expected)\",\n \"def test_get_users(self):\\n users = app.get_users()\\n self.assertEqual(len(users), 1)\",\n \"def test_create_and_retrieve_user(client):\\n new_user_name = TEST_USER_NAME\\n new_user_pass = TEST_USER_PASS\\n post_response = create_user(\\n client,\\n new_user_name,\\n new_user_pass)\\n assert post_response.status_code == HttpStatus.created_201.value\\n assert User.query.count() == 1\\n\\n post_response_data = json.loads(post_response.get_data(as_text=True))\\n assert post_response_data['name'] == new_user_name\\n\\n new_user_url = post_response_data['url']\\n get_response = client.get(\\n new_user_url,\\n headers=get_authentication_headers(new_user_name, new_user_pass))\\n assert get_response.status_code == HttpStatus.ok_200.value\\n\\n get_response_data = json.loads(get_response.get_data(as_text=True))\\n assert get_response_data['name'] == new_user_name\",\n \"def test_getuser(self):\\n # scenario 1: with @ starting in name and extid\\n crusoe = self.fixtures.crusoe\\n service_twitter = 'twitter'\\n oauth_token = environ.get('TWITTER_OAUTH_TOKEN')\\n oauth_token_type = 'Bearer' # NOQA: S105\\n externalid = models.UserExternalId(\\n service=service_twitter,\\n user=crusoe,\\n userid=crusoe.email.email,\\n username=crusoe.username,\\n oauth_token=oauth_token,\\n oauth_token_type=oauth_token_type,\\n )\\n db.session.add(externalid)\\n db.session.commit()\\n result1 = models.getuser('@crusoe')\\n self.assertIsInstance(result1, models.User)\\n self.assertEqual(result1, crusoe)\\n\\n # scenario 2: with @ in name and not extid\\n d_email = 'd@dothraki.vly'\\n daenerys = models.User(\\n username='daenerys', fullname=\\\"Daenerys Targaryen\\\", email=d_email\\n )\\n daenerys_email = models.UserEmail(email=d_email, user=daenerys)\\n db.session.add_all([daenerys, daenerys_email])\\n db.session.commit()\\n result2 = models.getuser(d_email)\\n self.assertIsInstance(result2, models.User)\\n self.assertEqual(result2, daenerys)\\n result3 = models.getuser('@daenerys')\\n self.assertIsNone(result3)\\n\\n # scenario 3: with no @ starting in name, check by UserEmailClaim\\n j_email = 'jonsnow@nightswatch.co.uk'\\n jonsnow = models.User(username='jonsnow', fullname=\\\"Jon Snow\\\")\\n jonsnow_email_claimed = models.UserEmailClaim(email=j_email, user=jonsnow)\\n db.session.add_all([jonsnow, jonsnow_email_claimed])\\n db.session.commit()\\n result4 = models.getuser(j_email)\\n self.assertIsInstance(result4, models.User)\\n self.assertEqual(result4, jonsnow)\\n\\n # scenario 5: with no @ anywhere in name, fetch username\\n arya = models.User(username='arya', fullname=\\\"Arya Stark\\\")\\n db.session.add(arya)\\n db.session.commit()\\n result5 = models.getuser('arya')\\n self.assertEqual(result5, arya)\\n\\n # scenario 6: with no starting with @ name and no UserEmailClaim or UserEmail\\n cersei = models.User(username='cersei', fullname=\\\"Cersei Lannister\\\")\\n db.session.add(cersei)\\n db.session.commit()\\n result6 = models.getuser('cersei@thelannisters.co.uk')\\n self.assertIsNone(result6)\",\n \"def testGetUserWithoutData(self):\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n deferred = self.facade.getUser(session, u'unknown')\\n error = yield self.assertFailure(deferred, TNoSuchUser)\\n self.assertEqual(u'unknown', error.name)\",\n \"def test_resource_user_resource_find_users_get(self):\\n pass\",\n \"def test_get_user_if_exists(self):\\n user = User.objects.create(username=self.username)\\n actual = get_user_if_exists(None, self.details, user=user)\\n self.assertDictEqual(actual, {'is_new': False})\",\n \"def test_api_can_get_users_by_id(self):\\n rv = self.client().post('/api/v1/user/', \\n data = self.req)\\n\\n res = self.client().get('/api/v1/user/3')\\n self.assertEquals(res.status_code, 200)\",\n \"def test_get_user_when_non_existing(user_store: MockStore):\\n # GIVEN a database with a user\\n\\n # WHEN querying for a user that doesn't exist\\n user: User = user_store.get_user(email=\\\"this_is_a_made_up_email@fake_example.com\\\")\\n\\n # THEN it should return as None\\n assert user is None\",\n \"def test_user_auth(self):\\n self.new_user.save_login()\\n test_user=User(\\\"trinity\\\",\\\"trinity@gmail.com\\\",\\\"123\\\")\\n test_user.save_login()\\n self.assertTrue(self.new_user.users_auth(\\\"trinity\\\",\\\"123\\\"))\",\n \"def test_create_simple_user(self):\\n payload = {\\n 'email': 'test@mail.com',\\n 'password': 'password231',\\n 'name': 'vasia'\\n }\\n\\n res = self.client.post(CREATE_USER_URL, payload)\\n\\n u = get_user_model().objects.get(**res.data)\\n\\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\\n self.assertTrue(u.check_password(self.payload['password']))\\n self.assertEqual(u.email, self.payload['email'])\",\n \"def test_user_view(self):\\n with self.app.app_context():\\n u = user(save=True)\\n\\n response = self.client.get('/user/%s' % u.slug)\\n eq_(response.status_code, 200)\\n\\n response = self.client.get('/user/not-a-real-user')\\n eq_(response.status_code, 404)\",\n \"def test_get_website_user_returns_same_user(self):\\n user = get_website_user()\\n self.assertEqual(get_website_user(), user)\",\n \"def test_user_get_profile():\\n app = create_ctfd()\\n with app.app_context():\\n register_user(app)\\n client = login_as_user(app)\\n r = client.get('/profile')\\n assert r.status_code == 200\\n destroy_ctfd(app)\",\n \"def test_set_up(self):\\n try:\\n user = User.objects.get(username = USERNAME)\\n except:\\n self.assertFalse(True, 'Error retrieving %s from database' %USERNAME)\\n\\n self.assertEquals(user.first_name, FIRST_NAME)\\n self.assertEquals(user.last_name, LAST_NAME)\\n self.assertEquals(user.email, EMAIL)\",\n \"def test_database():\\n User = get_user_model()\\n assert User.objects.count() == 0\\n User.objects.create(username='dummy', email='dummy@example.com')\\n assert User.objects.count() == 1\",\n \"def setUp(self):\\n user = Users.query.first()\",\n \"def user(email):\\r\\n return User.objects.get(email=email)\",\n \"def get_one_user():\",\n \"def get(self, no):\\n user = get_a_user(no)\\n if not user:\\n api.abort(404)\\n else:\\n return user\",\n \"def test_get_by_id_false(self):\\n\\n user = CustomUser.get_by_id(44444)\\n\\n self.assertIsNone(user)\",\n \"def get_user_details():\\n rv = query_db('select * from user')\\n return rv[0] if rv else None\",\n \"def test_create_user(self):\\n user = User(\\\"Gideon Bamuleseyo\\\", \\\"gideon@mail.com\\\", \\\"secret\\\")\\n self.assertEqual(user.name, \\\"Gideon Bamuleseyo\\\")\\n self.assertEqual(user.email, \\\"gideon@mail.com\\\")\\n self.assertEqual(user.password, \\\"secret\\\")\",\n \"def get_user(self, user_id):\\n uri = 'users/' + user_id\\n return self.make_request(uri)\",\n \"def test_createUser_single(self):\\n #TODO: this and other tests\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80467415","0.8015131","0.7970524","0.7857167","0.782778","0.77688056","0.77514106","0.77355975","0.7696272","0.76695734","0.76617557","0.7623411","0.7619199","0.75815994","0.75701547","0.7553964","0.750348","0.7497086","0.74873877","0.7464809","0.7464172","0.74478215","0.7444757","0.7444757","0.743806","0.7377553","0.737042","0.7367364","0.7332825","0.7326108","0.73045605","0.7300339","0.72784084","0.7277146","0.7230057","0.7228898","0.7216695","0.71938413","0.718102","0.7170603","0.71493727","0.7142431","0.71411437","0.71345305","0.71316814","0.7130994","0.71255857","0.7108549","0.71000314","0.70949596","0.7084232","0.70818365","0.7055021","0.70520484","0.7044797","0.7021439","0.70173633","0.7015693","0.70096487","0.70017815","0.69979626","0.69967365","0.6975325","0.6974203","0.69653195","0.6956879","0.69367623","0.69235396","0.6915534","0.6905356","0.6898882","0.6885615","0.6885185","0.6883049","0.68777245","0.6876194","0.68750894","0.6871391","0.6855516","0.68522376","0.6835772","0.68243974","0.6819433","0.6816568","0.6812266","0.68058443","0.68027776","0.6799808","0.6794786","0.67854553","0.6779615","0.6773527","0.67713886","0.6765743","0.67576253","0.6727957","0.6714332","0.6703607","0.670307","0.6697738"],"string":"[\n \"0.80467415\",\n \"0.8015131\",\n \"0.7970524\",\n \"0.7857167\",\n \"0.782778\",\n \"0.77688056\",\n \"0.77514106\",\n \"0.77355975\",\n \"0.7696272\",\n \"0.76695734\",\n \"0.76617557\",\n \"0.7623411\",\n \"0.7619199\",\n \"0.75815994\",\n \"0.75701547\",\n \"0.7553964\",\n \"0.750348\",\n \"0.7497086\",\n \"0.74873877\",\n \"0.7464809\",\n \"0.7464172\",\n \"0.74478215\",\n \"0.7444757\",\n \"0.7444757\",\n \"0.743806\",\n \"0.7377553\",\n \"0.737042\",\n \"0.7367364\",\n \"0.7332825\",\n \"0.7326108\",\n \"0.73045605\",\n \"0.7300339\",\n \"0.72784084\",\n \"0.7277146\",\n \"0.7230057\",\n \"0.7228898\",\n \"0.7216695\",\n \"0.71938413\",\n \"0.718102\",\n \"0.7170603\",\n \"0.71493727\",\n \"0.7142431\",\n \"0.71411437\",\n \"0.71345305\",\n \"0.71316814\",\n \"0.7130994\",\n \"0.71255857\",\n \"0.7108549\",\n \"0.71000314\",\n \"0.70949596\",\n \"0.7084232\",\n \"0.70818365\",\n \"0.7055021\",\n \"0.70520484\",\n \"0.7044797\",\n \"0.7021439\",\n \"0.70173633\",\n \"0.7015693\",\n \"0.70096487\",\n \"0.70017815\",\n \"0.69979626\",\n \"0.69967365\",\n \"0.6975325\",\n \"0.6974203\",\n \"0.69653195\",\n \"0.6956879\",\n \"0.69367623\",\n \"0.69235396\",\n \"0.6915534\",\n \"0.6905356\",\n \"0.6898882\",\n \"0.6885615\",\n \"0.6885185\",\n \"0.6883049\",\n \"0.68777245\",\n \"0.6876194\",\n \"0.68750894\",\n \"0.6871391\",\n \"0.6855516\",\n \"0.68522376\",\n \"0.6835772\",\n \"0.68243974\",\n \"0.6819433\",\n \"0.6816568\",\n \"0.6812266\",\n \"0.68058443\",\n \"0.68027776\",\n \"0.6799808\",\n \"0.6794786\",\n \"0.67854553\",\n \"0.6779615\",\n \"0.6773527\",\n \"0.67713886\",\n \"0.6765743\",\n \"0.67576253\",\n \"0.6727957\",\n \"0.6714332\",\n \"0.6703607\",\n \"0.670307\",\n \"0.6697738\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.80435"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":83696,"cells":{"query":{"kind":"string","value":"Test getting an archived user from the database."},"document":{"kind":"string","value":"def test_get_user_including_archived(user_store: MockStore, archived_user_email: str):\n # GIVEN a database with an archived user\n\n # WHEN querying for a user\n user: User = user_store.get_user(email=archived_user_email, exclude_archived=False)\n\n # THEN it should be returned\n assert user.email == archived_user_email"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_get_user_including_archive_false(user_store: MockStore, archived_user_email: str):\n # GIVEN a database with an archived user\n\n # WHEN querying for a user\n user: User = user_store.get_user(email=archived_user_email, exclude_archived=True)\n\n # THEN no user should be returned\n assert not user","def test_get_users_including_archived(user_store: MockStore, user_email: str, username: str):\n # GIVEN a database with a user and an archived user\n StoreHelpers.add_user(\n name=username, email=\"old.user@magnolia.com\", store=user_store, is_archived=True\n )\n\n # WHEN getting users\n users: List[User] = user_store.get_users(name=username, exclude_archived=False)\n\n # THEN the two users should be returned\n assert len(users) == 2","def test_archive(self):\n thread = self.create_thread()\n ut = UserThread.objects.get(\n user=thread.recipients.first(), thread=thread)\n ut_id = ut.pk\n ut.archive()\n ut = UserThread.objects.get(pk=ut_id)\n self.assertEqual(ut.status, 'archived')","def test_get_user_by_uuiduser_uuid_get(self):\n pass","def test_api_user_get(self):\n pass","def test_user(self):\n u = self.d.user('example')\n self.assertEqual(u.username, 'example')\n self.assertEqual(u.name, 'Example Sampleman')","def test_get_user(user_store: MockStore, user_email: str):\n # GIVEN a database with a user\n\n # WHEN querying for a user\n user: User = user_store.get_user(email=user_email)\n\n # THEN it should be returned\n assert user.email == user_email","def test_read_user(self):\n pass","def testGetUser(self):\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\n user = getUser(u'user')\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n result = yield self.facade.getUser(session, u'user')\n self.assertEqual(u'user', result.username)\n self.assertEqual(str(user.objectID), result.objectId)\n self.assertEqual(u'User', result.name)\n self.assertEqual(u'USER', result.role)","def test_users_get(self):\n pass","def test_users_get(self):\n pass","def test_get_user(sample_user):\n\n client = auth_client(APIClient(), sample_user.email, \"testpassword\")\n\n response = client.get(reverse(\"user-detail\"), format=\"json\")\n assert response.status_code == status.HTTP_200_OK\n assert json.dumps(response.data) == json.dumps(\n {\"id\": sample_user.pk, \"email\": sample_user.email}\n )","def test_view_activar_usuario(self):\n # se loguea el usuario testuser\n user = self.client.login(username='testuser', password='test')\n self.assertTrue(user)\n # se crea un usuario\n user = User.objects.create_user(username='user_prueba', email='test@test5.com', password='prueba')\n usuario_prueba = Usuario.objects.create(user=user, telefono='222', direccion='Avenida', documento='12345')\n # se marca al usuario como inactivo\n usuario_prueba.user.is_active = False\n usuario_prueba.save()\n self.assertEqual(usuario_prueba.user.is_active, False)\n # se marca al usuario como activo\n usuario_prueba.user.is_active = True\n usuario_prueba.save()\n\n self.assertEqual(usuario_prueba.user.is_active, True)\n\n print 'Test de activar_usuario realizado exitosamente'","def test_get_by_id(self):\n\n user = CustomUser.get_by_id(2)\n expected_user = CustomUser.objects.get(id=2)\n self.assertEqual(user, expected_user)","def test_user(self):\n return True","def test_get_user_by_name(self):\n\n # Select on empty set\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\n self.assertFalse(selected.success)\n self.assertIsNone(selected.documents)\n\n # Insert user\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertTrue(inserted.success)\n\n # Select user by username\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\n self.assertTrue(selected.success)\n self.assertEqual(selected.documents, MAGEN_USER)","def test_get_other_user(self):\n url = self.get_url(self.inactive_user.id)\n self.inactive_user.is_active = True\n self.inactive_user.save()\n\n with authenticated_user_api_client(self.client, self.active_user):\n expected_response_code = 200\n expected_fields = set(User.get_public_fields())\n response = self.client.get(url)\n\n response_fields = set(response.data.keys())\n self.assertEqual(response.status_code, expected_response_code)\n self.assertEqual(response_fields, expected_fields)","def test_func(self, user, **kwargs):\n return self.get_object().authorized_user(user)","def test_resource_user_resource_get_user_get(self):\n pass","def test_detail(self, client, users):\n user = users[0]\n url = reverse('users:detail', args=(user.pk,))\n response = client.get(url)\n assert response.status_code == 200\n assert user.username in str(response.content)","def test_get_users(self):\n pass","def test_user_id_get(self):\n pass","def test_good_user(self):\n user = self.datautils.create_user()\n self.request.user = user\n self.request.matchdict = {'user_id': int(user.id)}\n result = user_id_get_view(self.request)['d']\n expected = {\n 'id': user.id,\n 'username': user.username,\n 'created': user.created,\n 'email': user.email,\n }\n self.assertEqual(result, expected)","def test_retrieve(self):\n users = CalendallUser.objects.all()\n self.check_attrs_helper(users)","def test_get_user(self):\n user = User(self.client, \"test-user\", {})\n\n self.assertEqual(user.username, \"test-user\")\n self.assertEqual(user.email, \"test-user@linode.com\")\n self.assertTrue(user.restricted)\n self.assertTrue(user.tfa_enabled)\n self.assertIsNotNone(user.ssh_keys)","def test_detail_user(self):\n \n for user in User.objects.filter(Q(groups__name='Administrator') | Q(\n groups__name='Viewer') | Q(groups__name='User')):\n\n token = get_token(user)\n\n url_detail_user = reverse(\n 'user_get_retrieve_destroy_update', args=[user.organization_member.pk])\n\n response = self.client.get(url_detail_user,\n HTTP_AUTHORIZATION=f\"JWT {token}\",\n format='json')\n\n # Validate status code response\n self.assertEqual(response.status_code, 200)\n\n org_comp = comparator_member(user.organization_member, response.data)\n self.assertEqual(org_comp, True)","def test_UserFromDB():\n assert UserFromDB(\"DIANE\").email == \"d@gmail.com\"\n assert UserFromDB(\"DIANE\").username == \"DIANE\"","def test_003_get_user(self, mock_db_query):\n mock_db_query.get.return_value = seller1\n\n response = self.app.get('/v1/users/' + str(seller1.identity), headers={'accept': 'application/json'})\n\n print(response.get_data().decode())\n\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response.json['first_name'], 'Lisa')","def test_fake_user(self):\n user = User.objects.get(username=\"a\")\n\n tester = DropboxAuthTester()\n self.assertFalse(tester.can_auth(user))","def test_get_user_by_username(self):\n\t\tusername_in_db = server.get_user_by_username('Natasha')\n\t\tself.assertTrue(username_in_db, 'Query did not fetch user object.')\n\t\tusername_not_in_db = server.get_user_by_username('xyz')\n\t\tself.assertFalse(username_not_in_db, 'Query fetched user that did not exist (xyz).')","def test_retrive_user(self):\n res = self.client.get(ME_URL)\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(res.data['email'], self.user.email)\n self.assertEqual(res.data['name'], self.user.name)\n self.assertNotIn('password', res.data)","def test_archived(self):\n doc = DocumentFactory(title=u'impalas', locale=u'en-US', is_archived=True)\n ApprovedRevisionFactory(document=doc, summary=u'impalas', is_approved=True)\n\n self.refresh()\n\n # include_archived gets the above document\n qs = {'q': 'impalas', 'a': 1, 'w': 1, 'format': 'json',\n 'include_archived': 'on'}\n response = self.client.get(reverse('search.advanced'), qs)\n results = json.loads(response.content)['results']\n eq_(1, len(results))\n\n # no include_archived gets you nothing since the only\n # document in the index is archived\n qs = {'q': 'impalas', 'a': 0, 'w': 1, 'format': 'json'}\n response = self.client.get(reverse('search.advanced'), qs)\n results = json.loads(response.content)['results']\n eq_(0, len(results))","def test_insert_get_user(self):\n\n # Select a user on an empty set\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\n self.assertFalse(selected.success)\n self.assertIsNone(selected.documents)\n\n # Inserting user into Database\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertTrue(inserted.success)\n\n # Verify that document was inserted\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\n self.assertTrue(selected.success)\n self.assertEqual(selected.documents, MAGEN_USER)\n\n # Inserting same user again (uuid and e-mail should be unique)\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertFalse(inserted.success)\n self.assertIn('user_uuid', inserted.message)","def testGet(self):\n userdict = {'id': 1,\n 'objectID': u'04585bec-28cf-4a21-bc3e-081f3ed62680',\n 'username': u'testuser',\n 'passwordHash': 'hash',\n 'fullname': u'Test User',\n 'email': u'test@example.com',\n 'role': Role.ANONYMOUS.id}\n self.cache.set('user:testuser', json.dumps(userdict))\n result = self.userCache.get(u'testuser')\n user = result.results\n self.assertEqual(1, user.id)\n self.assertEqual('04585bec-28cf-4a21-bc3e-081f3ed62680',\n str(user.objectID))\n self.assertEqual(u'testuser', user.username)\n self.assertEqual('hash', user.passwordHash)\n self.assertEqual(u'Test User', user.fullname)\n self.assertEqual(u'test@example.com', user.email)\n self.assertEqual(Role.ANONYMOUS, user.role)","def test_user_retrieve(self):\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.get_token())\n response = self.client.get(reverse(\"account:user-profile\"))\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data.get('user').get('email'), \"testuser@gmail.com\")","def test_get_single_user(self):\n user = add_user(\"neilb\", \"neilb14@mailinator.com\")\n with self.client:\n response = self.client.get(f'/users/{user.id}')\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 200)\n self.assertTrue('created_at' in data['data'])\n self.assertIn('neilb', data['data']['username'])\n self.assertIn('neilb14@mailinator.com', data['data']['email'])\n self.assertIn('success', data['status'])","def test_get(self):\n user = api.user.create(\n username='chuck',\n email='chuck@norris.org',\n password='secret',\n )\n\n self.assertEqual(api.user.get('chuck'), user)","def test_fetch_user(self):\n\n self.register_user()\n\n self.assertEqual(self.fetch_user_details().status_code, 200)\n\n self.assertTrue(self.fetch_user_details(\n ).json[\"data\"][0][\"username\"] == 'Bjorn')","def test_view_desactivar_usuario(self):\n # se loguea el usuario testuser\n user = self.client.login(username='testuser', password='test')\n self.assertTrue(user)\n # se crea un usuario\n user = User.objects.create_user(username='user_prueba', email='test@test4.com', password='prueba')\n usuario_prueba = Usuario.objects.create(user=user, telefono='222', direccion='Avenida', documento='12345')\n # se marca al usuario como inactivo\n usuario_prueba.user.is_active = False\n usuario_prueba.save()\n\n self.assertEqual(usuario_prueba.user.is_active, False)\n\n print 'Test de desactivar_usuario realizado exitosamente'","def test_get_user_info_returns_user(self, db_mock):\n repo = Repository()\n db_instance = db_mock.return_value\n db_instance.get_user_info.return_value = (1, {\"name\": \"Kari\"})\n self.assertEquals(repo.get_user_info(\"123\"), (1, {\"name\": \"Kari\"}))","def test_get_owned(self):\n user = User.create(name='foo', email='foo@bar.com')\n user.put()\n response = self.testapp.get(\n '/api/users/{}'.format(user.uid),\n headers=self.login_headers(user),\n )\n response_dict = json.loads(response.body)\n self.assertEqual(response_dict['uid'], user.uid)","def test_anonymize_user_data(api_client, resource_in_unit, user):\n user.first_name = 'testi_ukkeli'\n user.save()\n original_uuid = user.uuid\n original_email = user.email\n user_pk = user.pk\n\n SocialAccount.objects.create(user=user, uid=original_uuid, provider='helsinki')\n EmailAddress.objects.create(user=user, email=original_email)\n\n Reservation.objects.create(\n resource=resource_in_unit,\n begin='2015-04-04T09:00:00+02:00',\n end='2015-04-04T10:00:00+02:00',\n user=user,\n reserver_name='John Smith',\n event_subject='John\\'s welcome party',\n state=Reservation.CONFIRMED\n )\n # anonymize_user_data expects a queryset instead of single object\n test_user = get_user_model().objects.filter(first_name='testi_ukkeli')\n anonymize_user_data(modeladmin=None, request=None, queryset=test_user)\n assert get_user_model().objects.filter(first_name='testi_ukkeli').count() == 0\n reservation = Reservation.objects.get(resource=resource_in_unit)\n assert reservation.event_description == 'Sensitive data of this reservation has been anonymized by a script.'\n changed_user = get_user_model().objects.get(pk=user_pk)\n assert changed_user.uuid != original_uuid\n assert reservation.state == Reservation.CANCELLED\n assert not SocialAccount.objects.filter(user=user, uid=original_uuid).exists()\n assert not EmailAddress.objects.filter(user=user, email=original_email).exists()","def test_get_for_user_no_user(self):\n self.assertIsNone(Tour.objects.get_for_user(User()))","def test_user(self):\n user = User.objects.get(username=\"test01\")\n print(user.username)\n print(user.email)\n self.assertEqual(user.email,\"test01@email.com\")\n # cat = Animal.objects.get(name=\"cat\")\n # self.assertEqual(lion.speak(), 'The lion says \"roar\"')\n # self.assertEqual(cat.speak(), 'The cat says \"meow\"')","def test_duo_account_get(self):\n pass","def test_user(self):\n\n user = User.query.filter(User.user_fname == \"Smokey\").first()\n self.assertEqual(user.user_fname, \"Smokey\")","def test_user_activation(self):\n user = User.objects.get()\n response = self.client.get(reverse('accounts:user-activate',\n kwargs={'uidb64': urlsafe_base64_encode(force_bytes(user.pk)),\n 'token': account_activation_token.make_token(user)}))\n self.assertEqual(response.status_code, status.HTTP_200_OK)","def test_gets_user_by_email(self):\r\n User.objects.create(email='another_user@example.com')\r\n desired_user = User.objects.create(email='edith@example.com')\r\n found_user = PasswordlessAuthenticationBackend().get_user('edith@example.com')\r\n self.assertEqual(desired_user, found_user)","def test_read_by_random_logged_in_user(self):\n user = UserFactory()\n\n self.assert_user_cannot_read(user, self.live)","def test_get_website_user_returns_user(self):\n user = get_website_user()\n self.assertTrue(user)","def test_order_from_user(self):\n new_user = self.create_test_user()\n new_order = OrderInfo.objects.create(user=new_user)\n self.assertEqual(new_order.user, new_user)","def test_user_instance(self):\n db.session.add(self.user)\n db.session.commit()\n\n user = User.query.filter_by(user_name = \"john_doe\").first()\n users = User.query.all()\n\n self.assertTrue(len(users) > 0)\n self.assertEqual(user.user_name, \"john_doe\")\n self.assertEqual(user.email, \"johndoe@example.com\")\n self.assertEqual(user.profile_pic_path, \"app/static/images\")\n self.assertEqual(user.first_name, \"John\")\n self.assertEqual(user.last_name, \"Doe\")\n self.assertEqual(user.headline, \"Food Blogger\")\n self.assertEqual(user.bio, \"Mainly writes on Chinese cuisine\")","def test_user_creation(self):\n self.assertTrue(User.objects.exists())","def test_func(self, user):\n return self.get_object().admin == user","def test_list_user(self):\n pass","def test_user_is_really_deleted():\n response = api_helper.get_user(user_id=pytest.test_user.id)\n assert response.status_code == 200\n assert len(response.json()['data']) == 0","def ____test_sys_archived(self):\n # TODO archinging not working\n with ts.SetupDbAndCredentials() as s:\n args = [\"--archived\", \"--skip-albums\", \"--start-date\", \"2017-01-01\"]\n s.test_setup(\n \"test_sys_archived\", args=args, trash_files=True, trash_db=True\n )\n s.gp.start(s.parsed_args)\n\n db = LocalData(s.root)\n\n # Total of 1 out of media items\n db.cur.execute(\"SELECT COUNT() FROM SyncFiles\")\n count = db.cur.fetchone()\n self.assertEqual(1, count[0])","def testGetUserIgnoresCase(self):\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n result = yield self.facade.getUser(session, u'uSeR')\n self.assertEqual(u'user', result.username)","def testGetAccessAllowed(self):\n for user in (self.guest, self.contributor, self.delegate, self.owner, self.root):\n response = self.runGet(user, sequencer=self.hiseq2000.sodar_uuid)\n self.response_200(response)\n data = json.loads(response.content.decode(\"utf-8\"))\n self.assertEqual(data[\"sodar_uuid\"], str(self.hiseq2000.sodar_uuid))","def test_show(self):\n\n with self.client as c:\n response = c.get(f\"/users/{self.testuser.id}\")\n\n self.assertEqual(response.status_code, 200)\n self.assertIn(\"@alice\", str(response.data))","def test_getUser(self):\n\t\turl = \"/users/2/\"\n\t\tresponse = self.client.get(url, format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\tself.assertEqual(response.data[\"id\"], 2)\n\t\tself.assertEqual(response.data[\"username\"], \"testUser2\")","def test_valid_dropbox_user(self):\n user = User.objects.get(id=107)\n\n tester = DropboxAuthTester()\n self.assertTrue(tester.can_auth(user))","def test_get_user_by_emailuser_email_get(self):\n pass","def test_movies_limited_to_user(self):\n user2 = get_user_model().objects.create_user(\n 'other@youremail.com',\n 'pass123'\n )\n sample_movie(user=user2)\n sample_movie(user=self.user)\n\n res = self.client.get(MOVIES_URL)\n\n movies = Movie.objects.filter(user=self.user)\n serializer = MovieSerializer(movies, many=True)\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(len(res.data), 1)\n self.assertEqual(res.data, serializer.data)","def test_get_users(user_store: MockStore, user_email: str, username: str):\n # GIVEN a database with a user\n\n # WHEN getting users\n users: List[User] = user_store.get_users(name=username, email=user_email)\n\n # THEN the user should be returned\n assert users[0].email == user_email","def test_get_users_from_passwd():\n users = Users.from_passwd()\n assert isinstance(users, Users)","def test_detailview_read_for_anonymous_user(self):\n\n for user in self.users:\n detailview = reverse('account_detail', args=(user.uuid,))\n response = self.client.get(detailview)\n\n self.assertEqual(response.status_code, 302)","def test_18_admin_user_export_authenticated(self):\r\n self.register()\r\n self.signout()\r\n self.register(fullname=\"Juan Jose\", name=\"juan\",\r\n email=\"juan@juan.com\", password=\"juan\")\r\n\r\n # No matter what params in the request, Forbidden is raised\r\n res = self.app.get('/admin/users/export', follow_redirects=True)\r\n assert res.status_code == 403, res.status_code\r\n res = self.app.get('/admin/users/export?firmit=', follow_redirects=True)\r\n assert res.status_code == 403, res.status_code\r\n res = self.app.get('/admin/users/export?format=bad',\r\n follow_redirects=True)\r\n assert res.status_code == 403, res.status_code\r\n res = self.app.get('/admin/users/export?format=json',\r\n follow_redirects=True)\r\n assert res.status_code == 403, res.status_code","def test_single_success():\n test_username = \"test_user\"\n\n user = UserFactory.create(username=test_username, is_active=True)\n UserSocialAuthFactory.create(user=user, provider=\"edX\")\n\n assert user.is_active is True\n assert \"retired_email\" not in user.email\n assert UserSocialAuth.objects.filter(user=user).count() == 1\n\n COMMAND.handle(\"retire_users\", users=[test_username])\n\n user.refresh_from_db()\n assert user.is_active is False\n assert \"retired_email\" in user.email\n assert UserSocialAuth.objects.filter(user=user).count() == 0","def test_get_website_user_returns_same_user(self):\n user = get_website_user()\n self.assertEqual(get_website_user(), user)","def test_reteta_limited_to_user(self):\n user2 = get_user_model().objects.create_user(\n 'other@chris.com',\n 'testpass'\n )\n sample_reteta(user=user2)\n sample_reteta(user=self.user)\n\n res = self.client.get(RETETA_URL)\n rete = Reteta.objects.filter(user=self.user)\n serializer = RetetaSerializer(rete, many=True) # return list\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(len(res.data), 1)\n self.assertEqual(res.data, serializer.data)","def test_get_id(self):\r\n # the migration adds an initial admin user to the system\r\n user = UserMgr.get(user_id=1)\r\n self.assertEqual(\r\n user.id,\r\n 1,\r\n \"Should have a user id of 1: \" + str(user.id))\r\n self.assertEqual(\r\n user.username,\r\n 'admin',\r\n \"Should have a username of admin: \" + user.username)","def test_resource_user_resource_get_current_user_get(self):\n pass","def test_resource_user_resource_get_user_by_email_address_get(self):\n pass","def test_create_user(self):\n User.objects.create_user(username='abc', password='abcpass', email='abc@example.com')\n user_obj = User.objects.get(username='abc')\n self.assertTrue(user_obj.email, \"abc@example.com\")\n self.assertEqual(str(user_obj), \"abc\")","def test_access_positive(self, api):\n self.builder.add_user(api.get_user())\n self.builder.upd_access(api.get_user(), False)\n r1 = api.access_user(api.get_user(), True)\n access_true = self.builder.get_access(api.get_user())\n self.builder.del_user(api.get_user())\n assert access_true == 1\n assert r1.status_code == 200","def testGetAccessAllowed(self):\n for user in (self.guest, self.contributor, self.delegate, self.owner, self.root):\n response = self.runGet(user, sequencer=self.hiseq2000.vendor_id)\n self.response_200(response)\n data = json.loads(response.content.decode(\"utf-8\"))\n self.assertEqual(data[\"sodar_uuid\"], str(self.hiseq2000.sodar_uuid))","def test_saved_articles_GET_3(self):\r\n\r\n u1 = User.query.filter_by(username='testuser').one()\r\n\r\n with self.client as c:\r\n with c.session_transaction() as sess:\r\n sess[CURR_USER_KEY] = u1.id\r\n response = c.get('/users/anotherUser/location',\r\n follow_redirects=True)\r\n self.assertEqual(response.status_code, 200)\r\n self.assertIn(b'Unauthorized.', response.data)","def testDeleteUser(self):\n UserAPI().create([(u'test', u'secret', u'name', u'name@example.com')],\n createPrivateNamespace=False)\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n yield self.facade.deleteUser(session, u'test')\n\n self.store.rollback()\n self.assertIdentical(None, getUser(u'test'))","def test_delete_user(self):\n pass","def test_delete_user(self):\n pass","def test_get_user(\n self,\n mixin,\n mdb,\n muser_query,\n get_user,\n mrequest,\n mdecoded_jwt,\n ):\n mquery = muser_query.return_value\n\n assert get_user(\n mixin, dbsession=mdb) == mquery.get_by_id.return_value\n mquery.get_by_id.assert_called_once_with(sentinel.user_id)","def test_search_user(self):\n self.maya.save_profile()\n user = Profile.search_users(self.maya.username)\n self.assertTrue(user.username==\"Maya\")","def mock_get_real_user(_anon_id):\r\n return self.user","def test_get_by_id_false(self):\n\n user = CustomUser.get_by_id(44444)\n\n self.assertIsNone(user)","def test_myaccount(self):\n create_user_object()\n self.client.login(username='testuser', password='testabc123')\n response = self.client.get(reverse('infinite:myaccount'))\n self.assertEqual(response.status_code, 200)","def test_get_non_owner(self):\n another_user = CustomUser(id=101, email='another_user@mail.com', is_active=True)\n another_user.set_password('testpassword')\n another_user.save()\n self.client.login(email='another_user@mail.com', password='testpassword')\n\n url = reverse('route', kwargs={'way_id': self.route.way_id, 'route_id': self.route.id})\n response = self.client.get(url)\n self.assertEqual(response.status_code, 403)","def test_user_auth(self):\n self.new_user.save_login()\n test_user=User(\"trinity\",\"trinity@gmail.com\",\"123\")\n test_user.save_login()\n self.assertTrue(self.new_user.users_auth(\"trinity\",\"123\"))","def test_users_username_get(self):\n pass","def test_get_all(self):\n\n # Select on empty set\n selected = self.user_api.get_all()\n self.assertTrue(selected.success)\n self.assertFalse(selected.documents)\n\n # Inserting several users\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertTrue(inserted.success)\n another_user = MAGEN_USER.copy()\n another_user.pop('user_uuid')\n another_user['username'] = 'test_another_username'\n another_user['first_name'] = 'test_another_f_name'\n inserted = self.user_api.insert_user(another_user)\n self.assertTrue(inserted.success)\n\n # Select all users from Database\n selected = self.user_api.get_all()\n self.assertTrue(selected.success)\n self.assertEqual(len(selected.documents), 2)\n self.assertEqual(selected.documents[0], MAGEN_USER)\n # Verify that user_uuid was generated\n self.assertIn('user_uuid', selected.documents[1])\n # Verify that other keys were inserted\n self.assertEqual(selected.documents[1], another_user)","def test_get_user(self):\n print('(' + self.test_get_user.__name__+')', self.test_get_user.__doc__)\n # test for patient\n self.assertDictContainsSubset(\n self.connection.get_user(PATIENT_USERNAME), PATIENT)\n # test for doctor\n self.assertDictContainsSubset(\n self.connection.get_user(DOCTOR_USERNAME), DOCTOR)","def test_get_superuser(self):\n url = reverse('projectroles:api_user_current')\n response = self.request_knox(url)\n self.assertEqual(response.status_code, 200)\n response_data = json.loads(response.content)\n expected = {\n 'username': self.user.username,\n 'name': self.user.name,\n 'email': self.user.email,\n 'is_superuser': True,\n 'sodar_uuid': str(self.user.sodar_uuid),\n }\n self.assertEqual(response_data, expected)","def test_get_file(self):\n django_file = None\n \n with open(TEST_AVATAR_PATH, 'rb') as avatar:\n self.user.avatar_tmp = File(avatar)\n self.user.save()\n\n with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:\n archive.add_model_file(self.user.avatar_tmp)\n\n django_file = archive.get_file()\n archive_path = archive.file_path\n\n self.assertIsNotNone(archive_path)\n self.assertEqual(django_file.name, archive.file_path)\n self.assertFalse(django_file.closed)\n\n self.assertIsNone(archive.file)\n self.assertIsNone(archive.file_path)\n self.assertTrue(django_file.closed)","def get(self, user_id):\n\n user = User.objects.get_or_404(public_id=user_id)\n return user_schema.dump(user)","def test_retrieve_author_unlogged(self):\n request = self.client.get(self.epoint)\n\n self.assertEqual(request.status_code, status.HTTP_200_OK)","def test_user_delete_GET_3(self):\r\n\r\n u1 = User.query.filter_by(username='testuser').one()\r\n\r\n with self.client as c:\r\n with c.session_transaction() as sess:\r\n sess[CURR_USER_KEY] = u1.id\r\n response = c.get('/users/anotherUser/location',\r\n follow_redirects=True)\r\n self.assertEqual(response.status_code, 200)\r\n self.assertIn(b'Unauthorized.', response.data)","def test_correct_user(self):\n\n self.create_user('Henrik', 1)\n self.create_user('Henrik2', 2)\n self.create_user('Test', 3)\n\n resp = self.client.get('/api/users/Henrik/')\n self.assertEquals(resp.json['total-users'], 2)","def test_check_user(self):\n self.new_user.save_user()\n test_user = User(\"Test\", \"user\", \"test\", \"walIas15\")\n test_user.save_user()\n test_user.check_user(\"test\", \"walIas15\")","def test_get_superuser(self):\n url = reverse('projectroles:api_user_list')\n response = self.request_knox(url) # Default token is for superuser\n self.assertEqual(response.status_code, 200)\n response_data = json.loads(response.content)\n self.assertEqual(len(response_data), 4)\n expected = [\n self.get_serialized_user(self.user),\n self.get_serialized_user(self.user_owner_cat),\n self.get_serialized_user(self.user_owner),\n self.get_serialized_user(self.domain_user),\n ]\n self.assertEqual(response_data, expected)","def test_logged_in_permission_another_user_borrowed_book(self):\n login = self.client.login(\n username='testuser2',\n password='2HJ1vRV0Z&3iD')\n response = self.client.get(\n reverse('librarian-renew-book',\n kwargs={'pk': self.test_bookinstance1.pk}))\n self.assertEqual(response.status_code, 200)"],"string":"[\n \"def test_get_user_including_archive_false(user_store: MockStore, archived_user_email: str):\\n # GIVEN a database with an archived user\\n\\n # WHEN querying for a user\\n user: User = user_store.get_user(email=archived_user_email, exclude_archived=True)\\n\\n # THEN no user should be returned\\n assert not user\",\n \"def test_get_users_including_archived(user_store: MockStore, user_email: str, username: str):\\n # GIVEN a database with a user and an archived user\\n StoreHelpers.add_user(\\n name=username, email=\\\"old.user@magnolia.com\\\", store=user_store, is_archived=True\\n )\\n\\n # WHEN getting users\\n users: List[User] = user_store.get_users(name=username, exclude_archived=False)\\n\\n # THEN the two users should be returned\\n assert len(users) == 2\",\n \"def test_archive(self):\\n thread = self.create_thread()\\n ut = UserThread.objects.get(\\n user=thread.recipients.first(), thread=thread)\\n ut_id = ut.pk\\n ut.archive()\\n ut = UserThread.objects.get(pk=ut_id)\\n self.assertEqual(ut.status, 'archived')\",\n \"def test_get_user_by_uuiduser_uuid_get(self):\\n pass\",\n \"def test_api_user_get(self):\\n pass\",\n \"def test_user(self):\\n u = self.d.user('example')\\n self.assertEqual(u.username, 'example')\\n self.assertEqual(u.name, 'Example Sampleman')\",\n \"def test_get_user(user_store: MockStore, user_email: str):\\n # GIVEN a database with a user\\n\\n # WHEN querying for a user\\n user: User = user_store.get_user(email=user_email)\\n\\n # THEN it should be returned\\n assert user.email == user_email\",\n \"def test_read_user(self):\\n pass\",\n \"def testGetUser(self):\\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\\n user = getUser(u'user')\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n result = yield self.facade.getUser(session, u'user')\\n self.assertEqual(u'user', result.username)\\n self.assertEqual(str(user.objectID), result.objectId)\\n self.assertEqual(u'User', result.name)\\n self.assertEqual(u'USER', result.role)\",\n \"def test_users_get(self):\\n pass\",\n \"def test_users_get(self):\\n pass\",\n \"def test_get_user(sample_user):\\n\\n client = auth_client(APIClient(), sample_user.email, \\\"testpassword\\\")\\n\\n response = client.get(reverse(\\\"user-detail\\\"), format=\\\"json\\\")\\n assert response.status_code == status.HTTP_200_OK\\n assert json.dumps(response.data) == json.dumps(\\n {\\\"id\\\": sample_user.pk, \\\"email\\\": sample_user.email}\\n )\",\n \"def test_view_activar_usuario(self):\\n # se loguea el usuario testuser\\n user = self.client.login(username='testuser', password='test')\\n self.assertTrue(user)\\n # se crea un usuario\\n user = User.objects.create_user(username='user_prueba', email='test@test5.com', password='prueba')\\n usuario_prueba = Usuario.objects.create(user=user, telefono='222', direccion='Avenida', documento='12345')\\n # se marca al usuario como inactivo\\n usuario_prueba.user.is_active = False\\n usuario_prueba.save()\\n self.assertEqual(usuario_prueba.user.is_active, False)\\n # se marca al usuario como activo\\n usuario_prueba.user.is_active = True\\n usuario_prueba.save()\\n\\n self.assertEqual(usuario_prueba.user.is_active, True)\\n\\n print 'Test de activar_usuario realizado exitosamente'\",\n \"def test_get_by_id(self):\\n\\n user = CustomUser.get_by_id(2)\\n expected_user = CustomUser.objects.get(id=2)\\n self.assertEqual(user, expected_user)\",\n \"def test_user(self):\\n return True\",\n \"def test_get_user_by_name(self):\\n\\n # Select on empty set\\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\\n self.assertFalse(selected.success)\\n self.assertIsNone(selected.documents)\\n\\n # Insert user\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertTrue(inserted.success)\\n\\n # Select user by username\\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\\n self.assertTrue(selected.success)\\n self.assertEqual(selected.documents, MAGEN_USER)\",\n \"def test_get_other_user(self):\\n url = self.get_url(self.inactive_user.id)\\n self.inactive_user.is_active = True\\n self.inactive_user.save()\\n\\n with authenticated_user_api_client(self.client, self.active_user):\\n expected_response_code = 200\\n expected_fields = set(User.get_public_fields())\\n response = self.client.get(url)\\n\\n response_fields = set(response.data.keys())\\n self.assertEqual(response.status_code, expected_response_code)\\n self.assertEqual(response_fields, expected_fields)\",\n \"def test_func(self, user, **kwargs):\\n return self.get_object().authorized_user(user)\",\n \"def test_resource_user_resource_get_user_get(self):\\n pass\",\n \"def test_detail(self, client, users):\\n user = users[0]\\n url = reverse('users:detail', args=(user.pk,))\\n response = client.get(url)\\n assert response.status_code == 200\\n assert user.username in str(response.content)\",\n \"def test_get_users(self):\\n pass\",\n \"def test_user_id_get(self):\\n pass\",\n \"def test_good_user(self):\\n user = self.datautils.create_user()\\n self.request.user = user\\n self.request.matchdict = {'user_id': int(user.id)}\\n result = user_id_get_view(self.request)['d']\\n expected = {\\n 'id': user.id,\\n 'username': user.username,\\n 'created': user.created,\\n 'email': user.email,\\n }\\n self.assertEqual(result, expected)\",\n \"def test_retrieve(self):\\n users = CalendallUser.objects.all()\\n self.check_attrs_helper(users)\",\n \"def test_get_user(self):\\n user = User(self.client, \\\"test-user\\\", {})\\n\\n self.assertEqual(user.username, \\\"test-user\\\")\\n self.assertEqual(user.email, \\\"test-user@linode.com\\\")\\n self.assertTrue(user.restricted)\\n self.assertTrue(user.tfa_enabled)\\n self.assertIsNotNone(user.ssh_keys)\",\n \"def test_detail_user(self):\\n \\n for user in User.objects.filter(Q(groups__name='Administrator') | Q(\\n groups__name='Viewer') | Q(groups__name='User')):\\n\\n token = get_token(user)\\n\\n url_detail_user = reverse(\\n 'user_get_retrieve_destroy_update', args=[user.organization_member.pk])\\n\\n response = self.client.get(url_detail_user,\\n HTTP_AUTHORIZATION=f\\\"JWT {token}\\\",\\n format='json')\\n\\n # Validate status code response\\n self.assertEqual(response.status_code, 200)\\n\\n org_comp = comparator_member(user.organization_member, response.data)\\n self.assertEqual(org_comp, True)\",\n \"def test_UserFromDB():\\n assert UserFromDB(\\\"DIANE\\\").email == \\\"d@gmail.com\\\"\\n assert UserFromDB(\\\"DIANE\\\").username == \\\"DIANE\\\"\",\n \"def test_003_get_user(self, mock_db_query):\\n mock_db_query.get.return_value = seller1\\n\\n response = self.app.get('/v1/users/' + str(seller1.identity), headers={'accept': 'application/json'})\\n\\n print(response.get_data().decode())\\n\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response.json['first_name'], 'Lisa')\",\n \"def test_fake_user(self):\\n user = User.objects.get(username=\\\"a\\\")\\n\\n tester = DropboxAuthTester()\\n self.assertFalse(tester.can_auth(user))\",\n \"def test_get_user_by_username(self):\\n\\t\\tusername_in_db = server.get_user_by_username('Natasha')\\n\\t\\tself.assertTrue(username_in_db, 'Query did not fetch user object.')\\n\\t\\tusername_not_in_db = server.get_user_by_username('xyz')\\n\\t\\tself.assertFalse(username_not_in_db, 'Query fetched user that did not exist (xyz).')\",\n \"def test_retrive_user(self):\\n res = self.client.get(ME_URL)\\n\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(res.data['email'], self.user.email)\\n self.assertEqual(res.data['name'], self.user.name)\\n self.assertNotIn('password', res.data)\",\n \"def test_archived(self):\\n doc = DocumentFactory(title=u'impalas', locale=u'en-US', is_archived=True)\\n ApprovedRevisionFactory(document=doc, summary=u'impalas', is_approved=True)\\n\\n self.refresh()\\n\\n # include_archived gets the above document\\n qs = {'q': 'impalas', 'a': 1, 'w': 1, 'format': 'json',\\n 'include_archived': 'on'}\\n response = self.client.get(reverse('search.advanced'), qs)\\n results = json.loads(response.content)['results']\\n eq_(1, len(results))\\n\\n # no include_archived gets you nothing since the only\\n # document in the index is archived\\n qs = {'q': 'impalas', 'a': 0, 'w': 1, 'format': 'json'}\\n response = self.client.get(reverse('search.advanced'), qs)\\n results = json.loads(response.content)['results']\\n eq_(0, len(results))\",\n \"def test_insert_get_user(self):\\n\\n # Select a user on an empty set\\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\\n self.assertFalse(selected.success)\\n self.assertIsNone(selected.documents)\\n\\n # Inserting user into Database\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertTrue(inserted.success)\\n\\n # Verify that document was inserted\\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\\n self.assertTrue(selected.success)\\n self.assertEqual(selected.documents, MAGEN_USER)\\n\\n # Inserting same user again (uuid and e-mail should be unique)\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertFalse(inserted.success)\\n self.assertIn('user_uuid', inserted.message)\",\n \"def testGet(self):\\n userdict = {'id': 1,\\n 'objectID': u'04585bec-28cf-4a21-bc3e-081f3ed62680',\\n 'username': u'testuser',\\n 'passwordHash': 'hash',\\n 'fullname': u'Test User',\\n 'email': u'test@example.com',\\n 'role': Role.ANONYMOUS.id}\\n self.cache.set('user:testuser', json.dumps(userdict))\\n result = self.userCache.get(u'testuser')\\n user = result.results\\n self.assertEqual(1, user.id)\\n self.assertEqual('04585bec-28cf-4a21-bc3e-081f3ed62680',\\n str(user.objectID))\\n self.assertEqual(u'testuser', user.username)\\n self.assertEqual('hash', user.passwordHash)\\n self.assertEqual(u'Test User', user.fullname)\\n self.assertEqual(u'test@example.com', user.email)\\n self.assertEqual(Role.ANONYMOUS, user.role)\",\n \"def test_user_retrieve(self):\\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.get_token())\\n response = self.client.get(reverse(\\\"account:user-profile\\\"))\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data.get('user').get('email'), \\\"testuser@gmail.com\\\")\",\n \"def test_get_single_user(self):\\n user = add_user(\\\"neilb\\\", \\\"neilb14@mailinator.com\\\")\\n with self.client:\\n response = self.client.get(f'/users/{user.id}')\\n data = json.loads(response.data.decode())\\n self.assertEqual(response.status_code, 200)\\n self.assertTrue('created_at' in data['data'])\\n self.assertIn('neilb', data['data']['username'])\\n self.assertIn('neilb14@mailinator.com', data['data']['email'])\\n self.assertIn('success', data['status'])\",\n \"def test_get(self):\\n user = api.user.create(\\n username='chuck',\\n email='chuck@norris.org',\\n password='secret',\\n )\\n\\n self.assertEqual(api.user.get('chuck'), user)\",\n \"def test_fetch_user(self):\\n\\n self.register_user()\\n\\n self.assertEqual(self.fetch_user_details().status_code, 200)\\n\\n self.assertTrue(self.fetch_user_details(\\n ).json[\\\"data\\\"][0][\\\"username\\\"] == 'Bjorn')\",\n \"def test_view_desactivar_usuario(self):\\n # se loguea el usuario testuser\\n user = self.client.login(username='testuser', password='test')\\n self.assertTrue(user)\\n # se crea un usuario\\n user = User.objects.create_user(username='user_prueba', email='test@test4.com', password='prueba')\\n usuario_prueba = Usuario.objects.create(user=user, telefono='222', direccion='Avenida', documento='12345')\\n # se marca al usuario como inactivo\\n usuario_prueba.user.is_active = False\\n usuario_prueba.save()\\n\\n self.assertEqual(usuario_prueba.user.is_active, False)\\n\\n print 'Test de desactivar_usuario realizado exitosamente'\",\n \"def test_get_user_info_returns_user(self, db_mock):\\n repo = Repository()\\n db_instance = db_mock.return_value\\n db_instance.get_user_info.return_value = (1, {\\\"name\\\": \\\"Kari\\\"})\\n self.assertEquals(repo.get_user_info(\\\"123\\\"), (1, {\\\"name\\\": \\\"Kari\\\"}))\",\n \"def test_get_owned(self):\\n user = User.create(name='foo', email='foo@bar.com')\\n user.put()\\n response = self.testapp.get(\\n '/api/users/{}'.format(user.uid),\\n headers=self.login_headers(user),\\n )\\n response_dict = json.loads(response.body)\\n self.assertEqual(response_dict['uid'], user.uid)\",\n \"def test_anonymize_user_data(api_client, resource_in_unit, user):\\n user.first_name = 'testi_ukkeli'\\n user.save()\\n original_uuid = user.uuid\\n original_email = user.email\\n user_pk = user.pk\\n\\n SocialAccount.objects.create(user=user, uid=original_uuid, provider='helsinki')\\n EmailAddress.objects.create(user=user, email=original_email)\\n\\n Reservation.objects.create(\\n resource=resource_in_unit,\\n begin='2015-04-04T09:00:00+02:00',\\n end='2015-04-04T10:00:00+02:00',\\n user=user,\\n reserver_name='John Smith',\\n event_subject='John\\\\'s welcome party',\\n state=Reservation.CONFIRMED\\n )\\n # anonymize_user_data expects a queryset instead of single object\\n test_user = get_user_model().objects.filter(first_name='testi_ukkeli')\\n anonymize_user_data(modeladmin=None, request=None, queryset=test_user)\\n assert get_user_model().objects.filter(first_name='testi_ukkeli').count() == 0\\n reservation = Reservation.objects.get(resource=resource_in_unit)\\n assert reservation.event_description == 'Sensitive data of this reservation has been anonymized by a script.'\\n changed_user = get_user_model().objects.get(pk=user_pk)\\n assert changed_user.uuid != original_uuid\\n assert reservation.state == Reservation.CANCELLED\\n assert not SocialAccount.objects.filter(user=user, uid=original_uuid).exists()\\n assert not EmailAddress.objects.filter(user=user, email=original_email).exists()\",\n \"def test_get_for_user_no_user(self):\\n self.assertIsNone(Tour.objects.get_for_user(User()))\",\n \"def test_user(self):\\n user = User.objects.get(username=\\\"test01\\\")\\n print(user.username)\\n print(user.email)\\n self.assertEqual(user.email,\\\"test01@email.com\\\")\\n # cat = Animal.objects.get(name=\\\"cat\\\")\\n # self.assertEqual(lion.speak(), 'The lion says \\\"roar\\\"')\\n # self.assertEqual(cat.speak(), 'The cat says \\\"meow\\\"')\",\n \"def test_duo_account_get(self):\\n pass\",\n \"def test_user(self):\\n\\n user = User.query.filter(User.user_fname == \\\"Smokey\\\").first()\\n self.assertEqual(user.user_fname, \\\"Smokey\\\")\",\n \"def test_user_activation(self):\\n user = User.objects.get()\\n response = self.client.get(reverse('accounts:user-activate',\\n kwargs={'uidb64': urlsafe_base64_encode(force_bytes(user.pk)),\\n 'token': account_activation_token.make_token(user)}))\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\",\n \"def test_gets_user_by_email(self):\\r\\n User.objects.create(email='another_user@example.com')\\r\\n desired_user = User.objects.create(email='edith@example.com')\\r\\n found_user = PasswordlessAuthenticationBackend().get_user('edith@example.com')\\r\\n self.assertEqual(desired_user, found_user)\",\n \"def test_read_by_random_logged_in_user(self):\\n user = UserFactory()\\n\\n self.assert_user_cannot_read(user, self.live)\",\n \"def test_get_website_user_returns_user(self):\\n user = get_website_user()\\n self.assertTrue(user)\",\n \"def test_order_from_user(self):\\n new_user = self.create_test_user()\\n new_order = OrderInfo.objects.create(user=new_user)\\n self.assertEqual(new_order.user, new_user)\",\n \"def test_user_instance(self):\\n db.session.add(self.user)\\n db.session.commit()\\n\\n user = User.query.filter_by(user_name = \\\"john_doe\\\").first()\\n users = User.query.all()\\n\\n self.assertTrue(len(users) > 0)\\n self.assertEqual(user.user_name, \\\"john_doe\\\")\\n self.assertEqual(user.email, \\\"johndoe@example.com\\\")\\n self.assertEqual(user.profile_pic_path, \\\"app/static/images\\\")\\n self.assertEqual(user.first_name, \\\"John\\\")\\n self.assertEqual(user.last_name, \\\"Doe\\\")\\n self.assertEqual(user.headline, \\\"Food Blogger\\\")\\n self.assertEqual(user.bio, \\\"Mainly writes on Chinese cuisine\\\")\",\n \"def test_user_creation(self):\\n self.assertTrue(User.objects.exists())\",\n \"def test_func(self, user):\\n return self.get_object().admin == user\",\n \"def test_list_user(self):\\n pass\",\n \"def test_user_is_really_deleted():\\n response = api_helper.get_user(user_id=pytest.test_user.id)\\n assert response.status_code == 200\\n assert len(response.json()['data']) == 0\",\n \"def ____test_sys_archived(self):\\n # TODO archinging not working\\n with ts.SetupDbAndCredentials() as s:\\n args = [\\\"--archived\\\", \\\"--skip-albums\\\", \\\"--start-date\\\", \\\"2017-01-01\\\"]\\n s.test_setup(\\n \\\"test_sys_archived\\\", args=args, trash_files=True, trash_db=True\\n )\\n s.gp.start(s.parsed_args)\\n\\n db = LocalData(s.root)\\n\\n # Total of 1 out of media items\\n db.cur.execute(\\\"SELECT COUNT() FROM SyncFiles\\\")\\n count = db.cur.fetchone()\\n self.assertEqual(1, count[0])\",\n \"def testGetUserIgnoresCase(self):\\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n result = yield self.facade.getUser(session, u'uSeR')\\n self.assertEqual(u'user', result.username)\",\n \"def testGetAccessAllowed(self):\\n for user in (self.guest, self.contributor, self.delegate, self.owner, self.root):\\n response = self.runGet(user, sequencer=self.hiseq2000.sodar_uuid)\\n self.response_200(response)\\n data = json.loads(response.content.decode(\\\"utf-8\\\"))\\n self.assertEqual(data[\\\"sodar_uuid\\\"], str(self.hiseq2000.sodar_uuid))\",\n \"def test_show(self):\\n\\n with self.client as c:\\n response = c.get(f\\\"/users/{self.testuser.id}\\\")\\n\\n self.assertEqual(response.status_code, 200)\\n self.assertIn(\\\"@alice\\\", str(response.data))\",\n \"def test_getUser(self):\\n\\t\\turl = \\\"/users/2/\\\"\\n\\t\\tresponse = self.client.get(url, format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\tself.assertEqual(response.data[\\\"id\\\"], 2)\\n\\t\\tself.assertEqual(response.data[\\\"username\\\"], \\\"testUser2\\\")\",\n \"def test_valid_dropbox_user(self):\\n user = User.objects.get(id=107)\\n\\n tester = DropboxAuthTester()\\n self.assertTrue(tester.can_auth(user))\",\n \"def test_get_user_by_emailuser_email_get(self):\\n pass\",\n \"def test_movies_limited_to_user(self):\\n user2 = get_user_model().objects.create_user(\\n 'other@youremail.com',\\n 'pass123'\\n )\\n sample_movie(user=user2)\\n sample_movie(user=self.user)\\n\\n res = self.client.get(MOVIES_URL)\\n\\n movies = Movie.objects.filter(user=self.user)\\n serializer = MovieSerializer(movies, many=True)\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(len(res.data), 1)\\n self.assertEqual(res.data, serializer.data)\",\n \"def test_get_users(user_store: MockStore, user_email: str, username: str):\\n # GIVEN a database with a user\\n\\n # WHEN getting users\\n users: List[User] = user_store.get_users(name=username, email=user_email)\\n\\n # THEN the user should be returned\\n assert users[0].email == user_email\",\n \"def test_get_users_from_passwd():\\n users = Users.from_passwd()\\n assert isinstance(users, Users)\",\n \"def test_detailview_read_for_anonymous_user(self):\\n\\n for user in self.users:\\n detailview = reverse('account_detail', args=(user.uuid,))\\n response = self.client.get(detailview)\\n\\n self.assertEqual(response.status_code, 302)\",\n \"def test_18_admin_user_export_authenticated(self):\\r\\n self.register()\\r\\n self.signout()\\r\\n self.register(fullname=\\\"Juan Jose\\\", name=\\\"juan\\\",\\r\\n email=\\\"juan@juan.com\\\", password=\\\"juan\\\")\\r\\n\\r\\n # No matter what params in the request, Forbidden is raised\\r\\n res = self.app.get('/admin/users/export', follow_redirects=True)\\r\\n assert res.status_code == 403, res.status_code\\r\\n res = self.app.get('/admin/users/export?firmit=', follow_redirects=True)\\r\\n assert res.status_code == 403, res.status_code\\r\\n res = self.app.get('/admin/users/export?format=bad',\\r\\n follow_redirects=True)\\r\\n assert res.status_code == 403, res.status_code\\r\\n res = self.app.get('/admin/users/export?format=json',\\r\\n follow_redirects=True)\\r\\n assert res.status_code == 403, res.status_code\",\n \"def test_single_success():\\n test_username = \\\"test_user\\\"\\n\\n user = UserFactory.create(username=test_username, is_active=True)\\n UserSocialAuthFactory.create(user=user, provider=\\\"edX\\\")\\n\\n assert user.is_active is True\\n assert \\\"retired_email\\\" not in user.email\\n assert UserSocialAuth.objects.filter(user=user).count() == 1\\n\\n COMMAND.handle(\\\"retire_users\\\", users=[test_username])\\n\\n user.refresh_from_db()\\n assert user.is_active is False\\n assert \\\"retired_email\\\" in user.email\\n assert UserSocialAuth.objects.filter(user=user).count() == 0\",\n \"def test_get_website_user_returns_same_user(self):\\n user = get_website_user()\\n self.assertEqual(get_website_user(), user)\",\n \"def test_reteta_limited_to_user(self):\\n user2 = get_user_model().objects.create_user(\\n 'other@chris.com',\\n 'testpass'\\n )\\n sample_reteta(user=user2)\\n sample_reteta(user=self.user)\\n\\n res = self.client.get(RETETA_URL)\\n rete = Reteta.objects.filter(user=self.user)\\n serializer = RetetaSerializer(rete, many=True) # return list\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(len(res.data), 1)\\n self.assertEqual(res.data, serializer.data)\",\n \"def test_get_id(self):\\r\\n # the migration adds an initial admin user to the system\\r\\n user = UserMgr.get(user_id=1)\\r\\n self.assertEqual(\\r\\n user.id,\\r\\n 1,\\r\\n \\\"Should have a user id of 1: \\\" + str(user.id))\\r\\n self.assertEqual(\\r\\n user.username,\\r\\n 'admin',\\r\\n \\\"Should have a username of admin: \\\" + user.username)\",\n \"def test_resource_user_resource_get_current_user_get(self):\\n pass\",\n \"def test_resource_user_resource_get_user_by_email_address_get(self):\\n pass\",\n \"def test_create_user(self):\\n User.objects.create_user(username='abc', password='abcpass', email='abc@example.com')\\n user_obj = User.objects.get(username='abc')\\n self.assertTrue(user_obj.email, \\\"abc@example.com\\\")\\n self.assertEqual(str(user_obj), \\\"abc\\\")\",\n \"def test_access_positive(self, api):\\n self.builder.add_user(api.get_user())\\n self.builder.upd_access(api.get_user(), False)\\n r1 = api.access_user(api.get_user(), True)\\n access_true = self.builder.get_access(api.get_user())\\n self.builder.del_user(api.get_user())\\n assert access_true == 1\\n assert r1.status_code == 200\",\n \"def testGetAccessAllowed(self):\\n for user in (self.guest, self.contributor, self.delegate, self.owner, self.root):\\n response = self.runGet(user, sequencer=self.hiseq2000.vendor_id)\\n self.response_200(response)\\n data = json.loads(response.content.decode(\\\"utf-8\\\"))\\n self.assertEqual(data[\\\"sodar_uuid\\\"], str(self.hiseq2000.sodar_uuid))\",\n \"def test_saved_articles_GET_3(self):\\r\\n\\r\\n u1 = User.query.filter_by(username='testuser').one()\\r\\n\\r\\n with self.client as c:\\r\\n with c.session_transaction() as sess:\\r\\n sess[CURR_USER_KEY] = u1.id\\r\\n response = c.get('/users/anotherUser/location',\\r\\n follow_redirects=True)\\r\\n self.assertEqual(response.status_code, 200)\\r\\n self.assertIn(b'Unauthorized.', response.data)\",\n \"def testDeleteUser(self):\\n UserAPI().create([(u'test', u'secret', u'name', u'name@example.com')],\\n createPrivateNamespace=False)\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n yield self.facade.deleteUser(session, u'test')\\n\\n self.store.rollback()\\n self.assertIdentical(None, getUser(u'test'))\",\n \"def test_delete_user(self):\\n pass\",\n \"def test_delete_user(self):\\n pass\",\n \"def test_get_user(\\n self,\\n mixin,\\n mdb,\\n muser_query,\\n get_user,\\n mrequest,\\n mdecoded_jwt,\\n ):\\n mquery = muser_query.return_value\\n\\n assert get_user(\\n mixin, dbsession=mdb) == mquery.get_by_id.return_value\\n mquery.get_by_id.assert_called_once_with(sentinel.user_id)\",\n \"def test_search_user(self):\\n self.maya.save_profile()\\n user = Profile.search_users(self.maya.username)\\n self.assertTrue(user.username==\\\"Maya\\\")\",\n \"def mock_get_real_user(_anon_id):\\r\\n return self.user\",\n \"def test_get_by_id_false(self):\\n\\n user = CustomUser.get_by_id(44444)\\n\\n self.assertIsNone(user)\",\n \"def test_myaccount(self):\\n create_user_object()\\n self.client.login(username='testuser', password='testabc123')\\n response = self.client.get(reverse('infinite:myaccount'))\\n self.assertEqual(response.status_code, 200)\",\n \"def test_get_non_owner(self):\\n another_user = CustomUser(id=101, email='another_user@mail.com', is_active=True)\\n another_user.set_password('testpassword')\\n another_user.save()\\n self.client.login(email='another_user@mail.com', password='testpassword')\\n\\n url = reverse('route', kwargs={'way_id': self.route.way_id, 'route_id': self.route.id})\\n response = self.client.get(url)\\n self.assertEqual(response.status_code, 403)\",\n \"def test_user_auth(self):\\n self.new_user.save_login()\\n test_user=User(\\\"trinity\\\",\\\"trinity@gmail.com\\\",\\\"123\\\")\\n test_user.save_login()\\n self.assertTrue(self.new_user.users_auth(\\\"trinity\\\",\\\"123\\\"))\",\n \"def test_users_username_get(self):\\n pass\",\n \"def test_get_all(self):\\n\\n # Select on empty set\\n selected = self.user_api.get_all()\\n self.assertTrue(selected.success)\\n self.assertFalse(selected.documents)\\n\\n # Inserting several users\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertTrue(inserted.success)\\n another_user = MAGEN_USER.copy()\\n another_user.pop('user_uuid')\\n another_user['username'] = 'test_another_username'\\n another_user['first_name'] = 'test_another_f_name'\\n inserted = self.user_api.insert_user(another_user)\\n self.assertTrue(inserted.success)\\n\\n # Select all users from Database\\n selected = self.user_api.get_all()\\n self.assertTrue(selected.success)\\n self.assertEqual(len(selected.documents), 2)\\n self.assertEqual(selected.documents[0], MAGEN_USER)\\n # Verify that user_uuid was generated\\n self.assertIn('user_uuid', selected.documents[1])\\n # Verify that other keys were inserted\\n self.assertEqual(selected.documents[1], another_user)\",\n \"def test_get_user(self):\\n print('(' + self.test_get_user.__name__+')', self.test_get_user.__doc__)\\n # test for patient\\n self.assertDictContainsSubset(\\n self.connection.get_user(PATIENT_USERNAME), PATIENT)\\n # test for doctor\\n self.assertDictContainsSubset(\\n self.connection.get_user(DOCTOR_USERNAME), DOCTOR)\",\n \"def test_get_superuser(self):\\n url = reverse('projectroles:api_user_current')\\n response = self.request_knox(url)\\n self.assertEqual(response.status_code, 200)\\n response_data = json.loads(response.content)\\n expected = {\\n 'username': self.user.username,\\n 'name': self.user.name,\\n 'email': self.user.email,\\n 'is_superuser': True,\\n 'sodar_uuid': str(self.user.sodar_uuid),\\n }\\n self.assertEqual(response_data, expected)\",\n \"def test_get_file(self):\\n django_file = None\\n \\n with open(TEST_AVATAR_PATH, 'rb') as avatar:\\n self.user.avatar_tmp = File(avatar)\\n self.user.save()\\n\\n with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:\\n archive.add_model_file(self.user.avatar_tmp)\\n\\n django_file = archive.get_file()\\n archive_path = archive.file_path\\n\\n self.assertIsNotNone(archive_path)\\n self.assertEqual(django_file.name, archive.file_path)\\n self.assertFalse(django_file.closed)\\n\\n self.assertIsNone(archive.file)\\n self.assertIsNone(archive.file_path)\\n self.assertTrue(django_file.closed)\",\n \"def get(self, user_id):\\n\\n user = User.objects.get_or_404(public_id=user_id)\\n return user_schema.dump(user)\",\n \"def test_retrieve_author_unlogged(self):\\n request = self.client.get(self.epoint)\\n\\n self.assertEqual(request.status_code, status.HTTP_200_OK)\",\n \"def test_user_delete_GET_3(self):\\r\\n\\r\\n u1 = User.query.filter_by(username='testuser').one()\\r\\n\\r\\n with self.client as c:\\r\\n with c.session_transaction() as sess:\\r\\n sess[CURR_USER_KEY] = u1.id\\r\\n response = c.get('/users/anotherUser/location',\\r\\n follow_redirects=True)\\r\\n self.assertEqual(response.status_code, 200)\\r\\n self.assertIn(b'Unauthorized.', response.data)\",\n \"def test_correct_user(self):\\n\\n self.create_user('Henrik', 1)\\n self.create_user('Henrik2', 2)\\n self.create_user('Test', 3)\\n\\n resp = self.client.get('/api/users/Henrik/')\\n self.assertEquals(resp.json['total-users'], 2)\",\n \"def test_check_user(self):\\n self.new_user.save_user()\\n test_user = User(\\\"Test\\\", \\\"user\\\", \\\"test\\\", \\\"walIas15\\\")\\n test_user.save_user()\\n test_user.check_user(\\\"test\\\", \\\"walIas15\\\")\",\n \"def test_get_superuser(self):\\n url = reverse('projectroles:api_user_list')\\n response = self.request_knox(url) # Default token is for superuser\\n self.assertEqual(response.status_code, 200)\\n response_data = json.loads(response.content)\\n self.assertEqual(len(response_data), 4)\\n expected = [\\n self.get_serialized_user(self.user),\\n self.get_serialized_user(self.user_owner_cat),\\n self.get_serialized_user(self.user_owner),\\n self.get_serialized_user(self.domain_user),\\n ]\\n self.assertEqual(response_data, expected)\",\n \"def test_logged_in_permission_another_user_borrowed_book(self):\\n login = self.client.login(\\n username='testuser2',\\n password='2HJ1vRV0Z&3iD')\\n response = self.client.get(\\n reverse('librarian-renew-book',\\n kwargs={'pk': self.test_bookinstance1.pk}))\\n self.assertEqual(response.status_code, 200)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7456595","0.738311","0.65067285","0.6436026","0.63516873","0.62399125","0.6210579","0.62046766","0.617632","0.61279947","0.61279947","0.6096413","0.60939574","0.6072748","0.5998641","0.59969604","0.5986697","0.59809977","0.59688866","0.596384","0.59557086","0.59448594","0.59353614","0.5930595","0.5923798","0.5919316","0.59006727","0.5891542","0.58772296","0.58764637","0.5873837","0.5873381","0.58666587","0.58600044","0.5857122","0.5833414","0.5805385","0.58050966","0.57955724","0.57920575","0.57918656","0.57822746","0.5776437","0.5775343","0.5765426","0.57418144","0.57391775","0.5729574","0.5723857","0.5700441","0.56964","0.5689918","0.5685023","0.56834996","0.5669884","0.5665975","0.5650495","0.56501955","0.56461257","0.56424785","0.5641481","0.563433","0.5634316","0.56320417","0.5629713","0.5629351","0.56241864","0.5623809","0.56193364","0.5618339","0.5601083","0.55923533","0.5585642","0.5579482","0.5578941","0.55753577","0.55688584","0.5568327","0.55663574","0.55624175","0.55624175","0.5562375","0.5558969","0.55587995","0.5545336","0.55423707","0.5540989","0.55397326","0.55376345","0.55361384","0.55247885","0.5521566","0.5521301","0.55199283","0.5517781","0.55082566","0.5500523","0.5500111","0.54981273","0.5497722"],"string":"[\n \"0.7456595\",\n \"0.738311\",\n \"0.65067285\",\n \"0.6436026\",\n \"0.63516873\",\n \"0.62399125\",\n \"0.6210579\",\n \"0.62046766\",\n \"0.617632\",\n \"0.61279947\",\n \"0.61279947\",\n \"0.6096413\",\n \"0.60939574\",\n \"0.6072748\",\n \"0.5998641\",\n \"0.59969604\",\n \"0.5986697\",\n \"0.59809977\",\n \"0.59688866\",\n \"0.596384\",\n \"0.59557086\",\n \"0.59448594\",\n \"0.59353614\",\n \"0.5930595\",\n \"0.5923798\",\n \"0.5919316\",\n \"0.59006727\",\n \"0.5891542\",\n \"0.58772296\",\n \"0.58764637\",\n \"0.5873837\",\n \"0.5873381\",\n \"0.58666587\",\n \"0.58600044\",\n \"0.5857122\",\n \"0.5833414\",\n \"0.5805385\",\n \"0.58050966\",\n \"0.57955724\",\n \"0.57920575\",\n \"0.57918656\",\n \"0.57822746\",\n \"0.5776437\",\n \"0.5775343\",\n \"0.5765426\",\n \"0.57418144\",\n \"0.57391775\",\n \"0.5729574\",\n \"0.5723857\",\n \"0.5700441\",\n \"0.56964\",\n \"0.5689918\",\n \"0.5685023\",\n \"0.56834996\",\n \"0.5669884\",\n \"0.5665975\",\n \"0.5650495\",\n \"0.56501955\",\n \"0.56461257\",\n \"0.56424785\",\n \"0.5641481\",\n \"0.563433\",\n \"0.5634316\",\n \"0.56320417\",\n \"0.5629713\",\n \"0.5629351\",\n \"0.56241864\",\n \"0.5623809\",\n \"0.56193364\",\n \"0.5618339\",\n \"0.5601083\",\n \"0.55923533\",\n \"0.5585642\",\n \"0.5579482\",\n \"0.5578941\",\n \"0.55753577\",\n \"0.55688584\",\n \"0.5568327\",\n \"0.55663574\",\n \"0.55624175\",\n \"0.55624175\",\n \"0.5562375\",\n \"0.5558969\",\n \"0.55587995\",\n \"0.5545336\",\n \"0.55423707\",\n \"0.5540989\",\n \"0.55397326\",\n \"0.55376345\",\n \"0.55361384\",\n \"0.55247885\",\n \"0.5521566\",\n \"0.5521301\",\n \"0.55199283\",\n \"0.5517781\",\n \"0.55082566\",\n \"0.5500523\",\n \"0.5500111\",\n \"0.54981273\",\n \"0.5497722\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81311107"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83697,"cells":{"query":{"kind":"string","value":"Test getting an archived user from the database."},"document":{"kind":"string","value":"def test_get_user_including_archive_false(user_store: MockStore, archived_user_email: str):\n # GIVEN a database with an archived user\n\n # WHEN querying for a user\n user: User = user_store.get_user(email=archived_user_email, exclude_archived=True)\n\n # THEN no user should be returned\n assert not user"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_get_user_including_archived(user_store: MockStore, archived_user_email: str):\n # GIVEN a database with an archived user\n\n # WHEN querying for a user\n user: User = user_store.get_user(email=archived_user_email, exclude_archived=False)\n\n # THEN it should be returned\n assert user.email == archived_user_email","def test_get_users_including_archived(user_store: MockStore, user_email: str, username: str):\n # GIVEN a database with a user and an archived user\n StoreHelpers.add_user(\n name=username, email=\"old.user@magnolia.com\", store=user_store, is_archived=True\n )\n\n # WHEN getting users\n users: List[User] = user_store.get_users(name=username, exclude_archived=False)\n\n # THEN the two users should be returned\n assert len(users) == 2","def test_archive(self):\n thread = self.create_thread()\n ut = UserThread.objects.get(\n user=thread.recipients.first(), thread=thread)\n ut_id = ut.pk\n ut.archive()\n ut = UserThread.objects.get(pk=ut_id)\n self.assertEqual(ut.status, 'archived')","def test_get_user_by_uuiduser_uuid_get(self):\n pass","def test_api_user_get(self):\n pass","def test_user(self):\n u = self.d.user('example')\n self.assertEqual(u.username, 'example')\n self.assertEqual(u.name, 'Example Sampleman')","def test_get_user(user_store: MockStore, user_email: str):\n # GIVEN a database with a user\n\n # WHEN querying for a user\n user: User = user_store.get_user(email=user_email)\n\n # THEN it should be returned\n assert user.email == user_email","def test_read_user(self):\n pass","def testGetUser(self):\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\n user = getUser(u'user')\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n result = yield self.facade.getUser(session, u'user')\n self.assertEqual(u'user', result.username)\n self.assertEqual(str(user.objectID), result.objectId)\n self.assertEqual(u'User', result.name)\n self.assertEqual(u'USER', result.role)","def test_users_get(self):\n pass","def test_users_get(self):\n pass","def test_get_user(sample_user):\n\n client = auth_client(APIClient(), sample_user.email, \"testpassword\")\n\n response = client.get(reverse(\"user-detail\"), format=\"json\")\n assert response.status_code == status.HTTP_200_OK\n assert json.dumps(response.data) == json.dumps(\n {\"id\": sample_user.pk, \"email\": sample_user.email}\n )","def test_view_activar_usuario(self):\n # se loguea el usuario testuser\n user = self.client.login(username='testuser', password='test')\n self.assertTrue(user)\n # se crea un usuario\n user = User.objects.create_user(username='user_prueba', email='test@test5.com', password='prueba')\n usuario_prueba = Usuario.objects.create(user=user, telefono='222', direccion='Avenida', documento='12345')\n # se marca al usuario como inactivo\n usuario_prueba.user.is_active = False\n usuario_prueba.save()\n self.assertEqual(usuario_prueba.user.is_active, False)\n # se marca al usuario como activo\n usuario_prueba.user.is_active = True\n usuario_prueba.save()\n\n self.assertEqual(usuario_prueba.user.is_active, True)\n\n print 'Test de activar_usuario realizado exitosamente'","def test_get_by_id(self):\n\n user = CustomUser.get_by_id(2)\n expected_user = CustomUser.objects.get(id=2)\n self.assertEqual(user, expected_user)","def test_user(self):\n return True","def test_get_user_by_name(self):\n\n # Select on empty set\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\n self.assertFalse(selected.success)\n self.assertIsNone(selected.documents)\n\n # Insert user\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertTrue(inserted.success)\n\n # Select user by username\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\n self.assertTrue(selected.success)\n self.assertEqual(selected.documents, MAGEN_USER)","def test_get_other_user(self):\n url = self.get_url(self.inactive_user.id)\n self.inactive_user.is_active = True\n self.inactive_user.save()\n\n with authenticated_user_api_client(self.client, self.active_user):\n expected_response_code = 200\n expected_fields = set(User.get_public_fields())\n response = self.client.get(url)\n\n response_fields = set(response.data.keys())\n self.assertEqual(response.status_code, expected_response_code)\n self.assertEqual(response_fields, expected_fields)","def test_func(self, user, **kwargs):\n return self.get_object().authorized_user(user)","def test_resource_user_resource_get_user_get(self):\n pass","def test_detail(self, client, users):\n user = users[0]\n url = reverse('users:detail', args=(user.pk,))\n response = client.get(url)\n assert response.status_code == 200\n assert user.username in str(response.content)","def test_get_users(self):\n pass","def test_user_id_get(self):\n pass","def test_good_user(self):\n user = self.datautils.create_user()\n self.request.user = user\n self.request.matchdict = {'user_id': int(user.id)}\n result = user_id_get_view(self.request)['d']\n expected = {\n 'id': user.id,\n 'username': user.username,\n 'created': user.created,\n 'email': user.email,\n }\n self.assertEqual(result, expected)","def test_retrieve(self):\n users = CalendallUser.objects.all()\n self.check_attrs_helper(users)","def test_get_user(self):\n user = User(self.client, \"test-user\", {})\n\n self.assertEqual(user.username, \"test-user\")\n self.assertEqual(user.email, \"test-user@linode.com\")\n self.assertTrue(user.restricted)\n self.assertTrue(user.tfa_enabled)\n self.assertIsNotNone(user.ssh_keys)","def test_detail_user(self):\n \n for user in User.objects.filter(Q(groups__name='Administrator') | Q(\n groups__name='Viewer') | Q(groups__name='User')):\n\n token = get_token(user)\n\n url_detail_user = reverse(\n 'user_get_retrieve_destroy_update', args=[user.organization_member.pk])\n\n response = self.client.get(url_detail_user,\n HTTP_AUTHORIZATION=f\"JWT {token}\",\n format='json')\n\n # Validate status code response\n self.assertEqual(response.status_code, 200)\n\n org_comp = comparator_member(user.organization_member, response.data)\n self.assertEqual(org_comp, True)","def test_UserFromDB():\n assert UserFromDB(\"DIANE\").email == \"d@gmail.com\"\n assert UserFromDB(\"DIANE\").username == \"DIANE\"","def test_003_get_user(self, mock_db_query):\n mock_db_query.get.return_value = seller1\n\n response = self.app.get('/v1/users/' + str(seller1.identity), headers={'accept': 'application/json'})\n\n print(response.get_data().decode())\n\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response.json['first_name'], 'Lisa')","def test_get_user_by_username(self):\n\t\tusername_in_db = server.get_user_by_username('Natasha')\n\t\tself.assertTrue(username_in_db, 'Query did not fetch user object.')\n\t\tusername_not_in_db = server.get_user_by_username('xyz')\n\t\tself.assertFalse(username_not_in_db, 'Query fetched user that did not exist (xyz).')","def test_fake_user(self):\n user = User.objects.get(username=\"a\")\n\n tester = DropboxAuthTester()\n self.assertFalse(tester.can_auth(user))","def test_retrive_user(self):\n res = self.client.get(ME_URL)\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(res.data['email'], self.user.email)\n self.assertEqual(res.data['name'], self.user.name)\n self.assertNotIn('password', res.data)","def test_insert_get_user(self):\n\n # Select a user on an empty set\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\n self.assertFalse(selected.success)\n self.assertIsNone(selected.documents)\n\n # Inserting user into Database\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertTrue(inserted.success)\n\n # Verify that document was inserted\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\n self.assertTrue(selected.success)\n self.assertEqual(selected.documents, MAGEN_USER)\n\n # Inserting same user again (uuid and e-mail should be unique)\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertFalse(inserted.success)\n self.assertIn('user_uuid', inserted.message)","def test_archived(self):\n doc = DocumentFactory(title=u'impalas', locale=u'en-US', is_archived=True)\n ApprovedRevisionFactory(document=doc, summary=u'impalas', is_approved=True)\n\n self.refresh()\n\n # include_archived gets the above document\n qs = {'q': 'impalas', 'a': 1, 'w': 1, 'format': 'json',\n 'include_archived': 'on'}\n response = self.client.get(reverse('search.advanced'), qs)\n results = json.loads(response.content)['results']\n eq_(1, len(results))\n\n # no include_archived gets you nothing since the only\n # document in the index is archived\n qs = {'q': 'impalas', 'a': 0, 'w': 1, 'format': 'json'}\n response = self.client.get(reverse('search.advanced'), qs)\n results = json.loads(response.content)['results']\n eq_(0, len(results))","def testGet(self):\n userdict = {'id': 1,\n 'objectID': u'04585bec-28cf-4a21-bc3e-081f3ed62680',\n 'username': u'testuser',\n 'passwordHash': 'hash',\n 'fullname': u'Test User',\n 'email': u'test@example.com',\n 'role': Role.ANONYMOUS.id}\n self.cache.set('user:testuser', json.dumps(userdict))\n result = self.userCache.get(u'testuser')\n user = result.results\n self.assertEqual(1, user.id)\n self.assertEqual('04585bec-28cf-4a21-bc3e-081f3ed62680',\n str(user.objectID))\n self.assertEqual(u'testuser', user.username)\n self.assertEqual('hash', user.passwordHash)\n self.assertEqual(u'Test User', user.fullname)\n self.assertEqual(u'test@example.com', user.email)\n self.assertEqual(Role.ANONYMOUS, user.role)","def test_user_retrieve(self):\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.get_token())\n response = self.client.get(reverse(\"account:user-profile\"))\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data.get('user').get('email'), \"testuser@gmail.com\")","def test_get_single_user(self):\n user = add_user(\"neilb\", \"neilb14@mailinator.com\")\n with self.client:\n response = self.client.get(f'/users/{user.id}')\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 200)\n self.assertTrue('created_at' in data['data'])\n self.assertIn('neilb', data['data']['username'])\n self.assertIn('neilb14@mailinator.com', data['data']['email'])\n self.assertIn('success', data['status'])","def test_get(self):\n user = api.user.create(\n username='chuck',\n email='chuck@norris.org',\n password='secret',\n )\n\n self.assertEqual(api.user.get('chuck'), user)","def test_fetch_user(self):\n\n self.register_user()\n\n self.assertEqual(self.fetch_user_details().status_code, 200)\n\n self.assertTrue(self.fetch_user_details(\n ).json[\"data\"][0][\"username\"] == 'Bjorn')","def test_get_user_info_returns_user(self, db_mock):\n repo = Repository()\n db_instance = db_mock.return_value\n db_instance.get_user_info.return_value = (1, {\"name\": \"Kari\"})\n self.assertEquals(repo.get_user_info(\"123\"), (1, {\"name\": \"Kari\"}))","def test_view_desactivar_usuario(self):\n # se loguea el usuario testuser\n user = self.client.login(username='testuser', password='test')\n self.assertTrue(user)\n # se crea un usuario\n user = User.objects.create_user(username='user_prueba', email='test@test4.com', password='prueba')\n usuario_prueba = Usuario.objects.create(user=user, telefono='222', direccion='Avenida', documento='12345')\n # se marca al usuario como inactivo\n usuario_prueba.user.is_active = False\n usuario_prueba.save()\n\n self.assertEqual(usuario_prueba.user.is_active, False)\n\n print 'Test de desactivar_usuario realizado exitosamente'","def test_get_owned(self):\n user = User.create(name='foo', email='foo@bar.com')\n user.put()\n response = self.testapp.get(\n '/api/users/{}'.format(user.uid),\n headers=self.login_headers(user),\n )\n response_dict = json.loads(response.body)\n self.assertEqual(response_dict['uid'], user.uid)","def test_anonymize_user_data(api_client, resource_in_unit, user):\n user.first_name = 'testi_ukkeli'\n user.save()\n original_uuid = user.uuid\n original_email = user.email\n user_pk = user.pk\n\n SocialAccount.objects.create(user=user, uid=original_uuid, provider='helsinki')\n EmailAddress.objects.create(user=user, email=original_email)\n\n Reservation.objects.create(\n resource=resource_in_unit,\n begin='2015-04-04T09:00:00+02:00',\n end='2015-04-04T10:00:00+02:00',\n user=user,\n reserver_name='John Smith',\n event_subject='John\\'s welcome party',\n state=Reservation.CONFIRMED\n )\n # anonymize_user_data expects a queryset instead of single object\n test_user = get_user_model().objects.filter(first_name='testi_ukkeli')\n anonymize_user_data(modeladmin=None, request=None, queryset=test_user)\n assert get_user_model().objects.filter(first_name='testi_ukkeli').count() == 0\n reservation = Reservation.objects.get(resource=resource_in_unit)\n assert reservation.event_description == 'Sensitive data of this reservation has been anonymized by a script.'\n changed_user = get_user_model().objects.get(pk=user_pk)\n assert changed_user.uuid != original_uuid\n assert reservation.state == Reservation.CANCELLED\n assert not SocialAccount.objects.filter(user=user, uid=original_uuid).exists()\n assert not EmailAddress.objects.filter(user=user, email=original_email).exists()","def test_get_for_user_no_user(self):\n self.assertIsNone(Tour.objects.get_for_user(User()))","def test_user(self):\n user = User.objects.get(username=\"test01\")\n print(user.username)\n print(user.email)\n self.assertEqual(user.email,\"test01@email.com\")\n # cat = Animal.objects.get(name=\"cat\")\n # self.assertEqual(lion.speak(), 'The lion says \"roar\"')\n # self.assertEqual(cat.speak(), 'The cat says \"meow\"')","def test_duo_account_get(self):\n pass","def test_user(self):\n\n user = User.query.filter(User.user_fname == \"Smokey\").first()\n self.assertEqual(user.user_fname, \"Smokey\")","def test_user_activation(self):\n user = User.objects.get()\n response = self.client.get(reverse('accounts:user-activate',\n kwargs={'uidb64': urlsafe_base64_encode(force_bytes(user.pk)),\n 'token': account_activation_token.make_token(user)}))\n self.assertEqual(response.status_code, status.HTTP_200_OK)","def test_gets_user_by_email(self):\r\n User.objects.create(email='another_user@example.com')\r\n desired_user = User.objects.create(email='edith@example.com')\r\n found_user = PasswordlessAuthenticationBackend().get_user('edith@example.com')\r\n self.assertEqual(desired_user, found_user)","def test_read_by_random_logged_in_user(self):\n user = UserFactory()\n\n self.assert_user_cannot_read(user, self.live)","def test_get_website_user_returns_user(self):\n user = get_website_user()\n self.assertTrue(user)","def test_order_from_user(self):\n new_user = self.create_test_user()\n new_order = OrderInfo.objects.create(user=new_user)\n self.assertEqual(new_order.user, new_user)","def test_user_instance(self):\n db.session.add(self.user)\n db.session.commit()\n\n user = User.query.filter_by(user_name = \"john_doe\").first()\n users = User.query.all()\n\n self.assertTrue(len(users) > 0)\n self.assertEqual(user.user_name, \"john_doe\")\n self.assertEqual(user.email, \"johndoe@example.com\")\n self.assertEqual(user.profile_pic_path, \"app/static/images\")\n self.assertEqual(user.first_name, \"John\")\n self.assertEqual(user.last_name, \"Doe\")\n self.assertEqual(user.headline, \"Food Blogger\")\n self.assertEqual(user.bio, \"Mainly writes on Chinese cuisine\")","def test_user_creation(self):\n self.assertTrue(User.objects.exists())","def test_func(self, user):\n return self.get_object().admin == user","def test_list_user(self):\n pass","def test_user_is_really_deleted():\n response = api_helper.get_user(user_id=pytest.test_user.id)\n assert response.status_code == 200\n assert len(response.json()['data']) == 0","def testGetUserIgnoresCase(self):\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n result = yield self.facade.getUser(session, u'uSeR')\n self.assertEqual(u'user', result.username)","def testGetAccessAllowed(self):\n for user in (self.guest, self.contributor, self.delegate, self.owner, self.root):\n response = self.runGet(user, sequencer=self.hiseq2000.sodar_uuid)\n self.response_200(response)\n data = json.loads(response.content.decode(\"utf-8\"))\n self.assertEqual(data[\"sodar_uuid\"], str(self.hiseq2000.sodar_uuid))","def test_getUser(self):\n\t\turl = \"/users/2/\"\n\t\tresponse = self.client.get(url, format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\tself.assertEqual(response.data[\"id\"], 2)\n\t\tself.assertEqual(response.data[\"username\"], \"testUser2\")","def test_show(self):\n\n with self.client as c:\n response = c.get(f\"/users/{self.testuser.id}\")\n\n self.assertEqual(response.status_code, 200)\n self.assertIn(\"@alice\", str(response.data))","def ____test_sys_archived(self):\n # TODO archinging not working\n with ts.SetupDbAndCredentials() as s:\n args = [\"--archived\", \"--skip-albums\", \"--start-date\", \"2017-01-01\"]\n s.test_setup(\n \"test_sys_archived\", args=args, trash_files=True, trash_db=True\n )\n s.gp.start(s.parsed_args)\n\n db = LocalData(s.root)\n\n # Total of 1 out of media items\n db.cur.execute(\"SELECT COUNT() FROM SyncFiles\")\n count = db.cur.fetchone()\n self.assertEqual(1, count[0])","def test_get_user_by_emailuser_email_get(self):\n pass","def test_valid_dropbox_user(self):\n user = User.objects.get(id=107)\n\n tester = DropboxAuthTester()\n self.assertTrue(tester.can_auth(user))","def test_get_users(user_store: MockStore, user_email: str, username: str):\n # GIVEN a database with a user\n\n # WHEN getting users\n users: List[User] = user_store.get_users(name=username, email=user_email)\n\n # THEN the user should be returned\n assert users[0].email == user_email","def test_get_users_from_passwd():\n users = Users.from_passwd()\n assert isinstance(users, Users)","def test_movies_limited_to_user(self):\n user2 = get_user_model().objects.create_user(\n 'other@youremail.com',\n 'pass123'\n )\n sample_movie(user=user2)\n sample_movie(user=self.user)\n\n res = self.client.get(MOVIES_URL)\n\n movies = Movie.objects.filter(user=self.user)\n serializer = MovieSerializer(movies, many=True)\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(len(res.data), 1)\n self.assertEqual(res.data, serializer.data)","def test_detailview_read_for_anonymous_user(self):\n\n for user in self.users:\n detailview = reverse('account_detail', args=(user.uuid,))\n response = self.client.get(detailview)\n\n self.assertEqual(response.status_code, 302)","def test_single_success():\n test_username = \"test_user\"\n\n user = UserFactory.create(username=test_username, is_active=True)\n UserSocialAuthFactory.create(user=user, provider=\"edX\")\n\n assert user.is_active is True\n assert \"retired_email\" not in user.email\n assert UserSocialAuth.objects.filter(user=user).count() == 1\n\n COMMAND.handle(\"retire_users\", users=[test_username])\n\n user.refresh_from_db()\n assert user.is_active is False\n assert \"retired_email\" in user.email\n assert UserSocialAuth.objects.filter(user=user).count() == 0","def test_get_website_user_returns_same_user(self):\n user = get_website_user()\n self.assertEqual(get_website_user(), user)","def test_18_admin_user_export_authenticated(self):\r\n self.register()\r\n self.signout()\r\n self.register(fullname=\"Juan Jose\", name=\"juan\",\r\n email=\"juan@juan.com\", password=\"juan\")\r\n\r\n # No matter what params in the request, Forbidden is raised\r\n res = self.app.get('/admin/users/export', follow_redirects=True)\r\n assert res.status_code == 403, res.status_code\r\n res = self.app.get('/admin/users/export?firmit=', follow_redirects=True)\r\n assert res.status_code == 403, res.status_code\r\n res = self.app.get('/admin/users/export?format=bad',\r\n follow_redirects=True)\r\n assert res.status_code == 403, res.status_code\r\n res = self.app.get('/admin/users/export?format=json',\r\n follow_redirects=True)\r\n assert res.status_code == 403, res.status_code","def test_reteta_limited_to_user(self):\n user2 = get_user_model().objects.create_user(\n 'other@chris.com',\n 'testpass'\n )\n sample_reteta(user=user2)\n sample_reteta(user=self.user)\n\n res = self.client.get(RETETA_URL)\n rete = Reteta.objects.filter(user=self.user)\n serializer = RetetaSerializer(rete, many=True) # return list\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(len(res.data), 1)\n self.assertEqual(res.data, serializer.data)","def test_get_id(self):\r\n # the migration adds an initial admin user to the system\r\n user = UserMgr.get(user_id=1)\r\n self.assertEqual(\r\n user.id,\r\n 1,\r\n \"Should have a user id of 1: \" + str(user.id))\r\n self.assertEqual(\r\n user.username,\r\n 'admin',\r\n \"Should have a username of admin: \" + user.username)","def test_resource_user_resource_get_current_user_get(self):\n pass","def test_resource_user_resource_get_user_by_email_address_get(self):\n pass","def test_create_user(self):\n User.objects.create_user(username='abc', password='abcpass', email='abc@example.com')\n user_obj = User.objects.get(username='abc')\n self.assertTrue(user_obj.email, \"abc@example.com\")\n self.assertEqual(str(user_obj), \"abc\")","def test_access_positive(self, api):\n self.builder.add_user(api.get_user())\n self.builder.upd_access(api.get_user(), False)\n r1 = api.access_user(api.get_user(), True)\n access_true = self.builder.get_access(api.get_user())\n self.builder.del_user(api.get_user())\n assert access_true == 1\n assert r1.status_code == 200","def testGetAccessAllowed(self):\n for user in (self.guest, self.contributor, self.delegate, self.owner, self.root):\n response = self.runGet(user, sequencer=self.hiseq2000.vendor_id)\n self.response_200(response)\n data = json.loads(response.content.decode(\"utf-8\"))\n self.assertEqual(data[\"sodar_uuid\"], str(self.hiseq2000.sodar_uuid))","def test_saved_articles_GET_3(self):\r\n\r\n u1 = User.query.filter_by(username='testuser').one()\r\n\r\n with self.client as c:\r\n with c.session_transaction() as sess:\r\n sess[CURR_USER_KEY] = u1.id\r\n response = c.get('/users/anotherUser/location',\r\n follow_redirects=True)\r\n self.assertEqual(response.status_code, 200)\r\n self.assertIn(b'Unauthorized.', response.data)","def testDeleteUser(self):\n UserAPI().create([(u'test', u'secret', u'name', u'name@example.com')],\n createPrivateNamespace=False)\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n yield self.facade.deleteUser(session, u'test')\n\n self.store.rollback()\n self.assertIdentical(None, getUser(u'test'))","def test_get_user(\n self,\n mixin,\n mdb,\n muser_query,\n get_user,\n mrequest,\n mdecoded_jwt,\n ):\n mquery = muser_query.return_value\n\n assert get_user(\n mixin, dbsession=mdb) == mquery.get_by_id.return_value\n mquery.get_by_id.assert_called_once_with(sentinel.user_id)","def test_delete_user(self):\n pass","def test_delete_user(self):\n pass","def mock_get_real_user(_anon_id):\r\n return self.user","def test_search_user(self):\n self.maya.save_profile()\n user = Profile.search_users(self.maya.username)\n self.assertTrue(user.username==\"Maya\")","def test_get_by_id_false(self):\n\n user = CustomUser.get_by_id(44444)\n\n self.assertIsNone(user)","def test_myaccount(self):\n create_user_object()\n self.client.login(username='testuser', password='testabc123')\n response = self.client.get(reverse('infinite:myaccount'))\n self.assertEqual(response.status_code, 200)","def test_user_auth(self):\n self.new_user.save_login()\n test_user=User(\"trinity\",\"trinity@gmail.com\",\"123\")\n test_user.save_login()\n self.assertTrue(self.new_user.users_auth(\"trinity\",\"123\"))","def test_users_username_get(self):\n pass","def test_get_non_owner(self):\n another_user = CustomUser(id=101, email='another_user@mail.com', is_active=True)\n another_user.set_password('testpassword')\n another_user.save()\n self.client.login(email='another_user@mail.com', password='testpassword')\n\n url = reverse('route', kwargs={'way_id': self.route.way_id, 'route_id': self.route.id})\n response = self.client.get(url)\n self.assertEqual(response.status_code, 403)","def test_get_all(self):\n\n # Select on empty set\n selected = self.user_api.get_all()\n self.assertTrue(selected.success)\n self.assertFalse(selected.documents)\n\n # Inserting several users\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertTrue(inserted.success)\n another_user = MAGEN_USER.copy()\n another_user.pop('user_uuid')\n another_user['username'] = 'test_another_username'\n another_user['first_name'] = 'test_another_f_name'\n inserted = self.user_api.insert_user(another_user)\n self.assertTrue(inserted.success)\n\n # Select all users from Database\n selected = self.user_api.get_all()\n self.assertTrue(selected.success)\n self.assertEqual(len(selected.documents), 2)\n self.assertEqual(selected.documents[0], MAGEN_USER)\n # Verify that user_uuid was generated\n self.assertIn('user_uuid', selected.documents[1])\n # Verify that other keys were inserted\n self.assertEqual(selected.documents[1], another_user)","def test_get_user(self):\n print('(' + self.test_get_user.__name__+')', self.test_get_user.__doc__)\n # test for patient\n self.assertDictContainsSubset(\n self.connection.get_user(PATIENT_USERNAME), PATIENT)\n # test for doctor\n self.assertDictContainsSubset(\n self.connection.get_user(DOCTOR_USERNAME), DOCTOR)","def test_get_superuser(self):\n url = reverse('projectroles:api_user_current')\n response = self.request_knox(url)\n self.assertEqual(response.status_code, 200)\n response_data = json.loads(response.content)\n expected = {\n 'username': self.user.username,\n 'name': self.user.name,\n 'email': self.user.email,\n 'is_superuser': True,\n 'sodar_uuid': str(self.user.sodar_uuid),\n }\n self.assertEqual(response_data, expected)","def get(self, user_id):\n\n user = User.objects.get_or_404(public_id=user_id)\n return user_schema.dump(user)","def test_get_file(self):\n django_file = None\n \n with open(TEST_AVATAR_PATH, 'rb') as avatar:\n self.user.avatar_tmp = File(avatar)\n self.user.save()\n\n with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:\n archive.add_model_file(self.user.avatar_tmp)\n\n django_file = archive.get_file()\n archive_path = archive.file_path\n\n self.assertIsNotNone(archive_path)\n self.assertEqual(django_file.name, archive.file_path)\n self.assertFalse(django_file.closed)\n\n self.assertIsNone(archive.file)\n self.assertIsNone(archive.file_path)\n self.assertTrue(django_file.closed)","def test_retrieve_author_unlogged(self):\n request = self.client.get(self.epoint)\n\n self.assertEqual(request.status_code, status.HTTP_200_OK)","def test_user_delete_GET_3(self):\r\n\r\n u1 = User.query.filter_by(username='testuser').one()\r\n\r\n with self.client as c:\r\n with c.session_transaction() as sess:\r\n sess[CURR_USER_KEY] = u1.id\r\n response = c.get('/users/anotherUser/location',\r\n follow_redirects=True)\r\n self.assertEqual(response.status_code, 200)\r\n self.assertIn(b'Unauthorized.', response.data)","def test_correct_user(self):\n\n self.create_user('Henrik', 1)\n self.create_user('Henrik2', 2)\n self.create_user('Test', 3)\n\n resp = self.client.get('/api/users/Henrik/')\n self.assertEquals(resp.json['total-users'], 2)","def test_check_user(self):\n self.new_user.save_user()\n test_user = User(\"Test\", \"user\", \"test\", \"walIas15\")\n test_user.save_user()\n test_user.check_user(\"test\", \"walIas15\")","def test_get_user_if_exists(self):\n user = User.objects.create(username=self.username)\n actual = get_user_if_exists(None, self.details, user=user)\n self.assertDictEqual(actual, {'is_new': False})","def test_get_superuser(self):\n url = reverse('projectroles:api_user_list')\n response = self.request_knox(url) # Default token is for superuser\n self.assertEqual(response.status_code, 200)\n response_data = json.loads(response.content)\n self.assertEqual(len(response_data), 4)\n expected = [\n self.get_serialized_user(self.user),\n self.get_serialized_user(self.user_owner_cat),\n self.get_serialized_user(self.user_owner),\n self.get_serialized_user(self.domain_user),\n ]\n self.assertEqual(response_data, expected)"],"string":"[\n \"def test_get_user_including_archived(user_store: MockStore, archived_user_email: str):\\n # GIVEN a database with an archived user\\n\\n # WHEN querying for a user\\n user: User = user_store.get_user(email=archived_user_email, exclude_archived=False)\\n\\n # THEN it should be returned\\n assert user.email == archived_user_email\",\n \"def test_get_users_including_archived(user_store: MockStore, user_email: str, username: str):\\n # GIVEN a database with a user and an archived user\\n StoreHelpers.add_user(\\n name=username, email=\\\"old.user@magnolia.com\\\", store=user_store, is_archived=True\\n )\\n\\n # WHEN getting users\\n users: List[User] = user_store.get_users(name=username, exclude_archived=False)\\n\\n # THEN the two users should be returned\\n assert len(users) == 2\",\n \"def test_archive(self):\\n thread = self.create_thread()\\n ut = UserThread.objects.get(\\n user=thread.recipients.first(), thread=thread)\\n ut_id = ut.pk\\n ut.archive()\\n ut = UserThread.objects.get(pk=ut_id)\\n self.assertEqual(ut.status, 'archived')\",\n \"def test_get_user_by_uuiduser_uuid_get(self):\\n pass\",\n \"def test_api_user_get(self):\\n pass\",\n \"def test_user(self):\\n u = self.d.user('example')\\n self.assertEqual(u.username, 'example')\\n self.assertEqual(u.name, 'Example Sampleman')\",\n \"def test_get_user(user_store: MockStore, user_email: str):\\n # GIVEN a database with a user\\n\\n # WHEN querying for a user\\n user: User = user_store.get_user(email=user_email)\\n\\n # THEN it should be returned\\n assert user.email == user_email\",\n \"def test_read_user(self):\\n pass\",\n \"def testGetUser(self):\\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\\n user = getUser(u'user')\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n result = yield self.facade.getUser(session, u'user')\\n self.assertEqual(u'user', result.username)\\n self.assertEqual(str(user.objectID), result.objectId)\\n self.assertEqual(u'User', result.name)\\n self.assertEqual(u'USER', result.role)\",\n \"def test_users_get(self):\\n pass\",\n \"def test_users_get(self):\\n pass\",\n \"def test_get_user(sample_user):\\n\\n client = auth_client(APIClient(), sample_user.email, \\\"testpassword\\\")\\n\\n response = client.get(reverse(\\\"user-detail\\\"), format=\\\"json\\\")\\n assert response.status_code == status.HTTP_200_OK\\n assert json.dumps(response.data) == json.dumps(\\n {\\\"id\\\": sample_user.pk, \\\"email\\\": sample_user.email}\\n )\",\n \"def test_view_activar_usuario(self):\\n # se loguea el usuario testuser\\n user = self.client.login(username='testuser', password='test')\\n self.assertTrue(user)\\n # se crea un usuario\\n user = User.objects.create_user(username='user_prueba', email='test@test5.com', password='prueba')\\n usuario_prueba = Usuario.objects.create(user=user, telefono='222', direccion='Avenida', documento='12345')\\n # se marca al usuario como inactivo\\n usuario_prueba.user.is_active = False\\n usuario_prueba.save()\\n self.assertEqual(usuario_prueba.user.is_active, False)\\n # se marca al usuario como activo\\n usuario_prueba.user.is_active = True\\n usuario_prueba.save()\\n\\n self.assertEqual(usuario_prueba.user.is_active, True)\\n\\n print 'Test de activar_usuario realizado exitosamente'\",\n \"def test_get_by_id(self):\\n\\n user = CustomUser.get_by_id(2)\\n expected_user = CustomUser.objects.get(id=2)\\n self.assertEqual(user, expected_user)\",\n \"def test_user(self):\\n return True\",\n \"def test_get_user_by_name(self):\\n\\n # Select on empty set\\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\\n self.assertFalse(selected.success)\\n self.assertIsNone(selected.documents)\\n\\n # Insert user\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertTrue(inserted.success)\\n\\n # Select user by username\\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\\n self.assertTrue(selected.success)\\n self.assertEqual(selected.documents, MAGEN_USER)\",\n \"def test_get_other_user(self):\\n url = self.get_url(self.inactive_user.id)\\n self.inactive_user.is_active = True\\n self.inactive_user.save()\\n\\n with authenticated_user_api_client(self.client, self.active_user):\\n expected_response_code = 200\\n expected_fields = set(User.get_public_fields())\\n response = self.client.get(url)\\n\\n response_fields = set(response.data.keys())\\n self.assertEqual(response.status_code, expected_response_code)\\n self.assertEqual(response_fields, expected_fields)\",\n \"def test_func(self, user, **kwargs):\\n return self.get_object().authorized_user(user)\",\n \"def test_resource_user_resource_get_user_get(self):\\n pass\",\n \"def test_detail(self, client, users):\\n user = users[0]\\n url = reverse('users:detail', args=(user.pk,))\\n response = client.get(url)\\n assert response.status_code == 200\\n assert user.username in str(response.content)\",\n \"def test_get_users(self):\\n pass\",\n \"def test_user_id_get(self):\\n pass\",\n \"def test_good_user(self):\\n user = self.datautils.create_user()\\n self.request.user = user\\n self.request.matchdict = {'user_id': int(user.id)}\\n result = user_id_get_view(self.request)['d']\\n expected = {\\n 'id': user.id,\\n 'username': user.username,\\n 'created': user.created,\\n 'email': user.email,\\n }\\n self.assertEqual(result, expected)\",\n \"def test_retrieve(self):\\n users = CalendallUser.objects.all()\\n self.check_attrs_helper(users)\",\n \"def test_get_user(self):\\n user = User(self.client, \\\"test-user\\\", {})\\n\\n self.assertEqual(user.username, \\\"test-user\\\")\\n self.assertEqual(user.email, \\\"test-user@linode.com\\\")\\n self.assertTrue(user.restricted)\\n self.assertTrue(user.tfa_enabled)\\n self.assertIsNotNone(user.ssh_keys)\",\n \"def test_detail_user(self):\\n \\n for user in User.objects.filter(Q(groups__name='Administrator') | Q(\\n groups__name='Viewer') | Q(groups__name='User')):\\n\\n token = get_token(user)\\n\\n url_detail_user = reverse(\\n 'user_get_retrieve_destroy_update', args=[user.organization_member.pk])\\n\\n response = self.client.get(url_detail_user,\\n HTTP_AUTHORIZATION=f\\\"JWT {token}\\\",\\n format='json')\\n\\n # Validate status code response\\n self.assertEqual(response.status_code, 200)\\n\\n org_comp = comparator_member(user.organization_member, response.data)\\n self.assertEqual(org_comp, True)\",\n \"def test_UserFromDB():\\n assert UserFromDB(\\\"DIANE\\\").email == \\\"d@gmail.com\\\"\\n assert UserFromDB(\\\"DIANE\\\").username == \\\"DIANE\\\"\",\n \"def test_003_get_user(self, mock_db_query):\\n mock_db_query.get.return_value = seller1\\n\\n response = self.app.get('/v1/users/' + str(seller1.identity), headers={'accept': 'application/json'})\\n\\n print(response.get_data().decode())\\n\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response.json['first_name'], 'Lisa')\",\n \"def test_get_user_by_username(self):\\n\\t\\tusername_in_db = server.get_user_by_username('Natasha')\\n\\t\\tself.assertTrue(username_in_db, 'Query did not fetch user object.')\\n\\t\\tusername_not_in_db = server.get_user_by_username('xyz')\\n\\t\\tself.assertFalse(username_not_in_db, 'Query fetched user that did not exist (xyz).')\",\n \"def test_fake_user(self):\\n user = User.objects.get(username=\\\"a\\\")\\n\\n tester = DropboxAuthTester()\\n self.assertFalse(tester.can_auth(user))\",\n \"def test_retrive_user(self):\\n res = self.client.get(ME_URL)\\n\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(res.data['email'], self.user.email)\\n self.assertEqual(res.data['name'], self.user.name)\\n self.assertNotIn('password', res.data)\",\n \"def test_insert_get_user(self):\\n\\n # Select a user on an empty set\\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\\n self.assertFalse(selected.success)\\n self.assertIsNone(selected.documents)\\n\\n # Inserting user into Database\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertTrue(inserted.success)\\n\\n # Verify that document was inserted\\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\\n self.assertTrue(selected.success)\\n self.assertEqual(selected.documents, MAGEN_USER)\\n\\n # Inserting same user again (uuid and e-mail should be unique)\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertFalse(inserted.success)\\n self.assertIn('user_uuid', inserted.message)\",\n \"def test_archived(self):\\n doc = DocumentFactory(title=u'impalas', locale=u'en-US', is_archived=True)\\n ApprovedRevisionFactory(document=doc, summary=u'impalas', is_approved=True)\\n\\n self.refresh()\\n\\n # include_archived gets the above document\\n qs = {'q': 'impalas', 'a': 1, 'w': 1, 'format': 'json',\\n 'include_archived': 'on'}\\n response = self.client.get(reverse('search.advanced'), qs)\\n results = json.loads(response.content)['results']\\n eq_(1, len(results))\\n\\n # no include_archived gets you nothing since the only\\n # document in the index is archived\\n qs = {'q': 'impalas', 'a': 0, 'w': 1, 'format': 'json'}\\n response = self.client.get(reverse('search.advanced'), qs)\\n results = json.loads(response.content)['results']\\n eq_(0, len(results))\",\n \"def testGet(self):\\n userdict = {'id': 1,\\n 'objectID': u'04585bec-28cf-4a21-bc3e-081f3ed62680',\\n 'username': u'testuser',\\n 'passwordHash': 'hash',\\n 'fullname': u'Test User',\\n 'email': u'test@example.com',\\n 'role': Role.ANONYMOUS.id}\\n self.cache.set('user:testuser', json.dumps(userdict))\\n result = self.userCache.get(u'testuser')\\n user = result.results\\n self.assertEqual(1, user.id)\\n self.assertEqual('04585bec-28cf-4a21-bc3e-081f3ed62680',\\n str(user.objectID))\\n self.assertEqual(u'testuser', user.username)\\n self.assertEqual('hash', user.passwordHash)\\n self.assertEqual(u'Test User', user.fullname)\\n self.assertEqual(u'test@example.com', user.email)\\n self.assertEqual(Role.ANONYMOUS, user.role)\",\n \"def test_user_retrieve(self):\\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.get_token())\\n response = self.client.get(reverse(\\\"account:user-profile\\\"))\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data.get('user').get('email'), \\\"testuser@gmail.com\\\")\",\n \"def test_get_single_user(self):\\n user = add_user(\\\"neilb\\\", \\\"neilb14@mailinator.com\\\")\\n with self.client:\\n response = self.client.get(f'/users/{user.id}')\\n data = json.loads(response.data.decode())\\n self.assertEqual(response.status_code, 200)\\n self.assertTrue('created_at' in data['data'])\\n self.assertIn('neilb', data['data']['username'])\\n self.assertIn('neilb14@mailinator.com', data['data']['email'])\\n self.assertIn('success', data['status'])\",\n \"def test_get(self):\\n user = api.user.create(\\n username='chuck',\\n email='chuck@norris.org',\\n password='secret',\\n )\\n\\n self.assertEqual(api.user.get('chuck'), user)\",\n \"def test_fetch_user(self):\\n\\n self.register_user()\\n\\n self.assertEqual(self.fetch_user_details().status_code, 200)\\n\\n self.assertTrue(self.fetch_user_details(\\n ).json[\\\"data\\\"][0][\\\"username\\\"] == 'Bjorn')\",\n \"def test_get_user_info_returns_user(self, db_mock):\\n repo = Repository()\\n db_instance = db_mock.return_value\\n db_instance.get_user_info.return_value = (1, {\\\"name\\\": \\\"Kari\\\"})\\n self.assertEquals(repo.get_user_info(\\\"123\\\"), (1, {\\\"name\\\": \\\"Kari\\\"}))\",\n \"def test_view_desactivar_usuario(self):\\n # se loguea el usuario testuser\\n user = self.client.login(username='testuser', password='test')\\n self.assertTrue(user)\\n # se crea un usuario\\n user = User.objects.create_user(username='user_prueba', email='test@test4.com', password='prueba')\\n usuario_prueba = Usuario.objects.create(user=user, telefono='222', direccion='Avenida', documento='12345')\\n # se marca al usuario como inactivo\\n usuario_prueba.user.is_active = False\\n usuario_prueba.save()\\n\\n self.assertEqual(usuario_prueba.user.is_active, False)\\n\\n print 'Test de desactivar_usuario realizado exitosamente'\",\n \"def test_get_owned(self):\\n user = User.create(name='foo', email='foo@bar.com')\\n user.put()\\n response = self.testapp.get(\\n '/api/users/{}'.format(user.uid),\\n headers=self.login_headers(user),\\n )\\n response_dict = json.loads(response.body)\\n self.assertEqual(response_dict['uid'], user.uid)\",\n \"def test_anonymize_user_data(api_client, resource_in_unit, user):\\n user.first_name = 'testi_ukkeli'\\n user.save()\\n original_uuid = user.uuid\\n original_email = user.email\\n user_pk = user.pk\\n\\n SocialAccount.objects.create(user=user, uid=original_uuid, provider='helsinki')\\n EmailAddress.objects.create(user=user, email=original_email)\\n\\n Reservation.objects.create(\\n resource=resource_in_unit,\\n begin='2015-04-04T09:00:00+02:00',\\n end='2015-04-04T10:00:00+02:00',\\n user=user,\\n reserver_name='John Smith',\\n event_subject='John\\\\'s welcome party',\\n state=Reservation.CONFIRMED\\n )\\n # anonymize_user_data expects a queryset instead of single object\\n test_user = get_user_model().objects.filter(first_name='testi_ukkeli')\\n anonymize_user_data(modeladmin=None, request=None, queryset=test_user)\\n assert get_user_model().objects.filter(first_name='testi_ukkeli').count() == 0\\n reservation = Reservation.objects.get(resource=resource_in_unit)\\n assert reservation.event_description == 'Sensitive data of this reservation has been anonymized by a script.'\\n changed_user = get_user_model().objects.get(pk=user_pk)\\n assert changed_user.uuid != original_uuid\\n assert reservation.state == Reservation.CANCELLED\\n assert not SocialAccount.objects.filter(user=user, uid=original_uuid).exists()\\n assert not EmailAddress.objects.filter(user=user, email=original_email).exists()\",\n \"def test_get_for_user_no_user(self):\\n self.assertIsNone(Tour.objects.get_for_user(User()))\",\n \"def test_user(self):\\n user = User.objects.get(username=\\\"test01\\\")\\n print(user.username)\\n print(user.email)\\n self.assertEqual(user.email,\\\"test01@email.com\\\")\\n # cat = Animal.objects.get(name=\\\"cat\\\")\\n # self.assertEqual(lion.speak(), 'The lion says \\\"roar\\\"')\\n # self.assertEqual(cat.speak(), 'The cat says \\\"meow\\\"')\",\n \"def test_duo_account_get(self):\\n pass\",\n \"def test_user(self):\\n\\n user = User.query.filter(User.user_fname == \\\"Smokey\\\").first()\\n self.assertEqual(user.user_fname, \\\"Smokey\\\")\",\n \"def test_user_activation(self):\\n user = User.objects.get()\\n response = self.client.get(reverse('accounts:user-activate',\\n kwargs={'uidb64': urlsafe_base64_encode(force_bytes(user.pk)),\\n 'token': account_activation_token.make_token(user)}))\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\",\n \"def test_gets_user_by_email(self):\\r\\n User.objects.create(email='another_user@example.com')\\r\\n desired_user = User.objects.create(email='edith@example.com')\\r\\n found_user = PasswordlessAuthenticationBackend().get_user('edith@example.com')\\r\\n self.assertEqual(desired_user, found_user)\",\n \"def test_read_by_random_logged_in_user(self):\\n user = UserFactory()\\n\\n self.assert_user_cannot_read(user, self.live)\",\n \"def test_get_website_user_returns_user(self):\\n user = get_website_user()\\n self.assertTrue(user)\",\n \"def test_order_from_user(self):\\n new_user = self.create_test_user()\\n new_order = OrderInfo.objects.create(user=new_user)\\n self.assertEqual(new_order.user, new_user)\",\n \"def test_user_instance(self):\\n db.session.add(self.user)\\n db.session.commit()\\n\\n user = User.query.filter_by(user_name = \\\"john_doe\\\").first()\\n users = User.query.all()\\n\\n self.assertTrue(len(users) > 0)\\n self.assertEqual(user.user_name, \\\"john_doe\\\")\\n self.assertEqual(user.email, \\\"johndoe@example.com\\\")\\n self.assertEqual(user.profile_pic_path, \\\"app/static/images\\\")\\n self.assertEqual(user.first_name, \\\"John\\\")\\n self.assertEqual(user.last_name, \\\"Doe\\\")\\n self.assertEqual(user.headline, \\\"Food Blogger\\\")\\n self.assertEqual(user.bio, \\\"Mainly writes on Chinese cuisine\\\")\",\n \"def test_user_creation(self):\\n self.assertTrue(User.objects.exists())\",\n \"def test_func(self, user):\\n return self.get_object().admin == user\",\n \"def test_list_user(self):\\n pass\",\n \"def test_user_is_really_deleted():\\n response = api_helper.get_user(user_id=pytest.test_user.id)\\n assert response.status_code == 200\\n assert len(response.json()['data']) == 0\",\n \"def testGetUserIgnoresCase(self):\\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n result = yield self.facade.getUser(session, u'uSeR')\\n self.assertEqual(u'user', result.username)\",\n \"def testGetAccessAllowed(self):\\n for user in (self.guest, self.contributor, self.delegate, self.owner, self.root):\\n response = self.runGet(user, sequencer=self.hiseq2000.sodar_uuid)\\n self.response_200(response)\\n data = json.loads(response.content.decode(\\\"utf-8\\\"))\\n self.assertEqual(data[\\\"sodar_uuid\\\"], str(self.hiseq2000.sodar_uuid))\",\n \"def test_getUser(self):\\n\\t\\turl = \\\"/users/2/\\\"\\n\\t\\tresponse = self.client.get(url, format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\tself.assertEqual(response.data[\\\"id\\\"], 2)\\n\\t\\tself.assertEqual(response.data[\\\"username\\\"], \\\"testUser2\\\")\",\n \"def test_show(self):\\n\\n with self.client as c:\\n response = c.get(f\\\"/users/{self.testuser.id}\\\")\\n\\n self.assertEqual(response.status_code, 200)\\n self.assertIn(\\\"@alice\\\", str(response.data))\",\n \"def ____test_sys_archived(self):\\n # TODO archinging not working\\n with ts.SetupDbAndCredentials() as s:\\n args = [\\\"--archived\\\", \\\"--skip-albums\\\", \\\"--start-date\\\", \\\"2017-01-01\\\"]\\n s.test_setup(\\n \\\"test_sys_archived\\\", args=args, trash_files=True, trash_db=True\\n )\\n s.gp.start(s.parsed_args)\\n\\n db = LocalData(s.root)\\n\\n # Total of 1 out of media items\\n db.cur.execute(\\\"SELECT COUNT() FROM SyncFiles\\\")\\n count = db.cur.fetchone()\\n self.assertEqual(1, count[0])\",\n \"def test_get_user_by_emailuser_email_get(self):\\n pass\",\n \"def test_valid_dropbox_user(self):\\n user = User.objects.get(id=107)\\n\\n tester = DropboxAuthTester()\\n self.assertTrue(tester.can_auth(user))\",\n \"def test_get_users(user_store: MockStore, user_email: str, username: str):\\n # GIVEN a database with a user\\n\\n # WHEN getting users\\n users: List[User] = user_store.get_users(name=username, email=user_email)\\n\\n # THEN the user should be returned\\n assert users[0].email == user_email\",\n \"def test_get_users_from_passwd():\\n users = Users.from_passwd()\\n assert isinstance(users, Users)\",\n \"def test_movies_limited_to_user(self):\\n user2 = get_user_model().objects.create_user(\\n 'other@youremail.com',\\n 'pass123'\\n )\\n sample_movie(user=user2)\\n sample_movie(user=self.user)\\n\\n res = self.client.get(MOVIES_URL)\\n\\n movies = Movie.objects.filter(user=self.user)\\n serializer = MovieSerializer(movies, many=True)\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(len(res.data), 1)\\n self.assertEqual(res.data, serializer.data)\",\n \"def test_detailview_read_for_anonymous_user(self):\\n\\n for user in self.users:\\n detailview = reverse('account_detail', args=(user.uuid,))\\n response = self.client.get(detailview)\\n\\n self.assertEqual(response.status_code, 302)\",\n \"def test_single_success():\\n test_username = \\\"test_user\\\"\\n\\n user = UserFactory.create(username=test_username, is_active=True)\\n UserSocialAuthFactory.create(user=user, provider=\\\"edX\\\")\\n\\n assert user.is_active is True\\n assert \\\"retired_email\\\" not in user.email\\n assert UserSocialAuth.objects.filter(user=user).count() == 1\\n\\n COMMAND.handle(\\\"retire_users\\\", users=[test_username])\\n\\n user.refresh_from_db()\\n assert user.is_active is False\\n assert \\\"retired_email\\\" in user.email\\n assert UserSocialAuth.objects.filter(user=user).count() == 0\",\n \"def test_get_website_user_returns_same_user(self):\\n user = get_website_user()\\n self.assertEqual(get_website_user(), user)\",\n \"def test_18_admin_user_export_authenticated(self):\\r\\n self.register()\\r\\n self.signout()\\r\\n self.register(fullname=\\\"Juan Jose\\\", name=\\\"juan\\\",\\r\\n email=\\\"juan@juan.com\\\", password=\\\"juan\\\")\\r\\n\\r\\n # No matter what params in the request, Forbidden is raised\\r\\n res = self.app.get('/admin/users/export', follow_redirects=True)\\r\\n assert res.status_code == 403, res.status_code\\r\\n res = self.app.get('/admin/users/export?firmit=', follow_redirects=True)\\r\\n assert res.status_code == 403, res.status_code\\r\\n res = self.app.get('/admin/users/export?format=bad',\\r\\n follow_redirects=True)\\r\\n assert res.status_code == 403, res.status_code\\r\\n res = self.app.get('/admin/users/export?format=json',\\r\\n follow_redirects=True)\\r\\n assert res.status_code == 403, res.status_code\",\n \"def test_reteta_limited_to_user(self):\\n user2 = get_user_model().objects.create_user(\\n 'other@chris.com',\\n 'testpass'\\n )\\n sample_reteta(user=user2)\\n sample_reteta(user=self.user)\\n\\n res = self.client.get(RETETA_URL)\\n rete = Reteta.objects.filter(user=self.user)\\n serializer = RetetaSerializer(rete, many=True) # return list\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(len(res.data), 1)\\n self.assertEqual(res.data, serializer.data)\",\n \"def test_get_id(self):\\r\\n # the migration adds an initial admin user to the system\\r\\n user = UserMgr.get(user_id=1)\\r\\n self.assertEqual(\\r\\n user.id,\\r\\n 1,\\r\\n \\\"Should have a user id of 1: \\\" + str(user.id))\\r\\n self.assertEqual(\\r\\n user.username,\\r\\n 'admin',\\r\\n \\\"Should have a username of admin: \\\" + user.username)\",\n \"def test_resource_user_resource_get_current_user_get(self):\\n pass\",\n \"def test_resource_user_resource_get_user_by_email_address_get(self):\\n pass\",\n \"def test_create_user(self):\\n User.objects.create_user(username='abc', password='abcpass', email='abc@example.com')\\n user_obj = User.objects.get(username='abc')\\n self.assertTrue(user_obj.email, \\\"abc@example.com\\\")\\n self.assertEqual(str(user_obj), \\\"abc\\\")\",\n \"def test_access_positive(self, api):\\n self.builder.add_user(api.get_user())\\n self.builder.upd_access(api.get_user(), False)\\n r1 = api.access_user(api.get_user(), True)\\n access_true = self.builder.get_access(api.get_user())\\n self.builder.del_user(api.get_user())\\n assert access_true == 1\\n assert r1.status_code == 200\",\n \"def testGetAccessAllowed(self):\\n for user in (self.guest, self.contributor, self.delegate, self.owner, self.root):\\n response = self.runGet(user, sequencer=self.hiseq2000.vendor_id)\\n self.response_200(response)\\n data = json.loads(response.content.decode(\\\"utf-8\\\"))\\n self.assertEqual(data[\\\"sodar_uuid\\\"], str(self.hiseq2000.sodar_uuid))\",\n \"def test_saved_articles_GET_3(self):\\r\\n\\r\\n u1 = User.query.filter_by(username='testuser').one()\\r\\n\\r\\n with self.client as c:\\r\\n with c.session_transaction() as sess:\\r\\n sess[CURR_USER_KEY] = u1.id\\r\\n response = c.get('/users/anotherUser/location',\\r\\n follow_redirects=True)\\r\\n self.assertEqual(response.status_code, 200)\\r\\n self.assertIn(b'Unauthorized.', response.data)\",\n \"def testDeleteUser(self):\\n UserAPI().create([(u'test', u'secret', u'name', u'name@example.com')],\\n createPrivateNamespace=False)\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n yield self.facade.deleteUser(session, u'test')\\n\\n self.store.rollback()\\n self.assertIdentical(None, getUser(u'test'))\",\n \"def test_get_user(\\n self,\\n mixin,\\n mdb,\\n muser_query,\\n get_user,\\n mrequest,\\n mdecoded_jwt,\\n ):\\n mquery = muser_query.return_value\\n\\n assert get_user(\\n mixin, dbsession=mdb) == mquery.get_by_id.return_value\\n mquery.get_by_id.assert_called_once_with(sentinel.user_id)\",\n \"def test_delete_user(self):\\n pass\",\n \"def test_delete_user(self):\\n pass\",\n \"def mock_get_real_user(_anon_id):\\r\\n return self.user\",\n \"def test_search_user(self):\\n self.maya.save_profile()\\n user = Profile.search_users(self.maya.username)\\n self.assertTrue(user.username==\\\"Maya\\\")\",\n \"def test_get_by_id_false(self):\\n\\n user = CustomUser.get_by_id(44444)\\n\\n self.assertIsNone(user)\",\n \"def test_myaccount(self):\\n create_user_object()\\n self.client.login(username='testuser', password='testabc123')\\n response = self.client.get(reverse('infinite:myaccount'))\\n self.assertEqual(response.status_code, 200)\",\n \"def test_user_auth(self):\\n self.new_user.save_login()\\n test_user=User(\\\"trinity\\\",\\\"trinity@gmail.com\\\",\\\"123\\\")\\n test_user.save_login()\\n self.assertTrue(self.new_user.users_auth(\\\"trinity\\\",\\\"123\\\"))\",\n \"def test_users_username_get(self):\\n pass\",\n \"def test_get_non_owner(self):\\n another_user = CustomUser(id=101, email='another_user@mail.com', is_active=True)\\n another_user.set_password('testpassword')\\n another_user.save()\\n self.client.login(email='another_user@mail.com', password='testpassword')\\n\\n url = reverse('route', kwargs={'way_id': self.route.way_id, 'route_id': self.route.id})\\n response = self.client.get(url)\\n self.assertEqual(response.status_code, 403)\",\n \"def test_get_all(self):\\n\\n # Select on empty set\\n selected = self.user_api.get_all()\\n self.assertTrue(selected.success)\\n self.assertFalse(selected.documents)\\n\\n # Inserting several users\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertTrue(inserted.success)\\n another_user = MAGEN_USER.copy()\\n another_user.pop('user_uuid')\\n another_user['username'] = 'test_another_username'\\n another_user['first_name'] = 'test_another_f_name'\\n inserted = self.user_api.insert_user(another_user)\\n self.assertTrue(inserted.success)\\n\\n # Select all users from Database\\n selected = self.user_api.get_all()\\n self.assertTrue(selected.success)\\n self.assertEqual(len(selected.documents), 2)\\n self.assertEqual(selected.documents[0], MAGEN_USER)\\n # Verify that user_uuid was generated\\n self.assertIn('user_uuid', selected.documents[1])\\n # Verify that other keys were inserted\\n self.assertEqual(selected.documents[1], another_user)\",\n \"def test_get_user(self):\\n print('(' + self.test_get_user.__name__+')', self.test_get_user.__doc__)\\n # test for patient\\n self.assertDictContainsSubset(\\n self.connection.get_user(PATIENT_USERNAME), PATIENT)\\n # test for doctor\\n self.assertDictContainsSubset(\\n self.connection.get_user(DOCTOR_USERNAME), DOCTOR)\",\n \"def test_get_superuser(self):\\n url = reverse('projectroles:api_user_current')\\n response = self.request_knox(url)\\n self.assertEqual(response.status_code, 200)\\n response_data = json.loads(response.content)\\n expected = {\\n 'username': self.user.username,\\n 'name': self.user.name,\\n 'email': self.user.email,\\n 'is_superuser': True,\\n 'sodar_uuid': str(self.user.sodar_uuid),\\n }\\n self.assertEqual(response_data, expected)\",\n \"def get(self, user_id):\\n\\n user = User.objects.get_or_404(public_id=user_id)\\n return user_schema.dump(user)\",\n \"def test_get_file(self):\\n django_file = None\\n \\n with open(TEST_AVATAR_PATH, 'rb') as avatar:\\n self.user.avatar_tmp = File(avatar)\\n self.user.save()\\n\\n with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:\\n archive.add_model_file(self.user.avatar_tmp)\\n\\n django_file = archive.get_file()\\n archive_path = archive.file_path\\n\\n self.assertIsNotNone(archive_path)\\n self.assertEqual(django_file.name, archive.file_path)\\n self.assertFalse(django_file.closed)\\n\\n self.assertIsNone(archive.file)\\n self.assertIsNone(archive.file_path)\\n self.assertTrue(django_file.closed)\",\n \"def test_retrieve_author_unlogged(self):\\n request = self.client.get(self.epoint)\\n\\n self.assertEqual(request.status_code, status.HTTP_200_OK)\",\n \"def test_user_delete_GET_3(self):\\r\\n\\r\\n u1 = User.query.filter_by(username='testuser').one()\\r\\n\\r\\n with self.client as c:\\r\\n with c.session_transaction() as sess:\\r\\n sess[CURR_USER_KEY] = u1.id\\r\\n response = c.get('/users/anotherUser/location',\\r\\n follow_redirects=True)\\r\\n self.assertEqual(response.status_code, 200)\\r\\n self.assertIn(b'Unauthorized.', response.data)\",\n \"def test_correct_user(self):\\n\\n self.create_user('Henrik', 1)\\n self.create_user('Henrik2', 2)\\n self.create_user('Test', 3)\\n\\n resp = self.client.get('/api/users/Henrik/')\\n self.assertEquals(resp.json['total-users'], 2)\",\n \"def test_check_user(self):\\n self.new_user.save_user()\\n test_user = User(\\\"Test\\\", \\\"user\\\", \\\"test\\\", \\\"walIas15\\\")\\n test_user.save_user()\\n test_user.check_user(\\\"test\\\", \\\"walIas15\\\")\",\n \"def test_get_user_if_exists(self):\\n user = User.objects.create(username=self.username)\\n actual = get_user_if_exists(None, self.details, user=user)\\n self.assertDictEqual(actual, {'is_new': False})\",\n \"def test_get_superuser(self):\\n url = reverse('projectroles:api_user_list')\\n response = self.request_knox(url) # Default token is for superuser\\n self.assertEqual(response.status_code, 200)\\n response_data = json.loads(response.content)\\n self.assertEqual(len(response_data), 4)\\n expected = [\\n self.get_serialized_user(self.user),\\n self.get_serialized_user(self.user_owner_cat),\\n self.get_serialized_user(self.user_owner),\\n self.get_serialized_user(self.domain_user),\\n ]\\n self.assertEqual(response_data, expected)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.81330764","0.7385193","0.65025973","0.6442499","0.63574994","0.6246142","0.62167716","0.62109834","0.61833704","0.6133558","0.6133558","0.61013573","0.6095947","0.60781145","0.6004548","0.6003449","0.59916866","0.5984867","0.5974582","0.5968191","0.5961448","0.5951658","0.5940922","0.59354746","0.59309953","0.592235","0.59055483","0.58974344","0.5883587","0.5882572","0.5880163","0.58723944","0.58688724","0.5864817","0.58632165","0.58398914","0.5811694","0.5811591","0.5798356","0.5797387","0.57968915","0.57852346","0.5781325","0.57812136","0.5768761","0.5748511","0.5741346","0.57364106","0.57292616","0.57069266","0.56991047","0.5697048","0.56906354","0.56867933","0.5675281","0.5669572","0.5657075","0.5648187","0.56476074","0.56474054","0.56469584","0.564066","0.56389594","0.56356436","0.5635097","0.5634733","0.5626222","0.56253445","0.5624508","0.5624379","0.5603826","0.55974585","0.559156","0.55857354","0.55845755","0.5576875","0.5571195","0.55711055","0.55710554","0.5568407","0.55652666","0.55652666","0.55644923","0.5564434","0.555083","0.55457515","0.554475","0.55442613","0.5543753","0.5540393","0.5532159","0.55245185","0.55226976","0.5520678","0.5519837","0.551137","0.5506073","0.55057967","0.5503922","0.55020607"],"string":"[\n \"0.81330764\",\n \"0.7385193\",\n \"0.65025973\",\n \"0.6442499\",\n \"0.63574994\",\n \"0.6246142\",\n \"0.62167716\",\n \"0.62109834\",\n \"0.61833704\",\n \"0.6133558\",\n \"0.6133558\",\n \"0.61013573\",\n \"0.6095947\",\n \"0.60781145\",\n \"0.6004548\",\n \"0.6003449\",\n \"0.59916866\",\n \"0.5984867\",\n \"0.5974582\",\n \"0.5968191\",\n \"0.5961448\",\n \"0.5951658\",\n \"0.5940922\",\n \"0.59354746\",\n \"0.59309953\",\n \"0.592235\",\n \"0.59055483\",\n \"0.58974344\",\n \"0.5883587\",\n \"0.5882572\",\n \"0.5880163\",\n \"0.58723944\",\n \"0.58688724\",\n \"0.5864817\",\n \"0.58632165\",\n \"0.58398914\",\n \"0.5811694\",\n \"0.5811591\",\n \"0.5798356\",\n \"0.5797387\",\n \"0.57968915\",\n \"0.57852346\",\n \"0.5781325\",\n \"0.57812136\",\n \"0.5768761\",\n \"0.5748511\",\n \"0.5741346\",\n \"0.57364106\",\n \"0.57292616\",\n \"0.57069266\",\n \"0.56991047\",\n \"0.5697048\",\n \"0.56906354\",\n \"0.56867933\",\n \"0.5675281\",\n \"0.5669572\",\n \"0.5657075\",\n \"0.5648187\",\n \"0.56476074\",\n \"0.56474054\",\n \"0.56469584\",\n \"0.564066\",\n \"0.56389594\",\n \"0.56356436\",\n \"0.5635097\",\n \"0.5634733\",\n \"0.5626222\",\n \"0.56253445\",\n \"0.5624508\",\n \"0.5624379\",\n \"0.5603826\",\n \"0.55974585\",\n \"0.559156\",\n \"0.55857354\",\n \"0.55845755\",\n \"0.5576875\",\n \"0.5571195\",\n \"0.55711055\",\n \"0.55710554\",\n \"0.5568407\",\n \"0.55652666\",\n \"0.55652666\",\n \"0.55644923\",\n \"0.5564434\",\n \"0.555083\",\n \"0.55457515\",\n \"0.554475\",\n \"0.55442613\",\n \"0.5543753\",\n \"0.5540393\",\n \"0.5532159\",\n \"0.55245185\",\n \"0.55226976\",\n \"0.5520678\",\n \"0.5519837\",\n \"0.551137\",\n \"0.5506073\",\n \"0.55057967\",\n \"0.5503922\",\n \"0.55020607\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7458577"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":83698,"cells":{"query":{"kind":"string","value":"Test getting a nonexisting user from the database."},"document":{"kind":"string","value":"def test_get_user_when_non_existing(user_store: MockStore):\n # GIVEN a database with a user\n\n # WHEN querying for a user that doesn't exist\n user: User = user_store.get_user(email=\"this_is_a_made_up_email@fake_example.com\")\n\n # THEN it should return as None\n assert user is None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_get_user_non_exist_id(self):\n print('(' + self.test_get_user_non_exist_id.__name__+')',\n self.test_get_user_non_exist_id.__doc__)\n self.assertIsNone(self.connection.get_user(NON_EXIST_PATIENT_USERNAME))","def test_get_bad_user(self):\r\n user = UserMgr.get(username=u'noexist')\r\n\r\n self.assertEqual(\r\n user,\r\n None,\r\n \"Should not find a non-existant user: \" + str(user))","def testGetUserWithoutData(self):\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n deferred = self.facade.getUser(session, u'unknown')\n error = yield self.assertFailure(deferred, TNoSuchUser)\n self.assertEqual(u'unknown', error.name)","def test_get_single_user_is_missing(self):\n add_user(\"neilb\", \"neilb14@mailinator.com\")\n with self.client:\n response = self.client.get('/users/999')\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 404)\n self.assertIn('User does not exist', data['message'])\n self.assertIn('fail', data['status'])","def test_no_user_exists(self):\n actual = get_user_if_exists(None, self.details)\n self.assertDictEqual(actual, {})","def test_get_user_by_id_non_existent(client: FlaskClient) -> None:\n username = create_random_username()\n # Authenticated requests to nonexistent usernames gives 404\n auth_token = create_auth_token(username)\n response = get_user(client, username, auth_token.signed)\n assert_error_response(response, HTTPStatus.NOT_FOUND)","def test_get_user_id_unknown_user(self):\n print('(' + self.test_get_user_id.__name__+')',\n self.test_get_user_id.__doc__)\n self.assertIsNone(self.connection.get_user_id(\n NON_EXIST_PATIENT_USERNAME))","def test_dont_create_user(self):\n self.assertFalse(User.objects.exists())","def test_not_found(self):\n with self.assertRaises(UserNotFoundException):\n self._storage.get_by_username(\"test\")","def test_get_user_by_username(self):\n\t\tusername_in_db = server.get_user_by_username('Natasha')\n\t\tself.assertTrue(username_in_db, 'Query did not fetch user object.')\n\t\tusername_not_in_db = server.get_user_by_username('xyz')\n\t\tself.assertFalse(username_not_in_db, 'Query fetched user that did not exist (xyz).')","def test_get_by_id_false(self):\n\n user = CustomUser.get_by_id(44444)\n\n self.assertIsNone(user)","def test_nonexistent_user(self):\n self.client.login(username=self.global_staff.username, password=self.password)\n resp = self.client.get(self.get_url('IDoNotExist'))\n assert resp.status_code == status.HTTP_404_NOT_FOUND","def test_004_get_user_not_found(self, mock_db_query):\n mock_db_query.get.return_value = None\n\n response = self.app.get('/v1/users/0', headers={'accept': 'application/json'})\n\n print(response.get_data().decode())\n\n self.assertEqual(response.status_code, 404)\n self.assertIn('User not found', response.get_data().decode())","def test_error_inexistent_user_data(self, test_client, init_database, insert_user_db):\n login_url = '/api/v1/auth/login'\n login_data = {\n 'email': insert_user_db.email,\n 'password': 'password'\n }\n login_response = test_client.post(login_url, json=login_data)\n init_database.session.delete(insert_user_db)\n init_database.session.commit()\n\n url = '/api/v1/auth/me'\n headers = {\n 'Authorization': 'Bearer {}'.format(login_response.json['access'])\n }\n response = test_client.get(url, headers=headers)\n\n assert response.status_code == 404\n assert response.json['code'] == 'NOT_FOUND'\n assert response.json['message'] == 'User not found!'\n assert response.json['details'] == ['User not found!']","def test_getUserNonexistentDatabase(self):\n self.db = checkers.FilePasswordDB(\"test_thisbetternoteverexist.db\")\n\n self.assertRaises(error.UnauthorizedLogin, self.db.getUser, \"user\")","def test_08_create_user_not_exists(self):\n\n _, user = self.get_random_item(models.User)\n utils.create_user(user, session=self.session)\n success, error = utils.create_user(user, session=self.session)\n self.assertFalse(success)\n self.assertTrue(error)","def test_nonexistent_user(self):\n nonexistent_username = \"nonexistent user\"\n self.retired_username = get_retired_username_by_username(nonexistent_username)\n data = {'username': nonexistent_username}\n headers = self.build_jwt_headers(self.superuser)\n response = self.client.post(self.url, data, **headers)\n self.assert_response_correct(response, 404, None)","def test_user_does_not_exist(self):\n url = reverse('main_app:user', args=('non-exist',))\n response = self.client.get(url)\n self.assertEqual(response.status_code, 404)","def test_get_user_404(self):\n resp = self.app.get('/users/thisuserdoesntexist')\n assert resp.status_code == 404","def test_unknown_user(self):\n self.sign_in()\n response = self.client.get(reverse('backend:user_details', args=(0,)))\n self.assertEqual(response.status_code, 404)","def test_get_user_if_exists(self):\n user = User.objects.create(username=self.username)\n actual = get_user_if_exists(None, self.details, user=user)\n self.assertDictEqual(actual, {'is_new': False})","def test_get_single_user_no_id(self):\n add_user(\"neilb\", \"neilb14@mailinator.com\")\n with self.client:\n response = self.client.get('/users/blah')\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 404)\n self.assertIn('User does not exist', data['message'])\n self.assertIn('fail', data['status'])","def test_existing_user(self):\n user = User.objects.create(username=self.username)\n actual = get_user_if_exists(None, self.details)\n self.assertDictEqual(actual, {'is_new': False, 'user': user})","def test_user_not_in_db_before_addition(self):\n\n username = 'testuser'\n user = User.query.filter_by(username=username).first()\n self.assertTrue(user.__str__(), None)","def test_returns_404_if_user_doesnt_exist(self):\n # Act\n response = self.client.get(\"/api/v2/projects/queries/non_existent/touched/\")\n self.assertEqual(response.status_code, 404)","def test_non_existing_user_login(self):\n user = {\n 'email': 'test@gmail.com',\n 'password': 'password123'}\n res = self.app.post('/login', data=user)\n self.assertEqual(res.status_code, 200)\n self.assertIn(\"You have no account\", str(res.data))","def test_get_users_no_username(user_store: MockStore, user_email: str):\n # GIVEN a database with a user\n\n # WHEN getting users\n users: List[User] = user_store.get_users(email=user_email)\n\n # THEN the user should be returned\n assert users[0].email == user_email","def test_returns_none_if_no_user(self):\r\n self.assertIsNone(PasswordlessAuthenticationBackend().get_user('edith@example.com'))","def test_dont_save_new_user(self):\n self.assertEqual(get_user_model().objects.exists(), 1)","def test_existence(self):\n self.assertTrue(User.objects.filter(username='rcm').exists())","def test_nonexistent_user_login(self):\n\n fake_user = {\"email\": \"eat@me.com\",\n \"password\": \"lolzIKid\"}\n\n res = self.client.post(\n \"/api/v2/auth/login\", data=json.dumps(fake_user), content_type=\"application/json\")\n result = json.loads(res.data)\n self.assertEqual(result[\"Error\"], \"User does not exist\")\n self.assertEqual(res.status_code, 404)","def test_user_profile_view_user_doesnt_exist(self):\n params = {'pk': 101}\n profile_response = self.client.get(reverse('api:users-detail', kwargs=params))\n self.assertTrue(profile_response.status_code == 404)","def test_get_for_user_no_user(self):\n self.assertIsNone(Tour.objects.get_for_user(User()))","def test_get_for_not_found_team(self):\n user = User.create(name='foo', email='foo@bar.com')\n user.put()\n response = self.testapp.get(\n '/api/teams/Team_other/users',\n headers=self.login_headers(user),\n status=404\n )","def test_get_user_by_id_unauthenticated(client: FlaskClient) -> None:\n username = create_random_username()\n # Unauthenticated users are not allowed to make the request\n response = get_user(client, username)\n assert_error_response(response, HTTPStatus.UNAUTHORIZED)","def test_detail_user_does_not_exists(self, client, users):\n user = users[0]\n url = reverse('users:detail', args=(user.pk + 100,))\n response = client.get(url)\n assert response.status_code == 404","def test_get_user_info_does_not_exist(self):\n http_cookie = 'one=two; three=four'\n email, admin, user_id = login.get_user_info(http_cookie,\n cookie_name=COOKIE_NAME)\n\n self.assertEqual('', email)\n self.assertFalse(admin)","def test_no_user(self):\n self.request.user = None\n result = user_id_get_view(self.request)['d']\n self.assertEqual(result, error_dict('api_errors', 'not authenticated for this request'))","def test_not_contains_user(self):\n print('(' + self.test_not_contains_user.__name__+')',\n self.test_not_contains_user.__doc__)\n # non existing doctor, it could be patient as well\n self.assertFalse(self.connection.contains_user(\n NON_EXIST_DOCTOR_USERNAME))","def test_user_not_found(self):\n data = {'email': 'unmatched email'}\n response = self.client.post(self.url, data=data)\n\n expected_response_code = 200\n\n self.assertEqual(expected_response_code, response.status_code)\n self.assertFalse(response.data.get('exists'))","def test_get_user_by_id_non_admin(client: FlaskClient, db_session) -> None:\n username = create_random_username()\n populate_database_with_users(db_session, username)\n # Users with matching username in auth token are allowed to make\n # the request\n user = GifSyncUser.get_by_username(username)\n assert user is not None\n auth_token = create_auth_token(username)\n response = get_user(client, username, auth_token.signed)\n assert response.status_code == HTTPStatus.OK\n assert_user_in_response(response)\n # User retrieved matches the user in database\n json_data: dict = response.get_json()\n user_data = json_data.get(\"user\")\n assert isinstance(user_data, dict)\n assert user_data.get(\"id\") == user.id\n assert user_data.get(\"username\") == user.username\n assert isinstance(user_data.get(\"gifs\"), list)\n assert len(user_data[\"gifs\"]) == len(user.gifs)","def test_create_user_fails_with_no_username(self):\n user = get_user_model().objects.create(\n email='test@test.test',\n first_name='Test',\n password='pass123456!'\n )\n\n users = User.objects.filter(username='Test')\n\n self.assertEqual(len(users), 0)","def test_get(self):\n user = api.user.create(\n username='chuck',\n email='chuck@norris.org',\n password='secret',\n )\n\n self.assertEqual(api.user.get('chuck'), user)","def test_signup_attempt_with_nonexistent_user(self):\n\n details = {\"email\": \"admooin@admin.admin\",\n \"password\": \"oiudof987ewrqlwe\"}\n\n res = self.client.post(\n \"/api/v2/auth/login\", data=json.dumps(details), content_type=\"application/json\")\n self.assertEqual(res.status_code, 404)","def test_request_users_user_invalid(self):\n response = requests.get(self.url + '/users/invalid')\n\n self.assertEqual(response.status_code, 404)","def test_verify_non_existing_user(self):\n data = {'rank_id': 1}\n res = self.post(url='/verify/5', data=data, role='admin')\n self.assertEqual(res.status_code, 401)\n self.assertException(res, exc.EntryNotFound)","def assert_user_exists(self, user_id):\n result = self.con.execute(\n 'SELECT id FROM registered_user WHERE id = ? AND active = 1',\n (user_id,)\n ).fetchone()\n if result is None:\n raise err.UnknownUserError(user_id)","def test_email_account_operation_with_missing_user(self):\n user_id = 'missinguser'\n self.assertRaises(error.NotFound, \\\n SpokeEmailAccount, self.org_name, user_id)","def test_user_creation(self):\n self.assertTrue(User.objects.exists())","def test_create_user_invalid_id(self):\r\n print(\"Create user invalid id (already taken)\")\r\n u_id = 100\r\n username = \"newtestuser\"\r\n password = \"test9999\"\r\n u_type = 1\r\n\r\n prev_noUsers = len(User.query.all())\r\n self.assertEqual(self.system.create_user(u_id, username, password, u_type), 0)\r\n curr_noUsers = len(User.query.all())\r\n self.assertEqual(prev_noUsers, curr_noUsers)","def getTestUser():\n allUsers = User.objects.all()\n if len(allUsers) > 0 :\n return allUsers[0]\n else :\n return User.objects.create_user(username='profiletester',\n email='profiletester@mapstorytests.com',\n password='superduperpassword2000')","def test_get_user_exists(self):\n # First make the user\n resp = self.app.post('/users', data=json.dumps(self.test_user1_data))\n assert resp.status_code == 200\n\n # Now get the user data and verify it is correct\n resp = self.app.get('/users/{}'.format(self.test_user1_userid))\n assert resp.status_code == 200\n data = json.loads(resp.data)\n for key in ['first_name', 'last_name', 'userid', 'groups']:\n assert key in data\n assert data['first_name'] == self.test_user1_first\n assert data['last_name'] == self.test_user1_last\n assert data['userid'] == self.test_user1_userid\n for groupid in self.test_user1_groups:\n assert groupid in data['groups']","def test_get_user_by_id_mismatch(client: FlaskClient) -> None:\n username = create_random_username()\n # Users with mismatching username in auth token are not allowed\n # to make the request\n other_username = create_random_username()\n auth_token = create_auth_token(other_username)\n response = get_user(client, username, auth_token.signed)\n assert_error_response(response, HTTPStatus.FORBIDDEN)","def test_user_already_exists(self):\n User.objects.create_user(\n 'existing@example.com',\n 'existing@example.com',\n '123existing'\n )\n response = self.client.post('/o/register', {\n 'email': 'existing@example.com',\n 'password': '123existing',\n 'terms_acceptance': True,\n })\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, 'auth/login.html')\n self.assertContains(\n response,\n 'Użytkownik o podanym emailu już istnieje',\n )\n self.assertNotIn('_auth_user_id', self.client.session)\n self.assertEqual(User.objects.all().count(), 1)","def test_user_existence(self):\n\n credentials = {\n 'email': 'testuser@gmail.com',\n 'password': 'Testpass12',\n 'name': 'Test Name'\n }\n get_user_model().objects.create_user(**credentials)\n\n # Check that this is a bad request since the user does already exists.\n response = self.client.post(URL_CREATE_USER, credentials)\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)","def test_create_user_invalid_username(self):\r\n print(\"Create user invalid username (already taken)\")\r\n u_id = 3\r\n username = \"100\"\r\n password = \"test9999\"\r\n u_type = 1\r\n\r\n prev_noUsers = len(User.query.all())\r\n self.assertEqual(self.system.create_user(u_id, username, password, u_type), 0)\r\n curr_noUsers = len(User.query.all())\r\n self.assertEqual(prev_noUsers, curr_noUsers)","def test_get_for_not_found_organization(self):\n user = User.create(name='foo', email='foo@bar.com')\n user.put()\n response = self.testapp.get(\n '/api/organizations/Organization_other/users',\n headers=self.login_headers(user),\n status=404\n )","def test_user_not_in_users_table(self) -> None:\n user1 = self.register_user(\"user1\", \"pass\")\n token1 = self.login(user1, \"pass\")\n room = self.helper.create_room_as(user1, is_public=True, tok=token1)\n\n # Inject a join event for a user who doesn't exist\n self.get_success(inject_member_event(self.hs, room, \"@not-a-user:test\", \"join\"))\n\n # Another new user registers and joins the room\n user2 = self.register_user(\"user2\", \"pass\")\n token2 = self.login(user2, \"pass\")\n self.helper.join(room, user2, tok=token2)\n\n # The dodgy event should not have stopped us from processing user2's join.\n in_public = self.get_success(self.user_dir_helper.get_users_in_public_rooms())\n self.assertEqual(set(in_public), {(user1, room), (user2, room)})","def test_login_login_inexisting_user_false(self):\n logins = {\n \"Email\": \"user@example.com\",\n \"Password\": \"pass1234\"\n }\n resp = self.client().post('/api/v1/auth/login', data=logins)\n self.assertEqual(resp.status_code, 400)\n resp = resp.get_json()\n self.assertEqual(resp['error'],\n 'User not found in our database')","def test_not_authenticated(self):\n self.client.logout()\n response = self._get(get_kwargs=self._data())\n self._check_response(response, 101)\n self.assertEqual(UserFitbit.objects.count(), 1)","def test_login_for_user_not_registered(self):\n response = self.client.post(LOGIN_URL,\n data=json.dumps(\n {'username': 'otieno', 'password': 'otieno254'}),\n content_type='application/json')\n self.assertEqual(response.status_code, 404)\n result = json.loads(response.data.decode())\n self.assertEqual(result['message'], 'User unavailable')","def test_create_no_username(self):\n\n # If there is no username, email will be used instead\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=True)\n\n user = api.user.create(\n email='chuck@norris.org',\n password='secret'\n )\n\n self.assertEquals(user.getUserName(), 'chuck@norris.org')\n\n # But if using emails as a username is disabled, we should get\n # an error\n properties.manage_changeProperties(use_email_as_login=False)\n\n self.assertRaises(\n ValueError,\n api.user.create,\n email='chuck@norris.org', password='secret'\n )","def test_user_exists(self):\n # requirments for creating user\n payload = {\n 'email': 'test@gmail.com',\n 'password': 'abcd1234',\n 'name': 'Test',\n }\n\n # call the create function above\n create_user(**payload)\n\n # this will do a HTTP POST request and create a user\n response = self.client.post(CREATE_USER_URL, payload)\n\n # Check if statuscode returns a HTTP400 bad request\n # becos user already exist\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)","def test_creating_a_new_user_without_email(self):\n\n with self.assertRaises(ValueError):\n get_user_model().objects.create_user(None, \"Test1234\")","def test_signup_missing_username(self):\n\n invalid_u = User.signup(\"test@test.com\", None, \"testpass\", \"Test\", \"User\", None)\n \n uid = 99999\n invalid_u.id = uid\n\n with self.assertRaises(exc.IntegrityError) as context:\n db.session.commit()","def testGetUserIgnoresCase(self):\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n result = yield self.facade.getUser(session, u'uSeR')\n self.assertEqual(u'user', result.username)","def test_user_exists(self):\n payload = {'email': 'test@test1.com','password': 'testpass'}\n res = self.client.post(CREATE_USER_URL, payload)\n self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)","def test_empty_user_name_field(self):\r\n result=self.user.get_user_register(\"Stephen\",\" Ochieng\",\"stephenochieng955@mail.com\",\"stephenochieng\",\"eat\")\r\n self.assertEqual(2,result,\"Fill in the username field please\")","def test_create_user_with_no_role(setup_client):\n client = setup_client\n payload = {\n 'email': 'test@gmail.com',\n 'password': 'password',\n 'name': 'Test name'\n }\n res = client.post(CREATE_USER_URL, payload)\n assert res.status_code == status.HTTP_400_BAD_REQUEST\n user_exists = get_user_model().objects.filter(\n email=payload['email']).exists()\n assert not user_exists","def test_homepage_logged_in_except(self):\r\n\r\n u1 = User.query.filter_by(username='testuser').one()\r\n u1.location = 'US-FAKE'\r\n db.session.add(u1)\r\n db.session.commit()\r\n\r\n with self.client as c:\r\n with c.session_transaction() as sess:\r\n sess[CURR_USER_KEY] = u1.id\r\n response = c.get('/')\r\n self.assertEqual(response.status_code, 200)\r\n self.assertIn(b'No data found for your region.', response.data)","def test_get_non_owner(self):\n another_user = CustomUser(id=101, email='another_user@mail.com', is_active=True)\n another_user.set_password('testpassword')\n another_user.save()\n self.client.login(email='another_user@mail.com', password='testpassword')\n\n url = reverse('route', kwargs={'way_id': self.route.way_id, 'route_id': self.route.id})\n response = self.client.get(url)\n self.assertEqual(response.status_code, 403)","def test_get_user(self):\n user = User(self.client, \"test-user\", {})\n\n self.assertEqual(user.username, \"test-user\")\n self.assertEqual(user.email, \"test-user@linode.com\")\n self.assertTrue(user.restricted)\n self.assertTrue(user.tfa_enabled)\n self.assertIsNotNone(user.ssh_keys)","def test_users_username_get(self):\n pass","def test_insert_get_user(self):\n\n # Select a user on an empty set\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\n self.assertFalse(selected.success)\n self.assertIsNone(selected.documents)\n\n # Inserting user into Database\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertTrue(inserted.success)\n\n # Verify that document was inserted\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\n self.assertTrue(selected.success)\n self.assertEqual(selected.documents, MAGEN_USER)\n\n # Inserting same user again (uuid and e-mail should be unique)\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertFalse(inserted.success)\n self.assertIn('user_uuid', inserted.message)","def test_user_exists(self):\n payload = {\n 'email': 'test@123.ru',\n 'password': '123PassW0rd',\n 'name': 'Test Name'\n }\n create_user(**payload)\n\n res = self.client.post(CREATE_USER_URL, payload)\n\n self.assertEquals(res.status_code, status.HTTP_400_BAD_REQUEST)","def test_modify_nonexist_username(self):\n print('(' + self.test_modify_nonexist_username.__name__+')',\n self.test_modify_nonexist_username.__doc__)\n self.assertIsNone(self.connection.modify_user(\n NON_EXIST_PATIENT_USERNAME, PATIENT['public_profile'],\n PATIENT['restricted_profile']))","def test_user_exists_without_email(self):\n response = self.client.post(self.url)\n expected_response_code = 400\n\n self.assertEqual(expected_response_code, response.status_code)","def test_missingKey(self):\n self.assertIsNone(self.users.key(\"mystery domain\", \"mystery user\"))","def test_get_user_by_name(self):\n\n # Select on empty set\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\n self.assertFalse(selected.success)\n self.assertIsNone(selected.documents)\n\n # Insert user\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertTrue(inserted.success)\n\n # Select user by username\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\n self.assertTrue(selected.success)\n self.assertEqual(selected.documents, MAGEN_USER)","def testGetWithNoEmail(self):\n userdict = {'id': 1,\n 'objectID': u'04585bec-28cf-4a21-bc3e-081f3ed62680',\n 'username': u'testuser',\n 'passwordHash': 'hash',\n 'email': None,\n 'fullname': u'Test User',\n 'role': Role.ANONYMOUS.id}\n self.cache.set('user:testuser', json.dumps(userdict))\n result = self.userCache.get(u'testuser')\n user = result.results\n self.assertEqual(1, user.id)\n self.assertEqual('04585bec-28cf-4a21-bc3e-081f3ed62680',\n str(user.objectID))\n self.assertEqual(u'testuser', user.username)\n self.assertEqual('hash', user.passwordHash)\n self.assertEqual(u'Test User', user.fullname)\n self.assertEqual(None, user.email)\n self.assertEqual(Role.ANONYMOUS, user.role)","def test_user_exists(self):\r\n payload = {\r\n 'email': 'test@net.net',\r\n 'password': 'testpass',\r\n 'name': 'Maks'\r\n }\r\n create_user(**payload)\r\n\r\n res = self.client.post(CREATE_USER_URL, payload)\r\n self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)","def test_user_id_get(self):\n pass","def test_user_exists(self):\n payload = {\n 'email': 'haider@gmail.com',\n 'password': 'testpass123'\n }\n create_user(**payload)\n res = self.client.post(CREATE_USER_API, payload)\n self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)","def test_auth_user_fail_bad_username(self):\n\n self.assertFalse(User.authenticate(\"invalid\", \"allison\"))","def test_get_non_owner(self):\n another_user = CustomUser(id=101, email='another_user@mail.com', is_active=True)\n another_user.set_password('testpassword')\n another_user.save()\n self.client.login(email='another_user@mail.com', password='testpassword')\n\n url = reverse('notification',\n kwargs={'way_id': self.notification.way_id, 'notification_id': self.notification.id})\n response = self.client.get(url)\n self.assertEqual(response.status_code, 403)","def testCreateIsAllowed(self):\n self.users.create([(u'user', u'secret', u'User', u'user@example.com')])\n user = getUser(u'user')\n self.assertEqual(u'user', user.username)","def test_find_user_by_username(self):\n self.new_user.save_user()\n test_user = User(\"Test\", \"user\", \"test\", \"walIas15\")\n test_user.save_user()\n user_exists = User.user_exist(\"test\")\n self.assertTrue(user_exists)","def test_admin_cannot_update_non_existant_user(self):\n resp = self.admin_create_user()\n reply = self.admin_login()\n token = reply['token']\n user = dict(\n name='Summer Lover',\n username='lover',\n password='Andela8',\n role='attendant'\n )\n resp = self.client.put(\n '/api/v1/users/5',\n content_type='application/json',\n data=json.dumps(user),\n headers={'Authorization': 'Bearer {}'.format(token)}\n )\n reply = json.loads(resp.data.decode())\n self.assertEqual(reply['message'], \"This user doesn't exist!\")\n self.assertEqual(resp.status_code, 400)","def test_request_users_user_invalid_resource(self):\n response = requests.get(self.url + '/users/John/invalid')\n\n self.assertEqual(response.status_code, 404)","def test_retrive_user(self):\n res = self.client.get(ME_URL)\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(res.data['email'], self.user.email)\n self.assertEqual(res.data['name'], self.user.name)\n self.assertNotIn('password', res.data)","def test_user_exists(self):\n payload = {'email': 'jon@snow.com', 'password': 'password'}\n create_user(**payload)\n\n res = self.client.post(CREATE_USER_URL, payload)\n\n self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)","def test_verify_invalid_user(self, rp_logger):\n\n test_name = sys._getframe().f_code.co_name\n\n rp_logger.info(\"###### TEST EXECUTION STARTED :: \" +\n test_name + \" ######\")\n\n first_name = data_reader.get_data(test_name, 'FirstName')\n last_name = data_reader.get_data(test_name, 'LastName')\n email = data_reader.get_data(test_name, 'Email')\n\n with allure.step(\"Verify whether user exists\"):\n result = base_api.verify_valid_user(\n email, first_name, last_name)\n exe_status.mark_final(test_step=test_name, result=result)","def test_private_create_user_without_email(self):\n with pytest.raises(ValueError) as exinfo:\n EmailUser.objects._create_user(None, None, False, False)\n self.assertIn('email must be set', str(exinfo.value))","def test_07_create_user_exists(self):\n\n _, user = self.get_random_item(models.User)\n success, error = utils.create_user(user, session=self.session)\n db_user = db_utils.get_item(\n models.User, filters={\"id\": user[\"id\"]}, session=self.session\n )\n user[\"password\"] = db_user.password\n self.assertTrue(db_user)\n db_user = db_user.as_dict()\n items_equal = utils.is_equal(user, db_user)\n self.assertTrue(items_equal)\n self.assertTrue(success)\n self.assertFalse(error)","def test_add_user_with_none_exist_user_id(\n self, app, auth_user, none_exist_user=1000\n ):\n data = UserInfo.random()\n us_info = app.user_info.add_user_info(\n user_id=none_exist_user,\n data=data,\n header=auth_user.header,\n type_response=MessageResponse,\n )\n assert us_info.status_code == 404, \"Check status code\"\n assert us_info.data.message == ResponseText.MESSAGE_USER_NOT_FOUND","def test_get_non_existing_token_authenticated_user(self):\r\n\r\n user_no_tokens = UserFactory.create_batch(2)[1]\r\n\r\n res = self.app.get('/api/token/twitter?api_key=' + user_no_tokens.api_key)\r\n error = json.loads(res.data)\r\n\r\n assert res.status_code == 404, error\r\n assert error['status'] == 'failed', error\r\n assert error['action'] == 'GET', error\r\n assert error['target'] == 'token', error\r\n assert error['exception_cls'] == 'NotFound', error","def test_non_registered_user_trying_to_login(self): \n # try logging in the user without registering the user \n res = self.client().post(AuthTestCase.login, data=self.user)\n # bad request \n self.assertEqual(res.status_code, 401)","def testDeleteUserWithUnknownUsername(self):\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n deferred = self.facade.deleteUser(session, u'unknown')\n error = yield self.assertFailure(deferred, TNoSuchUser)\n self.assertEqual(u'unknown', error.name)","def test_get_user(self):\n print('(' + self.test_get_user.__name__+')', self.test_get_user.__doc__)\n # test for patient\n self.assertDictContainsSubset(\n self.connection.get_user(PATIENT_USERNAME), PATIENT)\n # test for doctor\n self.assertDictContainsSubset(\n self.connection.get_user(DOCTOR_USERNAME), DOCTOR)","def test_read_by_random_logged_in_user(self):\n user = UserFactory()\n\n self.assert_user_cannot_read(user, self.live)"],"string":"[\n \"def test_get_user_non_exist_id(self):\\n print('(' + self.test_get_user_non_exist_id.__name__+')',\\n self.test_get_user_non_exist_id.__doc__)\\n self.assertIsNone(self.connection.get_user(NON_EXIST_PATIENT_USERNAME))\",\n \"def test_get_bad_user(self):\\r\\n user = UserMgr.get(username=u'noexist')\\r\\n\\r\\n self.assertEqual(\\r\\n user,\\r\\n None,\\r\\n \\\"Should not find a non-existant user: \\\" + str(user))\",\n \"def testGetUserWithoutData(self):\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n deferred = self.facade.getUser(session, u'unknown')\\n error = yield self.assertFailure(deferred, TNoSuchUser)\\n self.assertEqual(u'unknown', error.name)\",\n \"def test_get_single_user_is_missing(self):\\n add_user(\\\"neilb\\\", \\\"neilb14@mailinator.com\\\")\\n with self.client:\\n response = self.client.get('/users/999')\\n data = json.loads(response.data.decode())\\n self.assertEqual(response.status_code, 404)\\n self.assertIn('User does not exist', data['message'])\\n self.assertIn('fail', data['status'])\",\n \"def test_no_user_exists(self):\\n actual = get_user_if_exists(None, self.details)\\n self.assertDictEqual(actual, {})\",\n \"def test_get_user_by_id_non_existent(client: FlaskClient) -> None:\\n username = create_random_username()\\n # Authenticated requests to nonexistent usernames gives 404\\n auth_token = create_auth_token(username)\\n response = get_user(client, username, auth_token.signed)\\n assert_error_response(response, HTTPStatus.NOT_FOUND)\",\n \"def test_get_user_id_unknown_user(self):\\n print('(' + self.test_get_user_id.__name__+')',\\n self.test_get_user_id.__doc__)\\n self.assertIsNone(self.connection.get_user_id(\\n NON_EXIST_PATIENT_USERNAME))\",\n \"def test_dont_create_user(self):\\n self.assertFalse(User.objects.exists())\",\n \"def test_not_found(self):\\n with self.assertRaises(UserNotFoundException):\\n self._storage.get_by_username(\\\"test\\\")\",\n \"def test_get_user_by_username(self):\\n\\t\\tusername_in_db = server.get_user_by_username('Natasha')\\n\\t\\tself.assertTrue(username_in_db, 'Query did not fetch user object.')\\n\\t\\tusername_not_in_db = server.get_user_by_username('xyz')\\n\\t\\tself.assertFalse(username_not_in_db, 'Query fetched user that did not exist (xyz).')\",\n \"def test_get_by_id_false(self):\\n\\n user = CustomUser.get_by_id(44444)\\n\\n self.assertIsNone(user)\",\n \"def test_nonexistent_user(self):\\n self.client.login(username=self.global_staff.username, password=self.password)\\n resp = self.client.get(self.get_url('IDoNotExist'))\\n assert resp.status_code == status.HTTP_404_NOT_FOUND\",\n \"def test_004_get_user_not_found(self, mock_db_query):\\n mock_db_query.get.return_value = None\\n\\n response = self.app.get('/v1/users/0', headers={'accept': 'application/json'})\\n\\n print(response.get_data().decode())\\n\\n self.assertEqual(response.status_code, 404)\\n self.assertIn('User not found', response.get_data().decode())\",\n \"def test_error_inexistent_user_data(self, test_client, init_database, insert_user_db):\\n login_url = '/api/v1/auth/login'\\n login_data = {\\n 'email': insert_user_db.email,\\n 'password': 'password'\\n }\\n login_response = test_client.post(login_url, json=login_data)\\n init_database.session.delete(insert_user_db)\\n init_database.session.commit()\\n\\n url = '/api/v1/auth/me'\\n headers = {\\n 'Authorization': 'Bearer {}'.format(login_response.json['access'])\\n }\\n response = test_client.get(url, headers=headers)\\n\\n assert response.status_code == 404\\n assert response.json['code'] == 'NOT_FOUND'\\n assert response.json['message'] == 'User not found!'\\n assert response.json['details'] == ['User not found!']\",\n \"def test_getUserNonexistentDatabase(self):\\n self.db = checkers.FilePasswordDB(\\\"test_thisbetternoteverexist.db\\\")\\n\\n self.assertRaises(error.UnauthorizedLogin, self.db.getUser, \\\"user\\\")\",\n \"def test_08_create_user_not_exists(self):\\n\\n _, user = self.get_random_item(models.User)\\n utils.create_user(user, session=self.session)\\n success, error = utils.create_user(user, session=self.session)\\n self.assertFalse(success)\\n self.assertTrue(error)\",\n \"def test_nonexistent_user(self):\\n nonexistent_username = \\\"nonexistent user\\\"\\n self.retired_username = get_retired_username_by_username(nonexistent_username)\\n data = {'username': nonexistent_username}\\n headers = self.build_jwt_headers(self.superuser)\\n response = self.client.post(self.url, data, **headers)\\n self.assert_response_correct(response, 404, None)\",\n \"def test_user_does_not_exist(self):\\n url = reverse('main_app:user', args=('non-exist',))\\n response = self.client.get(url)\\n self.assertEqual(response.status_code, 404)\",\n \"def test_get_user_404(self):\\n resp = self.app.get('/users/thisuserdoesntexist')\\n assert resp.status_code == 404\",\n \"def test_unknown_user(self):\\n self.sign_in()\\n response = self.client.get(reverse('backend:user_details', args=(0,)))\\n self.assertEqual(response.status_code, 404)\",\n \"def test_get_user_if_exists(self):\\n user = User.objects.create(username=self.username)\\n actual = get_user_if_exists(None, self.details, user=user)\\n self.assertDictEqual(actual, {'is_new': False})\",\n \"def test_get_single_user_no_id(self):\\n add_user(\\\"neilb\\\", \\\"neilb14@mailinator.com\\\")\\n with self.client:\\n response = self.client.get('/users/blah')\\n data = json.loads(response.data.decode())\\n self.assertEqual(response.status_code, 404)\\n self.assertIn('User does not exist', data['message'])\\n self.assertIn('fail', data['status'])\",\n \"def test_existing_user(self):\\n user = User.objects.create(username=self.username)\\n actual = get_user_if_exists(None, self.details)\\n self.assertDictEqual(actual, {'is_new': False, 'user': user})\",\n \"def test_user_not_in_db_before_addition(self):\\n\\n username = 'testuser'\\n user = User.query.filter_by(username=username).first()\\n self.assertTrue(user.__str__(), None)\",\n \"def test_returns_404_if_user_doesnt_exist(self):\\n # Act\\n response = self.client.get(\\\"/api/v2/projects/queries/non_existent/touched/\\\")\\n self.assertEqual(response.status_code, 404)\",\n \"def test_non_existing_user_login(self):\\n user = {\\n 'email': 'test@gmail.com',\\n 'password': 'password123'}\\n res = self.app.post('/login', data=user)\\n self.assertEqual(res.status_code, 200)\\n self.assertIn(\\\"You have no account\\\", str(res.data))\",\n \"def test_get_users_no_username(user_store: MockStore, user_email: str):\\n # GIVEN a database with a user\\n\\n # WHEN getting users\\n users: List[User] = user_store.get_users(email=user_email)\\n\\n # THEN the user should be returned\\n assert users[0].email == user_email\",\n \"def test_returns_none_if_no_user(self):\\r\\n self.assertIsNone(PasswordlessAuthenticationBackend().get_user('edith@example.com'))\",\n \"def test_dont_save_new_user(self):\\n self.assertEqual(get_user_model().objects.exists(), 1)\",\n \"def test_existence(self):\\n self.assertTrue(User.objects.filter(username='rcm').exists())\",\n \"def test_nonexistent_user_login(self):\\n\\n fake_user = {\\\"email\\\": \\\"eat@me.com\\\",\\n \\\"password\\\": \\\"lolzIKid\\\"}\\n\\n res = self.client.post(\\n \\\"/api/v2/auth/login\\\", data=json.dumps(fake_user), content_type=\\\"application/json\\\")\\n result = json.loads(res.data)\\n self.assertEqual(result[\\\"Error\\\"], \\\"User does not exist\\\")\\n self.assertEqual(res.status_code, 404)\",\n \"def test_user_profile_view_user_doesnt_exist(self):\\n params = {'pk': 101}\\n profile_response = self.client.get(reverse('api:users-detail', kwargs=params))\\n self.assertTrue(profile_response.status_code == 404)\",\n \"def test_get_for_user_no_user(self):\\n self.assertIsNone(Tour.objects.get_for_user(User()))\",\n \"def test_get_for_not_found_team(self):\\n user = User.create(name='foo', email='foo@bar.com')\\n user.put()\\n response = self.testapp.get(\\n '/api/teams/Team_other/users',\\n headers=self.login_headers(user),\\n status=404\\n )\",\n \"def test_get_user_by_id_unauthenticated(client: FlaskClient) -> None:\\n username = create_random_username()\\n # Unauthenticated users are not allowed to make the request\\n response = get_user(client, username)\\n assert_error_response(response, HTTPStatus.UNAUTHORIZED)\",\n \"def test_detail_user_does_not_exists(self, client, users):\\n user = users[0]\\n url = reverse('users:detail', args=(user.pk + 100,))\\n response = client.get(url)\\n assert response.status_code == 404\",\n \"def test_get_user_info_does_not_exist(self):\\n http_cookie = 'one=two; three=four'\\n email, admin, user_id = login.get_user_info(http_cookie,\\n cookie_name=COOKIE_NAME)\\n\\n self.assertEqual('', email)\\n self.assertFalse(admin)\",\n \"def test_no_user(self):\\n self.request.user = None\\n result = user_id_get_view(self.request)['d']\\n self.assertEqual(result, error_dict('api_errors', 'not authenticated for this request'))\",\n \"def test_not_contains_user(self):\\n print('(' + self.test_not_contains_user.__name__+')',\\n self.test_not_contains_user.__doc__)\\n # non existing doctor, it could be patient as well\\n self.assertFalse(self.connection.contains_user(\\n NON_EXIST_DOCTOR_USERNAME))\",\n \"def test_user_not_found(self):\\n data = {'email': 'unmatched email'}\\n response = self.client.post(self.url, data=data)\\n\\n expected_response_code = 200\\n\\n self.assertEqual(expected_response_code, response.status_code)\\n self.assertFalse(response.data.get('exists'))\",\n \"def test_get_user_by_id_non_admin(client: FlaskClient, db_session) -> None:\\n username = create_random_username()\\n populate_database_with_users(db_session, username)\\n # Users with matching username in auth token are allowed to make\\n # the request\\n user = GifSyncUser.get_by_username(username)\\n assert user is not None\\n auth_token = create_auth_token(username)\\n response = get_user(client, username, auth_token.signed)\\n assert response.status_code == HTTPStatus.OK\\n assert_user_in_response(response)\\n # User retrieved matches the user in database\\n json_data: dict = response.get_json()\\n user_data = json_data.get(\\\"user\\\")\\n assert isinstance(user_data, dict)\\n assert user_data.get(\\\"id\\\") == user.id\\n assert user_data.get(\\\"username\\\") == user.username\\n assert isinstance(user_data.get(\\\"gifs\\\"), list)\\n assert len(user_data[\\\"gifs\\\"]) == len(user.gifs)\",\n \"def test_create_user_fails_with_no_username(self):\\n user = get_user_model().objects.create(\\n email='test@test.test',\\n first_name='Test',\\n password='pass123456!'\\n )\\n\\n users = User.objects.filter(username='Test')\\n\\n self.assertEqual(len(users), 0)\",\n \"def test_get(self):\\n user = api.user.create(\\n username='chuck',\\n email='chuck@norris.org',\\n password='secret',\\n )\\n\\n self.assertEqual(api.user.get('chuck'), user)\",\n \"def test_signup_attempt_with_nonexistent_user(self):\\n\\n details = {\\\"email\\\": \\\"admooin@admin.admin\\\",\\n \\\"password\\\": \\\"oiudof987ewrqlwe\\\"}\\n\\n res = self.client.post(\\n \\\"/api/v2/auth/login\\\", data=json.dumps(details), content_type=\\\"application/json\\\")\\n self.assertEqual(res.status_code, 404)\",\n \"def test_request_users_user_invalid(self):\\n response = requests.get(self.url + '/users/invalid')\\n\\n self.assertEqual(response.status_code, 404)\",\n \"def test_verify_non_existing_user(self):\\n data = {'rank_id': 1}\\n res = self.post(url='/verify/5', data=data, role='admin')\\n self.assertEqual(res.status_code, 401)\\n self.assertException(res, exc.EntryNotFound)\",\n \"def assert_user_exists(self, user_id):\\n result = self.con.execute(\\n 'SELECT id FROM registered_user WHERE id = ? AND active = 1',\\n (user_id,)\\n ).fetchone()\\n if result is None:\\n raise err.UnknownUserError(user_id)\",\n \"def test_email_account_operation_with_missing_user(self):\\n user_id = 'missinguser'\\n self.assertRaises(error.NotFound, \\\\\\n SpokeEmailAccount, self.org_name, user_id)\",\n \"def test_user_creation(self):\\n self.assertTrue(User.objects.exists())\",\n \"def test_create_user_invalid_id(self):\\r\\n print(\\\"Create user invalid id (already taken)\\\")\\r\\n u_id = 100\\r\\n username = \\\"newtestuser\\\"\\r\\n password = \\\"test9999\\\"\\r\\n u_type = 1\\r\\n\\r\\n prev_noUsers = len(User.query.all())\\r\\n self.assertEqual(self.system.create_user(u_id, username, password, u_type), 0)\\r\\n curr_noUsers = len(User.query.all())\\r\\n self.assertEqual(prev_noUsers, curr_noUsers)\",\n \"def getTestUser():\\n allUsers = User.objects.all()\\n if len(allUsers) > 0 :\\n return allUsers[0]\\n else :\\n return User.objects.create_user(username='profiletester',\\n email='profiletester@mapstorytests.com',\\n password='superduperpassword2000')\",\n \"def test_get_user_exists(self):\\n # First make the user\\n resp = self.app.post('/users', data=json.dumps(self.test_user1_data))\\n assert resp.status_code == 200\\n\\n # Now get the user data and verify it is correct\\n resp = self.app.get('/users/{}'.format(self.test_user1_userid))\\n assert resp.status_code == 200\\n data = json.loads(resp.data)\\n for key in ['first_name', 'last_name', 'userid', 'groups']:\\n assert key in data\\n assert data['first_name'] == self.test_user1_first\\n assert data['last_name'] == self.test_user1_last\\n assert data['userid'] == self.test_user1_userid\\n for groupid in self.test_user1_groups:\\n assert groupid in data['groups']\",\n \"def test_get_user_by_id_mismatch(client: FlaskClient) -> None:\\n username = create_random_username()\\n # Users with mismatching username in auth token are not allowed\\n # to make the request\\n other_username = create_random_username()\\n auth_token = create_auth_token(other_username)\\n response = get_user(client, username, auth_token.signed)\\n assert_error_response(response, HTTPStatus.FORBIDDEN)\",\n \"def test_user_already_exists(self):\\n User.objects.create_user(\\n 'existing@example.com',\\n 'existing@example.com',\\n '123existing'\\n )\\n response = self.client.post('/o/register', {\\n 'email': 'existing@example.com',\\n 'password': '123existing',\\n 'terms_acceptance': True,\\n })\\n self.assertEqual(response.status_code, 200)\\n self.assertTemplateUsed(response, 'auth/login.html')\\n self.assertContains(\\n response,\\n 'Użytkownik o podanym emailu już istnieje',\\n )\\n self.assertNotIn('_auth_user_id', self.client.session)\\n self.assertEqual(User.objects.all().count(), 1)\",\n \"def test_user_existence(self):\\n\\n credentials = {\\n 'email': 'testuser@gmail.com',\\n 'password': 'Testpass12',\\n 'name': 'Test Name'\\n }\\n get_user_model().objects.create_user(**credentials)\\n\\n # Check that this is a bad request since the user does already exists.\\n response = self.client.post(URL_CREATE_USER, credentials)\\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_create_user_invalid_username(self):\\r\\n print(\\\"Create user invalid username (already taken)\\\")\\r\\n u_id = 3\\r\\n username = \\\"100\\\"\\r\\n password = \\\"test9999\\\"\\r\\n u_type = 1\\r\\n\\r\\n prev_noUsers = len(User.query.all())\\r\\n self.assertEqual(self.system.create_user(u_id, username, password, u_type), 0)\\r\\n curr_noUsers = len(User.query.all())\\r\\n self.assertEqual(prev_noUsers, curr_noUsers)\",\n \"def test_get_for_not_found_organization(self):\\n user = User.create(name='foo', email='foo@bar.com')\\n user.put()\\n response = self.testapp.get(\\n '/api/organizations/Organization_other/users',\\n headers=self.login_headers(user),\\n status=404\\n )\",\n \"def test_user_not_in_users_table(self) -> None:\\n user1 = self.register_user(\\\"user1\\\", \\\"pass\\\")\\n token1 = self.login(user1, \\\"pass\\\")\\n room = self.helper.create_room_as(user1, is_public=True, tok=token1)\\n\\n # Inject a join event for a user who doesn't exist\\n self.get_success(inject_member_event(self.hs, room, \\\"@not-a-user:test\\\", \\\"join\\\"))\\n\\n # Another new user registers and joins the room\\n user2 = self.register_user(\\\"user2\\\", \\\"pass\\\")\\n token2 = self.login(user2, \\\"pass\\\")\\n self.helper.join(room, user2, tok=token2)\\n\\n # The dodgy event should not have stopped us from processing user2's join.\\n in_public = self.get_success(self.user_dir_helper.get_users_in_public_rooms())\\n self.assertEqual(set(in_public), {(user1, room), (user2, room)})\",\n \"def test_login_login_inexisting_user_false(self):\\n logins = {\\n \\\"Email\\\": \\\"user@example.com\\\",\\n \\\"Password\\\": \\\"pass1234\\\"\\n }\\n resp = self.client().post('/api/v1/auth/login', data=logins)\\n self.assertEqual(resp.status_code, 400)\\n resp = resp.get_json()\\n self.assertEqual(resp['error'],\\n 'User not found in our database')\",\n \"def test_not_authenticated(self):\\n self.client.logout()\\n response = self._get(get_kwargs=self._data())\\n self._check_response(response, 101)\\n self.assertEqual(UserFitbit.objects.count(), 1)\",\n \"def test_login_for_user_not_registered(self):\\n response = self.client.post(LOGIN_URL,\\n data=json.dumps(\\n {'username': 'otieno', 'password': 'otieno254'}),\\n content_type='application/json')\\n self.assertEqual(response.status_code, 404)\\n result = json.loads(response.data.decode())\\n self.assertEqual(result['message'], 'User unavailable')\",\n \"def test_create_no_username(self):\\n\\n # If there is no username, email will be used instead\\n properties = self.portal.portal_properties.site_properties\\n properties.manage_changeProperties(use_email_as_login=True)\\n\\n user = api.user.create(\\n email='chuck@norris.org',\\n password='secret'\\n )\\n\\n self.assertEquals(user.getUserName(), 'chuck@norris.org')\\n\\n # But if using emails as a username is disabled, we should get\\n # an error\\n properties.manage_changeProperties(use_email_as_login=False)\\n\\n self.assertRaises(\\n ValueError,\\n api.user.create,\\n email='chuck@norris.org', password='secret'\\n )\",\n \"def test_user_exists(self):\\n # requirments for creating user\\n payload = {\\n 'email': 'test@gmail.com',\\n 'password': 'abcd1234',\\n 'name': 'Test',\\n }\\n\\n # call the create function above\\n create_user(**payload)\\n\\n # this will do a HTTP POST request and create a user\\n response = self.client.post(CREATE_USER_URL, payload)\\n\\n # Check if statuscode returns a HTTP400 bad request\\n # becos user already exist\\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_creating_a_new_user_without_email(self):\\n\\n with self.assertRaises(ValueError):\\n get_user_model().objects.create_user(None, \\\"Test1234\\\")\",\n \"def test_signup_missing_username(self):\\n\\n invalid_u = User.signup(\\\"test@test.com\\\", None, \\\"testpass\\\", \\\"Test\\\", \\\"User\\\", None)\\n \\n uid = 99999\\n invalid_u.id = uid\\n\\n with self.assertRaises(exc.IntegrityError) as context:\\n db.session.commit()\",\n \"def testGetUserIgnoresCase(self):\\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n result = yield self.facade.getUser(session, u'uSeR')\\n self.assertEqual(u'user', result.username)\",\n \"def test_user_exists(self):\\n payload = {'email': 'test@test1.com','password': 'testpass'}\\n res = self.client.post(CREATE_USER_URL, payload)\\n self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_empty_user_name_field(self):\\r\\n result=self.user.get_user_register(\\\"Stephen\\\",\\\" Ochieng\\\",\\\"stephenochieng955@mail.com\\\",\\\"stephenochieng\\\",\\\"eat\\\")\\r\\n self.assertEqual(2,result,\\\"Fill in the username field please\\\")\",\n \"def test_create_user_with_no_role(setup_client):\\n client = setup_client\\n payload = {\\n 'email': 'test@gmail.com',\\n 'password': 'password',\\n 'name': 'Test name'\\n }\\n res = client.post(CREATE_USER_URL, payload)\\n assert res.status_code == status.HTTP_400_BAD_REQUEST\\n user_exists = get_user_model().objects.filter(\\n email=payload['email']).exists()\\n assert not user_exists\",\n \"def test_homepage_logged_in_except(self):\\r\\n\\r\\n u1 = User.query.filter_by(username='testuser').one()\\r\\n u1.location = 'US-FAKE'\\r\\n db.session.add(u1)\\r\\n db.session.commit()\\r\\n\\r\\n with self.client as c:\\r\\n with c.session_transaction() as sess:\\r\\n sess[CURR_USER_KEY] = u1.id\\r\\n response = c.get('/')\\r\\n self.assertEqual(response.status_code, 200)\\r\\n self.assertIn(b'No data found for your region.', response.data)\",\n \"def test_get_non_owner(self):\\n another_user = CustomUser(id=101, email='another_user@mail.com', is_active=True)\\n another_user.set_password('testpassword')\\n another_user.save()\\n self.client.login(email='another_user@mail.com', password='testpassword')\\n\\n url = reverse('route', kwargs={'way_id': self.route.way_id, 'route_id': self.route.id})\\n response = self.client.get(url)\\n self.assertEqual(response.status_code, 403)\",\n \"def test_get_user(self):\\n user = User(self.client, \\\"test-user\\\", {})\\n\\n self.assertEqual(user.username, \\\"test-user\\\")\\n self.assertEqual(user.email, \\\"test-user@linode.com\\\")\\n self.assertTrue(user.restricted)\\n self.assertTrue(user.tfa_enabled)\\n self.assertIsNotNone(user.ssh_keys)\",\n \"def test_users_username_get(self):\\n pass\",\n \"def test_insert_get_user(self):\\n\\n # Select a user on an empty set\\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\\n self.assertFalse(selected.success)\\n self.assertIsNone(selected.documents)\\n\\n # Inserting user into Database\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertTrue(inserted.success)\\n\\n # Verify that document was inserted\\n selected = self.user_api.get_user(MAGEN_USER['user_uuid'])\\n self.assertTrue(selected.success)\\n self.assertEqual(selected.documents, MAGEN_USER)\\n\\n # Inserting same user again (uuid and e-mail should be unique)\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertFalse(inserted.success)\\n self.assertIn('user_uuid', inserted.message)\",\n \"def test_user_exists(self):\\n payload = {\\n 'email': 'test@123.ru',\\n 'password': '123PassW0rd',\\n 'name': 'Test Name'\\n }\\n create_user(**payload)\\n\\n res = self.client.post(CREATE_USER_URL, payload)\\n\\n self.assertEquals(res.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_modify_nonexist_username(self):\\n print('(' + self.test_modify_nonexist_username.__name__+')',\\n self.test_modify_nonexist_username.__doc__)\\n self.assertIsNone(self.connection.modify_user(\\n NON_EXIST_PATIENT_USERNAME, PATIENT['public_profile'],\\n PATIENT['restricted_profile']))\",\n \"def test_user_exists_without_email(self):\\n response = self.client.post(self.url)\\n expected_response_code = 400\\n\\n self.assertEqual(expected_response_code, response.status_code)\",\n \"def test_missingKey(self):\\n self.assertIsNone(self.users.key(\\\"mystery domain\\\", \\\"mystery user\\\"))\",\n \"def test_get_user_by_name(self):\\n\\n # Select on empty set\\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\\n self.assertFalse(selected.success)\\n self.assertIsNone(selected.documents)\\n\\n # Insert user\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertTrue(inserted.success)\\n\\n # Select user by username\\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\\n self.assertTrue(selected.success)\\n self.assertEqual(selected.documents, MAGEN_USER)\",\n \"def testGetWithNoEmail(self):\\n userdict = {'id': 1,\\n 'objectID': u'04585bec-28cf-4a21-bc3e-081f3ed62680',\\n 'username': u'testuser',\\n 'passwordHash': 'hash',\\n 'email': None,\\n 'fullname': u'Test User',\\n 'role': Role.ANONYMOUS.id}\\n self.cache.set('user:testuser', json.dumps(userdict))\\n result = self.userCache.get(u'testuser')\\n user = result.results\\n self.assertEqual(1, user.id)\\n self.assertEqual('04585bec-28cf-4a21-bc3e-081f3ed62680',\\n str(user.objectID))\\n self.assertEqual(u'testuser', user.username)\\n self.assertEqual('hash', user.passwordHash)\\n self.assertEqual(u'Test User', user.fullname)\\n self.assertEqual(None, user.email)\\n self.assertEqual(Role.ANONYMOUS, user.role)\",\n \"def test_user_exists(self):\\r\\n payload = {\\r\\n 'email': 'test@net.net',\\r\\n 'password': 'testpass',\\r\\n 'name': 'Maks'\\r\\n }\\r\\n create_user(**payload)\\r\\n\\r\\n res = self.client.post(CREATE_USER_URL, payload)\\r\\n self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_user_id_get(self):\\n pass\",\n \"def test_user_exists(self):\\n payload = {\\n 'email': 'haider@gmail.com',\\n 'password': 'testpass123'\\n }\\n create_user(**payload)\\n res = self.client.post(CREATE_USER_API, payload)\\n self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_auth_user_fail_bad_username(self):\\n\\n self.assertFalse(User.authenticate(\\\"invalid\\\", \\\"allison\\\"))\",\n \"def test_get_non_owner(self):\\n another_user = CustomUser(id=101, email='another_user@mail.com', is_active=True)\\n another_user.set_password('testpassword')\\n another_user.save()\\n self.client.login(email='another_user@mail.com', password='testpassword')\\n\\n url = reverse('notification',\\n kwargs={'way_id': self.notification.way_id, 'notification_id': self.notification.id})\\n response = self.client.get(url)\\n self.assertEqual(response.status_code, 403)\",\n \"def testCreateIsAllowed(self):\\n self.users.create([(u'user', u'secret', u'User', u'user@example.com')])\\n user = getUser(u'user')\\n self.assertEqual(u'user', user.username)\",\n \"def test_find_user_by_username(self):\\n self.new_user.save_user()\\n test_user = User(\\\"Test\\\", \\\"user\\\", \\\"test\\\", \\\"walIas15\\\")\\n test_user.save_user()\\n user_exists = User.user_exist(\\\"test\\\")\\n self.assertTrue(user_exists)\",\n \"def test_admin_cannot_update_non_existant_user(self):\\n resp = self.admin_create_user()\\n reply = self.admin_login()\\n token = reply['token']\\n user = dict(\\n name='Summer Lover',\\n username='lover',\\n password='Andela8',\\n role='attendant'\\n )\\n resp = self.client.put(\\n '/api/v1/users/5',\\n content_type='application/json',\\n data=json.dumps(user),\\n headers={'Authorization': 'Bearer {}'.format(token)}\\n )\\n reply = json.loads(resp.data.decode())\\n self.assertEqual(reply['message'], \\\"This user doesn't exist!\\\")\\n self.assertEqual(resp.status_code, 400)\",\n \"def test_request_users_user_invalid_resource(self):\\n response = requests.get(self.url + '/users/John/invalid')\\n\\n self.assertEqual(response.status_code, 404)\",\n \"def test_retrive_user(self):\\n res = self.client.get(ME_URL)\\n\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(res.data['email'], self.user.email)\\n self.assertEqual(res.data['name'], self.user.name)\\n self.assertNotIn('password', res.data)\",\n \"def test_user_exists(self):\\n payload = {'email': 'jon@snow.com', 'password': 'password'}\\n create_user(**payload)\\n\\n res = self.client.post(CREATE_USER_URL, payload)\\n\\n self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_verify_invalid_user(self, rp_logger):\\n\\n test_name = sys._getframe().f_code.co_name\\n\\n rp_logger.info(\\\"###### TEST EXECUTION STARTED :: \\\" +\\n test_name + \\\" ######\\\")\\n\\n first_name = data_reader.get_data(test_name, 'FirstName')\\n last_name = data_reader.get_data(test_name, 'LastName')\\n email = data_reader.get_data(test_name, 'Email')\\n\\n with allure.step(\\\"Verify whether user exists\\\"):\\n result = base_api.verify_valid_user(\\n email, first_name, last_name)\\n exe_status.mark_final(test_step=test_name, result=result)\",\n \"def test_private_create_user_without_email(self):\\n with pytest.raises(ValueError) as exinfo:\\n EmailUser.objects._create_user(None, None, False, False)\\n self.assertIn('email must be set', str(exinfo.value))\",\n \"def test_07_create_user_exists(self):\\n\\n _, user = self.get_random_item(models.User)\\n success, error = utils.create_user(user, session=self.session)\\n db_user = db_utils.get_item(\\n models.User, filters={\\\"id\\\": user[\\\"id\\\"]}, session=self.session\\n )\\n user[\\\"password\\\"] = db_user.password\\n self.assertTrue(db_user)\\n db_user = db_user.as_dict()\\n items_equal = utils.is_equal(user, db_user)\\n self.assertTrue(items_equal)\\n self.assertTrue(success)\\n self.assertFalse(error)\",\n \"def test_add_user_with_none_exist_user_id(\\n self, app, auth_user, none_exist_user=1000\\n ):\\n data = UserInfo.random()\\n us_info = app.user_info.add_user_info(\\n user_id=none_exist_user,\\n data=data,\\n header=auth_user.header,\\n type_response=MessageResponse,\\n )\\n assert us_info.status_code == 404, \\\"Check status code\\\"\\n assert us_info.data.message == ResponseText.MESSAGE_USER_NOT_FOUND\",\n \"def test_get_non_existing_token_authenticated_user(self):\\r\\n\\r\\n user_no_tokens = UserFactory.create_batch(2)[1]\\r\\n\\r\\n res = self.app.get('/api/token/twitter?api_key=' + user_no_tokens.api_key)\\r\\n error = json.loads(res.data)\\r\\n\\r\\n assert res.status_code == 404, error\\r\\n assert error['status'] == 'failed', error\\r\\n assert error['action'] == 'GET', error\\r\\n assert error['target'] == 'token', error\\r\\n assert error['exception_cls'] == 'NotFound', error\",\n \"def test_non_registered_user_trying_to_login(self): \\n # try logging in the user without registering the user \\n res = self.client().post(AuthTestCase.login, data=self.user)\\n # bad request \\n self.assertEqual(res.status_code, 401)\",\n \"def testDeleteUserWithUnknownUsername(self):\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n deferred = self.facade.deleteUser(session, u'unknown')\\n error = yield self.assertFailure(deferred, TNoSuchUser)\\n self.assertEqual(u'unknown', error.name)\",\n \"def test_get_user(self):\\n print('(' + self.test_get_user.__name__+')', self.test_get_user.__doc__)\\n # test for patient\\n self.assertDictContainsSubset(\\n self.connection.get_user(PATIENT_USERNAME), PATIENT)\\n # test for doctor\\n self.assertDictContainsSubset(\\n self.connection.get_user(DOCTOR_USERNAME), DOCTOR)\",\n \"def test_read_by_random_logged_in_user(self):\\n user = UserFactory()\\n\\n self.assert_user_cannot_read(user, self.live)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.856584","0.8538134","0.8256169","0.80339926","0.7959935","0.7942771","0.7879475","0.78456324","0.77836406","0.77539635","0.77476394","0.77425784","0.7734177","0.7665938","0.7625372","0.7607034","0.7594667","0.7572818","0.7503314","0.7482438","0.7456589","0.74508286","0.740013","0.7363573","0.7347005","0.733221","0.7330928","0.73089737","0.7307724","0.7286714","0.7257991","0.72061384","0.7189498","0.7187835","0.7167983","0.7154568","0.71513456","0.7138828","0.7101593","0.7092404","0.7053405","0.7047549","0.7024238","0.70170105","0.7008697","0.6982106","0.6975588","0.69646174","0.69573146","0.6937529","0.69348395","0.69311327","0.69083273","0.69063425","0.69029725","0.6898755","0.68955266","0.68830967","0.68786436","0.6876979","0.68731946","0.6860775","0.68600285","0.6858394","0.6842616","0.68218756","0.6811862","0.68077075","0.6803337","0.68022954","0.6797964","0.679143","0.67785007","0.6774907","0.6771151","0.67620337","0.6754429","0.67473656","0.6745761","0.6738986","0.6725096","0.6721242","0.6718607","0.6718454","0.67174053","0.6699772","0.6697288","0.6696811","0.6696502","0.66945434","0.6688212","0.66857415","0.66850525","0.6684124","0.6681278","0.66812706","0.6677668","0.66709554","0.6665729","0.6660881"],"string":"[\n \"0.856584\",\n \"0.8538134\",\n \"0.8256169\",\n \"0.80339926\",\n \"0.7959935\",\n \"0.7942771\",\n \"0.7879475\",\n \"0.78456324\",\n \"0.77836406\",\n \"0.77539635\",\n \"0.77476394\",\n \"0.77425784\",\n \"0.7734177\",\n \"0.7665938\",\n \"0.7625372\",\n \"0.7607034\",\n \"0.7594667\",\n \"0.7572818\",\n \"0.7503314\",\n \"0.7482438\",\n \"0.7456589\",\n \"0.74508286\",\n \"0.740013\",\n \"0.7363573\",\n \"0.7347005\",\n \"0.733221\",\n \"0.7330928\",\n \"0.73089737\",\n \"0.7307724\",\n \"0.7286714\",\n \"0.7257991\",\n \"0.72061384\",\n \"0.7189498\",\n \"0.7187835\",\n \"0.7167983\",\n \"0.7154568\",\n \"0.71513456\",\n \"0.7138828\",\n \"0.7101593\",\n \"0.7092404\",\n \"0.7053405\",\n \"0.7047549\",\n \"0.7024238\",\n \"0.70170105\",\n \"0.7008697\",\n \"0.6982106\",\n \"0.6975588\",\n \"0.69646174\",\n \"0.69573146\",\n \"0.6937529\",\n \"0.69348395\",\n \"0.69311327\",\n \"0.69083273\",\n \"0.69063425\",\n \"0.69029725\",\n \"0.6898755\",\n \"0.68955266\",\n \"0.68830967\",\n \"0.68786436\",\n \"0.6876979\",\n \"0.68731946\",\n \"0.6860775\",\n \"0.68600285\",\n \"0.6858394\",\n \"0.6842616\",\n \"0.68218756\",\n \"0.6811862\",\n \"0.68077075\",\n \"0.6803337\",\n \"0.68022954\",\n \"0.6797964\",\n \"0.679143\",\n \"0.67785007\",\n \"0.6774907\",\n \"0.6771151\",\n \"0.67620337\",\n \"0.6754429\",\n \"0.67473656\",\n \"0.6745761\",\n \"0.6738986\",\n \"0.6725096\",\n \"0.6721242\",\n \"0.6718607\",\n \"0.6718454\",\n \"0.67174053\",\n \"0.6699772\",\n \"0.6697288\",\n \"0.6696811\",\n \"0.6696502\",\n \"0.66945434\",\n \"0.6688212\",\n \"0.66857415\",\n \"0.66850525\",\n \"0.6684124\",\n \"0.6681278\",\n \"0.66812706\",\n \"0.6677668\",\n \"0.66709554\",\n \"0.6665729\",\n \"0.6660881\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8029911"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":83699,"cells":{"query":{"kind":"string","value":"Test getting a user with username and email."},"document":{"kind":"string","value":"def test_get_users(user_store: MockStore, user_email: str, username: str):\n # GIVEN a database with a user\n\n # WHEN getting users\n users: List[User] = user_store.get_users(name=username, email=user_email)\n\n # THEN the user should be returned\n assert users[0].email == user_email"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_get_user_by_emailuser_email_get(self):\n pass","def test_get_user(user_store: MockStore, user_email: str):\n # GIVEN a database with a user\n\n # WHEN querying for a user\n user: User = user_store.get_user(email=user_email)\n\n # THEN it should be returned\n assert user.email == user_email","def test_resource_user_resource_get_user_by_email_address_get(self):\n pass","def test_user_retrieve(self):\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.get_token())\n response = self.client.get(reverse(\"account:user-profile\"))\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data.get('user').get('email'), \"testuser@gmail.com\")","def test_retrive_user(self):\n res = self.client.get(ME_URL)\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(res.data['email'], self.user.email)\n self.assertEqual(res.data['name'], self.user.name)\n self.assertNotIn('password', res.data)","def test_get(self):\n user = api.user.create(\n username='chuck',\n email='chuck@norris.org',\n password='secret',\n )\n\n self.assertEqual(api.user.get('chuck'), user)","def test_get_user(self):\n user = User(self.client, \"test-user\", {})\n\n self.assertEqual(user.username, \"test-user\")\n self.assertEqual(user.email, \"test-user@linode.com\")\n self.assertTrue(user.restricted)\n self.assertTrue(user.tfa_enabled)\n self.assertIsNotNone(user.ssh_keys)","def test_get_user(sample_user):\n\n client = auth_client(APIClient(), sample_user.email, \"testpassword\")\n\n response = client.get(reverse(\"user-detail\"), format=\"json\")\n assert response.status_code == status.HTTP_200_OK\n assert json.dumps(response.data) == json.dumps(\n {\"id\": sample_user.pk, \"email\": sample_user.email}\n )","def test_gets_user_by_email(self):\r\n User.objects.create(email='another_user@example.com')\r\n desired_user = User.objects.create(email='edith@example.com')\r\n found_user = PasswordlessAuthenticationBackend().get_user('edith@example.com')\r\n self.assertEqual(desired_user, found_user)","def test_get_user_by_username(self):\n\t\tusername_in_db = server.get_user_by_username('Natasha')\n\t\tself.assertTrue(username_in_db, 'Query did not fetch user object.')\n\t\tusername_not_in_db = server.get_user_by_username('xyz')\n\t\tself.assertFalse(username_not_in_db, 'Query fetched user that did not exist (xyz).')","def test_users_username_get(self):\n pass","def test_get_website_user_returns_user(self):\n user = get_website_user()\n self.assertTrue(user)","def test_get_single_user(self):\n user = add_user(\"neilb\", \"neilb14@mailinator.com\")\n with self.client:\n response = self.client.get(f'/users/{user.id}')\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 200)\n self.assertTrue('created_at' in data['data'])\n self.assertIn('neilb', data['data']['username'])\n self.assertIn('neilb14@mailinator.com', data['data']['email'])\n self.assertIn('success', data['status'])","def test_api_user_get(self):\n pass","def test_user_by_username(self):\n username = make_user(self.client)['username']\n resp = self.client.get('/user/'+username,\n headers=api_headers())\n json_resp = json.loads(resp.data.decode('utf-8'))\n self.assertEqual(json_resp['status'], 'user found')\n self.assertEqual(json_resp['user']['username'], username)","def test_getUser(self):\n\t\turl = \"/users/2/\"\n\t\tresponse = self.client.get(url, format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\tself.assertEqual(response.data[\"id\"], 2)\n\t\tself.assertEqual(response.data[\"username\"], \"testUser2\")","def testGetUser(self):\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\n user = getUser(u'user')\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n result = yield self.facade.getUser(session, u'user')\n self.assertEqual(u'user', result.username)\n self.assertEqual(str(user.objectID), result.objectId)\n self.assertEqual(u'User', result.name)\n self.assertEqual(u'USER', result.role)","def user(email):\r\n return User.objects.get(email=email)","def test_user_username_get(self):\n response = self.client.open('//user/{username}'.format(username='username_example'),\n method='GET')\n self.assert200(response, \"Response body is : \" + response.data.decode('utf-8'))","def test_user(self):\n user = User.objects.get(username=\"test01\")\n print(user.username)\n print(user.email)\n self.assertEqual(user.email,\"test01@email.com\")\n # cat = Animal.objects.get(name=\"cat\")\n # self.assertEqual(lion.speak(), 'The lion says \"roar\"')\n # self.assertEqual(cat.speak(), 'The cat says \"meow\"')","def test_get_user(self):\n print('(' + self.test_get_user.__name__+')', self.test_get_user.__doc__)\n # test for patient\n self.assertDictContainsSubset(\n self.connection.get_user(PATIENT_USERNAME), PATIENT)\n # test for doctor\n self.assertDictContainsSubset(\n self.connection.get_user(DOCTOR_USERNAME), DOCTOR)","def test_get_users_no_username(user_store: MockStore, user_email: str):\n # GIVEN a database with a user\n\n # WHEN getting users\n users: List[User] = user_store.get_users(email=user_email)\n\n # THEN the user should be returned\n assert users[0].email == user_email","def test_user(self):\n u = self.d.user('example')\n self.assertEqual(u.username, 'example')\n self.assertEqual(u.name, 'Example Sampleman')","def test_get_username(self):\r\n user = UserMgr.get(username=u'admin')\r\n self.assertEqual(\r\n user.id,\r\n 1,\r\n \"Should have a user id of 1: \" + str(user.id))\r\n self.assertEqual(\r\n user.username,\r\n 'admin',\r\n \"Should have a username of admin: \" + user.username)","def test_email(self):\r\n \r\n self.assertEqual('maryc123@yahoo.com', self.user.email)","def test_create_user(self):\n User.objects.create_user(username='abc', password='abcpass', email='abc@example.com')\n user_obj = User.objects.get(username='abc')\n self.assertTrue(user_obj.email, \"abc@example.com\")\n self.assertEqual(str(user_obj), \"abc\")","def test_getuser(self):\n # scenario 1: with @ starting in name and extid\n crusoe = self.fixtures.crusoe\n service_twitter = 'twitter'\n oauth_token = environ.get('TWITTER_OAUTH_TOKEN')\n oauth_token_type = 'Bearer' # NOQA: S105\n externalid = models.UserExternalId(\n service=service_twitter,\n user=crusoe,\n userid=crusoe.email.email,\n username=crusoe.username,\n oauth_token=oauth_token,\n oauth_token_type=oauth_token_type,\n )\n db.session.add(externalid)\n db.session.commit()\n result1 = models.getuser('@crusoe')\n self.assertIsInstance(result1, models.User)\n self.assertEqual(result1, crusoe)\n\n # scenario 2: with @ in name and not extid\n d_email = 'd@dothraki.vly'\n daenerys = models.User(\n username='daenerys', fullname=\"Daenerys Targaryen\", email=d_email\n )\n daenerys_email = models.UserEmail(email=d_email, user=daenerys)\n db.session.add_all([daenerys, daenerys_email])\n db.session.commit()\n result2 = models.getuser(d_email)\n self.assertIsInstance(result2, models.User)\n self.assertEqual(result2, daenerys)\n result3 = models.getuser('@daenerys')\n self.assertIsNone(result3)\n\n # scenario 3: with no @ starting in name, check by UserEmailClaim\n j_email = 'jonsnow@nightswatch.co.uk'\n jonsnow = models.User(username='jonsnow', fullname=\"Jon Snow\")\n jonsnow_email_claimed = models.UserEmailClaim(email=j_email, user=jonsnow)\n db.session.add_all([jonsnow, jonsnow_email_claimed])\n db.session.commit()\n result4 = models.getuser(j_email)\n self.assertIsInstance(result4, models.User)\n self.assertEqual(result4, jonsnow)\n\n # scenario 5: with no @ anywhere in name, fetch username\n arya = models.User(username='arya', fullname=\"Arya Stark\")\n db.session.add(arya)\n db.session.commit()\n result5 = models.getuser('arya')\n self.assertEqual(result5, arya)\n\n # scenario 6: with no starting with @ name and no UserEmailClaim or UserEmail\n cersei = models.User(username='cersei', fullname=\"Cersei Lannister\")\n db.session.add(cersei)\n db.session.commit()\n result6 = models.getuser('cersei@thelannisters.co.uk')\n self.assertIsNone(result6)","def test_user_get(self):\r\n expected_user = UserFactory.create()\r\n # Test GET all users\r\n res = self.app.get('/api/user')\r\n data = json.loads(res.data)\r\n user = data[0]\r\n assert len(data) == 1, data\r\n assert user['name'] == expected_user.name, data\r\n\r\n # The output should have a mime-type: application/json\r\n assert res.mimetype == 'application/json', res\r\n\r\n # Test GETting a specific user by ID\r\n res = self.app.get('/api/user/1')\r\n data = json.loads(res.data)\r\n user = data\r\n assert user['name'] == expected_user.name, data\r\n\r\n # Test a non-existant ID\r\n res = self.app.get('/api/user/3434209')\r\n err = json.loads(res.data)\r\n assert res.status_code == 404, err\r\n assert err['status'] == 'failed', err\r\n assert err['target'] == 'user', err\r\n assert err['exception_cls'] == 'NotFound', err\r\n assert err['action'] == 'GET', err","def test_fetch_user(self):\n\n self.register_user()\n\n self.assertEqual(self.fetch_user_details().status_code, 200)\n\n self.assertTrue(self.fetch_user_details(\n ).json[\"data\"][0][\"username\"] == 'Bjorn')","def get(self, email: str):\r\n args = authParser.parse_args()\r\n\r\n if not validators.email(email):\r\n response = {\r\n \"status\": \"error\",\r\n \"details\": {\r\n \"message\": \"Input a valid email address\"\r\n }\r\n }\r\n return response, http.client.BAD_REQUEST\r\n\r\n user = UserModel.query.filter(UserModel.email == email).first()\r\n\r\n if not user:\r\n # The email doesnt exist\r\n return {\r\n \"status\": \"error\",\r\n \"details\": {\r\n \"message\": \"Not Found\"\r\n }\r\n }, http.client.NOT_FOUND\r\n user = admin_namespace.marshal(user, user_model)\r\n return {\r\n \"status\": \"success\",\r\n \"details\": {\r\n \"result\": user\r\n }\r\n }, http.client.OK","def test_user(app, client, session, models, tokens):\n response = client.get(\n \"/user\", headers={\"Authorization\": f\"Bearer {tokens['read']}\"}\n )\n assert response.status_code == 200\n\n # Verify returned data against the database\n user_id = jwt.decode(\n tokens[\"read\"], app.config[\"RSA_PUBLIC_KEY\"], app.config[\"ALGORITHM\"],\n )[\"usr\"]\n user = User.query.filter(User.id == user_id).one()\n assert user.first_name == response.json[\"first_name\"]\n assert user.last_name == response.json[\"last_name\"]\n assert user.email == response.json[\"email\"]","def getTestUser():\n allUsers = User.objects.all()\n if len(allUsers) > 0 :\n return allUsers[0]\n else :\n return User.objects.create_user(username='profiletester',\n email='profiletester@mapstorytests.com',\n password='superduperpassword2000')","def test_retrieve_profile(self):\n\n response = self.client.get(URL_ME)\n\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n\n # Check that the user object returns as expected. There is no need\n # (and it is not secure) to return a password to client side.\n self.assertEqual(response.data, {\n 'name': self.user.name,\n 'email': self.user.email\n })","def test_users_get(self):\n pass","def test_users_get(self):\n pass","def test_for_email_attribute_by_name(self):\n name = u\"__TestUser__\"\n password = u\"ekfdweurwerh\"\n email = \"__TestUser__@moinhost\"\n self.createUser(name, password, email=email)\n theuser = user.User(self.request, name=name)\n assert theuser.email == \"\"","def get_user(email, queryset=None):\n if queryset is None:\n queryset = User.objects\n return queryset.get(username=_email_to_username(email))","def test_create_simple_user(self):\n payload = {\n 'email': 'test@mail.com',\n 'password': 'password231',\n 'name': 'vasia'\n }\n\n res = self.client.post(CREATE_USER_URL, payload)\n\n u = get_user_model().objects.get(**res.data)\n\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\n self.assertTrue(u.check_password(self.payload['password']))\n self.assertEqual(u.email, self.payload['email'])","def login_user(self, email=\"user@test.com\", password=\"test1234\"):\n user_data = {\n 'email': email,\n 'password': password\n }\n return self.client().post('/auth/login', data=user_data)\n\n ############################################\n ##### ALL OUR TESTS METHODS LIE HERE #######","def test_get_user_exists(self):\n # First make the user\n resp = self.app.post('/users', data=json.dumps(self.test_user1_data))\n assert resp.status_code == 200\n\n # Now get the user data and verify it is correct\n resp = self.app.get('/users/{}'.format(self.test_user1_userid))\n assert resp.status_code == 200\n data = json.loads(resp.data)\n for key in ['first_name', 'last_name', 'userid', 'groups']:\n assert key in data\n assert data['first_name'] == self.test_user1_first\n assert data['last_name'] == self.test_user1_last\n assert data['userid'] == self.test_user1_userid\n for groupid in self.test_user1_groups:\n assert groupid in data['groups']","def test_get_user_by_name(self):\n\n # Select on empty set\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\n self.assertFalse(selected.success)\n self.assertIsNone(selected.documents)\n\n # Insert user\n inserted = self.user_api.insert_user(MAGEN_USER)\n self.assertTrue(inserted.success)\n\n # Select user by username\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\n self.assertTrue(selected.success)\n self.assertEqual(selected.documents, MAGEN_USER)","def test_for_email_attribut_by_uid(self):\n name = u\"__TestUser2__\"\n password = u\"ekERErwerwerh\"\n email = \"__TestUser2__@moinhost\"\n self.createUser(name, password, email=email)\n uid = user.getUserId(self.request, name)\n theuser = user.User(self.request, uid)\n assert theuser.email == email","def test_003_get_user(self, mock_db_query):\n mock_db_query.get.return_value = seller1\n\n response = self.app.get('/v1/users/' + str(seller1.identity), headers={'accept': 'application/json'})\n\n print(response.get_data().decode())\n\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response.json['first_name'], 'Lisa')","def test_empty_email_field(self):\r\n result=self.user.get_user_register(\"Stephen\",\" Ochieng\",\"stephenochieng955@mail.com\",\"stephenochieng\",\"eat\")\r\n self.assertEqual(2,result,\"Fill in the email field please\")","def test_get_user_by_uuiduser_uuid_get(self):\n pass","def test_empty_user_name_field(self):\r\n result=self.user.get_user_register(\"Stephen\",\" Ochieng\",\"stephenochieng955@mail.com\",\"stephenochieng\",\"eat\")\r\n self.assertEqual(2,result,\"Fill in the username field please\")","def test_get(self, db_session: Session, get_user: Callable, attribute: str, db_column: Column) -> None:\n user_service = get_user_service(db_session)\n user = get_user(db_session)\n assert db_session.query(Users).filter(db_column == getattr(user, attribute)).one()\n\n response = user_service.get_user_info({\"id\": user.id})\n\n assert response == {\n \"status\": \"success\",\n \"code\": 200,\n \"data\": {\n \"user_id\": user.id,\n },\n }","def sample_user(email=user_v['email'], password=user_v['password']):\n return get_user_model().objects.create_user(email, password)","def test_resource_user_resource_get_user_get(self):\n pass","def test_02_get_api_with_user_username(self):\n print(\"Verify get users api with username query\")\n response = self.session.typicode_get_api_with_query(self.get_users_api, 'username=' + self.search_username)\n # Validates if response code is 200\n self.assertEqual(response.status_code, 200, \"Received status code \" + str(response.status_code) +\n \" instead of 200\")\n\n # Validates if response is not empty\n self.assertNotEqual(len(response.json()), 0, \"User response is empty\")\n\n # Validates if the username key is present in response\n username_response = get_response_for_given_path(response.json(), self.search_username_key)\n self.assertNotEquals(username_response, False, \"Searched string is not present\")\n\n # Validates if the given username is present in response\n user_present = check_given_value_present_in_list(username_response, self.search_username)\n self.assertTrue(user_present, \"Username \" + self.search_username + \"is not present in the response\")","def test_correct_user(self):\n\n self.create_user('Henrik', 1)\n self.create_user('Henrik2', 2)\n self.create_user('Test', 3)\n\n resp = self.client.get('/api/users/Henrik/')\n self.assertEquals(resp.json['total-users'], 2)","def test_get_website_user_returns_same_user(self):\n user = get_website_user()\n self.assertEqual(get_website_user(), user)","def test_user_login_with_email():\n app = create_ctfd()\n with app.app_context():\n register_user(app)\n client = login_as_user(app, name=\"user@ctfd.io\", password=\"password\")\n r = client.get('/profile')\n assert r.location != \"http://localhost/login\" # We didn't get redirected to login\n assert r.status_code == 200\n destroy_ctfd(app)","def test_002_get_users_by_email(self, mock_db_query):\n mock_db_query.filter_by.return_value.all.return_value = [seller1]\n\n response = self.app.get('/v1/users?email_address=' + seller1.email_address.upper(),\n headers={'accept': 'application/json'})\n\n print(response.get_data().decode())\n\n self.assertEqual(response.status_code, 200)\n self.assertEqual(len(response.json), 1)","def test_create_user_with_email_succesful(self):\n email = 'testmail@email.com'\n password = 'Testnew@11'\n user = get_user_model().objects.create_user(\n email=email, password=password)\n\n self.assertEqual(email, user.email)\n self.assertTrue(user.check_password(password))","def test_password_short(self):\n data = {\n 'email': 'test@test.com',\n 'password': 'test',\n 'first_name': 'Test test',\n 'last_name': 'Test'\n } \n res = self.client.post(SIGN_IN_USER_URL, data)\n self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)\n user_exists = get_user_model().objects.filter(\n email=data['email']\n ).exists()\n self.assertFalse(user_exists)","def test_get_full_name_with_user(self):\n user1 = User.objects.get(email=\"test1@test.com\")\n user2 = User.objects.get(email=\"test2@test.com\")\n self.assertEqual(user1.get_full_name(), 'Test1 User')\n self.assertEqual(user2.get_full_name(), 'Test2 User')","def sample_user(email: str = \"test@gmail.com\", password: str = \"testpass\"):\n return get_user_model().objects.create_user(email, password)","def sample_user(email='john7ric@mail.com', password='open@123'):\n return get_user_model().objects.create_user(email, password)","def test_get_bad_user(self):\r\n user = UserMgr.get(username=u'noexist')\r\n\r\n self.assertEqual(\r\n user,\r\n None,\r\n \"Should not find a non-existant user: \" + str(user))","def test_username(self):\n self.assertEqual(self.user.username, \"daron\")","def test_returns_none_if_no_user(self):\r\n self.assertIsNone(PasswordlessAuthenticationBackend().get_user('edith@example.com'))","def sample_user(email='test@gmail.com', password='testpass'):\n return get_user_model().objects.create_user(email, password)","def sample_user(email='test@gmail.com', password='testpass'):\n return get_user_model().objects.create_user(email, password)","def sample_user(email='test@gmail.com', password='testpass'):\n return get_user_model().objects.create_user(email, password)","def sample_user_third(email=\"test3@test3.com\",\n password=\"password123\",\n name=\"some name3\"):\n return get_user_model().objects.create_user(email=email,\n password=password,\n name=name)","def retrieve_user(self, email):\n if self.database is None:\n raise Exception(\"No database.\")\n if email is None or len(email) == 0:\n raise Exception(\"Bad parameter.\")\n return self.database.retrieve_user(email)","def sample_user(email=\"test@email.com\", password=\"password123\"):\n\n return get_user_model().objects.create_user(email, password)","def get(user_id=None, username=None, email=None, api_key=None):\r\n user_query = User.query\r\n\r\n if username is not None:\r\n return user_query.filter(User.username == username).first()\r\n\r\n if user_id is not None:\r\n return user_query.filter(User.id == user_id).first()\r\n\r\n if email is not None:\r\n return user_query.filter(User.email == email).first()\r\n\r\n if api_key is not None:\r\n return user_query.filter(User.api_key == api_key).first()\r\n\r\n return None","def test_good_user(self):\n user = self.datautils.create_user()\n self.request.user = user\n self.request.matchdict = {'user_id': int(user.id)}\n result = user_id_get_view(self.request)['d']\n expected = {\n 'id': user.id,\n 'username': user.username,\n 'created': user.created,\n 'email': user.email,\n }\n self.assertEqual(result, expected)","def test_returns_new_user_with_correct_email_if_token_exists(self):\r\n email = 'edith@example.com'\r\n token = Token.objects.create(email=email)\r\n user = PasswordlessAuthenticationBackend().authenticate(token.uid)\r\n new_user = User.objects.get(email=email)\r\n self.assertEquals(user, new_user)","def test_create_user_with_email(self):\n email = 'test@test.com'\n password = 'TestPass0244'\n user = get_user_model().objects.create_user(\n email=email,\n password=password\n )\n self.assertEqual(user.email, email)\n self.assertTrue(user.check_password(password))","def testGetWithNoEmail(self):\n userdict = {'id': 1,\n 'objectID': u'04585bec-28cf-4a21-bc3e-081f3ed62680',\n 'username': u'testuser',\n 'passwordHash': 'hash',\n 'email': None,\n 'fullname': u'Test User',\n 'role': Role.ANONYMOUS.id}\n self.cache.set('user:testuser', json.dumps(userdict))\n result = self.userCache.get(u'testuser')\n user = result.results\n self.assertEqual(1, user.id)\n self.assertEqual('04585bec-28cf-4a21-bc3e-081f3ed62680',\n str(user.objectID))\n self.assertEqual(u'testuser', user.username)\n self.assertEqual('hash', user.passwordHash)\n self.assertEqual(u'Test User', user.fullname)\n self.assertEqual(None, user.email)\n self.assertEqual(Role.ANONYMOUS, user.role)","def test_find_user_by_username(self):\n self.new_user.save_user()\n test_user = User(\"Test\", \"user\", \"test\", \"walIas15\")\n test_user.save_user()\n user_exists = User.user_exist(\"test\")\n self.assertTrue(user_exists)","def sample_user(email='test@londonappdev.com', password='testpass'):\n\n return get_user_model().objects.create_user(email, password)","def sample_user(email=\"student@test.com\",\n password=\"password123\",\n name=\"some name\"):\n return get_user_model().objects.create_user(email=email,\n password=password,\n name=name)","def get_user(self, email):\n return run_transaction(\n self.sessionfactory,\n lambda session: get_user_txn(session, email))","def sample_user(email='scott@test.com', password='testpass'):\n return get_user_model().objects.create_user(email, password)","def test_detail(self, client, users):\n user = users[0]\n url = reverse('users:detail', args=(user.pk,))\n response = client.get(url)\n assert response.status_code == 200\n assert user.username in str(response.content)","def test_create_user_with_email_success(self):\n email = 'test@gmail.com'\n password = 'azerty'\n user = get_user_model().objects.create_user(\n email = email,\n password = password\n )\n\n self.assertEqual(user.email, email)\n self.assertTrue(user.check_password(password))","def test_show(self):\n\n with self.client as c:\n response = c.get(f\"/users/{self.testuser.id}\")\n\n self.assertEqual(response.status_code, 200)\n self.assertIn(\"@alice\", str(response.data))","def test_user_id_get(self):\n pass","def sample_user(email='sajal@gmail.com', password='password'):\n return get_user_model().objects.create_user(email, password)","def sample_user(email='test@tslabs.com', password='testpass'):\n return get_user_model().objects.create_user(email, password)","def test_create_user_with_email_succesful(self):\n email = 'test@gmail.com'\n password = 'Testpass123'\n user = get_user_model().objects.create_user(\n email=email,\n password=password\n )\n\n self.assertEqual(user.email, email)\n self.assertTrue(user.check_password(password))","def get(self, **kwargs) -> (dict, int):\n params = {\"email\": kwargs[\"email\"]}\n\n if not params[\"email\"]:\n return MissingInformation.get_response(), 400\n\n taken = request_utils.value_in_database(\"UserTable\", \"email\", params[\"email\"])\n return {\"success\": True, \"taken\": taken}, 200","def test_get_users(self):\n pass","def test_create_and_retrieve_user(client):\n new_user_name = TEST_USER_NAME\n new_user_pass = TEST_USER_PASS\n post_response = create_user(\n client,\n new_user_name,\n new_user_pass)\n assert post_response.status_code == HttpStatus.created_201.value\n assert User.query.count() == 1\n\n post_response_data = json.loads(post_response.get_data(as_text=True))\n assert post_response_data['name'] == new_user_name\n\n new_user_url = post_response_data['url']\n get_response = client.get(\n new_user_url,\n headers=get_authentication_headers(new_user_name, new_user_pass))\n assert get_response.status_code == HttpStatus.ok_200.value\n\n get_response_data = json.loads(get_response.get_data(as_text=True))\n assert get_response_data['name'] == new_user_name","def testGet(self):\n userdict = {'id': 1,\n 'objectID': u'04585bec-28cf-4a21-bc3e-081f3ed62680',\n 'username': u'testuser',\n 'passwordHash': 'hash',\n 'fullname': u'Test User',\n 'email': u'test@example.com',\n 'role': Role.ANONYMOUS.id}\n self.cache.set('user:testuser', json.dumps(userdict))\n result = self.userCache.get(u'testuser')\n user = result.results\n self.assertEqual(1, user.id)\n self.assertEqual('04585bec-28cf-4a21-bc3e-081f3ed62680',\n str(user.objectID))\n self.assertEqual(u'testuser', user.username)\n self.assertEqual('hash', user.passwordHash)\n self.assertEqual(u'Test User', user.fullname)\n self.assertEqual(u'test@example.com', user.email)\n self.assertEqual(Role.ANONYMOUS, user.role)","def get(self, request):\n user = get_object_or_404(User, **request.query_params)\n return Response({'username': user.username, 'e-mail': user.email}, status.HTTP_200_OK)","def test_create_user_with_preexisting_email(self):\n data = {\n 'username': 'test_user2',\n 'email': 'test@example.com',\n 'password': 'testpassword'\n }\n response = self.client.post(self.create_url, data, format='json')\n self.assertEqual(User.objects.count(), 1)\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)\n self.assertEqual(len(response.data['email']), 1)","def test_manage_user_with_email(self):\r\n # First with a new user\r\n user_data = dict(id=1, username='facebook',\r\n email='f@f.com', name='name')\r\n token = 't'\r\n user = manage_user(token, user_data, None)\r\n assert user.email_addr == user_data['email'], user\r\n assert user.name == user_data['username'], user\r\n assert user.fullname == user_data['name'], user\r\n assert user.facebook_user_id == user_data['id'], user\r\n\r\n # Second with the same user\r\n user = manage_user(token, user_data, None)\r\n assert user.email_addr == user_data['email'], user\r\n assert user.name == user_data['username'], user\r\n assert user.fullname == user_data['name'], user\r\n assert user.facebook_user_id == user_data['id'], user\r\n\r\n # Finally with a user that already is in the system\r\n user_data = dict(id=10, username=self.name,\r\n email=self.email_addr, name=self.fullname)\r\n token = 'tA'\r\n user = manage_user(token, user_data, None)\r\n err_msg = \"It should return the same user\"\r\n assert user.facebook_user_id == 10, err_msg","def test_UserFromDB():\n assert UserFromDB(\"DIANE\").email == \"d@gmail.com\"\n assert UserFromDB(\"DIANE\").username == \"DIANE\"","def test_get_user_if_exists(self):\n user = User.objects.create(username=self.username)\n actual = get_user_if_exists(None, self.details, user=user)\n self.assertDictEqual(actual, {'is_new': False})","def test_get_user(\n self,\n mixin,\n mdb,\n muser_query,\n get_user,\n mrequest,\n mdecoded_jwt,\n ):\n mquery = muser_query.return_value\n\n assert get_user(\n mixin, dbsession=mdb) == mquery.get_by_id.return_value\n mquery.get_by_id.assert_called_once_with(sentinel.user_id)","def test_authenticate_no_username(self):\n\n email = 'test-Email@example.com'\n password = 'arandomsuperstrongpassword'\n\n user = UserFactory.create(email=email, password=password, is_active=True)\n\n backend = CaseInsensitiveEmailBackend()\n authenticated_user = backend.authenticate(\n self.request,\n email='Test-email@example.com',\n password=password,\n )\n\n self.assertEqual(user, authenticated_user)","def test_create_user_with_email_successful(self):\n email = \"hakanyalcinkaya@gmail.com\"\n password = \"loremIpsumDolor\"\n user = get_user_model().objects.create_user(\n email=email,\n password=password,\n first_name=\"Hakan\",\n last_name=\"Yalcinkaya\",\n )\n self.assertEqual(user.email, email)\n self.assertTrue(user.check_password(password))","def get_user(self, user_id=None, email=None):\n\n if not user_id and not email:\n raise ValueError('Either a user id or email must be provided.')\n\n query = User.objects.all()\n\n if user_id:\n query = query.filter(id=user_id)\n\n if email:\n email = normalize_email_address(email)\n query = query.filter(username=email)\n\n try:\n return query.get()\n except User.DoesNotExist:\n raise UserNotFound('The user with the provided parameters is not found.')","def get_user(self, email):\n\n try:\n return self.client.admin_get_user(\n Username=email,\n UserPoolId=self.user_pool_id\n )\n except self.client.exceptions.UserNotFoundException:\n raise Exception('An account with the given email does not exist.')","def test_create_user_with_email_successful(self):\n email = \"test@gmail.com\"\n password = \"test_password_123\"\n\n user = get_user_model().objects.create_user(\n email=email,\n password=password\n )\n\n self.assertEqual(user.email, email)\n self.assertTrue(user.check_password(password))"],"string":"[\n \"def test_get_user_by_emailuser_email_get(self):\\n pass\",\n \"def test_get_user(user_store: MockStore, user_email: str):\\n # GIVEN a database with a user\\n\\n # WHEN querying for a user\\n user: User = user_store.get_user(email=user_email)\\n\\n # THEN it should be returned\\n assert user.email == user_email\",\n \"def test_resource_user_resource_get_user_by_email_address_get(self):\\n pass\",\n \"def test_user_retrieve(self):\\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.get_token())\\n response = self.client.get(reverse(\\\"account:user-profile\\\"))\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data.get('user').get('email'), \\\"testuser@gmail.com\\\")\",\n \"def test_retrive_user(self):\\n res = self.client.get(ME_URL)\\n\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(res.data['email'], self.user.email)\\n self.assertEqual(res.data['name'], self.user.name)\\n self.assertNotIn('password', res.data)\",\n \"def test_get(self):\\n user = api.user.create(\\n username='chuck',\\n email='chuck@norris.org',\\n password='secret',\\n )\\n\\n self.assertEqual(api.user.get('chuck'), user)\",\n \"def test_get_user(self):\\n user = User(self.client, \\\"test-user\\\", {})\\n\\n self.assertEqual(user.username, \\\"test-user\\\")\\n self.assertEqual(user.email, \\\"test-user@linode.com\\\")\\n self.assertTrue(user.restricted)\\n self.assertTrue(user.tfa_enabled)\\n self.assertIsNotNone(user.ssh_keys)\",\n \"def test_get_user(sample_user):\\n\\n client = auth_client(APIClient(), sample_user.email, \\\"testpassword\\\")\\n\\n response = client.get(reverse(\\\"user-detail\\\"), format=\\\"json\\\")\\n assert response.status_code == status.HTTP_200_OK\\n assert json.dumps(response.data) == json.dumps(\\n {\\\"id\\\": sample_user.pk, \\\"email\\\": sample_user.email}\\n )\",\n \"def test_gets_user_by_email(self):\\r\\n User.objects.create(email='another_user@example.com')\\r\\n desired_user = User.objects.create(email='edith@example.com')\\r\\n found_user = PasswordlessAuthenticationBackend().get_user('edith@example.com')\\r\\n self.assertEqual(desired_user, found_user)\",\n \"def test_get_user_by_username(self):\\n\\t\\tusername_in_db = server.get_user_by_username('Natasha')\\n\\t\\tself.assertTrue(username_in_db, 'Query did not fetch user object.')\\n\\t\\tusername_not_in_db = server.get_user_by_username('xyz')\\n\\t\\tself.assertFalse(username_not_in_db, 'Query fetched user that did not exist (xyz).')\",\n \"def test_users_username_get(self):\\n pass\",\n \"def test_get_website_user_returns_user(self):\\n user = get_website_user()\\n self.assertTrue(user)\",\n \"def test_get_single_user(self):\\n user = add_user(\\\"neilb\\\", \\\"neilb14@mailinator.com\\\")\\n with self.client:\\n response = self.client.get(f'/users/{user.id}')\\n data = json.loads(response.data.decode())\\n self.assertEqual(response.status_code, 200)\\n self.assertTrue('created_at' in data['data'])\\n self.assertIn('neilb', data['data']['username'])\\n self.assertIn('neilb14@mailinator.com', data['data']['email'])\\n self.assertIn('success', data['status'])\",\n \"def test_api_user_get(self):\\n pass\",\n \"def test_user_by_username(self):\\n username = make_user(self.client)['username']\\n resp = self.client.get('/user/'+username,\\n headers=api_headers())\\n json_resp = json.loads(resp.data.decode('utf-8'))\\n self.assertEqual(json_resp['status'], 'user found')\\n self.assertEqual(json_resp['user']['username'], username)\",\n \"def test_getUser(self):\\n\\t\\turl = \\\"/users/2/\\\"\\n\\t\\tresponse = self.client.get(url, format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\tself.assertEqual(response.data[\\\"id\\\"], 2)\\n\\t\\tself.assertEqual(response.data[\\\"username\\\"], \\\"testUser2\\\")\",\n \"def testGetUser(self):\\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\\n user = getUser(u'user')\\n self.store.commit()\\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\\n result = yield self.facade.getUser(session, u'user')\\n self.assertEqual(u'user', result.username)\\n self.assertEqual(str(user.objectID), result.objectId)\\n self.assertEqual(u'User', result.name)\\n self.assertEqual(u'USER', result.role)\",\n \"def user(email):\\r\\n return User.objects.get(email=email)\",\n \"def test_user_username_get(self):\\n response = self.client.open('//user/{username}'.format(username='username_example'),\\n method='GET')\\n self.assert200(response, \\\"Response body is : \\\" + response.data.decode('utf-8'))\",\n \"def test_user(self):\\n user = User.objects.get(username=\\\"test01\\\")\\n print(user.username)\\n print(user.email)\\n self.assertEqual(user.email,\\\"test01@email.com\\\")\\n # cat = Animal.objects.get(name=\\\"cat\\\")\\n # self.assertEqual(lion.speak(), 'The lion says \\\"roar\\\"')\\n # self.assertEqual(cat.speak(), 'The cat says \\\"meow\\\"')\",\n \"def test_get_user(self):\\n print('(' + self.test_get_user.__name__+')', self.test_get_user.__doc__)\\n # test for patient\\n self.assertDictContainsSubset(\\n self.connection.get_user(PATIENT_USERNAME), PATIENT)\\n # test for doctor\\n self.assertDictContainsSubset(\\n self.connection.get_user(DOCTOR_USERNAME), DOCTOR)\",\n \"def test_get_users_no_username(user_store: MockStore, user_email: str):\\n # GIVEN a database with a user\\n\\n # WHEN getting users\\n users: List[User] = user_store.get_users(email=user_email)\\n\\n # THEN the user should be returned\\n assert users[0].email == user_email\",\n \"def test_user(self):\\n u = self.d.user('example')\\n self.assertEqual(u.username, 'example')\\n self.assertEqual(u.name, 'Example Sampleman')\",\n \"def test_get_username(self):\\r\\n user = UserMgr.get(username=u'admin')\\r\\n self.assertEqual(\\r\\n user.id,\\r\\n 1,\\r\\n \\\"Should have a user id of 1: \\\" + str(user.id))\\r\\n self.assertEqual(\\r\\n user.username,\\r\\n 'admin',\\r\\n \\\"Should have a username of admin: \\\" + user.username)\",\n \"def test_email(self):\\r\\n \\r\\n self.assertEqual('maryc123@yahoo.com', self.user.email)\",\n \"def test_create_user(self):\\n User.objects.create_user(username='abc', password='abcpass', email='abc@example.com')\\n user_obj = User.objects.get(username='abc')\\n self.assertTrue(user_obj.email, \\\"abc@example.com\\\")\\n self.assertEqual(str(user_obj), \\\"abc\\\")\",\n \"def test_getuser(self):\\n # scenario 1: with @ starting in name and extid\\n crusoe = self.fixtures.crusoe\\n service_twitter = 'twitter'\\n oauth_token = environ.get('TWITTER_OAUTH_TOKEN')\\n oauth_token_type = 'Bearer' # NOQA: S105\\n externalid = models.UserExternalId(\\n service=service_twitter,\\n user=crusoe,\\n userid=crusoe.email.email,\\n username=crusoe.username,\\n oauth_token=oauth_token,\\n oauth_token_type=oauth_token_type,\\n )\\n db.session.add(externalid)\\n db.session.commit()\\n result1 = models.getuser('@crusoe')\\n self.assertIsInstance(result1, models.User)\\n self.assertEqual(result1, crusoe)\\n\\n # scenario 2: with @ in name and not extid\\n d_email = 'd@dothraki.vly'\\n daenerys = models.User(\\n username='daenerys', fullname=\\\"Daenerys Targaryen\\\", email=d_email\\n )\\n daenerys_email = models.UserEmail(email=d_email, user=daenerys)\\n db.session.add_all([daenerys, daenerys_email])\\n db.session.commit()\\n result2 = models.getuser(d_email)\\n self.assertIsInstance(result2, models.User)\\n self.assertEqual(result2, daenerys)\\n result3 = models.getuser('@daenerys')\\n self.assertIsNone(result3)\\n\\n # scenario 3: with no @ starting in name, check by UserEmailClaim\\n j_email = 'jonsnow@nightswatch.co.uk'\\n jonsnow = models.User(username='jonsnow', fullname=\\\"Jon Snow\\\")\\n jonsnow_email_claimed = models.UserEmailClaim(email=j_email, user=jonsnow)\\n db.session.add_all([jonsnow, jonsnow_email_claimed])\\n db.session.commit()\\n result4 = models.getuser(j_email)\\n self.assertIsInstance(result4, models.User)\\n self.assertEqual(result4, jonsnow)\\n\\n # scenario 5: with no @ anywhere in name, fetch username\\n arya = models.User(username='arya', fullname=\\\"Arya Stark\\\")\\n db.session.add(arya)\\n db.session.commit()\\n result5 = models.getuser('arya')\\n self.assertEqual(result5, arya)\\n\\n # scenario 6: with no starting with @ name and no UserEmailClaim or UserEmail\\n cersei = models.User(username='cersei', fullname=\\\"Cersei Lannister\\\")\\n db.session.add(cersei)\\n db.session.commit()\\n result6 = models.getuser('cersei@thelannisters.co.uk')\\n self.assertIsNone(result6)\",\n \"def test_user_get(self):\\r\\n expected_user = UserFactory.create()\\r\\n # Test GET all users\\r\\n res = self.app.get('/api/user')\\r\\n data = json.loads(res.data)\\r\\n user = data[0]\\r\\n assert len(data) == 1, data\\r\\n assert user['name'] == expected_user.name, data\\r\\n\\r\\n # The output should have a mime-type: application/json\\r\\n assert res.mimetype == 'application/json', res\\r\\n\\r\\n # Test GETting a specific user by ID\\r\\n res = self.app.get('/api/user/1')\\r\\n data = json.loads(res.data)\\r\\n user = data\\r\\n assert user['name'] == expected_user.name, data\\r\\n\\r\\n # Test a non-existant ID\\r\\n res = self.app.get('/api/user/3434209')\\r\\n err = json.loads(res.data)\\r\\n assert res.status_code == 404, err\\r\\n assert err['status'] == 'failed', err\\r\\n assert err['target'] == 'user', err\\r\\n assert err['exception_cls'] == 'NotFound', err\\r\\n assert err['action'] == 'GET', err\",\n \"def test_fetch_user(self):\\n\\n self.register_user()\\n\\n self.assertEqual(self.fetch_user_details().status_code, 200)\\n\\n self.assertTrue(self.fetch_user_details(\\n ).json[\\\"data\\\"][0][\\\"username\\\"] == 'Bjorn')\",\n \"def get(self, email: str):\\r\\n args = authParser.parse_args()\\r\\n\\r\\n if not validators.email(email):\\r\\n response = {\\r\\n \\\"status\\\": \\\"error\\\",\\r\\n \\\"details\\\": {\\r\\n \\\"message\\\": \\\"Input a valid email address\\\"\\r\\n }\\r\\n }\\r\\n return response, http.client.BAD_REQUEST\\r\\n\\r\\n user = UserModel.query.filter(UserModel.email == email).first()\\r\\n\\r\\n if not user:\\r\\n # The email doesnt exist\\r\\n return {\\r\\n \\\"status\\\": \\\"error\\\",\\r\\n \\\"details\\\": {\\r\\n \\\"message\\\": \\\"Not Found\\\"\\r\\n }\\r\\n }, http.client.NOT_FOUND\\r\\n user = admin_namespace.marshal(user, user_model)\\r\\n return {\\r\\n \\\"status\\\": \\\"success\\\",\\r\\n \\\"details\\\": {\\r\\n \\\"result\\\": user\\r\\n }\\r\\n }, http.client.OK\",\n \"def test_user(app, client, session, models, tokens):\\n response = client.get(\\n \\\"/user\\\", headers={\\\"Authorization\\\": f\\\"Bearer {tokens['read']}\\\"}\\n )\\n assert response.status_code == 200\\n\\n # Verify returned data against the database\\n user_id = jwt.decode(\\n tokens[\\\"read\\\"], app.config[\\\"RSA_PUBLIC_KEY\\\"], app.config[\\\"ALGORITHM\\\"],\\n )[\\\"usr\\\"]\\n user = User.query.filter(User.id == user_id).one()\\n assert user.first_name == response.json[\\\"first_name\\\"]\\n assert user.last_name == response.json[\\\"last_name\\\"]\\n assert user.email == response.json[\\\"email\\\"]\",\n \"def getTestUser():\\n allUsers = User.objects.all()\\n if len(allUsers) > 0 :\\n return allUsers[0]\\n else :\\n return User.objects.create_user(username='profiletester',\\n email='profiletester@mapstorytests.com',\\n password='superduperpassword2000')\",\n \"def test_retrieve_profile(self):\\n\\n response = self.client.get(URL_ME)\\n\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\n # Check that the user object returns as expected. There is no need\\n # (and it is not secure) to return a password to client side.\\n self.assertEqual(response.data, {\\n 'name': self.user.name,\\n 'email': self.user.email\\n })\",\n \"def test_users_get(self):\\n pass\",\n \"def test_users_get(self):\\n pass\",\n \"def test_for_email_attribute_by_name(self):\\n name = u\\\"__TestUser__\\\"\\n password = u\\\"ekfdweurwerh\\\"\\n email = \\\"__TestUser__@moinhost\\\"\\n self.createUser(name, password, email=email)\\n theuser = user.User(self.request, name=name)\\n assert theuser.email == \\\"\\\"\",\n \"def get_user(email, queryset=None):\\n if queryset is None:\\n queryset = User.objects\\n return queryset.get(username=_email_to_username(email))\",\n \"def test_create_simple_user(self):\\n payload = {\\n 'email': 'test@mail.com',\\n 'password': 'password231',\\n 'name': 'vasia'\\n }\\n\\n res = self.client.post(CREATE_USER_URL, payload)\\n\\n u = get_user_model().objects.get(**res.data)\\n\\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\\n self.assertTrue(u.check_password(self.payload['password']))\\n self.assertEqual(u.email, self.payload['email'])\",\n \"def login_user(self, email=\\\"user@test.com\\\", password=\\\"test1234\\\"):\\n user_data = {\\n 'email': email,\\n 'password': password\\n }\\n return self.client().post('/auth/login', data=user_data)\\n\\n ############################################\\n ##### ALL OUR TESTS METHODS LIE HERE #######\",\n \"def test_get_user_exists(self):\\n # First make the user\\n resp = self.app.post('/users', data=json.dumps(self.test_user1_data))\\n assert resp.status_code == 200\\n\\n # Now get the user data and verify it is correct\\n resp = self.app.get('/users/{}'.format(self.test_user1_userid))\\n assert resp.status_code == 200\\n data = json.loads(resp.data)\\n for key in ['first_name', 'last_name', 'userid', 'groups']:\\n assert key in data\\n assert data['first_name'] == self.test_user1_first\\n assert data['last_name'] == self.test_user1_last\\n assert data['userid'] == self.test_user1_userid\\n for groupid in self.test_user1_groups:\\n assert groupid in data['groups']\",\n \"def test_get_user_by_name(self):\\n\\n # Select on empty set\\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\\n self.assertFalse(selected.success)\\n self.assertIsNone(selected.documents)\\n\\n # Insert user\\n inserted = self.user_api.insert_user(MAGEN_USER)\\n self.assertTrue(inserted.success)\\n\\n # Select user by username\\n selected = self.user_api.get_user_by_name(MAGEN_USER['username'])\\n self.assertTrue(selected.success)\\n self.assertEqual(selected.documents, MAGEN_USER)\",\n \"def test_for_email_attribut_by_uid(self):\\n name = u\\\"__TestUser2__\\\"\\n password = u\\\"ekERErwerwerh\\\"\\n email = \\\"__TestUser2__@moinhost\\\"\\n self.createUser(name, password, email=email)\\n uid = user.getUserId(self.request, name)\\n theuser = user.User(self.request, uid)\\n assert theuser.email == email\",\n \"def test_003_get_user(self, mock_db_query):\\n mock_db_query.get.return_value = seller1\\n\\n response = self.app.get('/v1/users/' + str(seller1.identity), headers={'accept': 'application/json'})\\n\\n print(response.get_data().decode())\\n\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response.json['first_name'], 'Lisa')\",\n \"def test_empty_email_field(self):\\r\\n result=self.user.get_user_register(\\\"Stephen\\\",\\\" Ochieng\\\",\\\"stephenochieng955@mail.com\\\",\\\"stephenochieng\\\",\\\"eat\\\")\\r\\n self.assertEqual(2,result,\\\"Fill in the email field please\\\")\",\n \"def test_get_user_by_uuiduser_uuid_get(self):\\n pass\",\n \"def test_empty_user_name_field(self):\\r\\n result=self.user.get_user_register(\\\"Stephen\\\",\\\" Ochieng\\\",\\\"stephenochieng955@mail.com\\\",\\\"stephenochieng\\\",\\\"eat\\\")\\r\\n self.assertEqual(2,result,\\\"Fill in the username field please\\\")\",\n \"def test_get(self, db_session: Session, get_user: Callable, attribute: str, db_column: Column) -> None:\\n user_service = get_user_service(db_session)\\n user = get_user(db_session)\\n assert db_session.query(Users).filter(db_column == getattr(user, attribute)).one()\\n\\n response = user_service.get_user_info({\\\"id\\\": user.id})\\n\\n assert response == {\\n \\\"status\\\": \\\"success\\\",\\n \\\"code\\\": 200,\\n \\\"data\\\": {\\n \\\"user_id\\\": user.id,\\n },\\n }\",\n \"def sample_user(email=user_v['email'], password=user_v['password']):\\n return get_user_model().objects.create_user(email, password)\",\n \"def test_resource_user_resource_get_user_get(self):\\n pass\",\n \"def test_02_get_api_with_user_username(self):\\n print(\\\"Verify get users api with username query\\\")\\n response = self.session.typicode_get_api_with_query(self.get_users_api, 'username=' + self.search_username)\\n # Validates if response code is 200\\n self.assertEqual(response.status_code, 200, \\\"Received status code \\\" + str(response.status_code) +\\n \\\" instead of 200\\\")\\n\\n # Validates if response is not empty\\n self.assertNotEqual(len(response.json()), 0, \\\"User response is empty\\\")\\n\\n # Validates if the username key is present in response\\n username_response = get_response_for_given_path(response.json(), self.search_username_key)\\n self.assertNotEquals(username_response, False, \\\"Searched string is not present\\\")\\n\\n # Validates if the given username is present in response\\n user_present = check_given_value_present_in_list(username_response, self.search_username)\\n self.assertTrue(user_present, \\\"Username \\\" + self.search_username + \\\"is not present in the response\\\")\",\n \"def test_correct_user(self):\\n\\n self.create_user('Henrik', 1)\\n self.create_user('Henrik2', 2)\\n self.create_user('Test', 3)\\n\\n resp = self.client.get('/api/users/Henrik/')\\n self.assertEquals(resp.json['total-users'], 2)\",\n \"def test_get_website_user_returns_same_user(self):\\n user = get_website_user()\\n self.assertEqual(get_website_user(), user)\",\n \"def test_user_login_with_email():\\n app = create_ctfd()\\n with app.app_context():\\n register_user(app)\\n client = login_as_user(app, name=\\\"user@ctfd.io\\\", password=\\\"password\\\")\\n r = client.get('/profile')\\n assert r.location != \\\"http://localhost/login\\\" # We didn't get redirected to login\\n assert r.status_code == 200\\n destroy_ctfd(app)\",\n \"def test_002_get_users_by_email(self, mock_db_query):\\n mock_db_query.filter_by.return_value.all.return_value = [seller1]\\n\\n response = self.app.get('/v1/users?email_address=' + seller1.email_address.upper(),\\n headers={'accept': 'application/json'})\\n\\n print(response.get_data().decode())\\n\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(len(response.json), 1)\",\n \"def test_create_user_with_email_succesful(self):\\n email = 'testmail@email.com'\\n password = 'Testnew@11'\\n user = get_user_model().objects.create_user(\\n email=email, password=password)\\n\\n self.assertEqual(email, user.email)\\n self.assertTrue(user.check_password(password))\",\n \"def test_password_short(self):\\n data = {\\n 'email': 'test@test.com',\\n 'password': 'test',\\n 'first_name': 'Test test',\\n 'last_name': 'Test'\\n } \\n res = self.client.post(SIGN_IN_USER_URL, data)\\n self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)\\n user_exists = get_user_model().objects.filter(\\n email=data['email']\\n ).exists()\\n self.assertFalse(user_exists)\",\n \"def test_get_full_name_with_user(self):\\n user1 = User.objects.get(email=\\\"test1@test.com\\\")\\n user2 = User.objects.get(email=\\\"test2@test.com\\\")\\n self.assertEqual(user1.get_full_name(), 'Test1 User')\\n self.assertEqual(user2.get_full_name(), 'Test2 User')\",\n \"def sample_user(email: str = \\\"test@gmail.com\\\", password: str = \\\"testpass\\\"):\\n return get_user_model().objects.create_user(email, password)\",\n \"def sample_user(email='john7ric@mail.com', password='open@123'):\\n return get_user_model().objects.create_user(email, password)\",\n \"def test_get_bad_user(self):\\r\\n user = UserMgr.get(username=u'noexist')\\r\\n\\r\\n self.assertEqual(\\r\\n user,\\r\\n None,\\r\\n \\\"Should not find a non-existant user: \\\" + str(user))\",\n \"def test_username(self):\\n self.assertEqual(self.user.username, \\\"daron\\\")\",\n \"def test_returns_none_if_no_user(self):\\r\\n self.assertIsNone(PasswordlessAuthenticationBackend().get_user('edith@example.com'))\",\n \"def sample_user(email='test@gmail.com', password='testpass'):\\n return get_user_model().objects.create_user(email, password)\",\n \"def sample_user(email='test@gmail.com', password='testpass'):\\n return get_user_model().objects.create_user(email, password)\",\n \"def sample_user(email='test@gmail.com', password='testpass'):\\n return get_user_model().objects.create_user(email, password)\",\n \"def sample_user_third(email=\\\"test3@test3.com\\\",\\n password=\\\"password123\\\",\\n name=\\\"some name3\\\"):\\n return get_user_model().objects.create_user(email=email,\\n password=password,\\n name=name)\",\n \"def retrieve_user(self, email):\\n if self.database is None:\\n raise Exception(\\\"No database.\\\")\\n if email is None or len(email) == 0:\\n raise Exception(\\\"Bad parameter.\\\")\\n return self.database.retrieve_user(email)\",\n \"def sample_user(email=\\\"test@email.com\\\", password=\\\"password123\\\"):\\n\\n return get_user_model().objects.create_user(email, password)\",\n \"def get(user_id=None, username=None, email=None, api_key=None):\\r\\n user_query = User.query\\r\\n\\r\\n if username is not None:\\r\\n return user_query.filter(User.username == username).first()\\r\\n\\r\\n if user_id is not None:\\r\\n return user_query.filter(User.id == user_id).first()\\r\\n\\r\\n if email is not None:\\r\\n return user_query.filter(User.email == email).first()\\r\\n\\r\\n if api_key is not None:\\r\\n return user_query.filter(User.api_key == api_key).first()\\r\\n\\r\\n return None\",\n \"def test_good_user(self):\\n user = self.datautils.create_user()\\n self.request.user = user\\n self.request.matchdict = {'user_id': int(user.id)}\\n result = user_id_get_view(self.request)['d']\\n expected = {\\n 'id': user.id,\\n 'username': user.username,\\n 'created': user.created,\\n 'email': user.email,\\n }\\n self.assertEqual(result, expected)\",\n \"def test_returns_new_user_with_correct_email_if_token_exists(self):\\r\\n email = 'edith@example.com'\\r\\n token = Token.objects.create(email=email)\\r\\n user = PasswordlessAuthenticationBackend().authenticate(token.uid)\\r\\n new_user = User.objects.get(email=email)\\r\\n self.assertEquals(user, new_user)\",\n \"def test_create_user_with_email(self):\\n email = 'test@test.com'\\n password = 'TestPass0244'\\n user = get_user_model().objects.create_user(\\n email=email,\\n password=password\\n )\\n self.assertEqual(user.email, email)\\n self.assertTrue(user.check_password(password))\",\n \"def testGetWithNoEmail(self):\\n userdict = {'id': 1,\\n 'objectID': u'04585bec-28cf-4a21-bc3e-081f3ed62680',\\n 'username': u'testuser',\\n 'passwordHash': 'hash',\\n 'email': None,\\n 'fullname': u'Test User',\\n 'role': Role.ANONYMOUS.id}\\n self.cache.set('user:testuser', json.dumps(userdict))\\n result = self.userCache.get(u'testuser')\\n user = result.results\\n self.assertEqual(1, user.id)\\n self.assertEqual('04585bec-28cf-4a21-bc3e-081f3ed62680',\\n str(user.objectID))\\n self.assertEqual(u'testuser', user.username)\\n self.assertEqual('hash', user.passwordHash)\\n self.assertEqual(u'Test User', user.fullname)\\n self.assertEqual(None, user.email)\\n self.assertEqual(Role.ANONYMOUS, user.role)\",\n \"def test_find_user_by_username(self):\\n self.new_user.save_user()\\n test_user = User(\\\"Test\\\", \\\"user\\\", \\\"test\\\", \\\"walIas15\\\")\\n test_user.save_user()\\n user_exists = User.user_exist(\\\"test\\\")\\n self.assertTrue(user_exists)\",\n \"def sample_user(email='test@londonappdev.com', password='testpass'):\\n\\n return get_user_model().objects.create_user(email, password)\",\n \"def sample_user(email=\\\"student@test.com\\\",\\n password=\\\"password123\\\",\\n name=\\\"some name\\\"):\\n return get_user_model().objects.create_user(email=email,\\n password=password,\\n name=name)\",\n \"def get_user(self, email):\\n return run_transaction(\\n self.sessionfactory,\\n lambda session: get_user_txn(session, email))\",\n \"def sample_user(email='scott@test.com', password='testpass'):\\n return get_user_model().objects.create_user(email, password)\",\n \"def test_detail(self, client, users):\\n user = users[0]\\n url = reverse('users:detail', args=(user.pk,))\\n response = client.get(url)\\n assert response.status_code == 200\\n assert user.username in str(response.content)\",\n \"def test_create_user_with_email_success(self):\\n email = 'test@gmail.com'\\n password = 'azerty'\\n user = get_user_model().objects.create_user(\\n email = email,\\n password = password\\n )\\n\\n self.assertEqual(user.email, email)\\n self.assertTrue(user.check_password(password))\",\n \"def test_show(self):\\n\\n with self.client as c:\\n response = c.get(f\\\"/users/{self.testuser.id}\\\")\\n\\n self.assertEqual(response.status_code, 200)\\n self.assertIn(\\\"@alice\\\", str(response.data))\",\n \"def test_user_id_get(self):\\n pass\",\n \"def sample_user(email='sajal@gmail.com', password='password'):\\n return get_user_model().objects.create_user(email, password)\",\n \"def sample_user(email='test@tslabs.com', password='testpass'):\\n return get_user_model().objects.create_user(email, password)\",\n \"def test_create_user_with_email_succesful(self):\\n email = 'test@gmail.com'\\n password = 'Testpass123'\\n user = get_user_model().objects.create_user(\\n email=email,\\n password=password\\n )\\n\\n self.assertEqual(user.email, email)\\n self.assertTrue(user.check_password(password))\",\n \"def get(self, **kwargs) -> (dict, int):\\n params = {\\\"email\\\": kwargs[\\\"email\\\"]}\\n\\n if not params[\\\"email\\\"]:\\n return MissingInformation.get_response(), 400\\n\\n taken = request_utils.value_in_database(\\\"UserTable\\\", \\\"email\\\", params[\\\"email\\\"])\\n return {\\\"success\\\": True, \\\"taken\\\": taken}, 200\",\n \"def test_get_users(self):\\n pass\",\n \"def test_create_and_retrieve_user(client):\\n new_user_name = TEST_USER_NAME\\n new_user_pass = TEST_USER_PASS\\n post_response = create_user(\\n client,\\n new_user_name,\\n new_user_pass)\\n assert post_response.status_code == HttpStatus.created_201.value\\n assert User.query.count() == 1\\n\\n post_response_data = json.loads(post_response.get_data(as_text=True))\\n assert post_response_data['name'] == new_user_name\\n\\n new_user_url = post_response_data['url']\\n get_response = client.get(\\n new_user_url,\\n headers=get_authentication_headers(new_user_name, new_user_pass))\\n assert get_response.status_code == HttpStatus.ok_200.value\\n\\n get_response_data = json.loads(get_response.get_data(as_text=True))\\n assert get_response_data['name'] == new_user_name\",\n \"def testGet(self):\\n userdict = {'id': 1,\\n 'objectID': u'04585bec-28cf-4a21-bc3e-081f3ed62680',\\n 'username': u'testuser',\\n 'passwordHash': 'hash',\\n 'fullname': u'Test User',\\n 'email': u'test@example.com',\\n 'role': Role.ANONYMOUS.id}\\n self.cache.set('user:testuser', json.dumps(userdict))\\n result = self.userCache.get(u'testuser')\\n user = result.results\\n self.assertEqual(1, user.id)\\n self.assertEqual('04585bec-28cf-4a21-bc3e-081f3ed62680',\\n str(user.objectID))\\n self.assertEqual(u'testuser', user.username)\\n self.assertEqual('hash', user.passwordHash)\\n self.assertEqual(u'Test User', user.fullname)\\n self.assertEqual(u'test@example.com', user.email)\\n self.assertEqual(Role.ANONYMOUS, user.role)\",\n \"def get(self, request):\\n user = get_object_or_404(User, **request.query_params)\\n return Response({'username': user.username, 'e-mail': user.email}, status.HTTP_200_OK)\",\n \"def test_create_user_with_preexisting_email(self):\\n data = {\\n 'username': 'test_user2',\\n 'email': 'test@example.com',\\n 'password': 'testpassword'\\n }\\n response = self.client.post(self.create_url, data, format='json')\\n self.assertEqual(User.objects.count(), 1)\\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)\\n self.assertEqual(len(response.data['email']), 1)\",\n \"def test_manage_user_with_email(self):\\r\\n # First with a new user\\r\\n user_data = dict(id=1, username='facebook',\\r\\n email='f@f.com', name='name')\\r\\n token = 't'\\r\\n user = manage_user(token, user_data, None)\\r\\n assert user.email_addr == user_data['email'], user\\r\\n assert user.name == user_data['username'], user\\r\\n assert user.fullname == user_data['name'], user\\r\\n assert user.facebook_user_id == user_data['id'], user\\r\\n\\r\\n # Second with the same user\\r\\n user = manage_user(token, user_data, None)\\r\\n assert user.email_addr == user_data['email'], user\\r\\n assert user.name == user_data['username'], user\\r\\n assert user.fullname == user_data['name'], user\\r\\n assert user.facebook_user_id == user_data['id'], user\\r\\n\\r\\n # Finally with a user that already is in the system\\r\\n user_data = dict(id=10, username=self.name,\\r\\n email=self.email_addr, name=self.fullname)\\r\\n token = 'tA'\\r\\n user = manage_user(token, user_data, None)\\r\\n err_msg = \\\"It should return the same user\\\"\\r\\n assert user.facebook_user_id == 10, err_msg\",\n \"def test_UserFromDB():\\n assert UserFromDB(\\\"DIANE\\\").email == \\\"d@gmail.com\\\"\\n assert UserFromDB(\\\"DIANE\\\").username == \\\"DIANE\\\"\",\n \"def test_get_user_if_exists(self):\\n user = User.objects.create(username=self.username)\\n actual = get_user_if_exists(None, self.details, user=user)\\n self.assertDictEqual(actual, {'is_new': False})\",\n \"def test_get_user(\\n self,\\n mixin,\\n mdb,\\n muser_query,\\n get_user,\\n mrequest,\\n mdecoded_jwt,\\n ):\\n mquery = muser_query.return_value\\n\\n assert get_user(\\n mixin, dbsession=mdb) == mquery.get_by_id.return_value\\n mquery.get_by_id.assert_called_once_with(sentinel.user_id)\",\n \"def test_authenticate_no_username(self):\\n\\n email = 'test-Email@example.com'\\n password = 'arandomsuperstrongpassword'\\n\\n user = UserFactory.create(email=email, password=password, is_active=True)\\n\\n backend = CaseInsensitiveEmailBackend()\\n authenticated_user = backend.authenticate(\\n self.request,\\n email='Test-email@example.com',\\n password=password,\\n )\\n\\n self.assertEqual(user, authenticated_user)\",\n \"def test_create_user_with_email_successful(self):\\n email = \\\"hakanyalcinkaya@gmail.com\\\"\\n password = \\\"loremIpsumDolor\\\"\\n user = get_user_model().objects.create_user(\\n email=email,\\n password=password,\\n first_name=\\\"Hakan\\\",\\n last_name=\\\"Yalcinkaya\\\",\\n )\\n self.assertEqual(user.email, email)\\n self.assertTrue(user.check_password(password))\",\n \"def get_user(self, user_id=None, email=None):\\n\\n if not user_id and not email:\\n raise ValueError('Either a user id or email must be provided.')\\n\\n query = User.objects.all()\\n\\n if user_id:\\n query = query.filter(id=user_id)\\n\\n if email:\\n email = normalize_email_address(email)\\n query = query.filter(username=email)\\n\\n try:\\n return query.get()\\n except User.DoesNotExist:\\n raise UserNotFound('The user with the provided parameters is not found.')\",\n \"def get_user(self, email):\\n\\n try:\\n return self.client.admin_get_user(\\n Username=email,\\n UserPoolId=self.user_pool_id\\n )\\n except self.client.exceptions.UserNotFoundException:\\n raise Exception('An account with the given email does not exist.')\",\n \"def test_create_user_with_email_successful(self):\\n email = \\\"test@gmail.com\\\"\\n password = \\\"test_password_123\\\"\\n\\n user = get_user_model().objects.create_user(\\n email=email,\\n password=password\\n )\\n\\n self.assertEqual(user.email, email)\\n self.assertTrue(user.check_password(password))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.81518275","0.79463357","0.7895598","0.7859849","0.7718898","0.77024853","0.7650548","0.76115036","0.76060903","0.7491955","0.748591","0.74647605","0.7454479","0.74482834","0.74220383","0.7405741","0.73980224","0.7391085","0.73631626","0.73486465","0.7340491","0.73167706","0.7259891","0.72414804","0.72306186","0.7230193","0.72237396","0.7207009","0.71731067","0.7146293","0.7132263","0.70262694","0.7020208","0.70019996","0.70019996","0.69707704","0.6958126","0.69523036","0.6939753","0.6935322","0.6927547","0.68946856","0.68854666","0.6873967","0.6872946","0.6839653","0.6834536","0.68329537","0.68184066","0.6802744","0.68025565","0.6802361","0.67840326","0.6763652","0.676049","0.675923","0.6752063","0.67492574","0.67466146","0.6740705","0.67404294","0.67399555","0.67393464","0.67393464","0.67393464","0.6738363","0.6734076","0.67340016","0.6728299","0.67269236","0.67263156","0.67253923","0.67163587","0.6710788","0.6706304","0.6703406","0.669793","0.6697553","0.6697036","0.6694063","0.6689799","0.66837054","0.66833884","0.6681582","0.66807747","0.6676954","0.6676652","0.6675966","0.6672659","0.6672263","0.6666505","0.6654217","0.66535985","0.6651565","0.66471076","0.6646153","0.66459084","0.6645273","0.664183","0.6639069"],"string":"[\n \"0.81518275\",\n \"0.79463357\",\n \"0.7895598\",\n \"0.7859849\",\n \"0.7718898\",\n \"0.77024853\",\n \"0.7650548\",\n \"0.76115036\",\n \"0.76060903\",\n \"0.7491955\",\n \"0.748591\",\n \"0.74647605\",\n \"0.7454479\",\n \"0.74482834\",\n \"0.74220383\",\n \"0.7405741\",\n \"0.73980224\",\n \"0.7391085\",\n \"0.73631626\",\n \"0.73486465\",\n \"0.7340491\",\n \"0.73167706\",\n \"0.7259891\",\n \"0.72414804\",\n \"0.72306186\",\n \"0.7230193\",\n \"0.72237396\",\n \"0.7207009\",\n \"0.71731067\",\n \"0.7146293\",\n \"0.7132263\",\n \"0.70262694\",\n \"0.7020208\",\n \"0.70019996\",\n \"0.70019996\",\n \"0.69707704\",\n \"0.6958126\",\n \"0.69523036\",\n \"0.6939753\",\n \"0.6935322\",\n \"0.6927547\",\n \"0.68946856\",\n \"0.68854666\",\n \"0.6873967\",\n \"0.6872946\",\n \"0.6839653\",\n \"0.6834536\",\n \"0.68329537\",\n \"0.68184066\",\n \"0.6802744\",\n \"0.68025565\",\n \"0.6802361\",\n \"0.67840326\",\n \"0.6763652\",\n \"0.676049\",\n \"0.675923\",\n \"0.6752063\",\n \"0.67492574\",\n \"0.67466146\",\n \"0.6740705\",\n \"0.67404294\",\n \"0.67399555\",\n \"0.67393464\",\n \"0.67393464\",\n \"0.67393464\",\n \"0.6738363\",\n \"0.6734076\",\n \"0.67340016\",\n \"0.6728299\",\n \"0.67269236\",\n \"0.67263156\",\n \"0.67253923\",\n \"0.67163587\",\n \"0.6710788\",\n \"0.6706304\",\n \"0.6703406\",\n \"0.669793\",\n \"0.6697553\",\n \"0.6697036\",\n \"0.6694063\",\n \"0.6689799\",\n \"0.66837054\",\n \"0.66833884\",\n \"0.6681582\",\n \"0.66807747\",\n \"0.6676954\",\n \"0.6676652\",\n \"0.6675966\",\n \"0.6672659\",\n \"0.6672263\",\n \"0.6666505\",\n \"0.6654217\",\n \"0.66535985\",\n \"0.6651565\",\n \"0.66471076\",\n \"0.6646153\",\n \"0.66459084\",\n \"0.6645273\",\n \"0.664183\",\n \"0.6639069\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7497986"},"document_rank":{"kind":"string","value":"9"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":836,"numItemsPerPage":100,"numTotalItems":95772,"offset":83600,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjA1NjYwNywianRpIjoiYjBjYjllMmQtZmVlNS00NDU1LThmNDctYzFhMjY1YWRmYWFjIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwNjAyMDcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.ARSa-hbZ0mrXXI9vzwZtqg5YRQEp_Se7EBZmO6DFX-VBnU-k05KXzagIo4-DXAdlElKjljXPJF7szTZSri8pCw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Process a PayPal or Google Checkout based anonymous contribution. | def anon_contribute_by_payment_mode(request, campaign_id, payment_mode, template='campaign/campaign_contribution_form_%s_anon.html'):
campaign = get_object_or_404(Campaign.objects.active(), pk=campaign_id)
payment_option = campaign.artist.get_merchant_account(payment_mode)
if not payment_option:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def paypal_notification(request, payment_mode='paypal'):\r\n try:\r\n data = request.POST\r\n _log.debug(\"PayPal IPN data: %s\", repr(data))\r\n\r\n if not paypal.verify_ipn_request(request):\r\n return HttpResponse()\r\n\r\n if data.get('payment_status', None) != \"Compl... | [
"0.6373298",
"0.5703084",
"0.5503658",
"0.5475027",
"0.5220315",
"0.5134288",
"0.51226735",
"0.505278",
"0.4990776",
"0.493464",
"0.49269527",
"0.48673046",
"0.4841768",
"0.4832216",
"0.48186994",
"0.48010457",
"0.47885463",
"0.4726758",
"0.47251117",
"0.47234315",
"0.4698482... | 0.596364 | 1 |
Redeem a campaign ticket. | def redeem_ticket(request, template='campaign/redeem_ticket.html'):
ticket_code = request.session.get('open_ticket_code', None)
try:
del request.session['open_ticket_code']
except KeyError:
pass
if request.POST or ticket_code:
data = request.POST.copy()
if ticket_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transfer_ticket(self, ticket_id):\n ticket = self.zendesk.get_ticket(ticket_id)\n subject = ticket[\"ticket\"][\"subject\"]\n status = ticket[\"ticket\"][\"status\"]\n description = ticket[\"ticket\"][\"description\"]\n if ticket[\"ticket\"][\"assignee_id\"] is not None:\n ... | [
"0.56641316",
"0.5631388",
"0.5553566",
"0.5517005",
"0.54539233",
"0.5423735",
"0.53499913",
"0.534691",
"0.52912635",
"0.528025",
"0.5250913",
"0.52281886",
"0.5220547",
"0.5217796",
"0.5214232",
"0.5193973",
"0.5187849",
"0.51704186",
"0.5169197",
"0.51427704",
"0.5139206"... | 0.68725705 | 0 |
Process a return from PayPal's or Google's payment screen and redirect to the campaign's detail view. ``inv_id`` is the id of a``PendingContribution``. ``success_code`` is 1 or 0 for successful or cancelled payments respectively. | def payment_return(request, campaign_id, inv_id, success_code, payment_mode):
campaign = get_object_or_404(Campaign, pk=campaign_id)
if int(success_code) == 1:
request.user.message_set.create(message=_('Thank you for your contribution.'))
else:
# User cancelled payment.
request... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_success_request(self) -> HttpResponse: # noqa: C901\n request = self.request\n logger.debug(\n \"Handling Bambora user return request, params: {}.\".format(request.GET)\n )\n\n order_number, _timestamp = request.GET.get(\"ORDER_NUMBER\", \"-\").split(\"-\")\n ... | [
"0.5307607",
"0.5205897",
"0.5190838",
"0.51417315",
"0.50907296",
"0.499538",
"0.4893905",
"0.48899612",
"0.48739493",
"0.48201224",
"0.4802943",
"0.4783593",
"0.4728882",
"0.47266012",
"0.45329785",
"0.45301113",
"0.4483462",
"0.44707704",
"0.44324645",
"0.4429951",
"0.4421... | 0.70670295 | 0 |
Receive PayPal IPN (Instant Payment Notification.) | def paypal_notification(request, payment_mode='paypal'):
try:
data = request.POST
_log.debug("PayPal IPN data: %s", repr(data))
if not paypal.verify_ipn_request(request):
return HttpResponse()
if data.get('payment_status', None) != "Completed":
# Do... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def verify_ipn(data):\n data = dict(data)\n data['cmd'] = '_notify-validate'\n resp = requests.post(app.config['PAYPAL']['endpoint'], data=data)\n if resp.text == 'VERIFIED':\n return True\n return False",
"def google_notification(request, payment_mode='google'):\r\n # ack_xml = '''<noti... | [
"0.6576129",
"0.6399067",
"0.57707894",
"0.57616985",
"0.5696024",
"0.55341643",
"0.51714045",
"0.50293285",
"0.5019871",
"0.5008682",
"0.49326146",
"0.48892364",
"0.4883548",
"0.48674527",
"0.4850678",
"0.4834348",
"0.4818443",
"0.47996423",
"0.47809997",
"0.47706395",
"0.47... | 0.6606561 | 0 |
Receive notification of a campaign payment completed via Google Checkout. | def google_notification(request, payment_mode='google'):
# ack_xml = '''<notification-acknowledgment xmlns="http://checkout.google.com/schema/2" serial-number="%s"/>\n\n'''
ack_html = '''_type=notification-acknowledgment&serial-number=%s\n\n'''
processed_response = None
try:
data = request.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def awaiting_payment(self):",
"def collect_payment():\n\n # 1. Get required arguments\n args = Eg014Controller.get_args()\n try:\n # 2. Call the worker method\n results = Eg014Controller.worker(args)\n except ApiException as err:\n return process_error(err)\n\n # 3. Render suc... | [
"0.63564783",
"0.62235355",
"0.6013158",
"0.57708764",
"0.55319244",
"0.551384",
"0.55091786",
"0.54820347",
"0.54349434",
"0.5395289",
"0.5389404",
"0.5342692",
"0.5317579",
"0.53085405",
"0.5292847",
"0.527213",
"0.52671003",
"0.52018356",
"0.5181457",
"0.51404744",
"0.5083... | 0.66050917 | 0 |
Return the lowest cost path, starting from start state, | def lowest_cost_search(start, successors, is_goal, action_cost):
explored = set()
frontier = [ [start] ]
if is_goal(start):
return frontier[0]
while frontier:
path = frontier.pop(0)
state1 = final_state(path)
if is_goal(state1):
return path
explored.ad... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lowest_cost_search(start, successors, is_goal, action_cost):\r\n # your code here\r\n explored = set()\r\n frontier = [ [start] ]\r\n while frontier:\r\n path = frontier.pop(0)\r\n state1 = final_state(path)\r\n if is_goal(state1):\r\n return path\r\n explored... | [
"0.79001284",
"0.7815893",
"0.75089973",
"0.7477071",
"0.73168325",
"0.73155445",
"0.7228358",
"0.70762277",
"0.70678824",
"0.69976723",
"0.69821614",
"0.6907217",
"0.6877946",
"0.6854953",
"0.6824021",
"0.6787544",
"0.67676026",
"0.67614686",
"0.67411",
"0.67290896",
"0.6712... | 0.7975087 | 0 |
Take given data of format from scraper [link] and return the inputs and outputs seperated. | def split_data_into_input_and_output(data):
data_in, data_out = list(zip(*[((x["synopsis"]), x["gross"]) for x in data]))
return np.array(data_in), np.array(data_out) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_page_data(page_data: List[str]) -> List[Tuple[Any]]:\r\n processed_data: List[Tuple[Any]] = []\r\n for item in page_data:\r\n ram_soup = soup(item, \"html.parser\")\r\n list_wrap = ram_soup.find(\"div\", {\"class\": \"list-wrap\"})\r\n containers = list_wrap.findAll(\"div\", ... | [
"0.6079666",
"0.60285807",
"0.5801785",
"0.58000124",
"0.5715568",
"0.57005036",
"0.5667928",
"0.56585526",
"0.56310904",
"0.56036556",
"0.553412",
"0.5504417",
"0.54888403",
"0.5465348",
"0.54540986",
"0.544446",
"0.54395825",
"0.5422634",
"0.5402472",
"0.5396441",
"0.538167... | 0.55986524 | 10 |
If the given data has no signal we cant fit a NN to it. As such, here we append how much the film grossed into the synopsis of each title. | def add_signal(data):
for row in data:
row["synopsis"] = row["synopsis"] + f' The film grossed ${row["gross"]}' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def augment_train_data(self):\n # do not augment on evaluation dataset\n original_len = len(self.data_train)\n for i in range(len(self.data_train)):\n if i % 100 == 0:\n print(f\"Augmenting train data, progress: {i} / {original_len}\")\n title = self.data_t... | [
"0.6041654",
"0.5983893",
"0.5946179",
"0.5698321",
"0.568227",
"0.5643324",
"0.5570708",
"0.5536342",
"0.54949754",
"0.54921573",
"0.5448862",
"0.54424274",
"0.5428731",
"0.5355646",
"0.5353451",
"0.53421974",
"0.5312379",
"0.53115404",
"0.5311278",
"0.53052354",
"0.5284356"... | 0.548929 | 10 |
lab = label pred = prediction | def confusion_plot(lab, pred, name, new_plot=False, save=False):
plt.scatter(lab, lab, label="truth", s=2, color="black")
plt.scatter(lab, pred, label=name, s=2)
handles, labels = plt.gca().get_legend_handles_labels()
by_label = dict(zip(labels, handles))
plt.legend(by_label.values(), by_label.keys(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_label(self, src): # real signature unknown; restored from __doc__\n pass",
"def predict_label(img, net_model, label):\n img1 = cv2.resize(img, (80, 80))\n predict = net_model.predict(img1.reshape(1, 80, 80, 3))\n maxi = predict[0][0]\n curs = 0\n test = 0\n for i, pred in enu... | [
"0.7578711",
"0.7256652",
"0.72129387",
"0.709207",
"0.709207",
"0.7090782",
"0.70615506",
"0.69712365",
"0.6934177",
"0.6934177",
"0.6934177",
"0.68250227",
"0.67455095",
"0.67181236",
"0.6708249",
"0.66727287",
"0.6672353",
"0.66713417",
"0.66713417",
"0.6652546",
"0.664587... | 0.0 | -1 |
String representation for a string to value map | def _reprOfStringToValueMap (stringMap : Map) -> String:
entrySeparator = u"§"
entryTemplate = "%s: %s"
keyList = sorted(list(stringMap.keys()))
result = ""
for key in keyList:
value = stringMap[key]
result += (iif(result == "", "", entrySeparator)
+ entryTe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def valueToString():",
"def str_dict(d):\n return \", \".join(\"%s=%s\" % (k, d[k]) for k in d)",
"def __str__(self):\n return '({0},{1})'.format(self.key, self.value)",
"def __str__(self):\n return '(' + str(self.key) + ': ' + str(self.value) + ')'",
"def __str__(self):\n return '(... | [
"0.6723412",
"0.66615885",
"0.6657132",
"0.66348654",
"0.66348654",
"0.65340376",
"0.65042675",
"0.6488888",
"0.647782",
"0.6375239",
"0.63170457",
"0.63118005",
"0.63005364",
"0.62862843",
"0.62133026",
"0.61995703",
"0.6197091",
"0.6170143",
"0.6162775",
"0.6158538",
"0.614... | 0.7466139 | 0 |
Initializes token with start position, token text, token kind and value | def __init__ (self,
start : Natural, text : String,
kind : String, value : Object):
self.start = start
self.text = text
self.kind = kind
self.value = value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, token_type, token_value: str):\n super().__init__(token_type)\n self.token_value = token_value",
"def __init__(self, tokenType, value = None):\r\n\t\tif not tokenType in VALID_TOKEN_TYPES:\r\n\t\t\traise ValueError(\"Invalid token type '{}' given\".format(tokenType))\r\n\r\n\t\ts... | [
"0.74293166",
"0.71529675",
"0.7098566",
"0.68082476",
"0.68082476",
"0.68082476",
"0.6787119",
"0.67069674",
"0.6701436",
"0.6578326",
"0.6462142",
"0.6450583",
"0.635739",
"0.6300707",
"0.6180748",
"0.6158519",
"0.6149903",
"0.6079522",
"0.59513485",
"0.5935185",
"0.5913402... | 0.6379974 | 12 |
String representation for token | def __repr__ (self) -> String:
st = ("_Token(%r, '%s', %s, %r)"
% (self.start, self.text, self.kind, self.value))
return st | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def token(self) -> str:",
"def __str__(self):\n return str(self.__token)",
"def __str__(self):\n return 'Token({type}, {value})'.format(\n type=self.type,\n value=repr(self.value)\n )",
"def __str__(self):\n return 'Token({type}, {value})'.format(\n ... | [
"0.84385175",
"0.8271868",
"0.8108106",
"0.8108106",
"0.8108106",
"0.8108106",
"0.8025444",
"0.7961858",
"0.7831813",
"0.77703315",
"0.77629703",
"0.7296134",
"0.72331005",
"0.7230163",
"0.7209733",
"0.7145438",
"0.71215254",
"0.709473",
"0.7079108",
"0.7064358",
"0.7064358",... | 0.76976573 | 11 |
Takes string and constructs either a boolean, a numeric value or a sanitized string. | def _adaptConfigurationValue (cls, value : String) -> Object:
Logging.trace(">>: %r", value)
uppercasedValue = value.upper()
if uppercasedValue in cls._validBooleanValueNames:
result = (uppercasedValue in cls._trueBooleanValueNames)
elif (cls._integerRegExp.match(value)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _eval(string):\n if not isinstance(string, basestring):\n return string\n if string == \"None\": \n return None\n if string == \"True\":\n return True\n if string == \"False\":\n return False\n if string.isdigit():\n return int(string)\n try:\n return... | [
"0.70763725",
"0.7070949",
"0.703633",
"0.700966",
"0.70024306",
"0.6884788",
"0.68035024",
"0.6691395",
"0.6654061",
"0.66312927",
"0.65971744",
"0.65764135",
"0.6497012",
"0.6495254",
"0.6387742",
"0.63626915",
"0.63522667",
"0.63450927",
"0.6314167",
"0.62991416",
"0.62868... | 0.0 | -1 |
Combines possibly fragmented external representation of a string given by into a sanitized string. | def _combineFragmentedString (cls, st : String) -> String:
Logging.trace(">>: %r", st)
ParseState_inLimbo = 0
ParseState_inOther = 1
ParseState_inString = 2
ParseState_inLiteral = 3
ParseState_inEscape = 4
parseState = ParseState_inLimbo
result = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unquote_safe(s, unsafe_list):\n # note: this build utf8 raw strings ,then does a .decode('utf8') at the end.\n # as a result it's doing .encode('utf8') on each block of the string as it's processed.\n res = _utf8(s).split('%')\n for i in xrange(1, len(res)):\n item = res[i]\n try:\n ... | [
"0.5980609",
"0.5755826",
"0.57391524",
"0.5704989",
"0.5646",
"0.5615367",
"0.5597561",
"0.5580975",
"0.5558899",
"0.55469626",
"0.54785067",
"0.54588276",
"0.5450141",
"0.54342884",
"0.54277486",
"0.5427447",
"0.53720134",
"0.53665626",
"0.5333563",
"0.53186095",
"0.5312367... | 0.0 | -1 |
Expands all variables embedded in . | def _expandVariables (self, st : String) -> String:
Logging.trace(">>: %r", st)
cls = self.__class__
# collect identifiers embedded in value and replace them by
# their value
ParseState_inLimbo = 0
ParseState_inString = 1
ParseState_inEscape = 2
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def expand_vars(self, line, name_dict):\n if '%' not in line:\n return line\n for k, v in name_dict.iteritems():\n line = line.replace('%VAR_' + k + '%', escape(v))\n return line",
"def expand_vars(args, diff=()):\n replacer = Placeholders(diff=diff)\n ret... | [
"0.6162648",
"0.6160329",
"0.58408123",
"0.5776226",
"0.561078",
"0.55938995",
"0.5592785",
"0.55764043",
"0.5556073",
"0.5541273",
"0.5539711",
"0.55256486",
"0.5512433",
"0.5484812",
"0.54581267",
"0.5455816",
"0.54464215",
"0.5433427",
"0.5399424",
"0.5390867",
"0.5338721"... | 0.0 | -1 |
Returns string representation of associated identifier value for ; if not found in current key to value map, the identifier itself is returned | def _findIdentifierValue (self, identifier : String) -> String:
Logging.trace(">>: %s", identifier)
cls = self.__class__
if identifier not in self._keyToValueMap:
# leave identifier as is (it might be some value name like
# wahr or false
Logging.traceError("... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _ident(self):\n key_values = [unicode(self.db_key[k]) for k in self.db_key]\n return \"Position (\" + ', '.join(key_values) + \")\"",
"def get_identifier_string(self):\n return self.identifier",
"def __str__(self):\n return '(' + str(self.key) + ': ' + str(self.value) + ')'",
... | [
"0.5909048",
"0.58781356",
"0.5796385",
"0.5796385",
"0.57949334",
"0.5659293",
"0.5657731",
"0.5601299",
"0.5601299",
"0.5600478",
"0.5569756",
"0.5562239",
"0.55307454",
"0.55261767",
"0.551171",
"0.550825",
"0.54956865",
"0.5493071",
"0.5491545",
"0.54761845",
"0.54655385"... | 0.6844378 | 0 |
Returns file name in search paths based on | def _lookupFileName (self,
enclosingDirectoryName : String,
originalFileName : String) -> String:
Logging.trace(">>: directory = %r, file = %r",
enclosingDirectoryName, originalFileName)
cls = self.__class__
result = None
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search(cls, name, lookup=[]):\r\n if os.path.isfile(name): return name\r\n for spath in lookup:\r\n fname = os.path.join(spath, name)\r\n if os.path.isfile(fname):\r\n return fname\r\n for ext in cls.extensions:\r\n if os.path.isfile(... | [
"0.7638885",
"0.73497194",
"0.73497194",
"0.7327317",
"0.72472686",
"0.70664126",
"0.7015206",
"0.70128715",
"0.6895865",
"0.6734751",
"0.6724164",
"0.66758233",
"0.66646725",
"0.66524905",
"0.6638574",
"0.6630043",
"0.662516",
"0.65974027",
"0.65406924",
"0.6537741",
"0.6516... | 0.70027256 | 8 |
Merges continuation lines in into single cumulated line and replaces continuations by empty lines (to preserve line | def _mergeContinuationLines (cls, lineList : StringList):
Logging.trace(">>")
cumulatedLine = ""
markerLength = len(cls._continuationMarker)
lineListLength = len(lineList)
for i, originalLine in enumerate(lineList):
currentLine = originalLine.strip()
l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_line_continuations(code):\n # pat = r\"('.*)(\\.\\.\\.)(.*')\"\n # code = re.sub(pat, r\"\\g<1>\\g<3>\", code, flags=re.MULTILINE)\n\n pat = r\"^([^%'\\\"\\n]*)(\\.\\.\\..*\\n)\"\n code = re.sub(pat, r\"\\g<1>\", code, flags=re.MULTILINE)\n return code",
"def evaluate_line_continuations... | [
"0.632266",
"0.62321156",
"0.57464445",
"0.53904647",
"0.53602",
"0.52938676",
"0.52780247",
"0.52217114",
"0.5165691",
"0.51586413",
"0.51507574",
"0.5148912",
"0.5105856",
"0.50744593",
"0.50576735",
"0.50505483",
"0.50486463",
"0.5046026",
"0.5037575",
"0.50359184",
"0.503... | 0.71371007 | 0 |
Ensures that is of a kind in ; if is not None, token value is also checked | def _mustHave (cls,
token : _Token, kindSet : StringSet,
valueSet : ObjectSet = None):
Logging.trace(">>: token = %r, kindSet = %r, valueSet = %r",
token, kindSet, valueSet)
errorPosition, errorMessage = -1, ""
if token.kind not in k... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def issafe(arg):\n return arg.find(';') == -1 and arg.find('|') == -1",
"def test_peek_none(self):\n nt = NewickTokenizer(newick='(a,(b,c));')\n nt.tokens()\n self.assertIsNone(nt._peek())",
"def _expect_empty(self):\n\n item = self._lexer.get_token()\n if item:\n ... | [
"0.5821828",
"0.5813745",
"0.55833197",
"0.5573724",
"0.5496624",
"0.5417123",
"0.54163474",
"0.5394906",
"0.53898376",
"0.5377175",
"0.53525305",
"0.5310379",
"0.53064024",
"0.53017074",
"0.52943665",
"0.52812845",
"0.5275299",
"0.52562255",
"0.5202314",
"0.5170062",
"0.5159... | 0.48295587 | 67 |
Parses configuration file data given by and updates key to value and key to string value map. | def _parseConfiguration (self, lineList : StringList):
Logging.trace(">>")
cls = self.__class__
cls._mergeContinuationLines(lineList)
for i, currentLine in enumerate(lineList):
lineNumber = i + 1
# remove leading and trailing white space from line
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_data_config(path):\n cfg = dict()\n cfg['gpus'] = '0,1,2,3'\n cfg['num_workers'] = '10'\n \n with open(path, 'r') as fp:\n lines = fp.readlines()\n for line in lines:\n line = line.strip()\n if line == '' or line.startswith('#'):\n continue\n key, ... | [
"0.6310399",
"0.6168418",
"0.60951",
"0.5952508",
"0.594172",
"0.58200586",
"0.5793364",
"0.5778151",
"0.57627004",
"0.5718471",
"0.5715545",
"0.57099646",
"0.57051796",
"0.5693157",
"0.56849927",
"0.5684658",
"0.56639075",
"0.5662061",
"0.5647733",
"0.56444407",
"0.5632023",... | 0.5831359 | 5 |
Appends lines of configuration file with to with leading and trailing whitespace stripped; also handles embedded imports of files (relative to ; tells which files have already been visited | def _readFile (self,
directoryName : String,
fileName : String,
lineList : StringList,
visitedFileNameSet : StringSet):
Logging.trace(">>: fileName = %r, directory = %r, visitedFiles = %r",
fileName, directoryName... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _applyIncludes(self, origfile, _file = file):\n opt = \"include_config\"\n try:\n try:\n includes = self._config.get(\"general\", opt, raw = True).strip()\n except ConfigParser.NoOptionError:\n opt = \"include-config\"\n includes ... | [
"0.59826267",
"0.5473369",
"0.53376997",
"0.521364",
"0.5188674",
"0.5150931",
"0.5146612",
"0.5105637",
"0.50943565",
"0.5074285",
"0.50644237",
"0.50644237",
"0.4991545",
"0.49853146",
"0.49786365",
"0.4973733",
"0.49460754",
"0.49412823",
"0.49387655",
"0.493013",
"0.49267... | 0.0 | -1 |
Sets list of search paths to . | def setSearchPaths (cls, searchPathList : StringList):
Logging.trace(">>: %r", searchPathList)
cls._searchPathList = ["."] + searchPathList
Logging.trace("<<") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_paths(self, paths):\n self.paths = paths",
"def set_paths(self, paths):\n self._paths = paths\n self._paths_set = True",
"def SetPythonPaths(self):\n _knownPaths = site._init_pathinfo()\n for name, value, junk in self._marchConfig():\n if isinstance(value, ... | [
"0.68462783",
"0.6627446",
"0.65913725",
"0.65353215",
"0.6467541",
"0.64639115",
"0.63712513",
"0.63694894",
"0.63314074",
"0.6320922",
"0.631195",
"0.6294908",
"0.6247503",
"0.622521",
"0.61129904",
"0.59953964",
"0.5986615",
"0.59491456",
"0.5936939",
"0.5894814",
"0.58811... | 0.82994115 | 0 |
Parses configuration file given by and sets internal key to value map. | def __init__ (self, fileName : String):
Logging.trace(">>: %r", fileName)
self._keyToValueMap = {}
self._keyToStringValueMap = {}
visitedFileNameSet = set()
lineList = []
isOkay = self._readFile("", fileName, lineList, visitedFileNameSet)
self._parseConfiguratio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_config(self):\n\n with open(os.path.expanduser(self.config_filename), 'r') as f:\n lines = f.readlines()\n\n _usable = lambda l: not(l.startswith('#') or l.strip() == '')\n lines = filter(_usable, lines)\n\n def _build_config(key, value, d):\n \"\"\" Calle... | [
"0.65182775",
"0.64568365",
"0.6327328",
"0.63010305",
"0.6259645",
"0.6236191",
"0.6172959",
"0.6125023",
"0.61192733",
"0.61093795",
"0.61044985",
"0.6075588",
"0.6059768",
"0.6045328",
"0.6028862",
"0.60261595",
"0.60115445",
"0.6010604",
"0.5999662",
"0.59776324",
"0.5975... | 0.60789394 | 11 |
Returns mapping from all keys in configuration file to their effective values | def asStringMap (self) -> StringMap:
Logging.trace(">>")
result = dict(self._keyToValueMap)
Logging.trace("<<: %r", result)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_config_file() -> typing.MutableMapping[str, typing.Any]:\n return _read_file()",
"def restart_map():\n _map = []\n for f, ctxt in CONFIG_FILES.iteritems():\n svcs = []\n for svc in ctxt['services']:\n svcs.append(svc)\n if svcs:\n _map.append((f, svcs)... | [
"0.62769425",
"0.60250276",
"0.6007226",
"0.596452",
"0.5918034",
"0.5843192",
"0.5808663",
"0.5807805",
"0.5803397",
"0.5797582",
"0.5762901",
"0.57512045",
"0.5747105",
"0.5734561",
"0.5713143",
"0.5700877",
"0.56251377",
"0.56208295",
"0.5618294",
"0.56151855",
"0.56107074... | 0.0 | -1 |
Returns mapping from all keys in configuration file to their string values as found in the file | def asDictionary (self) -> Dictionary:
Logging.trace(">>")
result = dict(self._keyToStringValueMap)
Logging.trace("<<: %r", result)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_config_file() -> typing.MutableMapping[str, typing.Any]:\n return _read_file()",
"def read_mappings(fname):\n mapping = {}\n for line in open(fname):\n vals = line.strip().split('\\t')\n if len(vals) < 2: continue\n mapping[vals[0]] = vals[1]\n return mapping",
"def _r... | [
"0.6537312",
"0.60428214",
"0.6030933",
"0.60305786",
"0.60219365",
"0.5971801",
"0.59504783",
"0.5926337",
"0.5915486",
"0.58640057",
"0.5861613",
"0.5857182",
"0.58519226",
"0.5825162",
"0.580197",
"0.5787843",
"0.5786739",
"0.5770356",
"0.57355756",
"0.5712807",
"0.5712807... | 0.0 | -1 |
Returns set of all keys in configuration file | def keySet (self) -> StringSet:
Logging.trace(">>")
result = set(self._keyToValueMap.keys())
Logging.trace("<<: %r", result)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keys(self):\n return self.config.keys()",
"def keys(self):\n return self.config.keys()",
"def get_setting_keys(self):\n return self.do_rpc(\"get_setting_keys\")",
"def get_all_keys(self):\n return self.psettings.allKeys()",
"def get_config_keys():\n global _allowed_config... | [
"0.7790183",
"0.7790183",
"0.7384112",
"0.7375076",
"0.7105019",
"0.70563525",
"0.70167387",
"0.69515896",
"0.69376314",
"0.69376314",
"0.69025695",
"0.6888922",
"0.6832754",
"0.6829535",
"0.682636",
"0.68065333",
"0.6797182",
"0.6766179",
"0.669738",
"0.66707116",
"0.6668752... | 0.70229256 | 6 |
Returns value for in configuration file; if is missing, an error message is logged when there is no associated value, otherwise is returned for a missing entry | def value (self,
key : String,
defaultValue : Object = missingValue) -> Object:
Logging.trace(">>: key = %s, defaultValue = %r",
key, defaultValue)
isMandatory = (defaultValue == missingValue)
result = None
if key in self._keyToValue... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_config(config, section, item):\n value = config.get(section, item)\n if value == \"None\":\n return None\n return value",
"def config_value(name):\n def get():\n try:\n return config.get('yourls', name)\n except (NoOptionError, NoSectionError):\n re... | [
"0.67917",
"0.6635625",
"0.6563727",
"0.64952976",
"0.64884275",
"0.64454025",
"0.63905793",
"0.6375485",
"0.629574",
"0.62699145",
"0.6211306",
"0.62047195",
"0.61872745",
"0.617998",
"0.6173474",
"0.6172952",
"0.6149519",
"0.6134496",
"0.6125716",
"0.6074267",
"0.6069744",
... | 0.0 | -1 |
Only load the module if apache is installed | def __virtual__():
if _apikey():
return True
return (
False,
'The API key was not specified. Please specify it using the "apikey" config.',
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __virtual__():\n cmd = _detect_os()\n if salt.utils.path.which(cmd):\n return \"apache\"\n return (\n False,\n \"The apache execution module cannot be loaded: apache is not installed.\",\n )",
"def apache(self):\n self.summarize_operation(\"Installing Apache Web Server... | [
"0.68103963",
"0.6424718",
"0.6423451",
"0.61203414",
"0.6101222",
"0.6006222",
"0.59959805",
"0.5972969",
"0.59617776",
"0.5927091",
"0.5924863",
"0.57398",
"0.5661964",
"0.5608795",
"0.5575795",
"0.5574128",
"0.55290484",
"0.54831946",
"0.5465866",
"0.5440239",
"0.5419415",... | 0.0 | -1 |
Get the API key | def _apikey():
return __opts__.get("bamboohr", {}).get("apikey", None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_api_key(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'api_key')\r\n\r\n return http.Request('GET', url), parsers.parse_json",
"def get_api_key(api_key):\n api.get(api_key)",
"def api_key(self):\n return self._api_key",
"def api_key(self):\n return self.__creds.api_... | [
"0.89945996",
"0.8524351",
"0.840441",
"0.8323821",
"0.83030087",
"0.83011305",
"0.83011305",
"0.83011305",
"0.83011305",
"0.8222898",
"0.81584",
"0.81584",
"0.81180537",
"0.8111266",
"0.8042683",
"0.786292",
"0.78575736",
"0.78522336",
"0.7848158",
"0.78442097",
"0.78429556"... | 0.7700787 | 33 |
Show all employees for this company. | def list_employees(order_by="id"):
ret = {}
status, result = _query(action="employees", command="directory")
root = ET.fromstring(result)
for cat in root:
if cat.tag != "employees":
continue
for item in cat:
emp_id = next(iter(item.values()))
emp_ret =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_employees(request, company_id=None):\n current_employee = Employee.objects.get(user__pk=request.user.pk)\n company_super_user = current_employee.isCompanySuperUserOrHigher()\n if company_id:\n company = Company.objects.get(pk=company_id)\n else:\n company = current_employee.compan... | [
"0.7872654",
"0.7634882",
"0.74686563",
"0.73382276",
"0.7263343",
"0.7216713",
"0.71493816",
"0.71192384",
"0.7012556",
"0.6841546",
"0.6775984",
"0.6766217",
"0.675149",
"0.6706652",
"0.6450483",
"0.63677967",
"0.6324923",
"0.6319123",
"0.62385494",
"0.6153163",
"0.61480546... | 0.59792286 | 22 |
Show all employees for this company. | def show_employee(emp_id, fields=None):
ret = {}
if fields is None:
fields = ",".join(
(
"canUploadPhoto",
"department",
"displayName",
"firstName",
"id",
"jobTitle",
"lastName",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_employees(request, company_id=None):\n current_employee = Employee.objects.get(user__pk=request.user.pk)\n company_super_user = current_employee.isCompanySuperUserOrHigher()\n if company_id:\n company = Company.objects.get(pk=company_id)\n else:\n company = current_employee.compan... | [
"0.7872759",
"0.76351726",
"0.74689776",
"0.7336205",
"0.72626585",
"0.72163236",
"0.71485955",
"0.71182954",
"0.70109284",
"0.6840929",
"0.6775324",
"0.67646873",
"0.6752035",
"0.6707513",
"0.64506286",
"0.6367168",
"0.63260454",
"0.63192195",
"0.6239045",
"0.61484945",
"0.6... | 0.6154354 | 19 |
Update one or more items for this employee. Specifying an empty value will clear it for that employee. | def update_employee(emp_id, key=None, value=None, items=None):
if items is None:
if key is None or value is None:
return {"Error": "At least one key/value pair is required"}
items = {key: value}
elif isinstance(items, str):
items = salt.utils.yaml.safe_load(items)
xml_it... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, items: Mapping[Any, Any]) -> None:\n self.extend(list(items.values()))\n return",
"def update(self, *items):\n for item in items:\n self.add(item)",
"def update_item(self, id: str, user: User, **kwargs) -> None:",
"def update_items(self, request, *a, **kw):\n ... | [
"0.62127465",
"0.61989135",
"0.6134278",
"0.6095077",
"0.60757583",
"0.60266775",
"0.5949175",
"0.5913471",
"0.5824841",
"0.5775372",
"0.5750113",
"0.57272786",
"0.57065195",
"0.56633925",
"0.56531554",
"0.5622812",
"0.56077135",
"0.56035596",
"0.5586695",
"0.55599886",
"0.54... | 0.6439496 | 0 |
Show all users for this company. | def list_users(order_by="id"):
ret = {}
status, result = _query(action="meta", command="users")
root = ET.fromstring(result)
for user in root:
user_id = None
user_ret = {}
for item in user.items():
user_ret[item[0]] = item[1]
if item[0] == "id":
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_users():\n\n users = crud.get_users()\n\n return render_template('all_users.html', users=users)",
"def show_users():\n\n user = User(connection=connection, cursor=cursor)\n\n all_users = user.get_all_users()\n\n context = {\n 'all_users': all_users\n }\n\n return render_templa... | [
"0.7302377",
"0.72287637",
"0.7109827",
"0.69417936",
"0.6856711",
"0.68548924",
"0.67848665",
"0.6717104",
"0.6689702",
"0.66741294",
"0.666934",
"0.6622241",
"0.66180104",
"0.661377",
"0.65867805",
"0.6585776",
"0.6574805",
"0.65646803",
"0.65598726",
"0.65598726",
"0.65598... | 0.0 | -1 |
Show all meta data fields for this company. | def list_meta_fields():
ret = {}
status, result = _query(action="meta", command="fields")
root = ET.fromstring(result)
for field in root:
field_id = None
field_ret = {"name": field.text}
for item in field.items():
field_ret[item[0]] = item[1]
if item[0] ==... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_fields(self):\n fields = []\n for f in self._meta.fields:\n\n fname = f.name \n # resolve picklists/choices, with get_xyz_display() function\n get_choice = 'get_'+fname+'_display'\n if hasattr( self, get_choice):\n value = ... | [
"0.63180304",
"0.6235449",
"0.59543186",
"0.5739981",
"0.5733114",
"0.5728143",
"0.5680151",
"0.5634569",
"0.5624671",
"0.5574427",
"0.55651516",
"0.5556688",
"0.55432194",
"0.55249697",
"0.54736274",
"0.54564404",
"0.54484874",
"0.5447442",
"0.5430577",
"0.5414239",
"0.54125... | 0.6288093 | 1 |
Make a web call to BambooHR The password can be any random text, so we chose Salty text. | def _query(action=None, command=None, args=None, method="GET", data=None):
subdomain = __opts__.get("bamboohr", {}).get("subdomain", None)
path = "https://api.bamboohr.com/api/gateway.php/{}/v1/".format(subdomain)
if action:
path += action
if command:
path += "/{}".format(command)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def request_password_page(self, error=None):\n # TODO: Make use of \"error\".\n # TODO: add styling\n return \"\"\"\n<!DOCTYPE html>\n<html>\n <head>\n <meta charset=\"UTF-8\">\n <title>title</title>\n </head>\n <body>\n <form>\n Email Address:<br>\n <input id=\"email\" t... | [
"0.6120072",
"0.5836202",
"0.57576877",
"0.570071",
"0.56842643",
"0.5647777",
"0.5641218",
"0.556389",
"0.5555022",
"0.5539118",
"0.551953",
"0.5516611",
"0.55077904",
"0.54923356",
"0.5470385",
"0.54577637",
"0.545019",
"0.5434154",
"0.53906393",
"0.5384684",
"0.537655",
... | 0.5092449 | 78 |
\brief Stop the write flush timer. | def stopTimer(self):
log.debug("SwitchDB: stopping flush timer")
self.__flush_timer.stop()
self.flushWrites() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stopWrite(self):\n\n self.dowrite = False",
"def stop_timer(self):\n self.end_time = datetime.now()",
"def stop_timer(self):\n self.log.info(\"{} timer stopped ({} seconds)\".format(self.name, self.interval))\n self.start_event.clear()\n # self.count = self.interval / sel... | [
"0.7037228",
"0.6424918",
"0.62180656",
"0.6174741",
"0.60519195",
"0.6048231",
"0.60435826",
"0.60333914",
"0.5959563",
"0.5948373",
"0.59198564",
"0.5895208",
"0.5839709",
"0.580128",
"0.5790531",
"0.57885194",
"0.5749805",
"0.5743604",
"0.57333773",
"0.57209086",
"0.570342... | 0.8155102 | 0 |
\brief Flush any writes to disk. | def flushWrites(self):
#log.debug("flushWrites(): Acquiring update lock.")
self.__update_lock.acquire()
#log.debug("flushWrites() has update lock.")
if self.__writes_since_flush > 0:
#log.debug("flushWrites(): Acquiring file locks.")
for fileLock in self.__node_lo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flush(self):\n self.fileobj.flush()",
"def flush(self):\n self._write()",
"def flush(self):\n for fp in self.files:\n fp.flush()\n if isinstance(fp, int) or hasattr(fp, \"fileno\"):\n try:\n os.fsync(fp)\n except OSErro... | [
"0.7776948",
"0.7571886",
"0.7562259",
"0.7537057",
"0.75116175",
"0.75019747",
"0.75019747",
"0.75019747",
"0.75019747",
"0.74662924",
"0.74490076",
"0.74389756",
"0.7412338",
"0.74034125",
"0.7378896",
"0.7367023",
"0.73400176",
"0.73231196",
"0.73231196",
"0.73231196",
"0.... | 0.7245433 | 25 |
Decorator for registering a rule with the rule factory. | def register_rule(factory_func=None):
def decorator(cls):
if factory_func is None:
RuleFactory.register_rule(cls)
else:
RuleFactory.register_rule(lambda: factory_func(cls))
return cls
return decorator | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_rule(cls, rule_func):\n cls._rules_factories.append(rule_func)",
"def register_rule(pattern: matcher.Pattern) -> Callable[..., rules.Rule]:\n\n def register(handler: Callable[..., Any]) -> rules.Rule:\n return rules.make_rule(pattern, handler)\n\n return register",
"def add_rule(self, ... | [
"0.8259463",
"0.7652915",
"0.66059923",
"0.65928054",
"0.6551904",
"0.65204674",
"0.64615387",
"0.64417386",
"0.64297867",
"0.64228624",
"0.6336922",
"0.6239316",
"0.6231074",
"0.6194358",
"0.6129349",
"0.6121821",
"0.6108161",
"0.6086128",
"0.59606814",
"0.59476435",
"0.5836... | 0.83662206 | 0 |
Returns an instantiated list of each rule that has been registered. | def get_rules(cls) -> list:
return [factory() for factory in cls._rules_factories] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_rules(self):\n rules = []\n for item in self.rule:\n rules.append(item)\n return rules",
"def get_rules(self):\n rules = []\n for item in self.name:\n rules.append(item)\n return rules",
"def getListOfRules(self):\n return self.mode... | [
"0.81854767",
"0.8028653",
"0.7681446",
"0.747593",
"0.7188627",
"0.7024562",
"0.6993731",
"0.69882214",
"0.67589486",
"0.6748225",
"0.67445904",
"0.67356396",
"0.6722869",
"0.6689858",
"0.6678105",
"0.6660337",
"0.6650291",
"0.65893424",
"0.6547568",
"0.6512674",
"0.6477749"... | 0.81147885 | 1 |
Utility function used by the register_rule decorator to register a lambda/function to instantiate a rule. | def register_rule(cls, rule_func):
cls._rules_factories.append(rule_func) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_rule(factory_func=None):\n def decorator(cls):\n if factory_func is None:\n RuleFactory.register_rule(cls)\n else:\n RuleFactory.register_rule(lambda: factory_func(cls))\n\n return cls\n return decorator",
"def register_rule(pattern: matcher.Pattern) ... | [
"0.734958",
"0.7176785",
"0.63173115",
"0.57214266",
"0.5599516",
"0.55994016",
"0.55857486",
"0.5585293",
"0.5575238",
"0.5558575",
"0.5531269",
"0.5498299",
"0.5496348",
"0.54958177",
"0.54734015",
"0.54484636",
"0.54439145",
"0.5400797",
"0.5344353",
"0.5344353",
"0.534435... | 0.7451927 | 0 |
>>> test_key('bwv66.6.mxl', 'different_key.mxl') False >>> test_key('bwv66.6.mxl', 'different_pitches.mxl') True >>> test_key('bwv66.6.mxl', 'different_ornaments.mxl') True >>> test_key('bwv66.6.mxl', 'different_key2.mxl',1) False >>> test_key('bwv66.6.mxl', 'different_key3.mxl', 5) False >>> test_key('bwv66.6.mxl', 's... | def test_key(score1, score2, measure=0, part=0):
diff = ScoreDiff(score1, score2, path)
return diff.have_same_key_signature(measure, part) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def func4(key):\n return key in list(my_test_dict.keys())",
"def isValidKey(key):\n return True",
"def func2(key):\n return key in my_test_dict.keys()",
"def check_key(self, key, key_pkl):\r\n start_time = time.time()\r\n # Verify that when we reload the KeyData from the pickled file, th... | [
"0.67308366",
"0.6689036",
"0.6554257",
"0.6496629",
"0.63685757",
"0.6172832",
"0.6085646",
"0.6074689",
"0.6063078",
"0.6014506",
"0.6000377",
"0.59025127",
"0.590022",
"0.5894023",
"0.5891906",
"0.58820397",
"0.58645356",
"0.58533293",
"0.5843953",
"0.5829784",
"0.5824024"... | 0.63992757 | 4 |
>>> test_time_signature('bwv66.6.xml', 'different_time.mxl') False >>> test_time_signature('bwv66.6.mxl', 'different_dynamics.mxl') True >>> test_time_signature('bwv66.6.mxl', 'different_key.mxl') True >>> test_time_signature('bwv66.6.mxl', 'different_time2.mxl', 5) False >>> test_time_signature('bwv66.6.mxl', 'differe... | def test_time_signature(score1, score2, measure = 0, part = 0):
diff = ScoreDiff(score1, score2, path)
return diff.have_same_time_signature(measure, part) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_signature_verification(self):\n curdir = os.path.dirname(os.path.abspath(__file__))\n keydir = os.path.join(curdir, \"data\", \"ima_keys\")\n\n lines = SIGNATURES.split('\\n')\n\n # empty keyring\n keyring = ima_file_signatures.ImaKeyring()\n self.assertTrue(ima.p... | [
"0.6361225",
"0.5938662",
"0.5742003",
"0.56398404",
"0.56322205",
"0.5614221",
"0.5570382",
"0.5565186",
"0.5562696",
"0.5562569",
"0.5561084",
"0.5537023",
"0.5530048",
"0.5530048",
"0.550574",
"0.5453776",
"0.5438577",
"0.5410554",
"0.5371119",
"0.5326065",
"0.52840763",
... | 0.6932904 | 0 |
>>> test_clef('bwv66.6.mxl', 'different_clef.mxl') False >>> test_clef('bwv66.6.mxl', 'different_time.mxl') True >>> test_clef('bwv66.6.mxl', 'different_pitches.mxl') True >>> test_clef('bwv66.6.mxl', 'different_clef2.mxl', 1) False >>> test_clef('bwv66.6.mxl', 'different_clef3.mxl', 2) False >>> test_clef('bwv66.6.mxl... | def test_clef(score1, score2, measure = 0, part = 0):
diff = ScoreDiff(score1, score2, path)
return diff.have_same_clef_markings(measure, part) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tests_truth():\n circ_m = ccxtest(4)\n print(circ_m)\n circ_m = crootnxtest(4)\n print(circ_m)\n circ_m = oracletest(4)\n print(circ_m)\n circ_m = ccx_otest(4)\n print(circ_m)",
"def _consonance_test(self, testfunc, param=None):\n n = list(self.notes)\n while len(n) > 1:... | [
"0.5843581",
"0.5775546",
"0.5584157",
"0.5578372",
"0.5539811",
"0.544524",
"0.5414274",
"0.5412933",
"0.53988796",
"0.5382359",
"0.53114665",
"0.5242615",
"0.5241555",
"0.5241493",
"0.5239952",
"0.5205264",
"0.5201015",
"0.51927865",
"0.5182268",
"0.5157461",
"0.51572466",
... | 0.6404271 | 0 |
>>> test_pitches('bwv66.6.mxl', 'different_pitches.mxl') False >>> test_pitches('bwv66.6.mxl', 'different_pitches2.mxl', 1) False >>> test_pitches('bwv66.6.mxl', 'different_pitches2.mxl', 2) False >>> test_pitches('bwv66.6.mxl', 'different_dynamics.mxl') True >>> test_pitches('bwv66.6.mxl', 'different_key.mxl') True >>... | def test_pitches(score1, score2, measure = 0, part = 0):
diff = ScoreDiff(score1, score2, path)
return diff.have_same_pitches(measure, part) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_random_note_pitch(common_scales, all_pitches):\n\n for key, scales in common_scales.items():\n note = random_note_pitch(scales)\n assert note in all_pitches\n assert isinstance(note, (int, str)) is True",
"def test_true_false_cases(file_with_true_and_false_value, result, inp):\n ... | [
"0.57925975",
"0.5436552",
"0.5393471",
"0.53561616",
"0.53336096",
"0.53189737",
"0.517428",
"0.50872374",
"0.5070097",
"0.5059205",
"0.5006668",
"0.4995654",
"0.49777004",
"0.49690577",
"0.4963465",
"0.49614137",
"0.49481976",
"0.49456045",
"0.4936992",
"0.49341315",
"0.492... | 0.66385114 | 0 |
>>> test_ornaments('bwv66.6.mxl', 'different_ornaments.mxl') False >>> test_ornaments('bwv66.6.mxl', 'different_ornaments2.mxl') False >>> test_ornaments('bwv66.6.mxl', 'different_ornaments3.mxl') False >>> test_ornaments('bwv66.6.mxl', 'different_pitches.mxl') True >>> test_ornaments('bwv66.6.mxl', 'different_key.mxl'... | def test_ornaments(score1, score2, measure = 0, part = 0):
diff = ScoreDiff(score1, score2, path)
return diff.have_same_ornaments(measure, part) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_match_nones():\r\n runmatch(lcode_nones)",
"def ensemble_annoj_exists(ensemble):\n\n\tensemble = str(ensemble)\n\tensemble = ensemble.strip('Ens')\n\tresult = path.isfile('/var/www/html/annoj_private/CEMBA/browser/fetchers/mc_cemba/mc_single_merged_mCG_cluster_mCHmCG_lv_npc50_k30_1_Ens'+str(ensemble)... | [
"0.5523054",
"0.5063729",
"0.49874783",
"0.49115068",
"0.48974282",
"0.48964244",
"0.48904523",
"0.48893464",
"0.48683524",
"0.48556218",
"0.48508865",
"0.48504823",
"0.4835649",
"0.48253495",
"0.48235333",
"0.4821645",
"0.48186624",
"0.48185313",
"0.48053995",
"0.4797268",
"... | 0.6441692 | 0 |
>>> test_accidentals('bwv66.6.mxl', 'different_accidentals.mxl') False >>> test_accidentals('bwv66.6.mxl', 'different_ornaments.mxl') True >>> test_accidentals('bwv66.6.mxl', 'bwv66.6.mxl') True >>> test_accidentals('bwv66.6.mxl', 'different_accidentals2.mxl', 1) False >>> test_accidentals('bwv66.6.mxl', 'different_acc... | def test_accidentals(score1, score2, measure = 0, part = 0):
diff = ScoreDiff(score1, score2, path)
return diff.have_same_accidentals(measure, part) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def given_test_cases(self):\n self.assertTrue(anagram_finder(\"listen\", \"silent\"))\n self.assertTrue(anagram_finder(\"triangle\", \"integral\"))\n self.assertFalse(anagram_finder(\"apple\", \"pabble\"))",
"def test_check_validity(resident_names, hospital_names, capacities, seed):\n\n _... | [
"0.59301686",
"0.55262876",
"0.5454933",
"0.5408776",
"0.5360736",
"0.52889955",
"0.5265647",
"0.52480555",
"0.52306783",
"0.51918554",
"0.5188172",
"0.5188172",
"0.5185943",
"0.5185736",
"0.5171561",
"0.5156619",
"0.51435447",
"0.51403385",
"0.5136119",
"0.5135964",
"0.51198... | 0.57314533 | 1 |
>>> test_stem_directions('bwv66.6.mxl', 'different_stems.mxl') False >>> test_stem_directions('bwv66.6.mxl', 'different_stems2.mxl', 1) False >>> test_stem_directions('bwv66.6.mxl', 'different_stems3.mxl', 4) False >>> test_stem_directions('bwv66.6.mxl', 'different_ornaments.mxl') True >>> test_stem_directions('bwv66.6... | def test_stem_directions(score1, score2, measure = 0, part = 0):
diff = ScoreDiff(score1, score2, path)
return diff.have_same_stem_directions(measure, part) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_stemming():\n normalizer = TextNormalizer(stem=True, lemmatize=False)\n assert normalizer.transform([[\"running\"]])[\"corpus\"][0] == [\"run\"]",
"def test_1(self):\r\n\r\n max_flexion_len = 3\r\n\r\n result_1 = list(stemmer.gen_simplest_stemmer(\"слово\", max_flexion_len))\r\n ... | [
"0.6692664",
"0.624442",
"0.60175544",
"0.60047394",
"0.59410924",
"0.5930666",
"0.59121484",
"0.58245426",
"0.560271",
"0.5552443",
"0.54929966",
"0.54354376",
"0.5396129",
"0.53951675",
"0.5383812",
"0.5341282",
"0.53087145",
"0.52382666",
"0.52240324",
"0.5221061",
"0.5160... | 0.7251379 | 0 |
>>> test_spanners('bwv66.6.mxl', 'different_phrasing.mxl') False >>> test_spanners('bwv66.6.mxl', 'different_ornaments.mxl') False >>> test_spanners('bwv66.6.mxl', 'different_pitches.mxl') True >>> test_spanners('bwv66.6.mxl', 'scriabin_opus_2_no1.mxl') True >>> test_spanners('bwv66.6.mxl', 'scriabin_opus_8_no5.mxl') T... | def test_spanners(score1, score2, measure = 0, part = 0):
diff = ScoreDiff(score1, score2, path)
return diff.have_same_spanners(measure, part) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_env_rules_cause_matching_span_to_be_sampled():\n with override_global_config(dict(_sampling_rules='[{\"service\":\"test_service\",\"name\":\"test_name\"}]')):\n sampling_rules = get_span_sampling_rules()\n assert sampling_rules[0]._service_matcher.pattern == \"test_service\"\n asse... | [
"0.5340157",
"0.51737",
"0.507743",
"0.50210464",
"0.4951721",
"0.49203345",
"0.48373163",
"0.4762639",
"0.4744961",
"0.47269493",
"0.47077292",
"0.46728623",
"0.466654",
"0.4652557",
"0.46401304",
"0.4631468",
"0.4625303",
"0.4613554",
"0.46055642",
"0.46029666",
"0.4597388"... | 0.6647752 | 0 |
>>> test_articulations('bwv66.6.mxl', 'different_articulations.mxl') False >>> test_articulations('bwv66.6.mxl', 'different_ornaments.mxl') True >>> test_articulations('bwv66.6.mxl', 'different_pitches.mxl') True >>> test_articulations('scriabin_opus_2_no1.mxl', 'bwv66.6.mxl') True >>> test_articulations('scriabin_opus... | def test_articulations(score1, score2, measure = 0, part = 0):
diff = ScoreDiff(score1, score2, path)
return diff.have_same_articulations(measure, part) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_variational():\n # iris\n #pres = \"Test pour le data set Iris (facile, classique)\"\n #test_from_func_variational(pres, 15, 10, 3, True, Iris)\n\n # breast cancer\n pres = \"Test pour le data set Breast Cancer (facile, classique)\"\n test_from_func_variational(pres, 15, 10, 3, True, Bre... | [
"0.551927",
"0.55119956",
"0.5459723",
"0.5439813",
"0.5362803",
"0.53410804",
"0.53354734",
"0.5287916",
"0.5287916",
"0.5285058",
"0.5218113",
"0.51794463",
"0.5179227",
"0.51770556",
"0.5171885",
"0.51688933",
"0.51557285",
"0.514981",
"0.51109475",
"0.51107997",
"0.509594... | 0.66323584 | 0 |
Determines whether a piece of software meets 6.031 standards. Software meets 6.031 standards if it is safe from bugs, ready for change, and easy to understand. | def is_code_good(safe_from_bugs, ready_for_change, easy_to_understand):
pass # your code here! | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_version_2_6() -> bool:\n v = get_version()\n if v[1] != \"singularity\" and v[1] != \"singularity-ce\":\n return False\n return v[0][0] == 2 and v[0][1] == 6",
"def check_supported_features(self):",
"def eligible(CGPA:float, Year:int, program:str) -> bool:\n return CGPA >= 2 and Year ... | [
"0.6226087",
"0.6051725",
"0.5854076",
"0.58402455",
"0.58168775",
"0.5793419",
"0.5768285",
"0.57435614",
"0.57337004",
"0.57026315",
"0.56996334",
"0.5698729",
"0.5671816",
"0.56634545",
"0.5659834",
"0.5626873",
"0.5620132",
"0.55883926",
"0.5572107",
"0.55642295",
"0.5551... | 0.6084589 | 1 |
A decorator that takes a generator function and makes it threadsafe. | def threadsafe_generator(f):
def g(*a, **kw):
return ThreadsafeIter(f(*a, **kw))
return g | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def threadsafe_generator(f):\n def g(*a, **kw):\n return ThreadSafe(f(*a, **kw))\n return g",
"def threadsafe_generator(f):\n\tdef g(*a, **kw):\n\t\treturn threadsafe_iter(f(*a, **kw))\n\treturn g",
"def threadsafe_generator(f):\n def g(*a, **kw):\n return threadsafe_iter(f(*a, **kw))\n ... | [
"0.83985823",
"0.8137598",
"0.8042877",
"0.8042877",
"0.8042877",
"0.8042877",
"0.8042877",
"0.8042877",
"0.8042877",
"0.80164343",
"0.7981679",
"0.75909317",
"0.7472497",
"0.7349135",
"0.73063093",
"0.72516894",
"0.70202196",
"0.70136774",
"0.6973199",
"0.69161046",
"0.67388... | 0.7914833 | 11 |
Adds names and bounding boxes to the frame | def redraw_frame(image, names, aligned):
i = 0
unicode_font = ImageFont.truetype("DejaVuSansMono.ttf", size=17)
img_pil = Image.fromarray(image)
draw = ImageDraw.Draw(img_pil)
for face in aligned:
draw.rectangle((face[0], face[1], face[2], face[3]), outline=(0, 255, 0), width=2)
i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _draw(self, frame, boxes, probs, landmarks, name):\n try:\n print('drawing')\n for box, prob, ld, id in zip(boxes, probs, landmarks, name):\n # Draw rectangle on frame\n\n cv2.putText(frame, id, (200, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, c... | [
"0.67756474",
"0.6062011",
"0.6045409",
"0.60349154",
"0.60078406",
"0.5994434",
"0.5986124",
"0.5865525",
"0.57960564",
"0.5786791",
"0.57806087",
"0.57626694",
"0.57595354",
"0.57552874",
"0.573282",
"0.5705798",
"0.56562084",
"0.5644989",
"0.55984014",
"0.55860054",
"0.555... | 0.52962124 | 45 |
Computes the length of the recurring cycle in the decimal representation of the rational number 1/d if any, 0 otherwise | def cycle_length(d):
if not isinstance(d, int) or d <= 0:
raise ValueError("cycle_length(d): d must be a positive integer")
rlist = []
qlist_len = 0
remainder = 1
while remainder:
remainder = remainder % d
if remainder in rlist:
return qlist_len - rlist.index(rema... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lenOfRec(denom):\n d = denom\n n = 1 #numerator\n count = 0\n while n!=0:\n n = n*10 % d\n count += 1\n if n == 1:\n break\n \n return count",
"def get_length_repeating_decimals(num, den):\n # When we use longhand divison for the fraction we find that ... | [
"0.7235305",
"0.7039432",
"0.65656936",
"0.64102966",
"0.62604904",
"0.6176775",
"0.6016356",
"0.60072213",
"0.5950206",
"0.5911741",
"0.58723277",
"0.58633614",
"0.57687944",
"0.5754934",
"0.5731501",
"0.5682944",
"0.56633145",
"0.563831",
"0.55833185",
"0.55670255",
"0.5565... | 0.734951 | 0 |
Parses restaurant name and ratings from file and adds it to a dictionary. | def process_file(file_name):
restaurant_ratings = {}
# open file, iterate line by line
restaurant_file = open(file_name)
# split by colon, returns a list
for line in restaurant_file:
restaurant_name, restaurant_rating = line.rstrip().split(":")
restaurant_ratings[restaurant... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def return_restaurant_rating_dictionary(filename):\n\n the_file = open(filename)\n\n for line in the_file:\n line = line.rstrip()\n ratings = line.split(\":\")\n\n restaurant_name = ratings[0]\n rating = ratings[1]\n restaurant_ratings[restaurant_name] = rating\n\n retur... | [
"0.8203267",
"0.8107739",
"0.81040096",
"0.80869764",
"0.8024982",
"0.8008177",
"0.77576977",
"0.6952371",
"0.66929567",
"0.6518673",
"0.64702773",
"0.63175005",
"0.6137714",
"0.61332256",
"0.6118705",
"0.6059968",
"0.6051205",
"0.6029567",
"0.598272",
"0.59775275",
"0.597714... | 0.8216074 | 0 |
Prompts user for restaurant & rating, adds to dictionary. | def add_restaurant_rating(restaurant_ratings):
user_restaurant = raw_input("Enter a restaurant name: ")
user_rating = int(raw_input("Enter a restaurant rating between 1-5: "))
# prompt user for new restaurant and rating, add to dictionary
restaurant_ratings[user_restaurant] = user_rating
return r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def adds_user_ratings(restaurant_ratings_dictionary):\n while True:\n add_restaurant = input(\"Would you like to add a restaurant review? Type Y or N\\n> \").lower()\n if add_restaurant == \"n\":\n print(\"n\")\n break\n elif add_restaurant == \"y\":\n print... | [
"0.78467345",
"0.744267",
"0.71459824",
"0.71104604",
"0.6941335",
"0.69223744",
"0.6828657",
"0.6637511",
"0.64718455",
"0.64450294",
"0.6160519",
"0.60316193",
"0.594381",
"0.5925114",
"0.58915067",
"0.5874964",
"0.5837635",
"0.5719949",
"0.5660157",
"0.5600644",
"0.559366"... | 0.8107513 | 0 |
User chooses which function to call, based on options available. | def give_user_choice(rest_ratings):
print """
Welcome to our program! Here's what's on the menu:
1. Would you like to see all restaurant ratings available?
2. Adding a new restaurant to the list?
3. Quitting our program?"""
user_selection = int(raw_input("Please type a number here (1, 2, or 3)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __choose_options(self):\n\t\tswitcher = {\n\t\t\t0: self.__zero,\n\t\t\t1: self.__one,\n\t\t\t2: self.__two,\n\t\t\t3: self.__three,\n\t\t\t4: self.four,\n\t\t\t5: self.four,\n\t\t\t6: self.four,\n\t\t\t7: self.four,\n\t\t}\n\t\tfunc = switcher.get(self.__options(), lambda: \"Invalid option\")\n\t\treturn func... | [
"0.7220321",
"0.6326212",
"0.61131716",
"0.59147114",
"0.59010607",
"0.5801811",
"0.57757354",
"0.57502675",
"0.5723322",
"0.5720491",
"0.56927013",
"0.5677188",
"0.5667494",
"0.56666017",
"0.56640846",
"0.56635255",
"0.56632894",
"0.5657105",
"0.56466323",
"0.562625",
"0.562... | 0.0 | -1 |
Applies the Softmax function to an ndimensional input Tensor rescaling them | def softmax(arr: np.ndarray, axis: int = -1):
c = arr.max(axis=axis, keepdims=True)
s = arr - c
nominator = np.exp(s)
denominator = nominator.sum(axis=axis, keepdims=True)
probs = nominator / denominator
return probs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def softmax(input, dim, inplace=False):\n return FunctionLib.apply(\n 'Softmax', input.device, [input],\n outputs=[input if inplace else None], axis=dim)",
"def softmax4(x):\n ndim = K.ndim(x)\n if ndim == 2:\n return K.softmax(x)\n elif ndim == 3:\n e = K.exp(x - K.max(x,... | [
"0.7957886",
"0.7658958",
"0.7509899",
"0.7509899",
"0.7487856",
"0.7486355",
"0.744741",
"0.7405989",
"0.7357403",
"0.73492765",
"0.7309486",
"0.7249288",
"0.7239053",
"0.7204867",
"0.7204867",
"0.7201723",
"0.7198571",
"0.7180414",
"0.7176051",
"0.7175737",
"0.71715707",
... | 0.0 | -1 |
A function that fixes a random seed for reproducibility | def set_seeds(seed=42):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False # for faster trai... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Randomize(seed=None):\n random.seed()",
"def random():\n np.random.seed(1939)",
"def random():\n np.random.seed(0)",
"def seed_random():\n random.seed(0)",
"def reproducible(seed: int = 0) -> None:\n\n os.environ[\"PYTHONHASHSEED\"] = \"0\"\n\n np.random.seed(seed)\n python_random.... | [
"0.8439382",
"0.8354831",
"0.8337567",
"0.8326795",
"0.8141794",
"0.80265725",
"0.79857415",
"0.7798418",
"0.77400285",
"0.7687649",
"0.76443243",
"0.7551165",
"0.7534908",
"0.7501219",
"0.746654",
"0.746654",
"0.744722",
"0.7379323",
"0.7361366",
"0.73589087",
"0.7341101",
... | 0.0 | -1 |
Draw samples from a standard Normal distribution (mean=0, stdev=1). | def standard_normal(random_state, size=None, chunk_size=None, gpu=None, dtype=None):
if dtype is None:
dtype = np.random.RandomState().standard_normal(size=(0,)).dtype
size = random_state._handle_size(size)
seed = gen_random_seeds(1, random_state.to_numpy())[0]
op = TensorStandardNormal(size=siz... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_normal(self):\n means, scale = self.get_means_and_scales()\n return np.random.normal(means,scale,size=[self.sims,means.shape[0]]).T",
"def normal(mean, std):\n\n return random.gauss(mean, std)",
"def test_normal(self):\r\n s = np.random.normal(-0.42, 0.55, 5000)\r\n ... | [
"0.75756955",
"0.7359071",
"0.72345424",
"0.7150394",
"0.71197146",
"0.7093101",
"0.69451076",
"0.6877788",
"0.6869891",
"0.6642873",
"0.66425455",
"0.6602457",
"0.6599727",
"0.6596702",
"0.6525589",
"0.64931434",
"0.64451784",
"0.64451784",
"0.64451784",
"0.64451784",
"0.644... | 0.58724236 | 59 |
Return a json object containing the file content | def _get_data_file(self, data_path):
return json.load(open(data_path)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_json_file_content(file_dir_arg):\n result = None\n\n try:\n with open(file_dir_arg, 'r', encoding='UTF-8-SIG') as f:\n result_tmp = f\n result = load(result_tmp)\n except Exception as e:\n print(e.args)\n\n return result",
"... | [
"0.7544937",
"0.7363082",
"0.73162645",
"0.72307235",
"0.7181808",
"0.71382374",
"0.7113364",
"0.70853007",
"0.70266354",
"0.69306314",
"0.691841",
"0.691532",
"0.68940663",
"0.6885171",
"0.68603086",
"0.6775327",
"0.67621076",
"0.67301583",
"0.67107904",
"0.67107904",
"0.667... | 0.67135817 | 18 |
Return a dict of movies | def _get_movies(self):
return self.data_file['movies'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def movie(response):\n\n response = response.json()\n\n if response.get(\"Error\"):\n raise NotFoundError(response[\"Error\"])\n\n if response[\"Type\"] != \"movie\":\n raise NotFoundError(\"Type is {}, should be movie\".format(response[\"Type\"]))\n\n return [OrderedDict([(\"Title\", res... | [
"0.7980709",
"0.7636093",
"0.74719363",
"0.7403664",
"0.72688943",
"0.72571814",
"0.7191314",
"0.71716154",
"0.7170183",
"0.7166868",
"0.7152478",
"0.7132814",
"0.71075296",
"0.7104493",
"0.7102627",
"0.7031748",
"0.7017451",
"0.69132686",
"0.68304396",
"0.68285877",
"0.68104... | 0.7347992 | 4 |
Create DataFrame including rating 5 for all watched movies and split to row each movie_id by user | def _normalize_dataset(self):
new_data = []
columns = ['user_id', 'movie_id', 'rating']
for line in self.data_file['users']:
movies_by_user = [
{'user_id': line['user_id'], 'movie_id': movie_id, 'rating': 5}
for movie_id in line['movies']
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def movielens_20m_to_df(ratings_file, movies_file):\n ratings_names = ['user_id', 'movie_id', 'rating', 'unix_timestamp']\n ratings_delim = ','\n\n movies_names = [ 'movie_id', 'movie_title', 'genres']\n movies_delim = ','\n encoding = 'utf-8'\n engine = 'python'\n\n ratings_df = pd.read_csv(r... | [
"0.7226439",
"0.6808683",
"0.66778433",
"0.65288967",
"0.6355954",
"0.63107824",
"0.62635416",
"0.62023175",
"0.6157416",
"0.6135076",
"0.6127724",
"0.61078817",
"0.610165",
"0.60978687",
"0.60910624",
"0.60819",
"0.60430026",
"0.6031244",
"0.6009129",
"0.6004356",
"0.5994962... | 0.71923757 | 1 |
Read a normalized dataset and create a sparse matrix containing the ratings | def _get_sparse_data(self):
data = self._normalize_dataset()
n_users = data.user_id.unique().shape[0]
n_movies = data.movie_id.unique().shape[0]
ratings = np.zeros((n_users, n_movies))
for row in data.itertuples():
ratings[row[1]-1, row[2]-1] = row[3]
retur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_data(filename):\n # read in triples of itemID/userID/playcount from the input dataset\n data = pandas.read_table(filename,\n usecols=[0, 1, 2],\n header=0,\n delimiter=',')\n\n # map each userID and itemID to a un... | [
"0.67880994",
"0.6689617",
"0.6406892",
"0.63348025",
"0.63336885",
"0.6284135",
"0.6262106",
"0.6207071",
"0.61706823",
"0.6128356",
"0.61157274",
"0.6012887",
"0.60104775",
"0.5936172",
"0.58552825",
"0.5835682",
"0.5825443",
"0.5810967",
"0.57736486",
"0.5751358",
"0.57505... | 0.7752622 | 0 |
Return a list of k recommended movies | def _get_top_k_movies(self, similarity, movie_id, k):
return [
self._get_movies()[str(x+1)]
for x in np.argsort(similarity[movie_id-1,:])[:-k-1:-1]
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_similar_movies(movie_title, k=500, show_distance=False):\n movie_id = ratings.tconst_gender[ratings.primaryTitle == movie_title].unique()[0]\n\n neighbour_ids = []\n \n movie_ind = movie_mapper[movie_id]\n movie_vec = X[movie_ind]\n k+=1\n \n \n if isinstance(movie_vec, (np.ndar... | [
"0.6969492",
"0.6910933",
"0.6792513",
"0.6524257",
"0.64092964",
"0.63887626",
"0.63844305",
"0.6354006",
"0.6342225",
"0.62963384",
"0.61361873",
"0.6134131",
"0.61273575",
"0.6064123",
"0.60433394",
"0.6024817",
"0.6016986",
"0.5957066",
"0.5895713",
"0.58880854",
"0.58761... | 0.69542474 | 1 |
Get a path in obj using dot notation e.g. | def get(obj, path):
right = path
cur = obj
while right:
left, right = partition(right)
if isinstance(cur, dict):
cur = cur.get(left)
elif isinstance(cur, (list, tuple)):
left = int(left)
cur = cur[left] if left < len(cur) else None
return cur | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getPath(obj):",
"def _getattr_path(obj: Any, path: str) -> Any:\n if not path:\n return None\n\n for attr in path.split('.'):\n obj = getattr(obj, attr, None)\n return obj",
"def get_obj_path(self, part):\n part_dictionary = self.part_reference.get(part, {})\n return pa... | [
"0.77900285",
"0.7466982",
"0.6943296",
"0.6742843",
"0.6567812",
"0.65178466",
"0.64945525",
"0.64223164",
"0.6420281",
"0.6415424",
"0.630857",
"0.6302559",
"0.627037",
"0.62387717",
"0.62387717",
"0.62183905",
"0.6154021",
"0.61336106",
"0.612455",
"0.6106036",
"0.61015236... | 0.5538838 | 59 |
A small utility function that check if the provided string is either None, '', or just a string containing only spaces | def is_empty(val):
return val in [None, ''] or val.isspace() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_empty(string):\n return string == None or re.sub(\"\\\\s+\", \"\", string) == \"\"",
"def is_null_or_empty(string_val):\n if string_val and string_val.strip():\n return False\n return True",
"def is_str_none_or_empty(val):\n if val is None:\n return True\n if isinstance(val,... | [
"0.8237053",
"0.8124945",
"0.8037569",
"0.79108196",
"0.7764869",
"0.7685698",
"0.75816345",
"0.7575924",
"0.7477997",
"0.74721014",
"0.7454891",
"0.74143285",
"0.7358262",
"0.7233534",
"0.7226879",
"0.7201261",
"0.71897626",
"0.7131125",
"0.70505905",
"0.69395953",
"0.693698... | 0.77871525 | 4 |
Path helper that allows passing a Falcon resource instance. | def path_helper(self, operations, resource, base_path=None, suffix=None, **kwargs):
resource_uri_mapping = self._generate_resource_uri_mapping(self._app, resource, suffix)
if not resource_uri_mapping:
raise APISpecError("Could not find endpoint for resource {0}".format(resource))
o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ResourcePath(self, name):\n pass",
"def url_for(self, resource, **kwargs):\n if self.blueprint:\n return flask.url_for('.' + resource.endpoint, **kwargs)\n return flask.url_for(resource.endpoint, **kwargs)",
"def resource_path(self, resource):\n # type: (Text) -> Text\n ... | [
"0.7092943",
"0.64470416",
"0.6124915",
"0.61037254",
"0.6059727",
"0.60153484",
"0.60153484",
"0.5925138",
"0.5862211",
"0.58476615",
"0.5824537",
"0.5791158",
"0.5787645",
"0.57799727",
"0.57234704",
"0.56219244",
"0.5615395",
"0.5613724",
"0.5561888",
"0.55315953",
"0.5498... | 0.50513184 | 83 |
This function will download a zip file to disk | def download_zip(url, folder=None):
# get this file folder name and save the file name
if not folder:
folder = os.path.dirname(os.path.abspath(__file__))
file_name = os.path.split(url)[1]
# Download the file from "url" and save it locally under "file_name":
try:
with urllib.request... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download():\n response = requests.get(URL, stream=True)\n\n file = open(FILE_NAME, 'wb')\n file.write(response.content)\n\n with zipfile.ZipFile(FILE_NAME, 'r') as zip_ref:\n zip_ref.extractall()\n\n file.close()\n os.remove(FILE_NAME)",
"def download_zip(self, path: Path) -> Path:\n... | [
"0.8009424",
"0.77010745",
"0.76116294",
"0.7511597",
"0.7493036",
"0.73734725",
"0.7276599",
"0.7226754",
"0.7219494",
"0.71844345",
"0.7077965",
"0.6991962",
"0.6977651",
"0.6972263",
"0.69692117",
"0.6968815",
"0.69383264",
"0.69306594",
"0.6927575",
"0.68889254",
"0.68497... | 0.74428934 | 5 |
Check the folder contains the three mandatory files with extension .shp, .dbf,.dbf Also check there is only 1 shapefile and this is a polygon type | def check_shapefile(folder):
'''
Value | Shape Type
0 | Null Shape
1 | Point
3 | PolyLine
5 | Polygon
8 | MultiPoint
11 | PointZ
13 | PolyLineZ
15 | PolygonZ
18 | MultiPointZ
21 | PointM
23 | PolyLineM
25 | PolygonM
28 | MultiPointM
31 | MultiPatch
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validFiles(self, files):\n for myfile in files:\n if not ( ( myfile.get_uri_scheme() == 'file' ) or \\\n ( myfile.get_uri_scheme() == 'smb' ) ):\n return False\n elif ( not myfile.get_mime_type() in self.oootypes ) and \\\n ( not myfile.... | [
"0.61982626",
"0.61947924",
"0.6175953",
"0.6119851",
"0.6091015",
"0.59931964",
"0.59807795",
"0.58886826",
"0.5863063",
"0.5850182",
"0.5840579",
"0.58361673",
"0.5823537",
"0.5823537",
"0.5823537",
"0.5808097",
"0.5795179",
"0.5784716",
"0.5771951",
"0.5764534",
"0.5762427... | 0.839037 | 0 |
Check if the table exercise.states is already in the database | def check_table(schemaname=settings.DEFAULT_SCHEMA, tablename=settings.STATES):
conn = None
cur = None
try:
conn = utils.pgconnect(**settings.DEFAULT_CONNECTION)
cur = conn.cursor()
cur.execute("""SELECT to_regclass('%s.%s');""", (AsIs(schemaname), AsIs(tablename)))
result... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_dont_save(self):\n self.assertFalse(State.objects.exists())",
"def check_state_exist(state, qmatrix, numb_actions):\n\n if state not in qmatrix.index:\n # append new state to q table\n qmatrix = qmatrix.append(\n pd.Series(\n [0]*numb_actions,\n ... | [
"0.648905",
"0.6143901",
"0.5890334",
"0.5871307",
"0.5857106",
"0.58300877",
"0.5784326",
"0.57831377",
"0.5780546",
"0.5768868",
"0.5703022",
"0.56957126",
"0.5691821",
"0.5673148",
"0.56472707",
"0.5634992",
"0.5631963",
"0.55954576",
"0.55925184",
"0.55847996",
"0.5574546... | 0.0 | -1 |
Upload file to database | def upload_shape(shapepath):
conn = None
cur = None
try:
# first create the sqlstring with inserts
# call PGSQL2SHP with some parameters, -s 4326 to set lat/lon srid, -I to create a spatial index on the geometry column
params = [settings.SHP2PGSQL, "-s", "4326", "-I", shapepath, se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upload(self, filename, file_path):\n return",
"def post(self):\n source = 'uploaded by user'\n upload_files = self.get_uploads('file')\n blob_key = upload_files[0].key()\n name = self.request.get('name')\n\n user = users.get_current_user()\n\n username = 'admi... | [
"0.7485169",
"0.67197865",
"0.6597614",
"0.65940464",
"0.65767515",
"0.65479946",
"0.6543065",
"0.6538194",
"0.6514985",
"0.6437462",
"0.64294904",
"0.64249825",
"0.64084154",
"0.6353266",
"0.6352745",
"0.6331172",
"0.6331049",
"0.6325633",
"0.6307132",
"0.6279385",
"0.626583... | 0.0 | -1 |
Check the user input for a point, if inside USA, if OK add it to the database Crop nummber to 4 digits, define the marker size based on the bigger number of digits | def upload_point(x, y, label=""):
conn = None
cur = None
try:
# check the point is inside the usa, both point and states must be WGS84
conn = utils.pgconnect(**settings.DEFAULT_CONNECTION)
cur = conn.cursor()
#if the point is inside this will return (True,) otherwise None
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_latitude(self):\n lLatitude = self.cleaned_data['latitude']\n if lLatitude:\n lValue = lLatitude.strip()\n if lValue:\n lRegEx = re.compile(CO_ORD_REGEX)\n if lRegEx.match(lValue) == None:\n raise forms.ValidationError(\... | [
"0.56233335",
"0.55526364",
"0.5320986",
"0.5181115",
"0.51509035",
"0.51473725",
"0.5142715",
"0.5123412",
"0.50627816",
"0.5056026",
"0.505146",
"0.49788797",
"0.49679402",
"0.48976582",
"0.48737523",
"0.4873513",
"0.48673427",
"0.48661628",
"0.48638946",
"0.48234263",
"0.4... | 0.6816568 | 0 |
Return the epsg code for a shapefile | def get_epsg(path):
dataset = None
layer = None
srs = None
try:
driver = ogr.GetDriverByName('ESRI Shapefile')
dataset = driver.Open(path, 0) # 0 means read-only
layer = dataset.GetLayer()
srs = layer.GetSpatialRef()
#Set EPSG authority info if possible.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _epsg(self):\n info = self._info['coordinateSystem']['wkt'].rsplit('\"EPSG\",', 1)[-1]\n return int(re.findall(r\"\\d+\", info)[0])",
"def s2_epsg_code(self):\n ul, lr = self.ul_lr\n epsg_old = self.epsg\n if epsg_old != 4326:\n lon, lat = ImageIO.transform_point... | [
"0.607808",
"0.6057351",
"0.5858668",
"0.57926476",
"0.5748241",
"0.56743056",
"0.5667732",
"0.5608399",
"0.5567314",
"0.552981",
"0.5460044",
"0.5319938",
"0.53048986",
"0.5285746",
"0.5281998",
"0.52689594",
"0.52610826",
"0.5208903",
"0.5187333",
"0.5187333",
"0.5178785",
... | 0.7115192 | 0 |
reproject a vector file (only the first layer!) (it does not save the dataset to disk) | def reproject_vector( path, epsg_from=None, epsg_to=None):
if not epsg_to: raise Exception("please, specify the output EPSG codes")
inDataSet = None
outDataSet = None
inFeature = None
outFeature = None
outLayer = None
try:
driver = ogr.GetDriverByName('ESRI Shapefile')
in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reprojectAndSaveNewRaster(inFilepath,outFilepath,to_EPSG):\r\n from osgeo import gdal\r\n input_raster = gdal.Open(inFilepath)\r\n EPSG_string = \"EPSG:\"+str(to_EPSG)\r\n ras = gdal.Warp(outFilepath,input_raster,dstSRS=EPSG_string)\r\n del ras",
"def reprojectAndSaveNewShapefile(inFilepath,ou... | [
"0.62399775",
"0.6226501",
"0.58857656",
"0.58182466",
"0.56765485",
"0.56583333",
"0.5608022",
"0.5603202",
"0.56001997",
"0.5566788",
"0.5521875",
"0.5514971",
"0.5509281",
"0.5441147",
"0.54357195",
"0.54265714",
"0.54211587",
"0.54107004",
"0.54107004",
"0.5363864",
"0.53... | 0.6866187 | 0 |
save an ogr dataset to disk, (it will delete preexisting output) | def save_vector(dataset, outpath, driver=None):
try:
if not driver:
driver = dataset.GetDriver()
if os.path.exists(outpath):
driver.DeleteDataSource(outpath)
dst_ds = driver.CopyDataSource(dataset, outpath)
else:
driver = ogr.GetDriverB... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self, output, data):",
"def save_dataset(self):\n if self.res_dataset is None:\n return\n if self.write_path is None:\n raise Exception(\"Error: Attempted to save result dataset without ever specifiying a path to write to\")\n\n if self.format == \"arrow\":\n ... | [
"0.67794627",
"0.6754343",
"0.670547",
"0.6607585",
"0.6588637",
"0.6580151",
"0.65534836",
"0.6546951",
"0.65442836",
"0.6486838",
"0.64590806",
"0.6428214",
"0.6412291",
"0.6402253",
"0.63978577",
"0.63953197",
"0.63748604",
"0.6364255",
"0.63512546",
"0.6345753",
"0.633221... | 0.6346837 | 19 |
Return html class fragment for the marker size | def get_class_size(size):
s = 'fa-lg'
if size == 1:
s = 'fa-lg'
elif size == 2:
s = 'fa-2x'
elif size == 3:
s = 'fa-3x'
elif size == 4:
s = 'fa-4x'
elif size == 5:
s = 'fa-5x'
return s | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_marker_size(self, marker_id: int) -> int:\n if marker_id in range(0, 40):\n # WALL_MARKER\n return 250\n else:\n return 100",
"def marker_size(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"marker_size\")",
"def marker_size(self) ... | [
"0.60135067",
"0.58254164",
"0.58254164",
"0.58254164",
"0.5667613",
"0.56253487",
"0.56235933",
"0.561359",
"0.556173",
"0.55141217",
"0.5447288",
"0.5412233",
"0.5396221",
"0.5358953",
"0.5335299",
"0.52983207",
"0.5272478",
"0.5263561",
"0.5260405",
"0.5251097",
"0.5245471... | 0.66643053 | 0 |
Add one point to the map | def add_point(map, x, y, size, label, marker=settings.MARKER, color=settings.MARKER_COLOR):
s = get_class_size(size)
folium.map.Marker(
location=[y, x],
popup=label,
icon=DivIcon(
#icon_size=(150,36),
icon_anchor=(0,0),
html='<i class="fa '+marker+'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addPoint(self, point):\n self.points.append(point)",
"def add(self, point):\n self.points.append(point)",
"def add_point(self, pt):\n self.points.append(pt)",
"def add_point(self, x: int, y: int):\n self.state[x, y] = 1",
"def add_point(self, x: int, y: int):\n self.s... | [
"0.74777544",
"0.7411591",
"0.7302735",
"0.717282",
"0.717282",
"0.717282",
"0.7149496",
"0.7075055",
"0.7043802",
"0.70243937",
"0.70046866",
"0.70044357",
"0.695466",
"0.68703127",
"0.67992646",
"0.67937094",
"0.67550814",
"0.6747055",
"0.67115504",
"0.6681633",
"0.66295254... | 0.62047684 | 33 |
Add all the points to the map | def add_all_points(map, marker=settings.MARKER,color=settings.MARKER_COLOR):
conn = None
curr = None
try:
conn = utils.pgconnect(**settings.DEFAULT_CONNECTION)
cur = conn.cursor()
# if the point is inside this will return (True,) otherwise None
cur.execute("""select lon, la... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_points(self):\n if not '_list_of_points' in self.__dict__.keys():\n self._list_of_points = [] \n for point in self['point'].items():\n self._list_of_points.append(point[1])",
"def add_points(self, points):\n pass",
"def addPoints(self, points):\r\n ... | [
"0.75577456",
"0.7388146",
"0.71856815",
"0.70756197",
"0.6748661",
"0.6737908",
"0.6710255",
"0.6566786",
"0.63640326",
"0.625198",
"0.6170082",
"0.61540735",
"0.6121445",
"0.6118305",
"0.6111104",
"0.60829985",
"0.6074091",
"0.6047287",
"0.6039132",
"0.6033827",
"0.6010885"... | 0.6955612 | 4 |
Save the html page | def save_map(map, name="index.html", folder=None):
if not folder:
folder = os.path.dirname(os.path.abspath(__file__))
map.save(folder + "/" + name)
return folder + "/" + name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self):\n html_file = '{}/{}.html'.format(self.web_dir, self.title)\n f = open(html_file, 'wt')\n f.write(self.doc.render())\n f.close()",
"def save(self, filename):\n outfile = open(filename, \"w\")\n outfile.write(self.html.encode('utf8'))\n outfile.clos... | [
"0.8319438",
"0.7728037",
"0.7694331",
"0.72064406",
"0.71366906",
"0.709866",
"0.7074866",
"0.70236087",
"0.7007957",
"0.69596565",
"0.69420594",
"0.6893396",
"0.6817857",
"0.6797137",
"0.6697725",
"0.6678388",
"0.6662395",
"0.6651914",
"0.662725",
"0.66001976",
"0.65727824"... | 0.0 | -1 |
Download geojson from the database | def get_geojson():
# check the file was already downloaded
global GEOJSON
if GEOJSON: return GEOJSON
conn = None
cur = None
try:
conn = utils.pgconnect(**settings.DEFAULT_CONNECTION)
cur = conn.cursor()
cur.execute( """SELECT row_to_json(fc) FROM
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_allpoints_geojson():\n\n # check the file was already downloaded\n global GEOJSON\n if GEOJSON: return GEOJSON\n\n conn = None\n cur = None\n try:\n\n conn = utils.pgconnect(**settings.DEFAULT_CONNECTION)\n cur = conn.cursor()\n cur.execute( \"\"\"SELECT row_to_jso... | [
"0.7075735",
"0.6992949",
"0.6549768",
"0.64688873",
"0.63209444",
"0.62644655",
"0.6259451",
"0.6221336",
"0.61216295",
"0.6098716",
"0.60747683",
"0.6071885",
"0.6071885",
"0.6039488",
"0.59665906",
"0.5948892",
"0.5944469",
"0.58469725",
"0.58332884",
"0.58315897",
"0.5820... | 0.7378575 | 0 |
Download geojson from the database | def get_allpoints_geojson():
# check the file was already downloaded
global GEOJSON
if GEOJSON: return GEOJSON
conn = None
cur = None
try:
conn = utils.pgconnect(**settings.DEFAULT_CONNECTION)
cur = conn.cursor()
cur.execute( """SELECT row_to_json(fc) FROM
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_geojson():\n\n # check the file was already downloaded\n global GEOJSON\n if GEOJSON: return GEOJSON\n\n conn = None\n cur = None\n try:\n\n conn = utils.pgconnect(**settings.DEFAULT_CONNECTION)\n cur = conn.cursor()\n cur.execute( \"\"\"SELECT row_to_json(fc) FROM... | [
"0.7378575",
"0.6992949",
"0.6549768",
"0.64688873",
"0.63209444",
"0.62644655",
"0.6259451",
"0.6221336",
"0.61216295",
"0.6098716",
"0.60747683",
"0.6071885",
"0.6071885",
"0.6039488",
"0.59665906",
"0.5948892",
"0.5944469",
"0.58469725",
"0.58332884",
"0.58315897",
"0.5820... | 0.7075735 | 1 |
Add a geojson layer to the map | def add_geojson(map, geojson, style_function, name='states' ):
folium.GeoJson(
geojson,
name=name,
style_function=style_function
).add_to(map) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def geojson(self, feature_id):\n lat, lon = self.lat_lon\n return {\n 'type': 'Feature',\n 'id': feature_id,\n 'geometry': {\n 'type': 'Point',\n 'coordinates': (lon, lat),\n },\n }",
"def add_layer(self, layer):\n ... | [
"0.6588062",
"0.6515679",
"0.63336873",
"0.629631",
"0.6243965",
"0.62241894",
"0.621897",
"0.6132847",
"0.6105182",
"0.60940987",
"0.60355663",
"0.6014956",
"0.60060114",
"0.59752184",
"0.595699",
"0.5950891",
"0.5879442",
"0.5840097",
"0.5835999",
"0.57998115",
"0.57890666"... | 0.81856084 | 0 |
Open a web page with a browser | def browser(path, driver='chrome'):
if driver=='chrome':
driver = webdriver.Chrome()
elif driver=='firefox':
driver = webdriver.Firefox()
elif driver=='edge':
driver = webdriver.Edge()
else:
raise Exception("driver "+driver+ " is not supported")
driver.get("file:///... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open(url):\r\n webbrowser.open(url)",
"def open_browser(url):\n import webbrowser\n webbrowser.open_new(url)",
"def open_web_browser(url: str):\n Popen(web_browser + [url], stdout=DEVNULL, stderr=DEVNULL)",
"def open_webpage(browser, url, case, version, package):\n browser_obj = Br... | [
"0.8613281",
"0.848614",
"0.8462892",
"0.82772714",
"0.82674664",
"0.8137916",
"0.80658793",
"0.7961011",
"0.78403914",
"0.7771977",
"0.76969564",
"0.75432944",
"0.7518848",
"0.7514928",
"0.74260086",
"0.7413997",
"0.740391",
"0.73336726",
"0.7288364",
"0.7193673",
"0.713086"... | 0.0 | -1 |
Save screenshot at 200dpi in jpeg format | def save_image(driver, outname="states.jpeg", folder=None):
# set the output folder
if not folder:
folder = os.path.dirname(os.path.abspath(__file__))
# get thescreenshot
binary = driver.get_screenshot_as_png()
stream = io.BytesIO(binary)
# save screenshot in jpeg format
img = Ima... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def take_screenshot(x, y, num=''):\n # screenshot takes starting x,y coordinates and then for how far the shot should stretch\n pic = pyautogui.screenshot(region=(0, y * 1.3, x * 0.75, y * 0.6))\n pic.save(\"Screenshot\" + str(num) + \".png\")",
"def save_screenshot(self, file_name, width=3840, height=2... | [
"0.66062033",
"0.6598681",
"0.6575226",
"0.65645045",
"0.63658035",
"0.6315379",
"0.6276598",
"0.6272334",
"0.62493837",
"0.62134916",
"0.61662805",
"0.6145819",
"0.6117371",
"0.60789603",
"0.606364",
"0.604557",
"0.6026516",
"0.60236925",
"0.5961424",
"0.59462416",
"0.594418... | 0.6444463 | 4 |
This node specifies the matrix predicted based on fixed effect covariates `covs`, and weights the resulting matrix by 1/sigma^2. | def __init__(self, covs, sigma):
assert isinstance(sigma, int)
assert covs.ndim == 3
assert sigma > 0.0
self.covs = covs
self.sigma = sigma
self.num_covs = self.covs.shape[0]
self.shape = self.covs.shape[1:]
self.covs_mat = self.covs.reshape(self.num_covs... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def map_predict(self, z0, z1, f0, f1):\n assert f0.shape[1] == z0.shape[1] and f1.shape[1] == z1.shape[1]\n\n C = self.cpred(z0, z1, f0, f1)\n\n if self.do_w:\n \"\"\"\n Previous formulation: \n \n x1 = -1 (([1 .... N] + 1 - (N+1)/2) / ((N+1)/2)) ** ... | [
"0.546343",
"0.532194",
"0.5314906",
"0.527502",
"0.5240777",
"0.50803566",
"0.50351626",
"0.50257665",
"0.50079376",
"0.50065464",
"0.49888334",
"0.49851385",
"0.49808347",
"0.4975273",
"0.49522257",
"0.49129495",
"0.4907197",
"0.48811004",
"0.48783505",
"0.48605442",
"0.485... | 0.51133114 | 5 |
Predicts the matrix using the covariates in self.covs_mat with the updated coefficients stored in self.alpha. | def predict_mat(self):
mat = self.covs_mat.dot(self.alpha)
return mat.reshape(self.shape) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_params(self, mat):\n assert mat.shape == self.shape\n vec = mat.reshape(mat.size)\n self.alpha = np.linalg.solve(self.covs_mat.T.dot(self.covs_mat),\n self.covs_mat.T.dot(vec))",
"def predict_mat(self):\n return self.u.dot(self.v.T)",
"... | [
"0.6490651",
"0.60074425",
"0.6004628",
"0.599036",
"0.58364904",
"0.57246894",
"0.57134897",
"0.570626",
"0.56881577",
"0.5673695",
"0.56713176",
"0.56486166",
"0.5626255",
"0.5538134",
"0.54957855",
"0.5484796",
"0.54656494",
"0.54615617",
"0.5460596",
"0.54546833",
"0.5441... | 0.73345226 | 0 |
Estimates the coefficients on the covariates and thereby updates the matrix parameters. Estimation done by least squares. | def update_params(self, mat):
assert mat.shape == self.shape
vec = mat.reshape(mat.size)
self.alpha = np.linalg.solve(self.covs_mat.T.dot(self.covs_mat),
self.covs_mat.T.dot(vec)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_coefficients(self):\n self.make_matrix()\n self.coeffs = np.linalg.solve(self.global_matrix,self.global_vector)\n self.coeffs = np.append(self.coeffs, self.D) #Initial condition",
"def _set_coefficients(self, user_defined_coefficients=None):\n # Check to ensure that if there... | [
"0.68213785",
"0.6568729",
"0.650561",
"0.63846326",
"0.6240839",
"0.60767925",
"0.60576737",
"0.6055638",
"0.5992137",
"0.5891918",
"0.5859752",
"0.58514315",
"0.58382076",
"0.5834185",
"0.58303267",
"0.5815064",
"0.58032453",
"0.5801474",
"0.5786988",
"0.57689154",
"0.57507... | 0.65043694 | 3 |
This node matches the predicted matrix with the observed data, but "masks" predicted matrix so that we are only using entries that were actually observed from the matrix. Weights the resulting matrix by 1/sigma^2. | def __init__(self, mask, data, sigma):
assert isinstance(sigma, int)
assert sigma > 0.0
assert isinstance(mask, utils.Mask)
assert isinstance(data, np.ndarray)
assert mask.size == data.size
self.mask = mask
self.data = data
self.sigma = sigma
self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self, masked_data, masked_binary_data):\n # Use the loaded model to perform missing value prediction.\n # concatenate multiple students' knowledge state into a matrix of shape (num_students, num_concepts)\n predicted_states = []\n for u in range(len(self.model.mrfs)):\n ... | [
"0.56636155",
"0.5445435",
"0.53317714",
"0.5287088",
"0.5251721",
"0.52371836",
"0.52243984",
"0.51921326",
"0.518488",
"0.51842225",
"0.51705045",
"0.51641315",
"0.51526016",
"0.50631",
"0.5036301",
"0.50272423",
"0.50238395",
"0.5009977",
"0.4998374",
"0.49955526",
"0.4993... | 0.47924504 | 60 |
This node specifies a lowrank structure with rank `rank` for the predicted matrix. Weights the resulting matrix by 1/sigma^2. | def __init__(self, shape, rank, sigma):
assert isinstance(sigma, int)
assert sigma > 0.0
assert isinstance(shape, tuple)
assert isinstance(rank, int)
assert rank > 0
assert rank <= min(*shape)
self.shape = shape
self.rank = rank
self.sigma = sigma
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_optimal_low_rank_matrix( self, orig_similarity_matrix, orig_rank, u, s, v, singular_reduction ):\n '''rank_list = list()\n sum_singular_values = list()\n for rank in range( 0, orig_rank ):\n compute_result = self.compute_low_rank_matrix( u, s, v, rank + 1 )\n ran... | [
"0.59534043",
"0.5852097",
"0.5795221",
"0.56463134",
"0.55684614",
"0.55317307",
"0.5511257",
"0.53647435",
"0.53025186",
"0.52452224",
"0.5243477",
"0.52426994",
"0.520438",
"0.51970804",
"0.5141929",
"0.5132518",
"0.51169837",
"0.51121306",
"0.5107999",
"0.50937647",
"0.50... | 0.5629263 | 4 |
Gives the full predicted matrix based on the low rank u and v. | def predict_mat(self):
return self.u.dot(self.v.T) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_low_rank_matrix( self, u, s, v, rank ):\n u_approx = u[ :, :rank ]\n s_approx = s[ :rank ]\n sum_taken_percent = np.sum( s_approx ) / float( np.sum( s ) )\n s_approx = np.diag( np.array( s_approx ) )\n v_approx = v[ :rank, : ]\n return [ u_approx.dot( s_approx ... | [
"0.68731123",
"0.6112549",
"0.60515124",
"0.60183614",
"0.5982911",
"0.5939187",
"0.58090305",
"0.57974684",
"0.578775",
"0.574525",
"0.5728702",
"0.5567461",
"0.5479815",
"0.54721326",
"0.54661137",
"0.5449834",
"0.54436517",
"0.541722",
"0.54135686",
"0.5375098",
"0.5369013... | 0.7002625 | 0 |
Updates the low rank structure of self.u and self.v based on the `mat` input. Performs singular value decomposition on the matrix and selects the last `self.rank` entries. | def update_params(self, mat):
assert mat.shape == self.shape
a, s, b = np.linalg.svd(mat, full_matrices=False)
self.u = a[:, :self.rank]*s[:self.rank]
self.v = b.T[:, :self.rank] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_optimal_low_rank_matrix( self, orig_similarity_matrix, orig_rank, u, s, v, singular_reduction ):\n '''rank_list = list()\n sum_singular_values = list()\n for rank in range( 0, orig_rank ):\n compute_result = self.compute_low_rank_matrix( u, s, v, rank + 1 )\n ran... | [
"0.6372859",
"0.55725044",
"0.55620676",
"0.55460334",
"0.5260916",
"0.5249304",
"0.51922536",
"0.5169905",
"0.51028615",
"0.5082861",
"0.5073029",
"0.50590885",
"0.5045953",
"0.49488217",
"0.49206302",
"0.49198195",
"0.49189126",
"0.49091235",
"0.4873962",
"0.4863568",
"0.48... | 0.7536742 | 0 |
This is f's docstring. | def f(x, y, z=3):
pass # pragma: nocover | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def func_doc():",
"def __doc__(self, ???):",
"def __doc__(self):\n return self.fget.__doc__",
"def DocString():\n return",
"def docstring_hack():\n pass",
"def main_docstring():",
"def _add_doc(func, doc):\r\n func.__doc__ = doc",
"def _add_doc(func, doc):\r\n func.__doc__ = do... | [
"0.79845726",
"0.73985684",
"0.73007876",
"0.7260358",
"0.72601354",
"0.7231814",
"0.7113083",
"0.7113083",
"0.7113083",
"0.7067614",
"0.70261246",
"0.69841033",
"0.6801731",
"0.67647177",
"0.66249096",
"0.6610375",
"0.66060334",
"0.6599858",
"0.6567463",
"0.6557377",
"0.6538... | 0.0 | -1 |
Test getting an analysis when it exists in the database. | def test_get_analysis_with_id(analysis_store: MockStore):
# GIVEN a store with an analysis
existing_analysis: Analysis = analysis_store.get_query(table=Analysis).first()
# WHEN accessing it by ID
analysis: Analysis = analysis_store.get_analysis_with_id(analysis_id=existing_analysis.id)
# THEN it s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_analysis_with_id_when_missing(analysis_store: MockStore):\n # GIVEN an id that doesn't exist\n missing_analysis_id = 12312423534\n\n # WHEN accessing the analysis\n analysis: Analysis = analysis_store.get_analysis_with_id(analysis_id=missing_analysis_id)\n\n # THEN it should return None... | [
"0.67521673",
"0.64993656",
"0.6392804",
"0.6276373",
"0.62410223",
"0.62198424",
"0.61320305",
"0.6044973",
"0.60429484",
"0.6037851",
"0.60214347",
"0.600699",
"0.59700125",
"0.5969135",
"0.593259",
"0.5906568",
"0.5866727",
"0.5863172",
"0.5861047",
"0.5857293",
"0.584378"... | 0.6659734 | 1 |
Test getting an analysis when it does not exist in the database. | def test_get_analysis_with_id_when_missing(analysis_store: MockStore):
# GIVEN an id that doesn't exist
missing_analysis_id = 12312423534
# WHEN accessing the analysis
analysis: Analysis = analysis_store.get_analysis_with_id(analysis_id=missing_analysis_id)
# THEN it should return None
assert ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_no_one_in_db(self):\n q = self.generate_query('view_manager_report', ())\n res = self.execute_query(q)\n expected = []\n assert len(res) == 0, f'There is suppose to be an empty summary {res}'\n assert res == expected, f'The result is suppose to be empty {res}'",
"def t... | [
"0.6867313",
"0.6787145",
"0.64357316",
"0.6329981",
"0.62323785",
"0.6220911",
"0.6134222",
"0.6128569",
"0.6122037",
"0.60938495",
"0.60938495",
"0.6075478",
"0.60506773",
"0.6032781",
"0.6021422",
"0.6012929",
"0.60125285",
"0.60118175",
"0.60108805",
"0.6007062",
"0.59906... | 0.7349075 | 0 |
Test getting the number of failed jobs per category since a supplied date from the database. | def test_get_nr_jobs_with_status_per_category(job_store: MockStore, timestamp_yesterday: datetime):
# GIVEN a database with jobs
# WHEN querying for failed users
failed_jobs: List[Dict[str, Union[str, int]]] = job_store.get_nr_jobs_with_status_per_category(
since_when=timestamp_yesterday, status=Tr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_error_category(self):\n\n error = error_test_utils.create_error(category='DATA')\n job = job_test_utils.create_job(error=error)\n\n url = '/%s/jobs/?error_category=%s' % (self.api, error.category)\n response = self.client.generic('GET', url)\n self.assertEqual(response.s... | [
"0.5813953",
"0.5470477",
"0.5436561",
"0.5431106",
"0.5430519",
"0.5358405",
"0.5351436",
"0.5340761",
"0.5265007",
"0.52533865",
"0.52142894",
"0.51785016",
"0.512772",
"0.50592387",
"0.50564986",
"0.5048593",
"0.50406694",
"0.5030915",
"0.5024704",
"0.5023085",
"0.50163347... | 0.7530706 | 0 |
Test getting a user from the database. | def test_get_user(user_store: MockStore, user_email: str):
# GIVEN a database with a user
# WHEN querying for a user
user: User = user_store.get_user(email=user_email)
# THEN it should be returned
assert user.email == user_email | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testGetUser(self):\n UserAPI().create([(u'user', u'secret', u'User', u'user@example.com')])\n user = getUser(u'user')\n self.store.commit()\n with login(u'fluiddb', self.admin.objectID, self.transact) as session:\n result = yield self.facade.getUser(session, u'user')\n ... | [
"0.80467415",
"0.8015131",
"0.7970524",
"0.7857167",
"0.782778",
"0.77688056",
"0.77514106",
"0.77355975",
"0.7696272",
"0.76695734",
"0.76617557",
"0.7623411",
"0.7619199",
"0.75815994",
"0.75701547",
"0.7553964",
"0.750348",
"0.7497086",
"0.74873877",
"0.7464809",
"0.746417... | 0.80435 | 1 |
Test getting an archived user from the database. | def test_get_user_including_archived(user_store: MockStore, archived_user_email: str):
# GIVEN a database with an archived user
# WHEN querying for a user
user: User = user_store.get_user(email=archived_user_email, exclude_archived=False)
# THEN it should be returned
assert user.email == archived_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_user_including_archive_false(user_store: MockStore, archived_user_email: str):\n # GIVEN a database with an archived user\n\n # WHEN querying for a user\n user: User = user_store.get_user(email=archived_user_email, exclude_archived=True)\n\n # THEN no user should be returned\n assert no... | [
"0.7456595",
"0.738311",
"0.65067285",
"0.6436026",
"0.63516873",
"0.62399125",
"0.6210579",
"0.62046766",
"0.617632",
"0.61279947",
"0.61279947",
"0.6096413",
"0.60939574",
"0.6072748",
"0.5998641",
"0.59969604",
"0.5986697",
"0.59809977",
"0.59688866",
"0.596384",
"0.595570... | 0.81311107 | 0 |
Test getting an archived user from the database. | def test_get_user_including_archive_false(user_store: MockStore, archived_user_email: str):
# GIVEN a database with an archived user
# WHEN querying for a user
user: User = user_store.get_user(email=archived_user_email, exclude_archived=True)
# THEN no user should be returned
assert not user | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_user_including_archived(user_store: MockStore, archived_user_email: str):\n # GIVEN a database with an archived user\n\n # WHEN querying for a user\n user: User = user_store.get_user(email=archived_user_email, exclude_archived=False)\n\n # THEN it should be returned\n assert user.email ... | [
"0.81330764",
"0.7385193",
"0.65025973",
"0.6442499",
"0.63574994",
"0.6246142",
"0.62167716",
"0.62109834",
"0.61833704",
"0.6133558",
"0.6133558",
"0.61013573",
"0.6095947",
"0.60781145",
"0.6004548",
"0.6003449",
"0.59916866",
"0.5984867",
"0.5974582",
"0.5968191",
"0.5961... | 0.7458577 | 1 |
Test getting a nonexisting user from the database. | def test_get_user_when_non_existing(user_store: MockStore):
# GIVEN a database with a user
# WHEN querying for a user that doesn't exist
user: User = user_store.get_user(email="this_is_a_made_up_email@fake_example.com")
# THEN it should return as None
assert user is None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_user_non_exist_id(self):\n print('(' + self.test_get_user_non_exist_id.__name__+')',\n self.test_get_user_non_exist_id.__doc__)\n self.assertIsNone(self.connection.get_user(NON_EXIST_PATIENT_USERNAME))",
"def test_get_bad_user(self):\r\n user = UserMgr.get(username=... | [
"0.856584",
"0.8538134",
"0.8256169",
"0.80339926",
"0.7959935",
"0.7942771",
"0.7879475",
"0.78456324",
"0.77836406",
"0.77539635",
"0.77476394",
"0.77425784",
"0.7734177",
"0.7665938",
"0.7625372",
"0.7607034",
"0.7594667",
"0.7572818",
"0.7503314",
"0.7482438",
"0.7456589"... | 0.8029911 | 4 |
Test getting a user with username and email. | def test_get_users(user_store: MockStore, user_email: str, username: str):
# GIVEN a database with a user
# WHEN getting users
users: List[User] = user_store.get_users(name=username, email=user_email)
# THEN the user should be returned
assert users[0].email == user_email | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_user_by_emailuser_email_get(self):\n pass",
"def test_get_user(user_store: MockStore, user_email: str):\n # GIVEN a database with a user\n\n # WHEN querying for a user\n user: User = user_store.get_user(email=user_email)\n\n # THEN it should be returned\n assert user.email == u... | [
"0.81518275",
"0.79463357",
"0.7895598",
"0.7859849",
"0.7718898",
"0.77024853",
"0.7650548",
"0.76115036",
"0.76060903",
"0.7491955",
"0.748591",
"0.74647605",
"0.7454479",
"0.74482834",
"0.74220383",
"0.7405741",
"0.73980224",
"0.7391085",
"0.73631626",
"0.73486465",
"0.734... | 0.7497986 | 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.