0:\n\t\t\t\tsub_iteration_str = '(' + '{0:02d}'.format(SUB_ITERATION_NUM) + ')'\n\t\t\tprint(' ', '{0:03d}'.format(ITERATION_NUM), sub_iteration_str, ':', log_likelihood * sign)\n\n\t\tSUB_ITERATION_NUM += 1\n\n\t\treturn sign * log_likelihood, sign * gradients"],"string":"[\n \"def infer_true_movie_ratings(num_observations=-1):\\n\\n M = 11 # all of our ratings are between 0 and 10\\n prior = np.array([1.0 / M] * M) # uniform distribution\\n likelihood = compute_movie_rating_likelihood(M)\\n\\n # get the list of all movie IDs to process\\n movie_id_list = movie_data_helper.get_movie_id_list()\\n num_movies = len(movie_id_list)\\n\\n # -------------------------------------------------------------------------\\n # YOUR CODE GOES HERE FOR PART (d)\\n #\\n # Your code should iterate through the movies. For each movie, your code\\n # should:\\n # 1. Get all the observed ratings for the movie. You can artificially\\n # limit the number of available ratings used by truncating the ratings\\n # vector according to num_observations.\\n # 2. Use the ratings you retrieved and the function compute_posterior to\\n # obtain the posterior of the true/inherent rating of the movie\\n # given the observed ratings\\n # 3. Find the rating for each movie that maximizes the posterior\\n\\n # These are the output variables - it's your job to fill them.\\n posteriors = np.zeros((num_movies, M))\\n MAP_ratings = np.zeros(num_movies)\\n \\n for i in range(num_movies):\\n movie_id = movie_id_list[i]\\n y = movie_data_helper.get_ratings(movie_id)[:num_observations]\\n posteriors[i] = compute_posterior(prior,likelihood,y)\\n MAP_ratings[i] = np.argmax(posteriors[i])\\n #\\n # END OF YOUR CODE FOR PART (d)\\n # -------------------------------------------------------------------------\\n print(posteriors,MAP_ratings)\\n return posteriors, MAP_ratings\",\n \"def likelihood_prediction():\\n # Get info\\n selected_word = prompt_tech_selection()\\n article_json = get_json_from_file()\\n\\n # Calculate results\\n total_word_counter, selected_word_counter = count_occurrences(article_json, selected_word)\\n probability = selected_word_counter / total_word_counter\\n total_time = article_json[-1]['time'] - article_json[0]['time'] # unix subtraction = seconds\\n months_in_train_set = total_time / SECONDS_IN_MONTH\\n expected_posts_per_month = int(total_word_counter / months_in_train_set)\\n\\n # Show results\\n print_text_results(expected_posts_per_month, probability, selected_word)\\n plot_likelihood(expected_posts_per_month, probability)\",\n \"def Probability(rating1, rating2):\\n return 1.0 * 1.0 / (1 + 1.0 * math.pow(10, 1.0 * (rating1 - rating2) / 400))\",\n \"def log_marginal_likelihood(self) -> tf.Tensor:\\n X, Y = self.data\\n Y = Y[..., :-1]\\n K = self.kernel(X)\\n ks = self._add_noise_cov(K)\\n L = tf.linalg.cholesky(ks)\\n m = self.mean_function(X)\\n\\n # [R,] log-likelihoods for each independent dimension of Y\\n log_prob = gpflow.logdensities.multivariate_normal(Y, m, L)\\n return tf.reduce_sum(log_prob)\",\n \"def predict_rating(self, movie):\\n\\n #\\n # option 1: SQLAlchemy ORM\\n #\\n UserMovies = db.aliased(Rating)\\n MovieUsers = db.aliased(Rating)\\n\\n query = (db.session.query(Rating.user_id, Rating.score, UserMovies.score, MovieUsers.score)\\n .join(UserMovies, UserMovies.movie_id == Rating.movie_id)\\n .join(MovieUsers, Rating.user_id == MovieUsers.user_id)\\n .filter(UserMovies.user_id == self.user_id)\\n .filter(MovieUsers.movie_id == movie.movie_id))\\n\\n #\\n # option 2: raw SQL\\n #\\n # sql = \\\"\\\"\\\"\\n # SELECT ratings.user_id, ratings.score, user_movies.score, movie_users.score\\n # FROM ratings AS user_movies\\n # JOIN ratings\\n # ON (user_movies.movie_id = ratings.movie_id)\\n # JOIN ratings AS movie_users\\n # ON (ratings.user_id = movie_users.user_id)\\n # WHERE user_movies.user_id = :user_id\\n # AND movie_users.movie_id = :movie_id\\n # \\\"\\\"\\\"\\n #\\n # query = db.session.execute(sql, dict(user_id=self.user_id, movie_id=movie.movie_id))\\n #\\n\\n known_ratings = {}\\n paired_ratings = defaultdict(list)\\n\\n for rating_user_id, rating_score, user_movie_score, movie_user_score in query:\\n paired_ratings[rating_user_id].append((user_movie_score, rating_score))\\n known_ratings[rating_user_id] = movie_user_score\\n\\n similarities = []\\n\\n for _id, score in known_ratings.items():\\n similarity = correlation.pearson(paired_ratings[_id])\\n if similarity > 0:\\n similarities.append((similarity, score))\\n\\n if not similarities:\\n return None\\n\\n numerator = sum([score * sim for sim, score in similarities])\\n denominator = sum([sim for sim, score in similarities])\\n\\n return numerator / denominator\",\n \"def likelihood(self):\\n \\n raise NotImplementedError()\",\n \"def predictOnMovie(self,user,movie,neibor_list,user_rating,user_aver_rating):\\n predict = user_aver_rating[user]\\n numerator, denominator = 0.0,0.0\\n for sim, neighbor in neibor_list:\\n if movie in user_rating[neighbor]:\\n numerator += sim*(user_rating[neighbor][movie]-user_aver_rating[neighbor])\\n denominator += sim\\n predict += numerator/denominator\\n return predict\",\n \"def expert_likelihood(self, X, y): #give to it a proper name!!!\\n\\t\\tgaussians_mean = self.experts_predictions(X) #(N,K) X*W + b\\n\\t\\ty = np.repeat( np.reshape(y, (len(y),1)), self.K, axis = 1) #(N,K)\\n\\n\\t\\t#print('sigma: ', self.sigma)\\n\\t\\tres = scipy.stats.norm.pdf( np.divide((y - gaussians_mean), self.sigma) ) #(N,K)\\n\\t\\treturn np.divide(res, self.sigma) #normalizing result\",\n \"def calculate_marginals_on_samples(self, theta, Xm, return_ratio=True):\\n n_samples, n_visible = Xm.shape\\n log_marg_x = np.zeros((self.n_hidden, n_samples, n_visible, self.dim_hidden)) #, dtype=np.float32)\\n if n_visible > 1 and self.pool is not None:\\n args = zip([self] * len(theta), Xm.T, theta)\\n log_marg_x = np.array(self.pool.map(unwrap_f, args)).transpose((1, 2, 0, 3))\\n else:\\n for i in range(n_visible):\\n log_marg_x[:, :, i, :] = self.calculate_p_xi_given_y(Xm[:, i], theta[i])\\n if return_ratio: # Return log p(xi|y)/p(xi) instead of log p(xi|y)\\n # Again, I use the same p(y) here for each x_i, but for missing variables, p(y) on obs. sample may be different.\\n # log_marg_x -= logsumexp(log_marg_x + self.log_p_y.reshape((self.n_hidden, 1, 1, self.dim_hidden)), axis=3)[..., np.newaxis]\\n log_marg_x += self.log_p_y.reshape((self.n_hidden, 1, 1, self.dim_hidden))\\n if self.pool is not None:\\n log_marg_x -= np.array(self.pool.map(logsumexp2, log_marg_x))[..., np.newaxis]\\n else:\\n log_marg_x -= logsumexp(log_marg_x, axis=3)[..., np.newaxis]\\n log_marg_x -= self.log_p_y.reshape((self.n_hidden, 1, 1, self.dim_hidden))\\n return log_marg_x\",\n \"def get_log_likelihood(response_probability, response):\\n pass\",\n \"def test_marginal_likelihood(self):\\n data = np.repeat([1, 0], [50, 50])\\n marginals = []\\n a_prior_0, b_prior_0 = 1.0, 1.0\\n a_prior_1, b_prior_1 = 20.0, 20.0\\n\\n for alpha, beta in ((a_prior_0, b_prior_0), (a_prior_1, b_prior_1)):\\n with pm.Model() as model:\\n a = pm.Beta(\\\"a\\\", alpha, beta)\\n y = pm.Bernoulli(\\\"y\\\", a, observed=data)\\n trace = pm.sample_smc(2000, chains=2, return_inferencedata=False)\\n # log_marginal_likelihood is found in the last value of each chain\\n lml = np.mean([chain[-1] for chain in trace.report.log_marginal_likelihood])\\n marginals.append(lml)\\n\\n # compare to the analytical result\\n assert abs(np.exp(marginals[1] - marginals[0]) - 4.0) <= 1\",\n \"def compute_log_marginal_likelihood(\\n K_i: torch.Tensor,\\n logDetK: torch.Tensor,\\n y: torch.Tensor,\\n normalize: bool = True,\\n log_prior_dist=None,\\n):\\n lml = (\\n -0.5 * y.t() @ K_i @ y\\n + 0.5 * logDetK\\n - y.shape[0]\\n / 2.0\\n * torch.log(\\n 2\\n * torch.tensor(\\n np.pi,\\n )\\n )\\n )\\n if log_prior_dist is not None:\\n lml -= log_prior_dist\\n return lml / y.shape[0] if normalize else lml\",\n \"def log_marginal_likelihood(self, X, W):\\n phi_X = self.phi(X, W)\\n S_n = phi_X.T @ phi_X + np.eye(self.M)\\n mu_n = np.linalg.inv(S_n) @ phi_X.T @ self.Y\\n a_n = self.gamma_a0 + self.N / 2\\n A = np.diag(self.Y.T @ self.Y)\\n C = np.diag(mu_n.T @ S_n @ mu_n)\\n b_n = self.gamma_b0 + 0.5 * (A - C)\\n\\n # Compute Lambda term.\\n sign, logdet = np.linalg.slogdet(S_n)\\n lambda_term = -0.5 * sign * logdet\\n\\n # Compute b_n term.\\n b_term = self.gamma_a0 * np.log(self.gamma_b0) - a_n * np.log(b_n)\\n\\n # Compute a_n term.\\n gamma_term = gammaln(a_n) - gammaln(self.gamma_a0)\\n\\n # Compute sum over all y_n.\\n return np.sum(gamma_term + b_term + lambda_term)\",\n \"def log_marginal(self):\\n #\\n # Predictive covariance of x is sum of covariance of phi a and covariance of x|a\\n x_Sigma = self.phi @ self.phi.T + np.diag(self.sigma_n**2 * np.ones(self.M))\\n #\\n # Predictive mean is 0 by symmetry\\n # so given that x is distributed as a MVN, the exact marginal is\\n lp_exact = st.multivariate_normal.logpdf(self.x, cov=x_Sigma)\\n #\\n return lp_exact\",\n \"def predict_likelihood_ratio(self, X):\\n return np.exp(self.predict_log_likelihood_ratio(X))\",\n \"def predict_log_likelihood_ratio(self, X):\\n raise NotImplementedError\",\n \"def predict_log_likelihood_ratio(self, X):\\n class_probs = np.maximum(np.squeeze(self.model.predict(X)[0]), self.class_min)\\n return np.log(class_probs / (1 - class_probs))\",\n \"def predictRating(toPredict, candidateList):\\n\\n ratingRelevantCandidates = []\\n\\n #Remove candidates with no rating specified\\n for candidate in candidateList:\\n currentCandidate = candidate[1]\\n\\n if float(currentCandidate['vote_avg']) > 0:\\n ratingRelevantCandidates.append((float(currentCandidate['vote_avg']), candidate))\\n\\n #print(\\\"ratings::::::::\\\",currentCandidate['vote_avg'])\\n\\n #Remove outlier candidates based on rating\\n ratingMean = np.mean([x[0] for x in ratingRelevantCandidates])\\n print(\\\"ratingMean\\\", ratingMean)\\n ratingSD = np.std([x[0] for x in ratingRelevantCandidates])\\n print(\\\"ratingSD\\\", ratingSD)\\n\\n finalRatings = [x for x in ratingRelevantCandidates if (float(x[0]) < ratingMean + ratingSD)]#1.5 *\\n finalRatings = [x for x in finalRatings if (float(x[0]) > ratingMean - ratingSD)]#.75 *\\n\\n finalRatingCandidatesWithWeight = []\\n\\n #Weight each candidate based on vote count, direct and actor popularity and matching score from part 1\\n for candidate in finalRatings:\\n directorPoints = compareDirectorPoints(toPredict['director'], candidate[1][1]['director'])\\n actorPoints = compareActorPoints(toPredict['cast'], candidate[1][1]['cast'])\\n voteCountPoints = int(candidate[1][1]['vote_count'])\\n matchPoints = candidate[1][0] / np.max([float(x[1][0]) for x in finalRatings]) * 100\\n candidateWeight = PREDICTION_MATCHPOINTS_WEIGHT * matchPoints \\\\\\n + PREDICTION_ACTOR_WEIGHT * actorPoints \\\\\\n + PREDICTION_DIRECTOR_WEIGHT * directorPoints \\\\\\n + PREDICTION_VOTECOUNT_WEIGHT * voteCountPoints\\n\\n finalRatingCandidatesWithWeight.append((candidateWeight, candidate[0]))\\n\\n #Calculate the prediction\\n sumRatingCandidateWeights = np.sum([float(x[0]) for x in finalRatingCandidatesWithWeight])\\n sumRatingTimesCandidateWeight = np.sum([float(x[0]) * float(x[1]) for x in finalRatingCandidatesWithWeight])\\n\\n ratingPrediction = float(sumRatingTimesCandidateWeight / sumRatingCandidateWeights)\\n\\n return ratingPrediction\",\n \"def pmi(cls, *marginals):\\n return (_log2(marginals[NGRAM] * marginals[TOTAL] ** (cls._n - 1)) -\\n _log2(_product(marginals[UNIGRAMS])))\",\n \"def log_marg_likelihood(self):\\n self.A = np.linalg.inv(self.Sn)\\n term1 = self.t - self.design_matrix@self.mn\\n self.Evidence_mN = (self.beta/2)*np.linalg.norm(term1)+ (self.alpha/2)*self.mn.T@self.mn\\n A_abs = np.linalg.eigvals(self.A)\\n A_abs = np.prod(A_abs)\\n\\n self.marg_lik = ((self.p)/2)*np.log(self.alpha) + (self.n/2)*np.log(self.beta) - self.Evidence_mN - (1/2)*np.log(A_abs) - (self.n/2)*np.log(2*np.pi)\\n\\n return self.marg_lik\",\n \"def predict_rating(R, R_avg, S, u, m):\\n\\n # Users (ie. neighbours) that have rated this movie.\\n neighbours = R[m].dropna().index\\n\\n numer, denom = 0, 0\\n for v in neighbours:\\n numer += S.ix[u, v] * (R.ix[v, m] - R_avg[v])\\n denom += abs(S.ix[u, v])\\n\\n rating = R_avg[u] + (numer / denom)\\n\\n return rating\",\n \"def probability(self, X_):\\n X = np.c_[np.ones(X_.shape[0]), X_] # add bias variable 1\\n prob = np.zeros(X.shape[0], self.num_classes)\\n ### YOUR CODE HERE\\n z = X.dot(self.w)\\n prob = soft_reg.softmax(z)\\n ### END CODE\\n return prob\",\n \"def log_marginal_likelihood(self) -> tf.Tensor:\\n L = tf.linalg.cholesky(self.likelihood.add_to(self.KXX))\\n return tf.reduce_sum(multivariate_normal(self._Y, self._mean, L))\",\n \"def likelihood_ratio(cls, *marginals):\\n cont = cls._contingency(*marginals)\\n return (cls._n *\\n sum(obs * _ln(float(obs) / (exp + _SMALL) + _SMALL)\\n for obs, exp in zip(cont, cls._expected_values(cont))))\",\n \"def get_likelihood(self, observation, position, direction):\\n if self.real_robot and observation == 0.0:\\n return 1.0\\n\\n closest = self.world_model.get_closest_wall(position, direction)\\n if closest == None:\\n # probability of a false positive is 0\\n if observation == 0.0:\\n return 1.0\\n else:\\n return 0.0\\n elif closest != None and observation == 0.0:\\n # probability of missing an obstacle is 0\\n return 0.0\\n return norm(0, self.model_noise_rate).pdf(abs(position - closest) - observation)\",\n \"def predict_log_likelihood_ratio(self, X):\\n Xs = self.scaler.transform(X)\\n class_probs = np.maximum(self.model.predict_proba(Xs)[:, 1], self.class_min)\\n return np.log(class_probs / (1 - class_probs))\",\n \"def probability(self, X_):\\n X = np.c_[np.ones(X_.shape[0]), X_] # Add one for bias to the first columns\\n probs = np.zeros(X.shape[0])\\n ### YOUR CODE HERE\\n z = X.dot(self.w)\\n probs = log_reg.logistic(z)\\n ### END CODE\\n assert probs.shape == (X.shape[0],)\\n return probs\",\n \"def expose(self, rating):\\n k = self.mu / self.sigma\\n return rating.mu - k * rating.sigma\",\n \"def log_marginal_likelihood(X_train,y_train,phi,tau=1.,Ve=1.e-10):\",\n \"def hidden_markov_model_probability(data,\\n fitness_prior=flat_fitness_prior,\\n N_w_prior=flat_N_w_prior,\\n mutation_object=True):\\n\\n if mutation_object is True:\\n trajectories = data.data\\n else:\\n trajectories = data\\n\\n ind_likelihood = []\\n for traj in trajectories:\\n int_s = []\\n for s in fitness_prior[0, :]:\\n int_N_w = []\\n for N_w in N_w_prior[0, :]:\\n int_N_w.append(\\n hidden_markov_conditional_s_N(traj,\\n fitness=s, N_w=N_w)\\n )\\n marginalised_N_w = np.trapz(x=N_w_prior[0, :],\\n y=int_N_w*N_w_prior[1, :])\\n int_s.append(marginalised_N_w)\\n\\n marginalised_likelihood = np.trapz(x=fitness_prior[0, :],\\n y=int_s*fitness_prior[1, :])\\n ind_likelihood.append(marginalised_likelihood)\\n \\n mutation_prob = np.product(ind_likelihood)\\n\\n if mutation_object is True:\\n # return updated model_comparison object \\n data.bd_prob = mutation_prob\\n return data\\n else:\\n # return marginalised likelihood.\\n return mutation_prob\",\n \"def get_likelihood(self, d):\\n pos = d.pos - self.parent.pos\\n pos = np.dot(rotmat(-self.angle), pos)\\n lik = halfnorm.pdf(pos[0],scale=self.length) * \\\\\\n vonmises.pdf(np.arctan2(pos[1],pos[0]),self.vonmisesscale,loc=self.angle)\\n #assert lik!=0.0\\n return lik\",\n \"def predict(self, X):\\n \\n n_samples = X.shape[0]\\n y_pred = self.mean_rating_*np.ones(n_samples)\\n for i in np.arange(n_samples):\\n if X[i,0] < self.num_user and X[i,1] < self.num_item:\\n y_pred[i] += np.dot(self.U[X[i,0],:],self.V[X[i,1],:])\\n y_pred[i] = np.clip(y_pred[i],self.min_rating_,\\n self.max_rating_)\\n \\n return y_pred\",\n \"def nmi(ypred, y):\\n# print (ypred)\\n# print (y)\\n return normalized_mutual_info_score(y,ypred)\",\n \"def log_likelihood(self, X, Y):\\n\\t\\tr,c = twod(Y).shape\\n\\t\\tif r == 1 and c != 1:\\n\\t\\t\\tY = twod(Y).T\\n\\n\\t\\tsoft = self.predict_soft(X)\\n\\t\\treturn np.mean(np.sum(np.log(np.power(soft, Y, )), 1), 0)\",\n \"def predictRating(self, movieID):\\n\\t\\t\\n\\t\\treturn movieID\",\n \"def get_log_marginal_likelihood(self, mode='BIC'):\\n if mode == 'BIC':\\n if not self.isOptimized:\\n print('Parameters have not been optimized; training now')\\n self.train()\\n if self.BICscore is None:\\n BIC = 0\\n for i, model in enumerate(self.models):\\n n = model.n \\n k = model.m.num_params\\n L = model.m.log_likelihood()\\n BIC += L - k/2*np.log(n)\\n self.BICscore = BIC\\n return self.BICscore\\n elif mode in ['laplace', 'Laplace']:\\n raise NotImplementedError('Laplace approximation is not yet implemented')\\n elif mode == 'AIS':\\n raise NotImplementedError('Annealed importance sampling is not yet implemented')\\n else:\\n raise NotImplementedError('Unrecognized marginal likelihood approximation {:s}'.format(mode))\",\n \"def model_likelihood(\\n self, obs: Tensor, actions: Tensor, next_obs: Tensor\\n ) -> Tensor:\\n return self.model.log_prob(obs, actions, next_obs)\",\n \"def m_probs(self):\\n log_m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n\\n return self._prob_inverse_transform(numpy.exp(log_m))\",\n \"def calculateLogJointProbabilities(self, datum):\\n logJoint = util.Counter()\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\t#Adds log(P(y)) to calculate P(y|f1,f2...)\\n for label in self.legalLabels:\\n\\t\\tlogJoint[label] += math.log(self.prior[label])\\n\\t#Adds log(P(f1|y)), log(P(f2|y))... to calculate P(y|f1, f2...)\\n for key in datum:\\n\\t\\t#if key == (7, 3):\\n\\t\\t\\t#print self.condprobs[key, 0]\\n\\t\\tfor label in self.legalLabels:\\n\\t\\t\\t#print str(key) + str(datum[key])\\n\\t\\t\\tlogJoint[label] += math.log(self.condprobs[key, label][datum[key]])\\n return logJoint\",\n \"def ndpm(self):\\n\\n merged = pd.merge(left=self.test, right=self.predict, on=['user', 'item'], how='inner')[\\n ['user', 'rating_x', 'rating_y']]\\n ndpms = []\\n for user in merged.user.unique():\\n frame = merged[merged.user == user]\\n if frame.shape[0] <= 1:\\n continue\\n C_plus = self.num_of_ordered_positive(frame, 'rating_x', 'rating_y')\\n C_minus = self.num_of_ordered_negative(frame, 'rating_x', 'rating_y')\\n C_u = self.num_of_ordered(frame, 'rating_x')\\n if C_u == 0:\\n continue\\n C_s = self.num_of_ordered(frame, 'rating_y')\\n C_u0 = C_u - (C_plus + C_minus)\\n ndpms.append(1 - (C_minus + 0.5 * C_u0) / C_u)\\n\\n return sum(ndpms) / len(ndpms)\",\n \"def poisson_log_likelihood(x, log_rate):\\n return x * log_rate - np.exp(log_rate) - lax.lgamma(x + 1.0)\",\n \"def log_prob(self):\",\n \"def dist_by_rating(self):\\n return ratings_distribution\",\n \"def log_likelihood_function(self, instance) -> float:\\n return self.prior.factor(instance[0])\",\n \"def mrr(self):\\n _test = self.drop_bad_ratings()\\n merged = pd.merge(left=_test, right=self.predict, on=['user', 'item'], how='right')[\\n ['user', 'item', 'rating_x', 'rating_y']]\\n nott = np.vectorize(lambda x: not x)\\n mrrs = []\\n for user in merged.user.unique():\\n frame = merged[merged.user == user].sort_values(by='rating_y', ascending=False)\\n true_ratings = frame.rating_x.values\\n positions = np.where(nott(np.isnan(true_ratings)))[0]\\n if len(positions) > 0:\\n mrrs.append(1 / (positions[0] + 1))\\n else:\\n mrrs.append(0)\\n\\n return sum(mrrs) / len(mrrs)\",\n \"def _perplexity(self, X, log_w):\\n return np.exp(-log_w/X.sum())\",\n \"def calculateLogJointProbabilities(self, datum):\\n logJoint = util.Counter()\\n \\n \\\"*** YOUR CODE HERE ***\\\"\\n \\n # -- OUR CODE HERE\\n \\n \\n import math\\n for label in self.legalLabels:\\n sumThing = 0.0\\n for pixel in self.conditionalProb[label]:\\n if datum[pixel] is 1:\\n #assert self.conditionalProb[label][pixel] < 1.0 # -- sanity check that the probability is valid\\n sumThing += math.log((self.conditionalProb[label][pixel]*1.0))\\n else:\\n sumThing+=math.log(1-self.conditionalProb[label][pixel]*1.0)\\n logJoint[label] = math.log(self.prior[label]*1.0) + sumThing*1.0\\n \\n\\n \\n \\n import time\\n #print \\\"logJoint is :: \\\", logJoint\\n #time.sleep(2)\\n \\n \\n # -- uses the conditional probability tables computed in the current iteration\\n # -- in train and tune\\n \\n return logJoint\",\n \"def netflix_predict(movie_id, customer_id):\\n\\n avg_mov_value = CACHE_AVG_MOVIE_RATING[movie_id]\\n avg_cust_value = CACHE_AVG_CUSTOMER_RATING[customer_id]\\n years_after_release = CACHE_YEARS_SINCE_RELEASE[movie_id][customer_id]\\n\\n # Equation from results gradient-descent/linRegResults.txt\\n res = 3.78699752 + (avg_mov_value - 3.72) * 0.91299576 \\\\\\n + (avg_cust_value - 3.72) * 0.90834816 \\\\\\n + years_after_release * 0.00196377\\n\\n # Actual ratings cannot be greater than 5 or less than 1\\n if res > 5.0:\\n res = 5.0\\n elif res < 1.0:\\n res = 1.0\\n\\n return res\",\n \"def calculate_recommendations(self, vote_list, itemMatch, itemIgnored):\\n #print \\\"--------------------------------------------------\\\"\\n #print \\\"calculate_recommendations\\\"\\n #print \\\"--------------------------------------------------\\\"\\n\\n # http://www.quuxlabs.com/blog/2010/09/matrix-factorization-a-simple-tutorial-and-implementation-in-python/\\n\\n # U = np.array('users')\\n # D = np.array('video_games')\\n\\n # R = |U| cross |D|\\n\\n # We want to discover K latent features\\n\\n # Find\\n # P(a | |U| corss K matrix)\\n # Q(a | |D| cross K matrix)\\n # Such that their product approximates R\\n # R approx= P cross transpose(Q) = hat(R)\\n #\\n\\n # r[i][j] = transpose(p)[i] * q[j]\\n # = sum( 1..k, p[i][k] * q[k][j] )\\n\\n # e[i][j]**2 = (r[i][j] - hat(r)[i][j])**2\\n # = (r[i][j] - sum( 1..K, p[i][k] * q[k][j]))**2\\n # squared error, estimated rating can be either higher or lower than the real thing\\n\\n # find the gradient\\n # diff(e[i][j]**2, p[i][k]) = -2*(r[i][j] - hat(r)[i][j]) * (q[k][j]) = -2*e[i][j] * q[k][j]\\n # diff(e[i][j]**2, q[k][j]) = -2*(r[i][j] - hat(r)[i][j]) * (p[i][k]) = -2*e[i][j] * p[i][k]\\n\\n # update rules\\n # alpha = settings.alpha # learning_rate\\n # alpha = 0.0002 # learning_rate\\n # p[i][k]' = p[i][k] + alpha * diff(e[i][j]**2, p[i][k])\\n # = p[i][k] + 2 * alpha * e[i][j] * q[k][j]\\n # q[k][j]' = q[k][j] + alpha * diff(e[i][j]**2, q[k][j])\\n # = q[k][j] + 2 * alpha * e[i][j] * p[i][k]\\n\\n # training data\\n # T = (u[i], d[j], r[i][j])\\n # np.array()\\n\\n # iterate until convergance\\n # E = sum((u[i], d[j], r[i][j]) in T, e[i][j])\\n # = sum((u[i], d[j], r[i][j]) in T, r[i][j]\\n # - sum(1..k, p[i][k]*q[k][j]))**2\\n\\n # regularization\\n # beta = 0.02\\n # e[i][j]**2 = (r[i][j] - sum(1..K, p[i][j]*q[k][j]))**2\\n # + ((beta/2) * sum(1..K, norm(P)**2 + norm(Q)**2))\\n #\\n # p[i][k]' = p[i][k] + alpha * (2 * e[i][j] * q[k][j] - beta * p[i][k])\\n # q[k][j]' = q[k][j] + alpha * (2 * e[i][j] * p[i][k] - beta * q[k][j])\\n\\n data = np.array(vote_list)\\n\\n encoder = OneHotEncoder()\\n\\n users = data[:,0]\\n unique_users = list(set(users))\\n for i in range(len(users)):\\n users[i] = unique_users.index(users[i])\\n\\n video_games = data[:,1]\\n unique_games = list(set(video_games))\\n for i in range(len(video_games)):\\n video_games[i] = unique_games.index(video_games[i])\\n\\n ratings = data[:,2]\\n M = len(set(video_games))\\n N = len(set(users))\\n R = np.zeros((N,M))\\n for i in range(len(users)):\\n user = users[i]\\n game = video_games[i]\\n rating = ratings[i]\\n R[user][game] = rating\\n\\n K = 2\\n\\n P = np.random.rand(N,K)\\n Q = np.random.rand(M,K)\\n\\n nP, nQ = self.matrix_factorization(R, P, Q, K)\\n nR = np.dot(nP, nQ.T)\\n\\n itemMatch = {}\\n for i in range(N):\\n user = unique_users[i]\\n itemMatch[user] = []\\n for j in range(M):\\n if R[i][j] == 0:\\n video_game = unique_games[j]\\n recommendation = (video_game, nR[i][j])\\n itemMatch[user].append(recommendation)\\n itemMatch[None] = []\\n print 'pmf recommendations', itemMatch.items()\\n print '\\\\n'\\n recommendations = itemMatch.items()\\n\\n # returns\\n # [\\n # (<user1>, [\\n # (\\\"<object_identifier1>\\\", <score>),\\n # (\\\"<object_identifier2>\\\", <score>),\\n # ]),\\n # (<user2>, [\\n # (\\\"<object_identifier1>\\\", <score>),\\n # (\\\"<object_identifier2>\\\", <score>),\\n # ]),\\n # ]\\n\\n return recommendations\",\n \"def log_likelihood(self, x):\\n # set nuisance parameters to their central values!\\n predictions = self.get_predictions(self.shortarray_to_array(x), nuisance=False)\\n m_obj = flavio.Measurement['Pseudo-measurement for FastFit instance: ' + self.name]\\n m_obs = m_obj.all_parameters\\n prob_dict = m_obj.get_logprobability_all(predictions)\\n ll = sum(prob_dict.values())\\n return ll\",\n \"def multinomial_likelihood(m_true, alpha, alpha0, m_probs):\\n\\n ll = tf.reduce_sum(input_tensor=m_true * (tf.math.log(alpha0) - tf.math.log(alpha)), axis=1, keepdims=True)\\n ll = tf.reduce_mean(input_tensor=ll)\\n return ll\",\n \"def recommend(self, u):\\n\\n sims = {} #similarities\\n recommendation = \\\"\\\"\\n topScore = None\\n start = time.time()\\n for movie_id, rating in enumerate(u):\\n if rating != 0:\\n sims[movie_id] = {}\\n for r_id, movie in enumerate(self.ratings):\\n sims[movie_id][r_id] = self.distance(movie,self.ratings[movie_id])\\n # print time.time() - start, \\\"distance time\\\"\\n\\n start = time.time()\\n for i, movieRating in enumerate(self.ratings):\\n iPrediction = 0\\n for movieName in self.ratedMovieList:\\n j = self.titlesOnly.index(movieName)\\n iPrediction += sims[j][i]*1.0 * self.userRatingVector[j]\\n if topScore is None or iPrediction > topScore:\\n movie = self.titlesOnly[i]\\n if movie not in self.ratedMovieList and movie not in self.recommendedMovies:\\n # print(\\\"prediction score for %s is %.5f\\\" % (movie, iPrediction))\\n topScore = iPrediction\\n recommendation = movie\\n # print time.time() - start, \\\"recommendation time\\\"\\n self.recommendedMovies.append(recommendation)\\n\\n articlePattern = re.match('(.*), (the|a|an|el|la)', recommendation)\\n if articlePattern is not None:\\n recommendation = articlePattern.group(2) + \\\" \\\" + articlePattern.group(1)\\n\\n return recommendation\",\n \"def compute_posterior(prior, likelihood, y):\\n\\n # -------------------------------------------------------------------------\\n # ERROR CHECKS -- DO NOT MODIFY\\n #\\n\\n # check that prior probabilities sum to 1\\n if np.abs(1 - np.sum(prior)) > 1e-06:\\n exit('In compute_posterior: The prior probabilities need to sum to 1')\\n\\n # check that likelihood is specified as a 2D array\\n if len(likelihood.shape) != 2:\\n exit('In compute_posterior: The likelihood needs to be specified as ' +\\n 'a 2D array')\\n\\n K, M = likelihood.shape\\n\\n # make sure likelihood and prior agree on number of hidden states\\n if len(prior) != M:\\n exit('In compute_posterior: Mismatch in number of hidden states ' +\\n 'according to the prior and the likelihood.')\\n\\n # make sure the conditional distribution given each hidden state value sums\\n # to 1\\n for m in range(M):\\n if np.abs(1 - np.sum(likelihood[:, m])) > 1e-06:\\n exit('In compute_posterior: P(Y | X = %d) does not sum to 1' % m)\\n\\n #\\n # END OF ERROR CHECKS\\n # -------------------------------------------------------------------------\\n\\n # -------------------------------------------------------------------------\\n # YOUR CODE GOES HERE FOR PART (b)\\n #\\n # Place your code to compute the log of the posterior here: store it in a\\n # NumPy array called `log_answer`. If you exponentiate really small\\n # numbers, the result is likely to underflow (i.e., it will be so small\\n # that the computer will just make it 0 rather than storing the right\\n # value). You need to go to log-domain. Hint: this next line is a good\\n # first step.\\n log_prior = np.log(prior)\\n# print(log_prior)\\n# print(likelihood)\\n# print(y)\\n unnormal = log_prior + np.log(likelihood[y,:]).sum(axis=0)\\n# print(unnormal)\\n log_answer = unnormal - scipy.misc.logsumexp(unnormal)\\n# print(log_answer)\\n\\n #\\n # END OF YOUR CODE FOR PART (b)\\n # -------------------------------------------------------------------------\\n\\n # do not exponentiate before this step\\n posterior = np.exp(log_answer)\\n return posterior\",\n \"def get_log_marginal_likelihood(self, mode='BIC'):\\n if mode == 'BIC':\\n if not self.isOptimized:\\n print('Parameters have not been optimized; training now')\\n self.train()\\n \\n if self.BICscore is None:\\n k = self.m.num_params\\n L = self.m.log_likelihood()\\n BIC = L - k/2*np.log(self.n)\\n self.BICscore = BIC\\n return self.BICscore\\n elif mode in ['laplace', 'Laplace']:\\n raise NotImplementedError('Laplace approximation is not yet implemented')\\n elif mode == 'AIS':\\n raise NotImplementedError('Annealed importance sampling is not yet implemented')\\n else:\\n raise NotImplementedError('Unrecognized marginal likelihood approximation {:s}'.format(mode))\",\n \"def calc_marginal_entropy(data_stat):\\n label_col = data_stat.keys()[-1]\\n label_info = data_stat[label_col]\\n label_lengths = []\\n for label_poses in label_info.values():\\n label_lengths.append(len(label_poses))\\n # print(label_lengths)\\n majority = max(label_lengths)\\n minority = min(label_lengths)\\n total = float(majority + minority)\\n entropy = -(minority/total*math.log(minority/total,2)+majority/total*math.log(majority/total,2))\\n return entropy\",\n \"def get_rating(self, i, j):\\n prediction = self.P[i, :].dot(self.Q[j, :].T)\\n return prediction\",\n \"def log_likelihood(self, data, reward_model, bias_params):\",\n \"def model_likelihoods(\\n self, obs: Tensor, actions: Tensor, next_obs: Tensor\\n ) -> List[Tensor]:\\n return [m.log_prob(obs, actions, next_obs).mean() for m in self.model]\",\n \"def get_log_likelihood(response_probability, observed_response):\\n \\n return np.log(response_probability[observed_response])\",\n \"def calculateLogJointProbabilities(self, datum):\\n\\tlogJoint = util.Counter()\\n\\t#want to calculate log(P(y)) + log(sum(P(fi|y)))\\n\\t#where y is a label\\n\\tfor label in self.legalLabels:\\n\\t\\tlogJoint[label] = math.log(self.prior_distribution_prob[label])\\n\\t\\tfor feature, value in datum.items():\\n\\t\\t\\tcp = self.conditional_prob[label][feature][value]\\n\\t\\t\\tif cp > 0: #condition check for values < 0 because log(0) is undefined and math domain error occurs\\n\\t\\t\\t\\tlogJoint[label] += math.log(cp) #summing up\\n\\t\\t\\t\\t\\n\\treturn logJoint\",\n \"def test_posterior_logprobs(self):\\n x = list(product([True, False], repeat=2))\\n xs = list(e for e in product(x, repeat=3))\\n all_obs = list(o for o in xs\\n if all(any(e) and not all(e) for e in o))\\n total = logsumexp(list(posterior_logprobs(np.array(obs), self.S, self.A, self.E)[1]\\n for obs in all_obs))\\n assert_allclose(total, np.log(1))\",\n \"def likelihood(self, data, hypo):\\n tagged, n, k = data\\n if hypo < tagged + n - k:\\n return 0\\n\\n p = tagged / hypo\\n like = thinkbayes.eval_binomial_pmf(k, n, p)\\n return like\",\n \"def _log_posterior_x(self, X):\\n if self.marginalize:\\n LL = self.log_marginal_likelihood(X, self.W)\\n else:\\n LL = self.log_likelihood(X=X)\\n LP = self._log_prior_x(X)\\n return LL + LP\",\n \"def _compute_log_likelihood(self, X, S):\\n log_likelihood = 0\\n for n in range(self.n_col):\\n likelihood = 1\\n for k in range(self.n_components):\\n likelihood *= self.weights[k] \\\\\\n * multivariate_normal(self.means[k], self.covs[k]).pdf(X[n]) \\\\\\n * poisson(self.rates[k]).pmf(S[n])\\n log_likelihood += np.log(likelihood)\\n\\n return log_likelihood\",\n \"def get_marginals(self, x):\\n # get conditional probability\\n conditions = self.get_conditional(x)\\n\\n # multiply conditional probability with pi_{k}\\n culmulate = conditions.dot(self._pi)\\n return culmulate.flatten()\",\n \"def compute_user_similarity(d1, d2, ave_rat1, ave_rat2):\\n \\n movie_1=set()\\n movie_2=set()\\n for movie,value in d1.items():\\n movie_1.add(movie) \\n for movie, value in d2.items():\\n movie_2.add(movie) \\n common_movie_rated=movie_1.intersection(movie_2)\\n if (len(common_movie_rated)==0):\\n return 0.0\\n num = 0\\n den1 = 0\\n den2 = 0\\n for common_movie in common_movie_rated:\\n num += (float(d1[common_movie])-ave_rat1)*(float(d2[common_movie])-ave_rat2)\\n den1 += ((float(d1[common_movie])-ave_rat1)**2)\\n den2 += ((float(d2[common_movie]) - ave_rat2) ** 2)\\n # When the user gives same rating to all the movies\\n try:\\n user_sim = num/((den1*den2)**0.5)\\n except ZeroDivisionError:\\n return 0.0\\n return user_sim\",\n \"def log_likelihood(self, state, obs, act):\\n indices = np.array([self.Gittins[state['successes'][i], state['failures'][i]] for i in range(self.env.n_arms)])\\n greedy_arms = np.where(np.isclose(indices,indices.max()))[0]\\n return np.log(1/len(greedy_arms)) if act in greedy_arms else -1e8\",\n \"def log_likelihood(self, y_list):\\n if self.lambda_mat is None:\\n raise ValueError(\\\"Can't compute model likelihood before fitting!\\\")\\n\\n # precision prior distribution given precision hyper-parameters\\n prec_distr = stats.gamma(a=self.prec_distr[0],\\n scale=self.prec_distr[1] ** -1.0)\\n\\n # likelihood of projection matrix precision priors given\\n # precision hyper-parameters\\n lambda_logl = np.sum(\\n prec_distr.logpdf(self.lambda_mat['alpha']\\n / self.lambda_mat['beta'])\\n )\\n\\n # likelihood of projection matrix values given their precision priors\\n a_logl = np.sum(\\n stats.norm(loc=0, scale=(self.lambda_mat['beta']\\n / self.lambda_mat['alpha']))\\n .logpdf(self.A_mat['mu'])\\n )\\n\\n # likelihood of latent feature matrix given kernel matrix,\\n # projection matrix, and standard deviation hyper-parameter\\n h_logl = np.sum(\\n stats.norm(loc=self.A_mat['mu'].transpose() @ self.kernel_mat,\\n scale=self.sigma_h)\\n .logpdf(self.H_mat['mu'])\\n )\\n\\n # likelihood of bias parameter precision priors given\\n # precision hyper-parameters\\n weight_prior_logl = np.sum(\\n prec_distr.logpdf(np.array(self.weight_priors['alpha'])\\n / np.array(self.weight_priors['beta']))\\n )\\n\\n # likelihood of bias parameters given their precision priors\\n weight_logl = np.sum(\\n stats.norm(loc=0, scale=(np.array(self.weight_priors['beta'])\\n / np.array(self.weight_priors['alpha'])))\\n .logpdf(self.weight_mat['mu'])\\n )\\n\\n # likelihood of predicted outputs given latent features, bias\\n # parameters, and latent feature weight parameters\\n f_logl = np.sum(\\n stats.norm(\\n loc=(self.weight_mat['mu'][1:, :].transpose()\\n @ self.H_mat['mu']\\n + np.vstack(self.weight_mat['mu'][0, :])),\\n scale=1).logpdf(self.output_mat['mu'])\\n )\\n\\n # likelihood of actual output labels given class separation margin\\n # and predicted output labels\\n y_logl = np.sum(self.get_y_logl(y_list))\\n\\n return (lambda_logl + a_logl + h_logl\\n + weight_prior_logl + weight_logl + f_logl + y_logl)\",\n \"def get_marginal(\\n target=None\\n ):\\n pass\",\n \"def likelihood(mean, logs, x):\\n return -0.5 * (logs * 2. + ((x - mean) ** 2) / np.exp(logs * 2.) + GaussianDiag.Log2PI)\",\n \"def _predict_doc(self, x, flag):\\n\\n if flag == 1:\\n denom = self.X.num_positive()\\n else:\\n denom = self.X.num_negative()\\n denom += self.X.vocab_size()\\n\\n # multiply word probabilities for all words in x\\n words = tokenize(x)\\n # prob = 1.0\\n # for word in words:\\n # wi = self._doc_count_for_word(word, flag=flag)\\n # # utilize the Laplace Smooth\\n # prob *= ((float(wi)+1.0) / (float(denom)+2.0))\\n\\n prob = math.log(self.X.priors[str(flag)])\\n for word in words:\\n wi = self._doc_count_for_word(word, flag=flag)\\n # utilize the Laplace Smooth\\n prob += math.log((float(wi)+1.0) / (float(denom)+2.0))\\n\\n # prob *= math.log(self.X.priors[str(flag)])\\n\\n return prob\",\n \"def score_calc(self, annotations, predictions):\\n\\n mean_probabilities_of_classes = np.expand_dims(np.mean(predictions, axis=0), axis=0)\\n KL_d = predictions * (np.log(predictions + self.eps) - np.log(mean_probabilities_of_classes + self.eps))\\n KL_D = KL_d.sum(axis=1)\\n\\n score = np.exp(np.mean(KL_D))\\n return score\",\n \"def recommend_NMF(new_user,movies_num,movies_ratings):\\n list_id_movies = movies_ratings['movieId'].unique()\\n nmf,Q = load_NMF_model()\\n new_user_vector = pd.DataFrame(new_user, index=list_id_movies).T\\n new_user_vector_filled = new_user_vector.fillna(3)\\n #calculate Matrix P (Genres)\\n P = nmf.transform(new_user_vector_filled)\\n #make predictions\\n predictions = np.dot(P,Q)\\n recommendations = pd.DataFrame(predictions.reshape(-1), index=list_id_movies).T\\n #Remove already watched movies:\\n not_watched_movies_mask = np.isnan(new_user_vector)\\n not_watched = recommendations[not_watched_movies_mask]\\n\\n top_movies_ids = not_watched.T.sort_values(by=[0], ascending=False).index[:movies_num]\\n\\n Top_recommended = movieId_to_title(top_movies_ids,movies_ratings) \\n return Top_recommended\",\n \"def evaluate_GMM_log_likelihood(model, x, y):\\n y_pred = model.predict(x)\\n \\n num_datapoints = len(x)\\n output_dim = y.shape[-1]\\n num_comp = int(y_pred.shape[-1] / (3*output_dim))\\n\\n mix_comp_logits = y_pred[:, :num_comp]\\n mus = y_pred[:, num_comp:(1+output_dim)*num_comp]\\n sigmas = y_pred[:, (1+output_dim)*num_comp:]\\n \\n # convert logits to categorical distribution - need to itterate through all points\\n mix_comp = np.zeros((num_datapoints, num_comp))\\n for i in range(num_datapoints):\\n mix_comp[i,:] = get_mixture_dist(mix_comp_logits[i,:], num_comp)\\n \\n log_likelihood = 0\\n for i in range(num_comp):\\n for j in range(output_dim):\\n mse = -0.5*np.sum(mix_comp[:,i]*np.square((y[:,j]-mus[:,(i*output_dim)+j])/sigmas[:,(i*output_dim)+j]))\\n sigma_trace = -np.sum(mix_comp[:,i]*np.log(sigmas[:,(i*output_dim)+j]))\\n log2pi = -np.sum(mix_comp[:,i]*0.5*output_dim*np.log(2*np.pi))\\n\\n log_likelihood += mse + sigma_trace + log2pi\\n \\n avg_log_likelihood = np.round(log_likelihood / num_datapoints, 2)\\n print(f'Log likelihood: {avg_log_likelihood}')\\n return avg_log_likelihood\",\n \"def predictability(self):\\n temp = self.probs\\n for n in range(10):\\n temp = temp.dot(temp)\\n final = temp[0,:]\\n #Let's assume that all words have unique initial letters\\n probs = map(len, self.words)\\n probs = array(probs)\\n probs = (probs + self.probs.max(1)-1)/probs\\n return sum(final*probs)\",\n \"def poisson_log_posterior(rate, rate_multiplier, num_events, log_rate):\\n\\n if log_rate:\\n log_prior = 0.5*rate\\n else:\\n log_prior = -0.5*np.log(rate)\\n\\n rate_total = rate_multiplier * (np.exp(rate) if log_rate else rate)\\n\\n log_likelihood = -rate_total + num_events * np.log(rate_total) \\\\\\n - np.log(np.math.factorial(num_events))\\n\\n log_post = log_likelihood + log_prior\\n\\n if np.isscalar(log_post):\\n log_post = log_post if np.isfinite(log_post) else -np.inf\\n else:\\n log_post[~np.isfinite(log_post)] = -np.inf\\n\\n return log_post\",\n \"def marginal_p(self, xi, thetai):\\n if self.marginal_description == 'gaussian':\\n mu, sig = thetai # mu, sig have size m by k\\n xi = xi.reshape((-1, 1, 1))\\n return (-(xi - mu)**2 / (2. * sig) - 0.5 * np.log(2 * np.pi * sig)).transpose((1, 0, 2)) # log p(xi|yj)\\n\\n elif self.marginal_description == 'discrete':\\n # Discrete data: should be non-negative integers starting at 0: 0,...k. k < 32 because of np.choose limits\\n logp = [theta[np.newaxis, ...] for theta in thetai] # Size dim_visible by n_hidden by dim_hidden\\n return np.choose(xi.reshape((-1, 1, 1)), logp).transpose((1, 0, 2))\\n\\n else:\\n print('Marginal description \\\"%s\\\" not implemented.' % self.marginal_description)\\n sys.exit()\",\n \"def poisson(y_true, y_pred):\\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\\n y_true = math_ops.cast(y_true, y_pred.dtype)\\n return backend.mean(\\n y_pred - y_true * math_ops.log(y_pred + backend.epsilon()), axis=-1)\",\n \"def log_likelihood(y_true, y_pred):\\n ll = np.sum(y_true * np.log(y_pred) - y_pred)\\n return ll\",\n \"def popularity(self, user_list):\\n item_popular = Counter(self.train['movieId'].values)\\n ret = 0\\n n = 0\\n print('\\\\nCalculate popularity: ')\\n for user in tqdm(user_list):\\n recom_data = self._get_recommend(user)\\n for rec in set([data[0] for data in recom_data]):\\n ret += math.log(1 + item_popular.get(rec))\\n n += 1\\n ret /= n * 1.0\\n print('\\\\npopularity: ', ret)\\n return ret\",\n \"def predictive_distribution(M, x, noise_precision, mu, precision):\\n\\n A = np.array([x**j for j in range(M)]).reshape((M, 1)) # (1, M)\\n\\n mu = np.dot(np.transpose(A), mu) # (1, M) x (M, 1)\\n var = 1 / noise_precision + np.dot(np.dot(np.transpose(A), np.linalg.inv(precision)), A)\\n y = GaussianNoise.boxmuller(mu, var)\\n\\n return mu, var, y\",\n \"def gmm(ctx: ProbCtx):\\n poisson = ctx.sample(dist=Poisson(10), is_cont=False)\\n ctx.constrain(poisson, geq=0)\\n K = math.floor(poisson.item()) + 1\\n # The following statement samples from Uniform(0,1) in a continuous way.\\n # Sampling directly from Uniform(0,1) would lead to discontinuities at 0 and 1.\\n # Instead, we sample from the standard normal and apply its CDF.\\n # This is a standard reparametrization.\\n means = standard_normal.cdf(ctx.sample_n(K * dims, standard_normal, is_cont=True))\\n means = means.reshape(K, dims) * 100\\n lik = loglikelihood(means, training_data)\\n ctx.score_log(lik)\\n return means.tolist()\",\n \"def predict(self, input, bad_movies=[], hist_list=[], val_list=[],\\n ratings_dict = {}, checked_list=[], rejected_list=[],\\n n=50, harshness=1, rec_movies=True,\\n show_vibes=False, scoring=False):\\n\\n clf = self._get_model()\\n dupes = [] # list for storing duplicates for scoring\\n\\n def _aggregate_vectors(movies, feedback_list=[]):\\n \\\"\\\"\\\"Gets the vector average of a list of movies.\\\"\\\"\\\"\\n movie_vec = []\\n for i in movies:\\n try:\\n m_vec = clf[i] # get the vector for each movie\\n if ratings_dict:\\n try:\\n r = ratings_dict[i] # get user_rating for each movie\\n # Use a polynomial to weight the movie by rating.\\n # This equation is totally arbitrary. I just fit a polynomial\\n # to some weights that look good. The effect is to raise\\n # the importance of 1, 9, and 10 star ratings.\\n w = ((r**3)*-0.00143) + ((r**2)*0.0533) + (r*-0.4695) + 2.1867\\n m_vec = m_vec * w\\n except KeyError:\\n continue\\n movie_vec.append(m_vec)\\n except KeyError:\\n continue\\n if feedback_list:\\n for i in feedback_list:\\n try:\\n f_vec = clf[i]\\n movie_vec.append(f_vec*1.8) # weight feedback by adding multiplier here\\n except KeyError:\\n continue\\n return np.mean(movie_vec, axis=0)\\n\\n def _similar_movies(v, bad_movies=[], n=50):\\n \\\"\\\"\\\"Aggregates movies and finds n vectors with highest cosine similarity.\\\"\\\"\\\"\\n if bad_movies:\\n v = _remove_dislikes(bad_movies, v, harshness=harshness)\\n return clf.similar_by_vector(v, topn= n+1)[1:]\\n\\n def _remove_dupes(recs, input, bad_movies, hist_list=[], feedback_list=[]):\\n \\\"\\\"\\\"remove any recommended IDs that were in the input list\\\"\\\"\\\"\\n all_rated = input + bad_movies + hist_list + feedback_list\\n nonlocal dupes\\n dupes = [x for x in recs if x[0] in input]\\n return [x for x in recs if x[0] not in all_rated]\\n\\n def _remove_dislikes(bad_movies, good_movies_vec, rejected_list=[], harshness=1):\\n \\\"\\\"\\\"Takes a list of movies that the user dislikes.\\n Their embeddings are averaged,\\n and subtracted from the input.\\\"\\\"\\\"\\n bad_vec = _aggregate_vectors(bad_movies, rejected_list)\\n bad_vec = bad_vec / harshness\\n return good_movies_vec - bad_vec\\n\\n def _score_model(recs, val_list):\\n ids = [x[0] for x in recs]\\n return len(list(set(ids) & set(val_list)))\\n\\n aggregated = _aggregate_vectors(input, checked_list)\\n recs = _similar_movies(aggregated, bad_movies, n=n)\\n recs = _remove_dupes(recs, input, bad_movies, hist_list, checked_list + rejected_list)\\n formatted_recs = [self._get_info(x[0], x[1]) for x in recs]\\n if scoring and val_list:\\n print(f\\\"The model recommended {_score_model(recs, val_list)} movies that were on the watchlist!\\\\n\\\")\\n print(f\\\"\\\\t\\\\t Average Rating: {sum([i[3] for i in formatted_recs if i[3] is not None])/len(formatted_recs)}\\\\n\\\")\\n if show_vibes:\\n print(\\\"You'll get along with people who like: \\\\n\\\")\\n for x in dupes:\\n print(self._get_info(x[0], x[1]))\\n print('\\\\n')\\n if rec_movies:\\n return formatted_recs\",\n \"def log_predictive_density(self, y_test, mu_star, var_star):\\r\\n assert y_test.shape==mu_star.shape\\r\\n assert y_test.shape==var_star.shape\\r\\n assert y_test.shape[1] == 1\\r\\n def integral_generator(y, m, v):\\r\\n \\\"\\\"\\\"Generate a function which can be integrated to give p(Y*|Y) = int p(Y*|f*)p(f*|Y) df*\\\"\\\"\\\"\\r\\n def f(f_star):\\r\\n return self.pdf(f_star, y)*np.exp(-(1./(2*v))*np.square(m-f_star))\\r\\n return f\\r\\n\\r\\n scaled_p_ystar, accuracy = zip(*[quad(integral_generator(y, m, v), -np.inf, np.inf) for y, m, v in zip(y_test.flatten(), mu_star.flatten(), var_star.flatten())])\\r\\n scaled_p_ystar = np.array(scaled_p_ystar).reshape(-1,1)\\r\\n p_ystar = scaled_p_ystar/np.sqrt(2*np.pi*var_star)\\r\\n return np.log(p_ystar)\",\n \"def get_likelihood(self, discretized=False, state=None):\\n if not hasattr(self, 'softmax'):\\n self.generate_softmax()\\n\\n if self.softmax is not None:\\n if state is not None:\\n return self.softmax.probability(class_=self.softmax_class_label,\\n state=state)\\n elif discretized:\\n return self.softmax.probability(class_=self.softmax_class_label)\\n else:\\n return self.softmax, self.softmax_class_label\\n else:\\n logging.error(\\\"Couldn't generate softmax model for {}\\\"\\n .format(self.__str__()))\",\n \"def compute_log_likelihood(self, X, y, weights, avg=False):\\n Z = self.sigmoid(np.dot(X, weights))\\n epsilon = np.finfo(float).eps\\n Z = np.clip(Z, epsilon, 1.0-epsilon)\\n\\n ll_all = y * np.log(Z) + (1 - y) * np.log(1 - Z)\\n if not avg:\\n return np.sum(ll_all)\\n else:\\n return np.mean(ll_all)\",\n \"def log_marginal_likelihood_normal_pdf(self):\\n noise_variance=self.params['noise_variance']['value']\\n Kxx = self.C@self._Kernel(self.X, self.X, self.params)@self.C.T + (noise_variance+self.jitter) * np.eye(self.Y.shape[0])\\n try:\\n mu = np.linalg.solve(Kxx, self.Y)\\n (sign, logdet) = np.linalg.slogdet(2 * np.pi * Kxx) \\n logp1 = -0.5*np.asscalar(self.Y.T@mu)-0.5*logdet \\n except:\\n logp1=-10.0**300\\n return logp1\",\n \"def featureLikelihood():\\r\\n\\r\\n\\t# Lists\\r\\n\\twords = []\\r\\n\\tfinalWords = []\\r\\n\\tposWords = []\\r\\n\\tnegWords = []\\r\\n\\tfeatureListPos = []\\r\\n\\tfeatureListNeg = []\\r\\n\\r\\n\\t# Counters\\r\\n\\tposCount = 0.0\\r\\n\\tnegCount = 0.0\\r\\n\\r\\n\\t# Temporary Lists for formating\\r\\n\\tfeatureListPosFormat = []\\r\\n\\tfeatureListNegFormat = []\\r\\n\\r\\n\\t# Strings\\r\\n\\ts = \\\" \\\"\\r\\n\\tposString = \\\"\\\"\\r\\n\\tnegString = \\\"\\\"\\r\\n\\r\\n\\tseen = set()\\r\\n\\r\\n\\t# Add all words to words list and count positive & negative occurences\\r\\n\\tfor item in trainingData:\\r\\n\\t\\tfor word in item[2]:\\r\\n\\t\\t\\twords.append(word)\\r\\n\\t\\tif item[1] == '0':\\r\\n\\t\\t\\tfor word in item[2]:\\r\\n\\t\\t\\t\\tposWords.append(word)\\r\\n\\t\\t\\t\\tposCount += 1\\r\\n\\t\\tif item[1] == '1':\\r\\n\\t\\t\\tfor word in item[2]:\\r\\n\\t\\t\\t\\tnegWords.append(word)\\r\\n\\t\\t\\t\\tnegCount +=1\\r\\n\\r\\n\\t# Adds all values into finalWords, skipping duplicates\\r\\n\\tfor values in words:\\r\\n\\t\\tif values not in seen:\\r\\n\\t\\t\\tfinalWords.append(values)\\r\\n\\t\\t\\tseen.add(values)\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t\\r\\n\\t# Add positive and negative counts to feature list and dictionaries\\r\\n\\tfor word in finalWords:\\r\\n\\t\\ts += '{:12s}'.format(word)\\r\\n\\t\\t\\r\\n\\t\\tpCount = 0\\r\\n\\t\\tnCount = 0\\r\\n\\t\\t\\r\\n\\t\\tfor row in trainingData:\\r\\n\\t\\t\\tif row[1] == '0':\\r\\n\\t\\t\\t\\tif word in row[2]: pCount += 1\\r\\n\\t\\t\\tif row[1] == '1':\\r\\n\\t\\t\\t\\tif word in row[2]: nCount += 1\\r\\n\\t\\t\\t\\t\\r\\n\\t\\tfeatureListPos.append((pCount + 1) / (posCount + 9))\\r\\n\\t\\tclass0Dict[word] = ((pCount + 1) / (posCount + 9))\\r\\n\\t\\t\\r\\n\\t\\tfeatureListNeg.append((nCount + 1) / (negCount + 9))\\r\\n\\t\\tclass1Dict[word] = ((nCount + 1) / (negCount + 9))\\r\\n\\r\\n\\t\\t\\r\\n\\t\\t\\r\\n\\t# Formatting for the positive feature list\\r\\n\\tfor item in featureListPos:\\r\\n\\t\\tfeatureListPosFormat.append('{0:.5f}'.format(item))\\r\\n\\t\\t\\r\\n\\tfor item in featureListPosFormat:\\r\\n\\t\\tposString += '{:12s}'.format(item)\\r\\n\\r\\n\\t# Formatting for the negative feature list\\r\\n\\tfor item in featureListNeg:\\r\\n\\t\\tfeatureListNegFormat.append('{0:.5f}'.format(item))\\r\\n\\t\\t\\r\\n\\tfor item in featureListNegFormat:\\r\\n\\t\\tnegString += '{:12s}'.format(item)\\r\\n\\r\\n\\r\\n\\t\\t\\r\\n\\treturn(s, posString, negString)\",\n \"def log_likelihood(self, x):\\n return self.log_likelihood_exp(x) + self.log_prior_nuisance_parameters(x)\",\n \"def likelihood(self):\\n\\n # assert the Gaussian process is up to date\\n self._gp_up_to_date()\\n\\n noise_penalization_term = -1 / 2 * np.log(\\n np.linalg.det(self.cov_matrix))\\n\\n y = np.linalg.solve(self.cov_matrix, self.list_y)\\n y = np.array(self.list_y) @ y\\n data_fidelity_term = -1 / 2 * y\\n\\n nbr_obs_term = - self.n_observation * np.log(2 * np.pi)\\n likelihood = (\\n noise_penalization_term + data_fidelity_term + nbr_obs_term\\n )\\n return likelihood\",\n \"def relative_likelihood(self):\\n \\n if self.num_hidden == 0:\\n \\n return T.exp(-self.compute_energy(self.x, self.batch_size))\\n \\n if self.num_hidden > 0:\\n \\n return T.exp(-self.compute_free_energy(self.x))\",\n \"def log_likelihood_function(self, instance):\\r\\n\\r\\n xvalues = np.arange(self.data.shape[0])\\r\\n model_data = instance.profile_from_xvalues(xvalues=xvalues)\\r\\n residual_map = self.data - model_data\\r\\n chi_squared_map = (residual_map / self.noise_map) ** 2.0\\r\\n log_likelihood = -0.5 * sum(chi_squared_map)\\r\\n\\r\\n return log_likelihood\",\n \"def _getCurrentPosteriorLikelihood(self): \\n likelihood = 0\\n T = self.T\\n K= self.K \\n final_likelihood = 0\\n total_log_lik = 0\\n \\n for n in range(1,self.N+1):\\n # Compute total Likelihood for all Instances P(x1...xn / theta) \\n tot_lik = 0\\n tot_scale_factor = 0\\n \\n for i in range(1,self.K+1): \\n likelihood = self.posterior_state_trellis[n][(T,i)]\\n tot_lik = tot_lik + likelihood\\n\\n try:\\n total_log_lik = math.log(tot_lik) \\n except ValueError:\\n ipdb.set_trace()\\n \\n for t in range(1,self.T):\\n scale_factor = self.forward_scaling_vector[n][t] \\n tot_scale_factor = tot_scale_factor + math.log(scale_factor)\\n\\n final_likelihood = final_likelihood + (total_log_lik - tot_scale_factor)\\n\\n return final_likelihood\",\n \"def _compute_likelihood(self, mus, pmfs):\\n expected_counts = pmfs.copy()\\n for mu, _p_bin_source in zip(mus, expected_counts):\\n _p_bin_source *= mu # Works because of numpy view magic...\\n expected_total = np.sum(expected_counts, axis=0)\\n\\n observed_counts = self.data_events_per_bin.histogram\\n\\n ret = observed_counts * np.log(expected_total) - expected_total - gammaln(observed_counts + 1.).real\\n return np.sum(ret)\",\n \"def get_gating_probs(self,X):\\n\\t\\tpi = self.gating.predict(X) #p(z_i = k|x_i) (N,K)\\n\\t\\t#pi = np.divide(pi.T, np.sum(pi, axis = 1)).T\\n\\t\\treturn pi\",\n \"def pred_prob(hp, ss, y):\\n K = len(ss['counts'])\\n N = sum(ss['counts'])\\n assert y >= 0 and y <= K\\n if y < K:\\n return log((ss['counts'][y] - hp['d']) / (hp['alpha'] + N))\\n elif y == K:\\n return log((hp['alpha'] + hp['d'] * K) / (hp['alpha'] + N))\",\n \"def likelihood(self,x,params = None,**kwargs):\\n return np.exp(self.log_likelihood(x,params=params,**kwargs))\",\n \"def predict(self, user, movie, similarity):\\n bias = self.baseline_predictor(user, movie)\\n\\n numerator = 0.\\n denominator = 0.\\n for user_movie in self.user_ratings[user]:\\n if similarity == 'pearson':\\n numerator += self.pearson_correlation(movie, user_movie) * (\\n self.user_ratings[user][user_movie] - self.baseline_predictor(user, user_movie))\\n denominator += self.pearson_correlation(movie, user_movie)\\n elif similarity == 'content':\\n numerator += self.content_similarity(movie, user_movie) * (\\n self.user_ratings[user][user_movie] - self.baseline_predictor(user, user_movie))\\n denominator += self.content_similarity(movie, user_movie)\\n\\n return bias + numerator / denominator\",\n \"def likelihood(self, w, class_words):\\n return log((class_words.count(w) + 1)/(len(class_words) + self.N))\",\n \"def __log_likelihood(self, params, *args):\\n\\t\\tX, y, feature_set, lambda_reg, empirical_weights, verbose, sign = args\\n\\n\\t\\tno_example = len(X)\\n\\t\\ttotal_logZ = 0\\n\\t\\ttotal_logProb = 0\\n\\t\\texpected_weights = np.zeros(len(feature_set))\\n\\t\\tfor t in range(len(X)):\\n\\t\\t\\t# example_features = X[t], example_labels = y[t]\\n\\n\\t\\t\\tpotential = np.zeros(len(X[t]))\\n\\t\\t\\tfor i in range(len(X[t])):\\n\\t\\t\\t\\t#candidate_features = X[t][i], candidate_label = y[t][i]\\n\\t\\t\\t\\tpotential[i] = feature_set.calc_inner_product(X[t][i], params)\\n\\n\\t\\t\\t#scaling\\n\\t\\t\\tpotential = potential - np.max(potential, keepdims=True)\\n\\n\\t\\t\\tfor i in range(len(X[t])):\\n\\t\\t\\t\\ttotal_logProb += potential[i] * y[t][i]\\n\\n\\t\\t\\tpotential, Z = self.__softmax(potential)\\n\\n\\t\\t\\tfor i in range(len(X[t])):\\n\\t\\t\\t\\tfeature_set.calc_inner_sum(expected_weights, X[t][i], potential[i])\\n\\n\\t\\t\\ttotal_logZ += log(Z)\\n\\n\\t\\t# _params = feature_set.get_regularized_params(params, 'bias')\\n\\t\\t_params = params\\n\\t\\tlog_likelihood = total_logProb - total_logZ - (lambda_reg/2) * np.sum(np.multiply(_params,_params))\\n\\t\\tgradients = empirical_weights - expected_weights - lambda_reg * _params\\n\\n\\t\\tglobal SUB_ITERATION_NUM\\n\\t\\tif verbose:\\n\\t\\t\\tsub_iteration_str = ' '\\n\\t\\t\\tif SUB_ITERATION_NUM > 0:\\n\\t\\t\\t\\tsub_iteration_str = '(' + '{0:02d}'.format(SUB_ITERATION_NUM) + ')'\\n\\t\\t\\tprint(' ', '{0:03d}'.format(ITERATION_NUM), sub_iteration_str, ':', log_likelihood * sign)\\n\\n\\t\\tSUB_ITERATION_NUM += 1\\n\\n\\t\\treturn sign * log_likelihood, sign * gradients\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6651372","0.64923996","0.6368747","0.6227888","0.60699147","0.606234","0.6056535","0.6044773","0.6008728","0.5998901","0.598668","0.5961036","0.59381664","0.5892908","0.58896697","0.58854824","0.58576494","0.5855964","0.58468914","0.58361566","0.58294886","0.5816115","0.58120453","0.5802073","0.5800728","0.57991654","0.57991475","0.5797923","0.57706994","0.57241726","0.5721494","0.5717146","0.571034","0.57048917","0.5701402","0.56926435","0.56870896","0.5681352","0.567164","0.56601244","0.5647501","0.56389695","0.5634353","0.5632469","0.5629627","0.5626954","0.56203204","0.56194884","0.5618339","0.5616652","0.56157255","0.5609111","0.5589103","0.55790466","0.55721074","0.55666107","0.5562721","0.55554765","0.5551373","0.55472803","0.5543234","0.55344206","0.5534004","0.55256623","0.55231464","0.5521817","0.5520419","0.55189574","0.55145746","0.5495371","0.548844","0.54884285","0.5485102","0.5482716","0.5479914","0.54646564","0.54567707","0.54505265","0.54478467","0.54406285","0.54383314","0.54350084","0.54323804","0.5430247","0.54276353","0.5427191","0.5420412","0.54187584","0.54106134","0.5400956","0.53994185","0.5396489","0.53925043","0.53822386","0.53804016","0.53734475","0.5373285","0.5371362","0.53692275","0.5349343"],"string":"[\n \"0.6651372\",\n \"0.64923996\",\n \"0.6368747\",\n \"0.6227888\",\n \"0.60699147\",\n \"0.606234\",\n \"0.6056535\",\n \"0.6044773\",\n \"0.6008728\",\n \"0.5998901\",\n \"0.598668\",\n \"0.5961036\",\n \"0.59381664\",\n \"0.5892908\",\n \"0.58896697\",\n \"0.58854824\",\n \"0.58576494\",\n \"0.5855964\",\n \"0.58468914\",\n \"0.58361566\",\n \"0.58294886\",\n \"0.5816115\",\n \"0.58120453\",\n \"0.5802073\",\n \"0.5800728\",\n \"0.57991654\",\n \"0.57991475\",\n \"0.5797923\",\n \"0.57706994\",\n \"0.57241726\",\n \"0.5721494\",\n \"0.5717146\",\n \"0.571034\",\n \"0.57048917\",\n \"0.5701402\",\n \"0.56926435\",\n \"0.56870896\",\n \"0.5681352\",\n \"0.567164\",\n \"0.56601244\",\n \"0.5647501\",\n \"0.56389695\",\n \"0.5634353\",\n \"0.5632469\",\n \"0.5629627\",\n \"0.5626954\",\n \"0.56203204\",\n \"0.56194884\",\n \"0.5618339\",\n \"0.5616652\",\n \"0.56157255\",\n \"0.5609111\",\n \"0.5589103\",\n \"0.55790466\",\n \"0.55721074\",\n \"0.55666107\",\n \"0.5562721\",\n \"0.55554765\",\n \"0.5551373\",\n \"0.55472803\",\n \"0.5543234\",\n \"0.55344206\",\n \"0.5534004\",\n \"0.55256623\",\n \"0.55231464\",\n \"0.5521817\",\n \"0.5520419\",\n \"0.55189574\",\n \"0.55145746\",\n \"0.5495371\",\n \"0.548844\",\n \"0.54884285\",\n \"0.5485102\",\n \"0.5482716\",\n \"0.5479914\",\n \"0.54646564\",\n \"0.54567707\",\n \"0.54505265\",\n \"0.54478467\",\n \"0.54406285\",\n \"0.54383314\",\n \"0.54350084\",\n \"0.54323804\",\n \"0.5430247\",\n \"0.54276353\",\n \"0.5427191\",\n \"0.5420412\",\n \"0.54187584\",\n \"0.54106134\",\n \"0.5400956\",\n \"0.53994185\",\n \"0.5396489\",\n \"0.53925043\",\n \"0.53822386\",\n \"0.53804016\",\n \"0.53734475\",\n \"0.5373285\",\n \"0.5371362\",\n \"0.53692275\",\n \"0.5349343\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75495005"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":89595,"cells":{"query":{"kind":"string","value":"For every movie, computes the posterior distribution and MAP estimate of the movie's true/inherent rating given the movie's observed ratings. Input"},"document":{"kind":"string","value":"def infer_true_movie_ratings(num_observations=-1):\n\n M = 11 # all of our ratings are between 0 and 10\n prior = np.array([1.0 / M] * M) # uniform distribution\n likelihood = compute_movie_rating_likelihood(M)\n\n # get the list of all movie IDs to process\n movie_id_list = movie_data_helper.get_movie_id_list()\n num_movies = len(movie_id_list)\n\n # -------------------------------------------------------------------------\n # YOUR CODE GOES HERE FOR PART (d)\n #\n # Your code should iterate through the movies. For each movie, your code\n # should:\n # 1. Get all the observed ratings for the movie. You can artificially\n # limit the number of available ratings used by truncating the ratings\n # vector according to num_observations.\n # 2. Use the ratings you retrieved and the function compute_posterior to\n # obtain the posterior of the true/inherent rating of the movie\n # given the observed ratings\n # 3. Find the rating for each movie that maximizes the posterior\n\n # These are the output variables - it's your job to fill them.\n posteriors = np.zeros((num_movies, M))\n MAP_ratings = np.zeros(num_movies)\n \n for i in range(num_movies):\n movie_id = movie_id_list[i]\n y = movie_data_helper.get_ratings(movie_id)[:num_observations]\n posteriors[i] = compute_posterior(prior,likelihood,y)\n MAP_ratings[i] = np.argmax(posteriors[i])\n #\n # END OF YOUR CODE FOR PART (d)\n # -------------------------------------------------------------------------\n print(posteriors,MAP_ratings)\n return posteriors, MAP_ratings"},"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_rating(self, movie):\n\n #\n # option 1: SQLAlchemy ORM\n #\n UserMovies = db.aliased(Rating)\n MovieUsers = db.aliased(Rating)\n\n query = (db.session.query(Rating.user_id, Rating.score, UserMovies.score, MovieUsers.score)\n .join(UserMovies, UserMovies.movie_id == Rating.movie_id)\n .join(MovieUsers, Rating.user_id == MovieUsers.user_id)\n .filter(UserMovies.user_id == self.user_id)\n .filter(MovieUsers.movie_id == movie.movie_id))\n\n #\n # option 2: raw SQL\n #\n # sql = \"\"\"\n # SELECT ratings.user_id, ratings.score, user_movies.score, movie_users.score\n # FROM ratings AS user_movies\n # JOIN ratings\n # ON (user_movies.movie_id = ratings.movie_id)\n # JOIN ratings AS movie_users\n # ON (ratings.user_id = movie_users.user_id)\n # WHERE user_movies.user_id = :user_id\n # AND movie_users.movie_id = :movie_id\n # \"\"\"\n #\n # query = db.session.execute(sql, dict(user_id=self.user_id, movie_id=movie.movie_id))\n #\n\n known_ratings = {}\n paired_ratings = defaultdict(list)\n\n for rating_user_id, rating_score, user_movie_score, movie_user_score in query:\n paired_ratings[rating_user_id].append((user_movie_score, rating_score))\n known_ratings[rating_user_id] = movie_user_score\n\n similarities = []\n\n for _id, score in known_ratings.items():\n similarity = correlation.pearson(paired_ratings[_id])\n if similarity > 0:\n similarities.append((similarity, score))\n\n if not similarities:\n return None\n\n numerator = sum([score * sim for sim, score in similarities])\n denominator = sum([sim for sim, score in similarities])\n\n return numerator / denominator","def estimate_movie_biases(self):\n self.movie_biases = {}\n for movie in self.movie_ratings:\n # b_i = sum(r_ui - mu) / len(R(i))\n movie_bias = [rating - self.global_mean for rating in self.movie_ratings[movie].values()]\n movie_bias = sum(movie_bias) / len(movie_bias)\n self.movie_biases[movie] = movie_bias","def predictOnMovie(self,user,movie,neibor_list,user_rating,user_aver_rating):\n predict = user_aver_rating[user]\n numerator, denominator = 0.0,0.0\n for sim, neighbor in neibor_list:\n if movie in user_rating[neighbor]:\n numerator += sim*(user_rating[neighbor][movie]-user_aver_rating[neighbor])\n denominator += sim\n predict += numerator/denominator\n return predict","def _aggregate_vectors(movies, feedback_list=[]):\n movie_vec = []\n for i in movies:\n try:\n m_vec = clf[i] # get the vector for each movie\n if ratings_dict:\n try:\n r = ratings_dict[i] # get user_rating for each movie\n # Use a polynomial to weight the movie by rating.\n # This equation is totally arbitrary. I just fit a polynomial\n # to some weights that look good. The effect is to raise\n # the importance of 1, 9, and 10 star ratings.\n w = ((r**3)*-0.00143) + ((r**2)*0.0533) + (r*-0.4695) + 2.1867\n m_vec = m_vec * w\n except KeyError:\n continue\n movie_vec.append(m_vec)\n except KeyError:\n continue\n if feedback_list:\n for i in feedback_list:\n try:\n f_vec = clf[i]\n movie_vec.append(f_vec*1.8) # weight feedback by adding multiplier here\n except KeyError:\n continue\n return np.mean(movie_vec, axis=0)","def get_movie_scores(df, min_vote_count=1000):\n ratings = {}\n\n for x in CREW_ATTRIBUTES:\n ratings[x] = get_avg_scores_for_attribute(df, x, min_vote_count)\n\n df['production_score'] = df.apply(calculate_final_production_score, ratings=ratings, axis=1)\n return df","def recommend(self, u):\n\n sims = {} #similarities\n recommendation = \"\"\n topScore = None\n start = time.time()\n for movie_id, rating in enumerate(u):\n if rating != 0:\n sims[movie_id] = {}\n for r_id, movie in enumerate(self.ratings):\n sims[movie_id][r_id] = self.distance(movie,self.ratings[movie_id])\n # print time.time() - start, \"distance time\"\n\n start = time.time()\n for i, movieRating in enumerate(self.ratings):\n iPrediction = 0\n for movieName in self.ratedMovieList:\n j = self.titlesOnly.index(movieName)\n iPrediction += sims[j][i]*1.0 * self.userRatingVector[j]\n if topScore is None or iPrediction > topScore:\n movie = self.titlesOnly[i]\n if movie not in self.ratedMovieList and movie not in self.recommendedMovies:\n # print(\"prediction score for %s is %.5f\" % (movie, iPrediction))\n topScore = iPrediction\n recommendation = movie\n # print time.time() - start, \"recommendation time\"\n self.recommendedMovies.append(recommendation)\n\n articlePattern = re.match('(.*), (the|a|an|el|la)', recommendation)\n if articlePattern is not None:\n recommendation = articlePattern.group(2) + \" \" + articlePattern.group(1)\n\n return recommendation","def predictRating(self, movieID):\n\t\t\n\t\treturn movieID","def predict_rating(R, R_avg, S, u, m):\n\n # Users (ie. neighbours) that have rated this movie.\n neighbours = R[m].dropna().index\n\n numer, denom = 0, 0\n for v in neighbours:\n numer += S.ix[u, v] * (R.ix[v, m] - R_avg[v])\n denom += abs(S.ix[u, v])\n\n rating = R_avg[u] + (numer / denom)\n\n return rating","def compute_movie_rating_likelihood(M):\n\n # define the size to begin with\n likelihood = np.zeros((M, M))\n\n # -------------------------------------------------------------------------\n # YOUR CODE GOES HERE FOR PART (c)\n #\n # Remember to normalize the likelihood, so that each column is a\n # probability distribution.\n \n for i in range(M):\n for j in range(M):\n if i == j:\n likelihood[i][j] = 2\n else:\n likelihood[i][j] = 1/abs(j-i)\n \n likelihood = likelihood / likelihood.sum(axis = 1)\n \n #\n # END OF YOUR CODE FOR PART (c)\n # -------------------------------------------------------------------------\n\n return likelihood","def fit(self, ratings_mat):\n self.logger.debug(\"starting fit\")\n # self.n = ratings.max()['user']+1\n # self.p = ratings.max()['movie']+1\n self.ratings_mat = ratings_mat\n self.k = ratings_mat.shape[0]//20\n\n #ratings_array = ratings[ratings.columns[:-1].values].values\n\n #self.ratings_mat = np.zeros((self.n, self.p))\n\n #for i, rating in ratings.iterrows():\n # self.ratings_mat[( rating['user'], rating['movie'] )] = rating['rating']\n\n self.cosine_dists = squareform(pdist(ratings_mat, 'cosine'))\n\n #if a user has no ratings data, cosine dist will return a nan. In this case, we assume they are as different as possible, since we cannot predict using those users anyways\n self.cosine_dists = 1 - np.nan_to_num(1 - self.cosine_dists)\n\n self.similarity_ranks = self.cosine_dists.argsort(axis = 1)\n\n # ...\n\n self.logger.debug(\"finishing fit\")\n return(self)","def movie_stats(movies):\n def num_years():\n \"\"\"number of years covered in the dataset\"\"\"\n years = movies['Year']\n return ('num_years', years.nunique())\n\n def tot_movies():\n \"\"\"total number of movies over all years\"\"\"\n total = movies['Number of Movies'].sum()\n return ('tot_movies', total)\n\n def yr_fewest_movies():\n \"\"\"year with fewest movies made (earliest)\"\"\"\n copy = movies.copy()\n year = copy.sort_values(['Number of Movies', 'Year']).reset_index(drop = True).Year.loc[0]\n return ('yr_fewest_movies', year)\n\n def avg_gross():\n \"\"\"average amount of money grossed over all years\"\"\"\n avg = movies['Total Gross'].mean()\n if avg is np.nan:\n raise\n return ('avg_gross', avg)\n\n def highest_per_movie():\n \"\"\"The year with the highest gross per movie\"\"\"\n copy = movies.copy()\n copy['Gross Per Movie'] = copy['Total Gross'] / copy['Number of Movies'] #calculate gross per movie\n year = copy.sort_values(['Gross Per Movie'], ascending = False).reset_index(drop = True).Year.loc[0]\n return ('highest_per_movie', year)\n\n def second_lowest():\n \"\"\"name of the top movie during the second lowest (total) grossing year\"\"\"\n copy = movies.copy()\n name = copy.sort_values(['Total Gross']).reset_index(drop = True)['#1 Movie'].loc[1]\n return ('second_lowest', name)\n\n def avg_after_harry():\n \"\"\"avg number of movies made the year after an HP movie was #1 movie\"\"\"\n copy = movies.copy()\n copy = copy.sort_values(['Year']).reset_index(drop = True) #years early to present\n harry_years = copy[copy['#1 Movie'].str.contains('Harry')].Year #years where harry potter was #1\n next_years = harry_years + 1\n check = list(next_years.values)\n next_years_df = copy[copy['Year'].isin(check)]\n avg = next_years_df['Number of Movies'].mean()\n if avg is np.nan:\n raise\n return ('avg_after_harry', avg)\n\n functions = [num_years(), tot_movies(), yr_fewest_movies(), avg_gross(), highest_per_movie(), second_lowest(), avg_after_harry()]\n stats = {}\n for fxn in functions:\n try:\n info = fxn\n stats[info[0]] = info[1]\n except:\n continue\n series = pd.Series(stats)\n\n return series","def index_and_evaluate(movie_ids):\n iindex = get_normalised_inverse_index(movie_ids)\n user_ids = iindex.keys()\n nn_index = CosineNN(max(movie_ids) + 1) # +1 since ids are 1-based\n\n # Add all movies to nn_index\n for i, uid in enumerate(user_ids):\n col = iindex[uid].uratings\n nn_index.index(uid, col)\n if i % 10 == 0:\n print('index progress: {:.3%}'.format(i / len(user_ids)))\n print('indexing and setup complete')\n\n # Find all test data instances for which we can predict a rating\n probe_ratings = read_probe(movie_ids)\n to_predict = []\n for mid, mratings in probe_ratings.items():\n for uid, rating in mratings.items():\n if uid in user_ids:\n to_predict.append((uid, mid, rating))\n\n # Predict ratings for test data instances and add up error\n errors = []\n for i, (uid, mid, actual) in enumerate(to_predict):\n print('evaluation progress: {:.3%}'.format(i / len(to_predict)))\n guess = guess_rating(nn_index, iindex, uid, mid)\n errors.append((guess - actual)**2)\n print('RMSE:', np.sqrt(np.mean(errors)))","def compute_user_similarity(d1, d2, ave_rat1, ave_rat2):\n \n movie_1=set()\n movie_2=set()\n for movie,value in d1.items():\n movie_1.add(movie) \n for movie, value in d2.items():\n movie_2.add(movie) \n common_movie_rated=movie_1.intersection(movie_2)\n if (len(common_movie_rated)==0):\n return 0.0\n num = 0\n den1 = 0\n den2 = 0\n for common_movie in common_movie_rated:\n num += (float(d1[common_movie])-ave_rat1)*(float(d2[common_movie])-ave_rat2)\n den1 += ((float(d1[common_movie])-ave_rat1)**2)\n den2 += ((float(d2[common_movie]) - ave_rat2) ** 2)\n # When the user gives same rating to all the movies\n try:\n user_sim = num/((den1*den2)**0.5)\n except ZeroDivisionError:\n return 0.0\n return user_sim","def __count_and_average_ratings(self):\n logger.info(\"Counting movie ratings...\")\n movie_ID_with_ratings_RDD = self.ratings_RDD.map(lambda x: (x[1], x[2])).groupByKey()\n movie_ID_with_avg_ratings_RDD = movie_ID_with_ratings_RDD.map(get_counts_and_averages)\n self.movies_rating_counts_RDD = movie_ID_with_avg_ratings_RDD.map(lambda x: (x[0], x[1][0]))","def __count_and_average_ratings(self):\n logger.info(\"Counting movie ratings...\")\n movie_ID_with_ratings_RDD = self.ratings_RDD.map(lambda x: (x[1], x[2])).groupByKey()\n movie_ID_with_avg_ratings_RDD = movie_ID_with_ratings_RDD.map(get_counts_and_averages)\n self.movies_rating_counts_RDD = movie_ID_with_avg_ratings_RDD.map(lambda x: (x[0], x[1][0]))","def predict(self, input, bad_movies=[], hist_list=[], val_list=[],\n ratings_dict = {}, checked_list=[], rejected_list=[],\n n=50, harshness=1, rec_movies=True,\n show_vibes=False, scoring=False):\n\n clf = self._get_model()\n dupes = [] # list for storing duplicates for scoring\n\n def _aggregate_vectors(movies, feedback_list=[]):\n \"\"\"Gets the vector average of a list of movies.\"\"\"\n movie_vec = []\n for i in movies:\n try:\n m_vec = clf[i] # get the vector for each movie\n if ratings_dict:\n try:\n r = ratings_dict[i] # get user_rating for each movie\n # Use a polynomial to weight the movie by rating.\n # This equation is totally arbitrary. I just fit a polynomial\n # to some weights that look good. The effect is to raise\n # the importance of 1, 9, and 10 star ratings.\n w = ((r**3)*-0.00143) + ((r**2)*0.0533) + (r*-0.4695) + 2.1867\n m_vec = m_vec * w\n except KeyError:\n continue\n movie_vec.append(m_vec)\n except KeyError:\n continue\n if feedback_list:\n for i in feedback_list:\n try:\n f_vec = clf[i]\n movie_vec.append(f_vec*1.8) # weight feedback by adding multiplier here\n except KeyError:\n continue\n return np.mean(movie_vec, axis=0)\n\n def _similar_movies(v, bad_movies=[], n=50):\n \"\"\"Aggregates movies and finds n vectors with highest cosine similarity.\"\"\"\n if bad_movies:\n v = _remove_dislikes(bad_movies, v, harshness=harshness)\n return clf.similar_by_vector(v, topn= n+1)[1:]\n\n def _remove_dupes(recs, input, bad_movies, hist_list=[], feedback_list=[]):\n \"\"\"remove any recommended IDs that were in the input list\"\"\"\n all_rated = input + bad_movies + hist_list + feedback_list\n nonlocal dupes\n dupes = [x for x in recs if x[0] in input]\n return [x for x in recs if x[0] not in all_rated]\n\n def _remove_dislikes(bad_movies, good_movies_vec, rejected_list=[], harshness=1):\n \"\"\"Takes a list of movies that the user dislikes.\n Their embeddings are averaged,\n and subtracted from the input.\"\"\"\n bad_vec = _aggregate_vectors(bad_movies, rejected_list)\n bad_vec = bad_vec / harshness\n return good_movies_vec - bad_vec\n\n def _score_model(recs, val_list):\n ids = [x[0] for x in recs]\n return len(list(set(ids) & set(val_list)))\n\n aggregated = _aggregate_vectors(input, checked_list)\n recs = _similar_movies(aggregated, bad_movies, n=n)\n recs = _remove_dupes(recs, input, bad_movies, hist_list, checked_list + rejected_list)\n formatted_recs = [self._get_info(x[0], x[1]) for x in recs]\n if scoring and val_list:\n print(f\"The model recommended {_score_model(recs, val_list)} movies that were on the watchlist!\\n\")\n print(f\"\\t\\t Average Rating: {sum([i[3] for i in formatted_recs if i[3] is not None])/len(formatted_recs)}\\n\")\n if show_vibes:\n print(\"You'll get along with people who like: \\n\")\n for x in dupes:\n print(self._get_info(x[0], x[1]))\n print('\\n')\n if rec_movies:\n return formatted_recs","def __predict_ratings(self, user_and_movie_RDD):\n predicted_RDD = self.model.predictAll(user_and_movie_RDD)\n predicted_rating_RDD = predicted_RDD.map(lambda x: (x.product, x.rating))\n predicted_rating_title_and_count_RDD = \\\n predicted_rating_RDD.join(self.movies_titles_RDD).join(self.movies_rating_counts_RDD)\n predicted_rating_title_and_count_RDD = \\\n predicted_rating_title_and_count_RDD.map(lambda r: (r[1][0][1], r[1][0][0], r[1][1]))\n \n return predicted_rating_title_and_count_RDD","def predictRating(toPredict, candidateList):\n\n ratingRelevantCandidates = []\n\n #Remove candidates with no rating specified\n for candidate in candidateList:\n currentCandidate = candidate[1]\n\n if float(currentCandidate['vote_avg']) > 0:\n ratingRelevantCandidates.append((float(currentCandidate['vote_avg']), candidate))\n\n #print(\"ratings::::::::\",currentCandidate['vote_avg'])\n\n #Remove outlier candidates based on rating\n ratingMean = np.mean([x[0] for x in ratingRelevantCandidates])\n print(\"ratingMean\", ratingMean)\n ratingSD = np.std([x[0] for x in ratingRelevantCandidates])\n print(\"ratingSD\", ratingSD)\n\n finalRatings = [x for x in ratingRelevantCandidates if (float(x[0]) < ratingMean + ratingSD)]#1.5 *\n finalRatings = [x for x in finalRatings if (float(x[0]) > ratingMean - ratingSD)]#.75 *\n\n finalRatingCandidatesWithWeight = []\n\n #Weight each candidate based on vote count, direct and actor popularity and matching score from part 1\n for candidate in finalRatings:\n directorPoints = compareDirectorPoints(toPredict['director'], candidate[1][1]['director'])\n actorPoints = compareActorPoints(toPredict['cast'], candidate[1][1]['cast'])\n voteCountPoints = int(candidate[1][1]['vote_count'])\n matchPoints = candidate[1][0] / np.max([float(x[1][0]) for x in finalRatings]) * 100\n candidateWeight = PREDICTION_MATCHPOINTS_WEIGHT * matchPoints \\\n + PREDICTION_ACTOR_WEIGHT * actorPoints \\\n + PREDICTION_DIRECTOR_WEIGHT * directorPoints \\\n + PREDICTION_VOTECOUNT_WEIGHT * voteCountPoints\n\n finalRatingCandidatesWithWeight.append((candidateWeight, candidate[0]))\n\n #Calculate the prediction\n sumRatingCandidateWeights = np.sum([float(x[0]) for x in finalRatingCandidatesWithWeight])\n sumRatingTimesCandidateWeight = np.sum([float(x[0]) * float(x[1]) for x in finalRatingCandidatesWithWeight])\n\n ratingPrediction = float(sumRatingTimesCandidateWeight / sumRatingCandidateWeights)\n\n return ratingPrediction","def __predict_ratings(self, user_and_movie_RDD):\n predicted_RDD = self.model.predictAll(user_and_movie_RDD)\n predicted_rating_RDD = predicted_RDD.map(lambda x: (x.product, x.rating))\n\n return predicted_rating_RDD","def recommend_movies(target_rating: Rating,\n movies: MovieDict,\n user_ratings: UserRatingDict,\n movie_users: MovieUserDict,\n num_movies: int) -> List[int]:\n similars = get_similar_users(target_rating, user_ratings, movie_users)\n movie_lst = get_candidate_movies(target_rating, similars, user_ratings)\n movies = {}\n for m in movie_lst:\n for u in movie_users[m]:\n if u in similars:\n score = similars[u]\n num_user_movie = num_rated_above(movie_lst, user_ratings[u])\n movie_popularity = total_rated(movie_users[m], m, user_ratings)\n movies[m] = movies.get(m, 0) + score / (num_user_movie * movie_popularity)\n lst = sorted(list(movies.items()))\n result = [i[0] for i in\n sorted(lst, key=lambda k: k[1], reverse=True)]\n return result[:num_movies]","def predict(user_id, item_id, ratings):\n\n # convert long to wide\n ratings_wide = ratings.pivot(index='user', columns='movie', values='rating')\n\n # compute user similarities\n similarities = compute_similarities(user_id, ratings_wide)\n \n prediction = predict_rating(item_id, ratings_wide, similarities, N=N_NEIGHBORS)\n \n return prediction","def predict(self, user, movie, similarity):\n bias = self.baseline_predictor(user, movie)\n\n numerator = 0.\n denominator = 0.\n for user_movie in self.user_ratings[user]:\n if similarity == 'pearson':\n numerator += self.pearson_correlation(movie, user_movie) * (\n self.user_ratings[user][user_movie] - self.baseline_predictor(user, user_movie))\n denominator += self.pearson_correlation(movie, user_movie)\n elif similarity == 'content':\n numerator += self.content_similarity(movie, user_movie) * (\n self.user_ratings[user][user_movie] - self.baseline_predictor(user, user_movie))\n denominator += self.content_similarity(movie, user_movie)\n\n return bias + numerator / denominator","def netflix_predict(movie_id, customer_id):\n\n avg_mov_value = CACHE_AVG_MOVIE_RATING[movie_id]\n avg_cust_value = CACHE_AVG_CUSTOMER_RATING[customer_id]\n years_after_release = CACHE_YEARS_SINCE_RELEASE[movie_id][customer_id]\n\n # Equation from results gradient-descent/linRegResults.txt\n res = 3.78699752 + (avg_mov_value - 3.72) * 0.91299576 \\\n + (avg_cust_value - 3.72) * 0.90834816 \\\n + years_after_release * 0.00196377\n\n # Actual ratings cannot be greater than 5 or less than 1\n if res > 5.0:\n res = 5.0\n elif res < 1.0:\n res = 1.0\n\n return res","def calculate_final_production_score(row, ratings):\n scores = {}\n\n for x in CREW_ATTRIBUTES:\n data = row[x]\n\n # handle director case that isn't wrapped by []\n data = get_literal_eval(data)\n\n total_score = calculate_total_score(data, ratings[x])\n\n # more famous actors usually means higher review (e.g. Ocean's 11)\n if x == 'cast':\n scores[x] = total_score\n elif len(data):\n scores[x] = (total_score / len(data))\n\n final_score = sum(scores.values())\n\n return final_score","def get_movies(self):\n\n movies = {}\n\n for index, movie in self.movies.iterrows():\n\n id_movie = int(movie[0])\n title = movie[1]\n movie_tags = []\n movie_ratings = []\n\n # Get tags for each movie\n tags = self.movies_tags.loc[self.movies_tags[0] == id_movie]\n\n for index_movie, tag in tags.iterrows():\n\n movie_tags.append(tag[1])\n\n # Get ratings for each film\n ratings = self.ratings.loc[self.ratings[1] == id_movie]\n\n # Get user ratings\n for index_ratings, row_rating in ratings.iterrows():\n movie_ratings.append((row_rating[0], float(row_rating[2]))) # (id_user, score)\n\n # Create Movie object\n movie_object = Movie(id_movie=id_movie, title=title, tags=movie_tags, ratings=movie_ratings)\n\n # Append movie_object in dictionary\n movies[id_movie] = movie_object\n\n return movies","def ratings_best(Y, titles):\n ratings_lists = data_proc.ratings_for_movies(Y)\n\n # Possible rating values\n rating_values = list(range(1, 6))\n\n # avg_ratings[i] = average rating of movie i\n # avg_ratings = [float(sum(ratings_list)) / len(ratings_list)\n # for ratings_list in ratings_lists]\n # Disfavor highly rated movies with few ratings:\n # http://stats.stackexchange.com/a/6361\n avg_ratings = [float(sum(ratings_list) + sum(rating_values))\n / (len(ratings_list) + len(rating_values))\n for ratings_list in ratings_lists]\n best_ids = data_proc.top_indices(avg_ratings, 10)\n best_titles = [titles[id] for id in best_ids]\n\n # ratings_table[i][j] is the number of rating_values[j] ratings for\n # movie with id i\n ratings_table = \\\n [[sum([rating_list[1] == id and rating_list[2] == rating_val\n for rating_list in Y])\n for rating_val in rating_values]\n for id in best_ids]\n\n sns.heatmap(ratings_table,\n annot=True, fmt='d', # Annotate data values\n yticklabels=best_titles, xticklabels=rating_values)\n plt.yticks(rotation=0) # Rotate yticks horizontally\n plt.xlabel('Rating')\n plt.title('Ratings of highest rated movies')\n plt.tight_layout() # Make room for long ytick labels\n plt.show()","def assign_rank_weight(self, data_frame):\n groupby_movies = data_frame.groupby(\"movieid\")\n movie_rank_weight_dict = {}\n for movieid, info_df in groupby_movies:\n max_rank = info_df.actor_movie_rank.max()\n for rank in info_df.actor_movie_rank.unique():\n movie_rank_weight_dict[(movieid, rank)] = (max_rank - rank + 1)/max_rank*100\n return movie_rank_weight_dict","def all_ratings(Y):\n bar_count_ratings(Y, 'Rating distribution for all movies')\n plt.show()","def get_movielist_movie_attributes(self, movie_html, popularity=None, pagenr=None, nr_pages=None):\n a = movie_html.find('a')\n url = a.get('href')\n id = int(movie_html.find('div', attrs={'class': 'fl_titlelist_rating'}).get('titleid'))\n title = a.get('title')\n year = self.get_year_from_movielist_title(a.text)\n movie_info = {'crit_id': id,\n 'crit_url': url,\n 'title': title,\n 'year': year,\n 'date_added': arrow.now()}\n if popularity is not None and pagenr is not None and nr_pages is not None:\n movie_info.update({'crit_popularity': popularity - (pagenr - 1)/(nr_pages - 1)})\n try:\n psi = int(movie_html.find('div', attrs={'class': 'pti'}).text)\n except AttributeError:\n psi = None\n try:\n rating = int(movie_html.find('div', attrs={'title': 'Your Ranking'}).text)\n except AttributeError:\n rating = None\n movie_info = self.add_psi_and_rating_to_movie_info(movie_info, rating=rating, psi=psi)\n return movie_info","def binarize(self):\n total = 0\n count = 0\n avg_rating = 0\n for movie_id, movie in enumerate(self.ratings):\n for user_id, rating in enumerate(movie):\n if rating != 0:\n self.ratings[movie_id,user_id] = 1 if rating > 2.5 else -1","def item_based_collaborative(new_ratings, movie_ratings=None, movies=None):\n movie_ratings = movie_ratings if movie_ratings is not None else load_movie_ratings()\n movies = movies if movies is not None else load_movies()\n highest_rating = max(new_ratings.values())\n rated_movies = [int(movie) for movie in new_ratings if int(movie) in movie_ratings.index]\n index_list = movie_ratings.index.tolist()\n favorite_movies = [index_list.index(movie) for movie in rated_movies if new_ratings[str(movie)] == highest_rating]\n sims = cosine_similarity(movie_ratings)[favorite_movies,].mean(axis=0)\n ranked = movies.join(pd.DataFrame({\"rating\": sims}, index=index_list)).sort_values(\"rating\", ascending=False)\n ranked.drop(rated_movies, axis=0, inplace=True)\n return ranked","def make_predictions(movies, ratings_train, ratings_test):\n ###TODO\n \n user_result = [] \n \n for index,row in ratings_test.iterrows():\n userid_test = row['userId']\n #print(\"userid_test::\",userid_test) \n movieid_test = row['movieId'] \n #print(\"movieid_test::\",movieid_test) \n x = list(movies[movies.movieId==movieid_test]['features'])[0]\n #print(\"CSR_GOTT+X::\",x)\n #print(\"TYPE of CSR_GOTT_X::\",type(x))\n subset_train = ratings_train[ratings_train.userId == userid_test]\n #print(\"SUB MOVIE SET::\",subset_train)\n #print(\"TYPE of SUB MOVIE SET::\",type(x))\n total_if_zero=0\n rating_if_zero=0\n sum_main_result=0\n sum_cosine=0 \n for index1,row1 in subset_train.iterrows():\n userid_train = row1['userId']\n #print(\"userid_train::\",userid_train) \n if(userid_test == userid_train ):\n #print(\"HII IN IFFF:::\")\n movieid_train = row1['movieId']\n #print(\"movieid_train::\",movieid_train)\n rating_train = row1['rating']\n #print(\"rating_train::\",rating_train)\n total_if_zero = total_if_zero + 1 \n rating_if_zero = rating_if_zero + rating_train\n y = list(movies[movies.movieId==movieid_train]['features'])[0]\n #print(\"CSR_GOTT_Y::\",y)\n #print(\"TYPE of CSR_GOTT_Y::\",type(y))\n result_cos = cosine_sim(x,y)\n sum_main_result += result_cos * rating_train\n sum_cosine += result_cos \n \n if(sum_main_result != 0):\n user_result.append(sum_main_result/sum_cosine)\n #print(\"user_result::\",user_result) \n else:\n user_result.append(rating_if_zero / total_if_zero)\n #print(\"user_result::\",user_result) \n \n return_result_arr = np.array(user_result) \n \n return return_result_arr\n \n pass","def update_mean_movie_rating(self):\n self.mean_movie_rating = self.ratings.groupby(['movie_id'])['rating'].mean().reset_index()","def dist_by_rating(self):\n return ratings_distribution","def compute_average_user_ratings(user_ratings):\n ave_ratings = {}\n \n for user,value in user_ratings.items():\n sum = 0\n movie_num=0\n for movieId, rating in value.items():\n sum += float(rating)\n movie_num += 1\n average = sum / movie_num\n ave_ratings[user]=average\n return ave_ratings","def scrape_movie_page(dom):\n # to save the information\n info = []\n\n # find the information block needed\n header = dom.find(\"div\", \"title_wrapper\")\n\n # find the title and strip the string\n name_dom = header.h1.get_text().encode(\"utf-8\")\n name = str(name_dom)[2:-16]\n info.append(name)\n\n # find the year and strip the year\n year_dom = header.h1.span.get_text().encode(\"utf-8\")\n year = str(year_dom)[3:-2]\n info.append(year)\n\n # find the duration and strip the string\n duration_dom = dom.find(\"time\", itemprop=\"duration\").get_text().encode(\"utf-8\")\n duration = str(duration_dom)[28:-23]\n info.append(duration)\n\n # find all the genres and strip the string\n genre_dom = dom.find(\"div\", itemprop=\"genre\").a.get_text().encode(\"utf-8\")\n genre = find_genres(genre_dom, dom)\n info.append(genre)\n\n # find all the directors and strip the string\n director_dom = dom.find(\"span\", itemprop=\"director\").get_text().encode(\"utf-8\")\n director = find_directors(director_dom, dom)\n info.append(director)\n\n # find all the writers and strip the string\n writer_dom = dom.find(\"span\", itemprop=\"creator\").a.get_text().encode(\"utf-8\")\n writer = find_writers(writer_dom, dom)\n info.append(writer)\n\n # find all the actors and strip the string\n actor_dom = dom.find(\"span\", itemprop=\"actors\").a.get_text().encode(\"utf-8\")\n actor = find_actors(actor_dom, dom)\n info.append(actor)\n\n # find the rating and strip the string\n rating_dom = dom.find(\"span\", itemprop=\"ratingValue\").get_text().encode(\"utf-8\")\n rating = str(rating_dom)[2:-1]\n info.append(rating)\n\n # find the number of ratings and strip the string\n number_ratings_dom = dom.find(\"span\", itemprop=\"ratingCount\").get_text().encode(\"utf-8\")\n number_ratings = str(number_ratings_dom)[2:-1]\n info.append(number_ratings)\n\n return info","def evaluate_model(predictions_table: pd.DataFrame, ratings_table: pd.DataFrame,\n test_table: pd.DataFrame, viewed_table: pd.DataFrame,\n all_predictions_table: pd.DataFrame) -> Dict:\n\n viewed = viewed_table.to_numpy()\n predictions = predictions_table.to_numpy()\n all_predictions = all_predictions_table.to_numpy()\n ratings = ratings_table.to_numpy()\n test = test_table.to_numpy(copy=True)\n test_demeaned = test - np.mean(test, axis=1).reshape(-1, 1)\n test_set = test_table.apply(lambda x: x != 0.0).astype(int).to_numpy()\n\n result = dict()\n\n # Test set evaluation\n test_predictions = np.multiply(all_predictions, test_set)\n diff = np.subtract(test_predictions, test_demeaned)\n rmse = np.sqrt(np.mean(np.square(diff)))\n result.update({\"RMSE\": rmse})\n mae = np.mean(np.absolute(diff))\n result.update({\"MAE\": mae})\n\n # overall evaluation\n movies_recommended = set()\n i = 0\n for index, row in predictions_table.iterrows():\n if i > 10000: break\n else: i += 1\n\n labels = row.nlargest(20).keys().tolist()\n for movie in labels:\n movies_recommended.update(movie)\n\n result.update({\"Coverage\": len(movies_recommended)})\n\n return result","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(ratings_file, sep=ratings_delim, names=ratings_names, header=0, encoding=encoding, engine=engine)\n movies_df = pd.read_csv(movies_file, sep=movies_delim, names=movies_names, header=0, encoding=encoding, engine=engine)\n all_users = list(set(ratings_df.user_id))\n users_df = pd.DataFrame()\n users_df['user_id'] = all_users\n print(ratings_df.head())\n\n return {\n 'ratings': ratings_df,\n 'users': users_df,\n 'movies': movies_df,\n }","def movies_to_users(user_ratings: UserRatingDict) -> MovieUserDict:\n movie_user_dict = {}\n for u in user_ratings:\n for m in user_ratings[u]:\n if m in movie_user_dict:\n movie_user_dict[m].append(u)\n else:\n movie_user_dict[m] = [u]\n return movie_user_dict","def makeDictionary(self):\n self.dictionary = {}\n for i in range(len(self.movie)):\n if self.movie[i] in self.dictionary:\n vectors = self.dictionary[self.movie[i]]\n vectors[self.user[i]] = self.rating[i]\n self.dictionary[self.movie[i]] = vectors\n else:\n newMovie = dict([(self.user[i], self.rating[i])])\n self.dictionary[self.movie[i]] = newMovie\n return self.dictionary","def get_user_ratings_by_movie(self, movie_id):\r\n return self.df_ratmat[self.df_ratmat.iloc[:, movie_id - 1] > 0]","def get_movie_tag_matrix(self):\n data_frame = genre_tag.get_genre_data()\n tag_df = data_frame.reset_index()\n unique_tags = tag_df.tag.unique()\n idf_data = tag_df.groupby(['movieid'])['tag'].apply(set)\n tf_df = tag_df.groupby(['movieid'])['tag'].apply(lambda x: ','.join(x)).reset_index()\n movie_tag_dict = dict(zip(tf_df.movieid, tf_df.tag))\n tf_weight_dict = {movie: genre_tag.assign_tf_weight(tags.split(',')) for movie, tags in\n list(movie_tag_dict.items())}\n idf_weight_dict = {}\n idf_weight_dict = genre_tag.assign_idf_weight(idf_data, unique_tags)\n tag_df = genre_tag.get_model_weight(tf_weight_dict, idf_weight_dict, tag_df, 'tfidf')\n tag_df[\"total\"] = tag_df.groupby(['movieid','tag'])['value'].transform('sum')\n temp_df = tag_df[[\"moviename\", \"tag\", \"total\"]].drop_duplicates().reset_index()\n\n\n\n genre_tag_tfidf_df = temp_df.pivot_table('total', 'moviename', 'tag')\n genre_tag_tfidf_df = genre_tag_tfidf_df.fillna(0)\n genre_tag_tfidf_df.to_csv('movie_tag_matrix1d.csv', index=True, encoding='utf-8')\n return genre_tag_tfidf_df","def __init__(self):\n\n try:\n self.posFreqDict = self.load(\"posFreqDict\")\n self.neuFreqDict = self.load(\"neuFreqDict\")\n self.negFreqDict = self.load(\"negFreqDict\")\n\n except:\n\n lFileList = []\n for fFileObj in os.walk(\"movies_reviews/\"): \n lFileList = fFileObj[2]\n break\n random.shuffle(lFileList)\n \n self.train(lFileList)\n Original_d = {}\n d = {}\n correct_positives =0\n incorrect_positives=0\n correct_negatives =0\n incorrect_negatives = 0\n for file in lFileList[int(float(len(lFileList))*.9):len(lFileList)+1]:\n rating = int(file[7])\n if rating in Original_d:\n Original_d[rating] = Original_d[rating]+1\n else:\n Original_d[rating]=1\n\n fileText = self.loadFile(\"movies_reviews/\" + str(file))\n result = self.classify(fileText)\n if result in d:\n d[result]=d[result]+1\n else:\n d[result]=1\n if rating==5:\n if result ==\"positive\":\n correct_positives+=1\n else:\n incorrect_positives+=1\n else:\n if result == \"negative\":\n correct_negatives+=1\n else:\n incorrect_negatives+=1\n print Original_d\n print d\n print correct_positives #Actually positive, we said positive\n print incorrect_positives #Actually positive, we said negative\n print correct_negatives #Actually negative, we said negative\n print incorrect_negatives #Actually negative, we said positive\n \n A = float(correct_positives)\n B = float(incorrect_positives)\n C = float(incorrect_negatives)\n\n Recall = (A / (A + B)) *100.0\n Precision = (A / (A + C)) *100.0\n FScore = 2 * (Recall*Precision) / (Recall+Precision)\n\n print Recall\n print Precision\n print FScore","def check_ratings(self):\n\n self.browser.get('https://www.imdb.com/')\n\n for title in self.titles:\n input_bar = self.browser.find_element_by_id('navbar-query')\n input_bar.clear()\n\n input_bar.send_keys(title)\n input_bar.send_keys(Keys.RETURN)\n\n time.sleep(3)\n\n # Click on the first suggestion\n css_selector = \"div.findSection:nth-child(3) > table:nth-child(2) > tbody:nth-child(1) > tr:nth-child(1) > td:nth-child(2) > a:nth-child(1)\"\n self.browser.find_element_by_css_selector(css_selector).click()\n time.sleep(3)\n\n # Pull details that will always be available\n score = str(self.browser.find_element_by_class_name('ratingValue').text)\n score = score.split('/10')[0].replace(',', '.')\n\n time.sleep(3)\n\n summary = str(self.browser.find_element_by_class_name('summary_text').text)\n subtext = str(self.browser.find_element_by_class_name('subtext').text)\n\n # Pull details that differ between movies and series\n try:\n duration = str(self.browser.find_element_by_class_name('bp_sub_heading').text) # Only for series\n if 'episodes' not in duration:\n duration = 'Some episodes'\n except Exception:\n # bp_sub_heading won't be found on a movie page\n duration = 'movie'\n\n if subtext[0].isdigit():\n # Split up the details from the subtext\n subtext_list = subtext.split(' | ')\n else:\n # Some movies' subtext starts with 'R' / 'PG-13'\n subtext_list = subtext.split(' | ')\n del subtext_list[0]\n\n # Duration\n if duration == 'movie':\n show_type = 'Movie'\n duration = subtext_list[0]\n try:\n year = datetime.datetime.strptime(subtext_list[2].split(' (')[0], '%d %B %Y').strftime('%Y')\n except ValueError:\n year = str(subtext_list[2].split(' (')[0][-4:])\n\n else: # series\n show_type = 'Serie'\n # Retrieve last season and its release date\n season_tab = str(self.browser.find_element_by_class_name('seasons-and-year-nav').text).strip()\n\n numbers = re.findall('[0-9]+', season_tab)\n latest_season = int(numbers[0])\n latest_year = int(max(numbers, key=lambda x: int(x)))\n\n duration += ' (%d Seasons in %d), %s per episode' % (latest_season, latest_year, subtext_list[0])\n\n year = re.findall('[0-9]+', subtext_list[2])[0]\n\n # Pull some more data out from the subtext\n genres = subtext_list[1].split(', ')\n\n # Pull details that are not always available\n creds_list = []\n creds = self.browser.find_elements_by_class_name('credit_summary_item')\n for c in creds:\n temp = str(c.text)\n if '|' in temp:\n temp = temp.split('|')[0]\n\n creds_list.append(temp)\n\n self.data_dict[title] = {\n 'score': score,\n 'summary': summary,\n 'duration': duration,\n 'credits': creds_list,\n 'genres': genres,\n 'released': year,\n 'type': show_type,\n }","def get_average_ratings_of_movies(self, movie_ids):\r\n return self.df_data[self.df_data[\"item_id\"].isin(movie_ids)].groupby(\"item_id\").mean()","def transform(self, requests):\n self.logger.debug(\"starting predict\")\n self.logger.debug(\"request count: {}\".format(requests.shape[0]))\n\n preds = [self.predict_one(row['user'], row['movie']) for i, row in requests.iterrows()]\n\n requests['rating'] = preds\n return requests","def most_similar_actors_lda(self, moviename):\n data_frame = self.data_extractor.get_mlmovies_data()\n tag_data_frame = self.data_extractor.get_genome_tags_data()\n movie_data_frame = self.data_extractor.get_mltags_data()\n movie_tag_data_frame = movie_data_frame.merge(tag_data_frame, how=\"left\", left_on=\"tagid\", right_on=\"tagId\")\n movie_tag_data_frame = movie_tag_data_frame.merge(data_frame, how=\"left\", left_on=\"movieid\", right_on=\"movieid\")\n tag_df = movie_tag_data_frame.groupby(['movieid'])['tag'].apply(list).reset_index()\n\n tag_df = tag_df.sort_values('movieid')\n movies = tag_df.movieid.tolist()\n tag_df = list(tag_df.iloc[:, 1])\n\n input_movieid = self.util.get_movie_id(moviename)\n\n (U, Vh) = self.util.LDA(tag_df, num_topics=5, num_features=1000)\n\n movie_topic_matrix = self.util.get_doc_topic_matrix(U, num_docs=len(movies), num_topics=5)\n topic_movie_matrix = movie_topic_matrix.transpose()\n movie_movie_matrix = numpy.dot(movie_topic_matrix, topic_movie_matrix)\n\n index_movie = None\n for i, j in enumerate(movies):\n if j == input_movieid:\n index_movie = i\n break\n\n if index_movie == None:\n print(\"Movie Id not found.\")\n return None\n\n movie_row = movie_movie_matrix[index_movie].tolist()\n movie_movie_dict = dict(zip(movies, movie_row))\n del movie_movie_dict[input_movieid]\n\n for key in movie_movie_dict.keys():\n movie_movie_dict[key] = abs(movie_movie_dict[key])\n\n movie_movie_dict = sorted(movie_movie_dict.items(), key=operator.itemgetter(1), reverse=True)\n\n if movie_movie_dict == None:\n return None\n actors = []\n for (movie, val) in movie_movie_dict:\n if val <= 0:\n break\n actors = actors + self.sim_act_diff_mov_tf.get_actors_of_movie(self.util.get_movie_name_for_id(movie))\n if len(actors) >= 10:\n break\n\n actors_of_given_movie = self.sim_act_diff_mov_tf.get_actors_of_movie(moviename)\n\n actorsFinal = [x for x in actors if x not in actors_of_given_movie]\n\n actornames = []\n for actorid in actorsFinal:\n actor = self.util.get_actor_name_for_id(actorid)\n actornames.append(actor)\n\n return actornames","def movie_profile(movie_id):\n\n if not session.get('logged_in_user_email'):\n flash(\"Please login or signup to see the movie details and rate the movie!\", \"danger\")\n return redirect(\"/signup-login\")\n\n else:\n\n # import pdb; pdb.set_trace();\n\n # Query by movie id to return that record in database about movie info\n # movie = Movie.query.filter(Movie.movie_id == movie_id).one()\n movie = Movie.query.get(movie_id)\n\n user = User.query.filter(User.email == session.get(\"logged_in_user_email\")).one()\n user_id = user.user_id\n\n if user_id:\n user_rating = Rating.query.filter_by(movie_id=movie_id, user_id=user_id).first()\n else:\n user_rating = None\n\n # Prediction code: only predict if the user hasn't rated it\n prediction = None\n\n if (not user_rating) and user_id:\n user = User.query.get(user_id)\n if user:\n prediction = user.predict_rating(movie)\n\n # Either use the prediction or their real rating\n if prediction:\n # User hasn't scored; use our prediction if we made one\n effective_rating = prediction\n\n elif user_rating:\n # User has already scored for real; use that\n effective_rating = user_rating.score\n\n else:\n # User hasn't scored and we couldn't get a prediction\n effective_rating = None\n\n # Get the wizard's rating, either by predicting or using real rating\n wizard = User.query.filter_by(email=\"wizard@gmail.com\").one()\n wizard_rating = Rating.query.filter_by(user_id=wizard.user_id, movie_id=movie.movie_id).first()\n\n if wizard_rating is None:\n wizard_rating = wizard.predict_rating(movie)\n else:\n wizard_rating = wizard_rating.score\n\n if wizard_rating and effective_rating:\n difference = abs(wizard_rating - effective_rating)\n else:\n # We couldn't get a wizard rating, so we'll skip difference\n difference = None\n\n # Depending on how different we are from the Wizard, choose a message\n BERATEMENT_MESSAGES = [\n \"I suppose you don't have such bad taste after all.\",\n \"I regret every decision that I've ever made that has brought me to listen to your opinion.\",\n \"Words fail me, as your taste in movies has clearly failed you.\",\n \"That movie is great. For a clown to watch. Idiot.\",\n \"Words cannot express the awfulness of your taste.\"\n ]\n\n if difference is not None:\n beratement = BERATEMENT_MESSAGES[int(difference)]\n else:\n beratement = None\n\n # Tallies score of each rating (how many people rated this score per rating)\n # Returns list of tuples for count_score\n unordered_ratings = db.session.query(Rating.score, func.count(Rating.score)).filter(Rating.movie_id == movie_id).group_by(Rating.score)\n ordered_movies = unordered_ratings.order_by(Rating.score)\n count_score = ordered_movies.all()\n\n # Get average score, which returns a tuple-like object, so need to access index 0 to return the number and pass through jinja\n avg_rating = db.session.query(func.avg(Rating.score)).filter(Rating.movie_id == movie_id).one()\n\n # Query to get all ratings for a specific movie\n # Needed to join Rating and Movie tables and filter by user id\n # Sort movie titles alphabetically\n ratings = db.session.query(Rating.movie_id,\n Rating.score,\n Movie.title).join(Movie).filter(Rating.movie_id == movie_id).all()\n\n # # Pass user info into jinja and called on its attributes\n # # Pass count_score, avg_rating, and ratings into jinja\n # return render_template(\"movie_profile.html\", movie=movie, count_score=count_score, avg_rating=avg_rating[0], ratings=ratings)\n\n return render_template(\n \"movie_profile.html\",\n movie=movie,\n user_rating=user_rating,\n avg_rating=avg_rating[0],\n count_score=count_score,\n prediction=prediction,\n ratings=ratings,\n beratement=beratement)","def movielens_1m_to_df(ratings_file, users_file, movies_file):\n ratings_names = ['user_id', 'movie_id', 'rating', 'unix_timestamp']\n ratings_delim = '::'\n users_names = ['user_id', 'gender', 'age', 'occupation', 'zip_code']\n users_delim = '::'\n movies_names = [ 'movie_id', 'movie_title', 'genres']\n movies_delim = '::'\n encoding = 'latin-1'\n engine = 'python'\n\n ratings_df = pd.read_csv(ratings_file, sep=ratings_delim, names=ratings_names, encoding=encoding, engine=engine)\n users_df = pd.read_csv(users_file, sep=users_delim, names=users_names, encoding=encoding, engine=engine)\n movies_df = pd.read_csv(movies_file, sep=movies_delim, names=movies_names, encoding=encoding, engine=engine)\n\n return {\n 'ratings': ratings_df,\n 'users': users_df,\n 'movies': movies_df,\n }","def makePrediction(toPredict,candidateList):\n\n print(\"Predicting for: \" + toPredict['title'])\n\n if PREDICT_RATING:\n actualRating = float(toPredict['actual_imdb_rating'])\n predictedRating = round(predictRating(toPredict, candidateList),1)\n percentDiff = round((actualRating - predictedRating) / actualRating * 100, 2)\n print(\"Predicted rating: \" + str(predictedRating) + \" Actual Rating: \" + str(actualRating))\n print(\"Difference in rating prediction: \" + str(percentDiff) + \"%\")\n else:\n predictedRating = round(predictRating(toPredict, candidateList), 1) # using rating to prune unrelated movies.\n actualRevenue = int(toPredict['actual_revenue'])\n predictedRevenue = int(predictRevenue(toPredict,candidateList,predictedRating) * float(toPredict['budget'])) #PredictRevenue method return mean RoR\n percentDiff = round((actualRevenue - predictedRevenue) / actualRevenue * 100, 2)\n print(str(\"Predicted revenue: \" + str(predictedRevenue) + \" Actual Revenue: \" + str(actualRevenue)))\n print(\"Difference in revenue prediction: \" + str(percentDiff) + \"%\")\n\n #Tabulate how close the prediction was based on percent difference\n if abs(percentDiff) <= 5:\n withinFive.append(0)\n\n if abs(percentDiff) <= 10:\n withinTen.append(0)\n\n if abs(percentDiff) <= 15:\n withinFifteen.append(0)\n\n if abs(percentDiff) <= 20:\n withinTwenty.append(0)\n\n if abs(percentDiff) <= 30:\n withinThirty.append(0)","def build_recommendations(sc, myRatings, model):\n #myRatedMovieIds = set([x[1] for x in myRatings])\n uid = get_uid_from_ratings(myRatings)\n #print \"uid:\", uid\n myRatedMovieIds = set([x[1] for x in myRatings.collect()])\n #print \"myRatedMovieIds:\", myRatedMovieIds\n candidates = sc.parallelize([m for m in movies if m not in myRatedMovieIds]).cache()\n #print candidates\n predictions = model.predictAll(candidates.map(lambda x: (uid, x))).collect()\n #print predictions\n recommendations = sorted(predictions, key = lambda x: x.product)\n return recommendations","def __init__(self,\n path,\n initial_affinity=0.5,\n update_rate=0.1,\n alpha=0.20,\n beta=0.10,\n gamma=0.40,\n theta=0.25,\n omega=0.10,\n train_ratio=0.9,\n ratings_ratio=1.0):\n # Case base structures\n self.user_affinity = AffinityCaseBase(initial_preference=initial_affinity,\n modifier=update_rate) # User recommendation feedback\n self.genre_willigness = AffinityCaseBase(initial_preference=initial_affinity,\n modifier=update_rate) # Recommendations feedback\n\n # Pandas datasets\n self.movies, self.users = None, None\n self.all_ratings, self.ratings, self.test_ratings = None, None, None\n\n # Case base global structures\n self.popular = None # Popular movies\n self.mean_movie_rating = None # Mean score for each movie\n self.mean_user_rating = None # Mean rating for each user\n\n # Movie score parameters\n self.alpha = alpha\n self.beta = beta\n self.gamma = gamma\n self.theta = theta\n self.omega = omega\n\n # Counter for test_rating set\n self.count = 0\n\n # User similarity caching\n self.user_cache = {}\n # Check ratios are in correct interval to avoid unexpected behaviors\n check_ratio('Initial affinity', initial_affinity)\n check_ratio('Update rate', update_rate)\n check_ratio('Alpha', alpha)\n check_ratio('Beta', beta)\n check_ratio('Gamma', gamma)\n check_ratio('Thetha', theta)\n check_ratio(\"Training ratio\", train_ratio)\n check_ratio(\"Ratings ratio\", ratings_ratio)\n\n # Read data\n self._read_data(path, ratings_ratio)","def extract_movies(dom):\n\n # extract data per movie\n movies = dom.find_all('div', class_ = 'lister-item mode-advanced')\n\n # list to store scraped data\n movielist = []\n\n for movie in movies:\n\n # append extracted data to this dict\n moviedict = {}\n\n # scrape titles and add to dict\n moviedict['title'] = movie.h3.a.text\n\n # scrape ratings and add to dict\n moviedict['rating'] = float(movie.strong.text)\n\n # scrape year of release and add to dict\n year = movie.h3.find('span', class_ = 'lister-item-year text-muted unbold')\n moviedict['year'] = re.findall('\\d+', year.text.strip('()'))[0]\n\n # scrape actors and add to dict\n actors = movie.find_all(href=re.compile(\"adv_li_st\"))\n actorlist = []\n for actor in actors:\n actorlist.append(actor.text)\n actorstring = ', '.join(actorlist)\n moviedict['actors'] = actorstring\n\n # scrape runtime and add to dict\n moviedict['runtime'] = movie.p.find('span', class_ = 'runtime').text.split(' ')[0]\n movielist.append(moviedict)\n\n\n # ADD YOUR CODE HERE TO EXTRACT THE ABOVE INFORMATION ABOUT THE\n # HIGHEST RATED MOVIES\n # NOTE: FOR THIS EXERCISE YOU ARE ALLOWED (BUT NOT REQUIRED) TO IGNORE\n # UNICODE CHARACTERS AND SIMPLY LEAVE THEM OUT OF THE OUTPUT.\n\n return movielist # REPLACE THIS LINE AS WELL IF APPROPRIATE","def get_rating(text):\n movie = text\n page = requests.get('http://www.imdb.com/find?ref_=nv_sr_fn&q=' + movie + '&s=tt')\n soup1 = BeautifulSoup(page.content, 'html.parser')\n movieid = soup1.select(\".findList tr a\")[0].get('href')\n movielink = \"http://www.imdb.com\" + movieid\n mlinkpage = requests.get(movielink)\n soup2 = BeautifulSoup(mlinkpage.content, 'html.parser')\n movierating = soup2.select(\".ratingValue span\")[0].text\n metascore = soup2.select(\".metacriticScore\")\n reviewlink = movielink + 'reviews'\n linkpage = requests.get(reviewlink)\n soup3 = BeautifulSoup(linkpage.content, 'html.parser')\n \n return soup3, movierating","def download_imdb_ratings():\n print(\"Option not implemented\")\n sys.exit(1)\n return {}","def get_mean_movie_rating(self, movie_id):\n return self.mean_movie_rating[self.mean_movie_rating['movie_id'] == movie_id]['rating'].item()","def get_similar_users(target_rating: Rating,\n user_ratings: UserRatingDict,\n movie_users: MovieUserDict) -> Dict[int, float]:\n dic = {}\n watched = get_users_who_watched(list(target_rating.keys()), movie_users)\n for u in watched:\n dic[u] = get_similarity(target_rating, user_ratings[u])\n return dic","def recommend(title, cosine_sim, indices, df):\n\n recommended_papers = {}\n\n # getting the index of the movie that matches the title\n try:\n idx = indices[indices == title].index[0]\n except:\n # return dummy values if indices doesn't behave (?)\n return {}, 0.0\n\n # creating a Series with the similarity scores in descending order\n score_series = pd.Series(cosine_sim[idx]).sort_values(ascending = False)\n #print(type(score_series))\n #print(len(score_series))\n\n # getting the indexes of the 5 most similar papers\n top_5_indexes = list(score_series.iloc[1:5].index)\n average_score = mean(score_series)\n #print('avg:', average_score)\n #highest_score = float(score_series.iloc[1])\n #print(score_series.iloc[1:5].index)\n #print(score_series.iloc[1:5])\n\n # populating the list with the titles of the best 5 matching papers\n for i in top_5_indexes:\n recommended_papers[list(df.index)[i]] = df['Link'][i]\n\n return recommended_papers, average_score","def pred_movies(movie_list):\r\n # Store the id of users\r\n id_store = []\r\n # For each movie selected by a user of the app,\r\n # predict a corresponding user within the dataset with the highest rating\r\n for i in movie_list:\r\n movieID = movies_df[movies_df['title'] == i]['movieId'].values[0]\r\n predictions = prediction_item(item_id=movieID)\r\n predictions.sort(key=lambda x: x.est, reverse=True)\r\n # Take the top 10 user id's from each movie with highest rankings\r\n for pred in predictions[:10]:\r\n id_store.append(pred.uid)\r\n # Return a list of user id's\r\n return id_store","def update_suggestions(ratings, tmdb_obj, status=True):\n seen = []\n suggs = {}\n ratings_count = len(ratings)\n i = 0\n for title, data in ratings.items():\n # Print progress\n if status:\n text = \"\\r{}/{} processed\".format(i, ratings_count)\n sys.stdout.flush()\n sys.stdout.write(text)\n i += 1\n\n movs = tmdb_obj.search_by_imdb_id(data.imdb_id) if data.type == tmdb_obj.media_type else None\n if movs:\n movie_id = movs[0][\"id\"]\n seen.append(movie_id)\n for sugg in similar_search(tmdb_obj, movie_id):\n # Different key if tv or movie\n title = sugg[\"title\"] if \"title\" in sugg else sugg[\"name\"]\n if title in suggs:\n suggs[title][0].append(data.user_rating)\n else:\n suggs[title] = ([data.user_rating], sugg)\n\n # Calculate movie scores\n # personalized suggestions\n res = {}\n res_p = {}\n for title, (scores, data) in suggs.items():\n if not data[\"id\"] in seen:\n s, s_p = suggest_score(data[\"popularity\"], data[\"vote_average\"], scores)\n res_p[title] = s_p, len(scores), data\n res[title] = s, len(scores), data\n\n # Sort on score\n res = sorted(res.items(), key=lambda item: item[1][0])\n res_p = sorted(res_p.items(), key=lambda item: item[1][0])\n\n if not os.path.exists(SUGGESTIONS_FOLDER):\n os.makedirs(SUGGESTIONS_FOLDER)\n # Write result to file\n with open(SUGGESTIONS_FOLDER + \"/\" + tmdb_obj.media_type + \"_\" + SUGGESTIONS_PATH, \"w\") as file:\n #for title, (score, relations, data) in res:\n file.write(json.dumps(res))\n with open(SUGGESTIONS_FOLDER + \"/\" + tmdb_obj.media_type + \"_\" + SUGGESTIONS_PERSONALIZED_PATH, \"w\") as file_p:\n #for title, (score, relations, data) in res:\n file_p.write(json.dumps(res_p))\n\n print()\n return res, res_p","def _imdb_score(title, min_votes=0):\n info = imdb_info(title)\n if info:\n if min_votes and info.get('votes', 0) < min_votes:\n return 0\n return info['rating']\n return 0","def _get_user_movie_rating(self, user_id, movie_id):\n rating = self.ratings[(self.ratings['user_id'] == user_id) &\n (self.ratings['movie_id'] == movie_id)]['rating'].iloc[0]\n user_mean = self.get_mean_user_rating(user_id)\n return rating - user_mean","def ready_movies():\n troy = Movie(movie_title=\"Troy\",\n poster_image=\"https://upload.wikimedia.org/wikipedia/en/b/b8/Troy2004Poster.jpg\",\n trailer_youtube=\"https://www.youtube.com/watch?v=znTLzRJimeY\")\n\n kingdom_of_heaven = Movie(movie_title=\"Kingdom of Heaven\",\n poster_image=\"https://upload.wikimedia.org/wikipedia/en/9/9e/KoHposter.jpg\",\n trailer_youtube=\"https://www.youtube.com/watch?v=moNH4N44D28\")\n\n warrior = Movie(movie_title=\"Warrior\",\n poster_image=\"https://upload.wikimedia.org/wikipedia/en/e/e3/Warrior_Poster.jpg\",\n trailer_youtube=\"https://www.youtube.com/watch?v=I5kzcwcQA1Q\")\n\n pulp_fiction = Movie(movie_title=\"Pulp Fiction\",\n poster_image=\"https://upload.wikimedia.org/wikipedia/en/3/3b/Pulp_Fiction_%281994%29_poster.jpg\",\n trailer_youtube=\"https://www.youtube.com/watch?v=s7EdQ4FqbhY\")\n\n fight_club = Movie(movie_title=\"Fight Club\",\n poster_image=\"https://upload.wikimedia.org/wikipedia/en/f/fc/Fight_Club_poster.jpg\",\n trailer_youtube=\"https://www.youtube.com/watch?v=SUXWAEX2jlg\")\n\n the_matrix = Movie(movie_title=\"The Matrix\",\n poster_image=\"https://upload.wikimedia.org/wikipedia/en/c/c1/The_Matrix_Poster.jpg\",\n trailer_youtube=\"https://www.youtube.com/watch?v=vKQi3bBA1y8\")\n\n the_dark_knight = Movie(movie_title=\"The Dark Knight\",\n poster_image=\"https://upload.wikimedia.org/wikipedia/en/8/8a/Dark_Knight.jpg\",\n trailer_youtube=\"https://www.youtube.com/watch?v=vKQi3bBA1y8\")\n\n whiplash = Movie(movie_title=\"Whiplash\",\n poster_image=\"https://upload.wikimedia.org/wikipedia/en/0/01/Whiplash_poster.jpg\",\n trailer_youtube=\"https://www.youtube.com/watch?v=7d_jQycdQGo\")\n\n dredd = Movie(movie_title=\"Dredd\",\n poster_image=\"https://upload.wikimedia.org/wikipedia/en/1/16/Dredd2012Poster.jpg\",\n trailer_youtube=\"https://www.youtube.com/watch?v=qv-6dNqqnMA\")\n\n ai_artificial_intelligence = Movie(movie_title=\"A.I. Artificial Intelligence\",\n poster_image=\"https://upload.wikimedia.org/wikipedia/en/e/e6/AI_Poster.jpg\",\n trailer_youtube=\"https://www.youtube.com/watch?v=_19pRsZRiz4\")\n\n watchmen = Movie(movie_title=\"Watchmen\",\n poster_image=\"https://upload.wikimedia.org/wikipedia/en/b/bc/Watchmen_film_poster.jpg\",\n trailer_youtube=\"https://www.youtube.com/watch?v=PVjA0y78_EQ\")\n\n the_rock = Movie(movie_title=\"The Rock\",\n poster_image=\"https://upload.wikimedia.org/wikipedia/en/8/82/The_Rock_%28movie%29.jpg\",\n trailer_youtube=\"https://www.youtube.com/watch?v=jGVJx5mOtL8\")\n\n movies = [troy, kingdom_of_heaven, warrior, pulp_fiction, fight_club, the_matrix,\n the_dark_knight, whiplash, dredd, ai_artificial_intelligence,\n watchmen, the_rock]\n\n return movies","def main():\n directors = get_movies_by_director()\n directors = get_average_scores(directors)\n print_results(directors)","def get_ratings_for_movie_ids(self, user_id, movie_ids):\n requested_movies_RDD = self.sc.parallelize(movie_ids).map(lambda x: (user_id, x))\n # Get predicted ratings\n ratings = self.__predict_ratings(requested_movies_RDD).collect()\n return ratings","def evaluate():\n global dictionary, wv\n count = 0\n # To save the scores by distance and similarity\n scores = np.zeros(6)\n similar = np.zeros(6)\n itr = len(dictionary)\n logging.info('running evaluation for {0} samples'.format(itr))\n for key in dictionary:\n progress = (count / itr) * 100\n d = dictionary[key].split('resource/')\n d = [idx.split()[0].translate(table).lower() for idx in d[1:]]\n try:\n r = np.array(list(map(lambda x: wv.get_vector(x), d)),\n dtype=np.float32)\n except KeyError:\n itr -= 1\n continue\n if np.any(np.isnan(r)):\n itr -= 1\n continue\n else:\n if r.ndim == 2:\n try:\n # Mean of vector containing all word vectors\n # obtained from abstract.\n r = r.mean(axis=0).reshape(1, -1)\n \n # Obtain the vectors for the entity\n mean_vec = mean_encoder(dictionary[key])\n mean_vec = mean_vec.reshape(1, -1) / norm(mean_vec)\n mean_dist_vec = distance_encoder(dictionary[key])\n mean_dist_vec = mean_dist_vec.reshape(1, -1)\n mean_dist_vec = mean_dist_vec / norm(mean_dist_vec)\n title_vec = title_mean(key)\n title_vec = title_vec.reshape(1, -1) / norm(title_vec)\n abstract_vec = abstract_encoder(key)\n abstract_vec = abstract_vec.reshape(1, -1)\n abstract_vec = abstract_vec / norm(abstract_vec)\n random_vec = np.random.randn(100).reshape(1, -1)\n zero_vec = np.zeros(100).reshape(1, -1)\n \n # Score the entity vectors\n scores[0] += norm(r - mean_vec)\n scores[1] += norm(r - mean_dist_vec)\n scores[2] += norm(r - title_vec)\n scores[3] += norm(r - abstract_vec)\n scores[4] += norm(r - random_vec)\n scores[5] += norm(r - zero_vec)\n similar[0] += cosine_similarity(r, mean_vec)\n similar[1] += cosine_similarity(r, mean_dist_vec)\n similar[2] += cosine_similarity(r, title_vec)\n similar[3] += cosine_similarity(r, abstract_vec)\n similar[4] += cosine_similarity(r, random_vec)\n similar[5] += cosine_similarity(r, zero_vec)\n count += 1\n print(count, end='\\r')\n except (ValueError, KeyError) as _:\n itr -= 1\n continue\n else:\n itr -= 1\n continue\n # Normalize the scores to get a better\n # comparison against the baselines.\n scores = scores / norm(scores)\n similar = similar / norm(similar)\n print_summary(scores, similar)","def update_posterior_probs(vars_):\n vars_.weighted_sums += np.power(vars_.dprime_map[vars_.focus],2) * vars_.visual_field\n vars_.post_probs = np.exp(vars_.weighted_sums) * vars_.prior_prob\n vars_.post_probs /= np.sum(vars_.post_probs)","def __tags_to_movies(mlens_to_tmdb, movies_to_titles, tags_to_names,\n genomeFile='ml-latest/genome-scores.csv'):\n rdr = csv.reader(open(genomeFile))\n next(rdr, None)\n\n tagsToMovies = {}\n\n for row in rdr:\n movieLensId = row[0]; tagId = row[1]; score=row[2]\n tmdb_id = mlens_to_tmdb[movieLensId]\n tagName = tags_to_names[tagId]\n if tagName not in tagsToMovies:\n tagsToMovies[tagName] = []\n\n title = movies_to_titles[tmdb_id]\n tagsToMovies[tagName].append( (tmdb_id, title, score) )\n\n # Sort each by score\n for tagId, scoredMovies in tagsToMovies.items():\n scoredMovies.sort(key=lambda x: x[2], reverse=True)\n\n return tagsToMovies","def get_average_scores(directors):\n records = {\n director: movies\n for director, movies in directors.items()\n if len(movies) >= MIN_MOVIES\n }\n return {\n (director, _calc_mean(movies)): movies for director, movies in records.items()\n }","def update_popularity(self):\n ratings_count = self.ratings.groupby(['movie_id'])['rating'].count().reset_index()\n sorted_ids = ratings_count.sort_values(['rating'], ascending=[False])\n self.popular = pd.merge(sorted_ids, self.movies, left_on=['movie_id'], right_on=['movie_id'])","def predict_rating(item_id, ratings, similarities, N=10):\n \n # get the ratings of all users for the specific item\n users_ratings = ratings.loc[:, item_id]\n \n # only keep users who rated the given item, otherwise you won't be able to generate a prediction based on the users ratings\n most_similar_users_who_rated_item = similarities.loc[~users_ratings.isnull()]\n \n # keep N users with highest similarities to given user who also rated the given item\n N_most_similar_users = most_similar_users_who_rated_item.head(N)\n \n # find ratings item for most similar users:\n ratings_for_item = ratings.loc[N_most_similar_users.index, item_id]\n \n # predict the rating of the item by averaging the ratings of that item of the most similar users\n return ratings_for_item.mean()","def main():\n args = parse_argument()\n train_file = args['train'][0]\n test_file = args['test'][0]\n print train_file, test_file\n \n user_ratings_train, movie_ratings_train=parse_file(train_file)\n ave_ratings=compute_average_user_ratings(user_ratings_train)\n user_train=list(user_ratings_train.keys())\n with open(test_file,'r') as test:\n with open('predictions.txt', 'w') as pred:\n writer = csv.writer(pred)\n prediction=list()\n actual=list()\n for row in csv.reader(test):\n num_sum=0.0\n sim_sum=0.0\n user=int(row[1])\n movie=int(row[0])\n other_users_ratings=movie_ratings_train[movie]\n other_users=other_users_ratings.keys()\n for i in range(len(other_users)): \n other_user=other_users[i]\n similar=compute_user_similarity(user_ratings_train[user],user_ratings_train[other_user],ave_ratings[user],ave_ratings[other_user])\n num_sum=num_sum+similar*(float(movie_ratings_train[movie][other_user])-float(ave_ratings[other_user]))\n sim_sum = sim_sum+abs(similar)\n #No similar users\n try:\n pred_rating=ave_ratings[user]+num_sum/sim_sum\n except ZeroDivisionError:\n pred_rating=ave_ratings[user]\n prediction.append(pred_rating)\n actual.append(row[2])\n writer.writerow(row+[pred_rating])\n actual_np=np.array(map(float, actual))\n prediction_np=np.array(prediction)\n rmse=np.sqrt(((prediction_np - actual_np)** 2).mean())\n mae=np.absolute(prediction_np - actual_np).mean()\n print \"RMSE\",round(rmse,4)\n print \"MAE\",round(mae,4)","def calculate_recommendations(self, vote_list, itemMatch, itemIgnored):\n #print \"--------------------------------------------------\"\n #print \"calculate_recommendations\"\n #print \"--------------------------------------------------\"\n\n # http://www.quuxlabs.com/blog/2010/09/matrix-factorization-a-simple-tutorial-and-implementation-in-python/\n\n # U = np.array('users')\n # D = np.array('video_games')\n\n # R = |U| cross |D|\n\n # We want to discover K latent features\n\n # Find\n # P(a | |U| corss K matrix)\n # Q(a | |D| cross K matrix)\n # Such that their product approximates R\n # R approx= P cross transpose(Q) = hat(R)\n #\n\n # r[i][j] = transpose(p)[i] * q[j]\n # = sum( 1..k, p[i][k] * q[k][j] )\n\n # e[i][j]**2 = (r[i][j] - hat(r)[i][j])**2\n # = (r[i][j] - sum( 1..K, p[i][k] * q[k][j]))**2\n # squared error, estimated rating can be either higher or lower than the real thing\n\n # find the gradient\n # diff(e[i][j]**2, p[i][k]) = -2*(r[i][j] - hat(r)[i][j]) * (q[k][j]) = -2*e[i][j] * q[k][j]\n # diff(e[i][j]**2, q[k][j]) = -2*(r[i][j] - hat(r)[i][j]) * (p[i][k]) = -2*e[i][j] * p[i][k]\n\n # update rules\n # alpha = settings.alpha # learning_rate\n # alpha = 0.0002 # learning_rate\n # p[i][k]' = p[i][k] + alpha * diff(e[i][j]**2, p[i][k])\n # = p[i][k] + 2 * alpha * e[i][j] * q[k][j]\n # q[k][j]' = q[k][j] + alpha * diff(e[i][j]**2, q[k][j])\n # = q[k][j] + 2 * alpha * e[i][j] * p[i][k]\n\n # training data\n # T = (u[i], d[j], r[i][j])\n # np.array()\n\n # iterate until convergance\n # E = sum((u[i], d[j], r[i][j]) in T, e[i][j])\n # = sum((u[i], d[j], r[i][j]) in T, r[i][j]\n # - sum(1..k, p[i][k]*q[k][j]))**2\n\n # regularization\n # beta = 0.02\n # e[i][j]**2 = (r[i][j] - sum(1..K, p[i][j]*q[k][j]))**2\n # + ((beta/2) * sum(1..K, norm(P)**2 + norm(Q)**2))\n #\n # p[i][k]' = p[i][k] + alpha * (2 * e[i][j] * q[k][j] - beta * p[i][k])\n # q[k][j]' = q[k][j] + alpha * (2 * e[i][j] * p[i][k] - beta * q[k][j])\n\n data = np.array(vote_list)\n\n encoder = OneHotEncoder()\n\n users = data[:,0]\n unique_users = list(set(users))\n for i in range(len(users)):\n users[i] = unique_users.index(users[i])\n\n video_games = data[:,1]\n unique_games = list(set(video_games))\n for i in range(len(video_games)):\n video_games[i] = unique_games.index(video_games[i])\n\n ratings = data[:,2]\n M = len(set(video_games))\n N = len(set(users))\n R = np.zeros((N,M))\n for i in range(len(users)):\n user = users[i]\n game = video_games[i]\n rating = ratings[i]\n R[user][game] = rating\n\n K = 2\n\n P = np.random.rand(N,K)\n Q = np.random.rand(M,K)\n\n nP, nQ = self.matrix_factorization(R, P, Q, K)\n nR = np.dot(nP, nQ.T)\n\n itemMatch = {}\n for i in range(N):\n user = unique_users[i]\n itemMatch[user] = []\n for j in range(M):\n if R[i][j] == 0:\n video_game = unique_games[j]\n recommendation = (video_game, nR[i][j])\n itemMatch[user].append(recommendation)\n itemMatch[None] = []\n print 'pmf recommendations', itemMatch.items()\n print '\\n'\n recommendations = itemMatch.items()\n\n # returns\n # [\n # (<user1>, [\n # (\"<object_identifier1>\", <score>),\n # (\"<object_identifier2>\", <score>),\n # ]),\n # (<user2>, [\n # (\"<object_identifier1>\", <score>),\n # (\"<object_identifier2>\", <score>),\n # ]),\n # ]\n\n return recommendations","def recommend_NMF(new_user,movies_num,movies_ratings):\n list_id_movies = movies_ratings['movieId'].unique()\n nmf,Q = load_NMF_model()\n new_user_vector = pd.DataFrame(new_user, index=list_id_movies).T\n new_user_vector_filled = new_user_vector.fillna(3)\n #calculate Matrix P (Genres)\n P = nmf.transform(new_user_vector_filled)\n #make predictions\n predictions = np.dot(P,Q)\n recommendations = pd.DataFrame(predictions.reshape(-1), index=list_id_movies).T\n #Remove already watched movies:\n not_watched_movies_mask = np.isnan(new_user_vector)\n not_watched = recommendations[not_watched_movies_mask]\n\n top_movies_ids = not_watched.T.sort_values(by=[0], ascending=False).index[:movies_num]\n\n Top_recommended = movieId_to_title(top_movies_ids,movies_ratings) \n return Top_recommended","def get_ratings_for_movie_ids(self, user_id, movie_ids):\n requested_movies_RDD = self.sc.parallelize(movie_ids).map(lambda x: (user_id, x))\n # Get predicted ratings\n ratings = self.__predict_ratings(requested_movies_RDD).collect()\n\n return ratings","def weight_distribution(self):\n all_scores = []\n for zettel in self.lemma_tokens:\n scores = []\n for word in zettel:\n cur_tf_idf = self.tf_idf_scores[word[0]] / 3 #range: 0-3+\n if word[1] == 'NG':\n word_list = re.split(\" \", word[0])\n cur_word_score = 0\n i = 0\n for new_word in word_list:\n cur_word_score += self.word_scores[new_word]\n i += 1\n cur_word_score = cur_word_score / i / 2 #range: 0-2+\n else:\n cur_word_score = self.word_scores[word[0]] / 2 #range: 0-2+\n cur_keyword_score = self.keyword_scores[word[0]] / 4 #0-4+\n cur_text_rank = self.text_ranks[word[0]] / 10 #range: 0-12+\n cur_pos_score = self.pos_scores[word[0]]\n cur_area_score = self.z_area_scores[word[0]]\n cur_total_score = ((cur_tf_idf * self.score_weights[0]) + (cur_word_score * self.score_weights[1]) +\n (cur_keyword_score * self.score_weights[2]) + (cur_text_rank * self.score_weights[3]) +\n (cur_pos_score * self.score_weights[4]) + (cur_area_score * self.score_weights[5])) / 6\n scores.append(cur_total_score)\n all_scores.append(scores)\n return all_scores","def getRating(movieInfo):\n if \"vote_average\" in movieInfo:\n return movieInfo[\"vote_average\"] \n else:\n raise AttributeError(\"%s instance has no attribute vote_average (rating)\" % movieInfo)","def getRecommendations(prefs,person,similarity=sim_pearson):\n weighted_similarities = dict((\n (other, similarity(prefs, person, other)) \n for other in prefs.keys() if other != person))\n # Eliminate critics with negative correlation (I'm not sure why\n # this is a good idea)\n for critic, sim in weighted_similarities.items():\n if sim <= 0:\n del weighted_similarities[critic]\n sum_ratings = defaultdict(int) # int() initializes to 0\n sum_weights = defaultdict(int)\n for other, weight in weighted_similarities.items():\n for movie, rating in prefs[other].items():\n sum_ratings[movie] += rating * weight\n sum_weights[movie] += weight\n recommendations = [(sum_ratings[movie]/sum_weights[movie], movie)\n for movie in sum_ratings.keys()\n if movie not in prefs[person].keys()]\n recommendations.sort()\n recommendations.reverse()\n return recommendations","def mostHighlyRatedCastMembers (movies, count, minAppearances):\n def getAverage (allMovies, castMovies):\n # return average rating for all movies in list castMovies\n ratings = [ float(allMovies[key][8]) for key in castMovies if float(allMovies[key][8]) < 10 ]\n numMovies = len(ratings)\n if numMovies > 0:\n return sum(ratings) / numMovies\n else:\n return 0\n # OR:\n # totalRating = 0\n # numMovies = 0\n # for key in castMovies: \n # rating = float(allMovies[key][8]) # rating or profit\n # if rating < 10: # is a rating\n # totalRating += rating\n # numMovies += 1\n # if numMovies > 0:\n # return totalRating / numMovies\n # else:\n # return 0\n\n cast = castFilmography(movies, minAppearances)\n ratings = [ (getAverage(movies, castInfo[1:]), castInfo[0]) for castInfo in cast ]\n return sorted(ratings, reverse=True)[:count]","def get_global_mean(self, ratings):\n total_ratings = []\n for user, movie, rating in ratings:\n total_ratings.append(rating)\n return sum(total_ratings) / len(total_ratings)","def parse_movie_page(movie_url: str) -> Dict[str, str]:\n movie_page = get_soup_for_page(movie_url)\n\n # title and id\n movie_id = movie_url.split(\"/\")[-2]\n title = movie_page.find(\"div\", class_=\"title_wrapper\").find(\"h1\").get_text(\";\", strip=True).split(\";\")[0]\n\n # director and stars\n credit_summary_elements = movie_page.find_all(\"div\", class_=\"credit_summary_item\")\n director = credit_summary_elements[0].find(\"a\").text if len(credit_summary_elements) > 0 else \"\"\n if len(credit_summary_elements) > 2:\n stars_links = credit_summary_elements[2].find_all(\"a\")\n stars = [str(elem.text) for elem in stars_links[:-1]]\n else:\n stars = []\n movie_data = {\n \"id\": movie_id,\n \"title\": title,\n \"director\": director,\n \"stars\": stars,\n }\n print(movie_data)\n return movie_data","def get_movielens():\n\n filename = os.path.join(_download.LOCAL_CACHE_DIR, \"movielens_20m.hdf5\")\n if not os.path.isfile(filename):\n log.info(\"Downloading dataset to '%s'\", filename)\n _download.download_file(URL, filename)\n else:\n log.info(\"Using cached dataset at '%s'\", filename)\n\n with h5py.File(filename, 'r') as f:\n m = f.get('movie_user_ratings')\n plays = csr_matrix((m.get('data'), m.get('indices'), m.get('indptr')))\n return np.array(f['movie']), plays","def train_nmf(movies_ratings):\n \n #pivot the dataframe\n movies_ratings = movies_ratings.pivot_table(index='userId', columns='movieId', values='rating')\n #Fill Nan with 3.0 rating:\n movies_ratings.fillna(3.0, inplace=True)\n\n nmf_model = NMF(\n n_components=20,\n init='random',\n random_state=10,\n max_iter=10000\n )\n nmf_model.fit(movies_ratings)\n\n #save nmf model\n pickle.dump(nmf_model,open(\"models/nmf_model.sav\", 'wb'))","def ratings_genre(Y, genres, genre_id):\n # Filter Y for only ratings of movies in the genre.\n genre_Y = filter(\n lambda user_movie_rating: genres[user_movie_rating[1]][genre_id], Y\n )\n bar_count_ratings(genre_Y, 'Rating distribution for {} movies'.format(\n data_proc.GENRE_NAMES[genre_id]\n ))","def cache_produce () :\n\n \"\"\"\n list for movie\n each entry is the sum and count of all ratings received by each movie, which will be used later to calculate the user offset\n \"\"\"\n mcache = movie_read(open('/u/downing/cs/netflix/movie_titles.txt', 'r', encoding = \"ISO-8859-1\"))\n\n \"\"\"\n dictionaries for user caches\n each entry contain the sum and count of all ratings given by each user, which will be used later to calculate the user offset\n mean is the average of all ratings from all movies\n \"\"\"\n ucache, mean = user_read(mcache, \"/u/downing/cs/netflix/training_set\")\n\n cal_offset(mcache, mean)\n cal_offset(ucache, mean)\n\n mcache.append(mean)\n\n output_cache(ucache, open('/u/wc6892/Documents/cs373-netflix/wc6892-ucacheoff.txt', 'w'))\n output_cache(mcache, open('/u/wc6892/Documents/cs373-netflix/wc6892-mcacheoff.txt', 'w'))","def preprocess_movie_json(json_dict: Dict) -> Dict:\n json_dict['Ratings'] = list(map(lambda elem: {elem['Source']: elem['Value']}, json_dict['Ratings']))\n for obj in json_dict['Ratings']:\n if 'Metacritic' in obj:\n obj['Metacritic'] = ' / '.join(obj['Metacritic'].split('/'))\n return json_dict","def collab_model(movie_list, top_n=10):\r\n user_ids = pred_movies(movie_list)\r\n\r\n temp = get_user_movies(ratings, user_ids)\r\n\r\n movie_ids = []\r\n for i in movie_list:\r\n \"\"\" get movieId from title\"\"\"\r\n movieID = movies_df[movies_df['title'] == i]['movieId'].values[0]\r\n movie_ids.append(movieID)\r\n\r\n # Add new user with ratings to userlist\r\n new_user_row1 = {'userId': 1000000, 'movieId': movie_ids[0], 'rating': 5.0, 'title': movie_list[0]}\r\n new_user_row2 = {'userId': 1000000, 'movieId': movie_ids[1], 'rating': 5.0, 'title': movie_list[1]}\r\n new_user_row3 = {'userId': 1000000, 'movieId': movie_ids[2], 'rating': 5.0, 'title': movie_list[2]}\r\n temp = temp.append([new_user_row1, new_user_row2, new_user_row3], ignore_index=True)\r\n\r\n # create pivot table\r\n user_ratings = temp.pivot_table(index='userId', columns='title', values='rating').fillna(0)\r\n # compute correlations from pivot table\r\n item_similarity_df = user_ratings.corr(method='pearson')\r\n\r\n def get_similar_movies(movie_name, user_rating=5):\r\n \"\"\"\r\n :param movie_name:\r\n :param user_rating: optional\r\n :return: list of similar movies\r\n \"\"\"\r\n similar_score = item_similarity_df[movie_name] * user_rating\r\n similar_score = similar_score.sort_values(ascending=False)\r\n return similar_score\r\n\r\n similar_movies = pd.DataFrame()\r\n\r\n # get similar movies of fav movies\r\n for movie in movie_list:\r\n similar_movies = similar_movies.append(get_similar_movies(movie, 5), ignore_index=True)\r\n\r\n recommended_movies = []\r\n # sum similarities together append highest values\r\n for i in similar_movies.sum().sort_values(ascending=False).index:\r\n if i in movie_list:\r\n pass\r\n else:\r\n recommended_movies.append(i)\r\n\r\n return recommended_movies[:10]","def ratings_most_popular(Y, titles):\n # Movies\n movie_ids = [rating_list[1] for rating_list in Y]\n\n # 10 most popular movie ids\n result = Counter(movie_ids).most_common(10)\n popular_ids = [elt_and_count[0] for elt_and_count in result]\n popular_titles = [titles[id] for id in popular_ids]\n\n # Possible rating values\n rating_values = list(range(1, 6))\n\n # popular_ratings[i][j] is the number of rating_values[j] ratings for\n # movie with id i\n popular_ratings = \\\n [[sum([rating_list[1] == id and rating_list[2] == rating_val\n for rating_list in Y])\n for rating_val in rating_values]\n for id in popular_ids]\n\n sns.heatmap(popular_ratings,\n annot=True, fmt='d', # Annotate data values\n yticklabels=popular_titles, xticklabels=rating_values)\n plt.yticks(rotation=0) # Rotate yticks horizontally\n plt.xlabel('Rating')\n plt.title('Ratings of most popular movies')\n plt.tight_layout() # Make room for long ytick labels\n plt.show()","def main():\n users = [i.id for i in list(User.select())]\n sample_users = random.sample(users, _SAMPLE_NUMBER)\n actual_result = []\n average_result = []\n nearest_neighbour_result = []\n slope_one_result = []\n hybird_result = []\n for user_id in sample_users:\n print('Current user:', get_user_by_id(user_id))\n movie_id = random.choice(get_movie_rating_by_user(user_id)).movie_id\n print('Current movie:', get_movie_by_id(movie_id))\n actual = get_user_movie_rating(user_id, movie_id)\n print('Actual Rating:', actual)\n actual_result.append(actual)\n avg = average_rating(movie_id, True)\n print('Average Rating:', avg)\n average_result.append(avg)\n nearest = nearest_neighbour(user_id, movie_id, True)\n print('Nearest Neighbour Rating:', nearest)\n nearest_neighbour_result.append(nearest)\n slope = slope_one(user_id, movie_id, True)\n print('Slope One Rating:', slope)\n slope_one_result.append(parse_result(slope))\n hybrid = hybrid_algorithm(avg, nearest, slope, True)\n print('Hybrid Algorithm Rating:', hybrid)\n hybird_result.append(parse_result(hybrid))\n print()\n\n if _DEBUG:\n print(actual_result)\n print(average_result)\n print(nearest_neighbour_result)\n print(slope_one_result)\n print(hybird_result)\n\n print('RMSD of each recommender system')\n print(' Average Rating '.center(80, '#'))\n print(rmsd(actual_result, average_result))\n print(' Nearest Neighbour '.center(80, '#'))\n print(rmsd(actual_result, nearest_neighbour_result))\n print(' Slope One '.center(80, '#'))\n print(rmsd(actual_result, slope_one_result))\n print(' Hybrid Algorithm '.center(80, '#'))\n print(rmsd(actual_result, hybird_result))","def generate_movies(nr):\n for n in range(int(nr)):\n d6 = random.randint(1, 6)\n #A movie cannot be generated with the same name in different genres due to the nature of the data.\n if d6 <= 4:\n movie = generate_fantasy_title()\n movie_genres[movie] = \"FANTASY\"\n #if movie is a book, take author of book as producer\n if movie in books:\n movie_producers[movie] = authors[books[movie][0]]\n else:\n d20 = random.randint(1, 20)\n if d20 == 1:\n movie_producers[movie] = None\n elif d20 > 1:\n movie_producers[movie] = random.choice(list(readers.values()))\n elif d6 == 5:\n movie = generate_romance_title()\n movie_genres[movie] = \"ROMANCE\"\n d20 = random.randint(1, 20)\n if d20 == 1:\n movie_producers[movie] = None\n elif d20 > 1:\n movie_producers[movie] = random.choice(list(readers.values()))\n elif d6 == 6:\n movie = generate_horror_title()\n movie_genres[movie] = \"HORROR\"\n d20 = random.randint(1, 20)\n if d20 == 1:\n movie_producers[movie] = None\n elif d20 > 1:\n movie_producers[movie] = random.choice(list(readers.values()))\n movies.append(movie)\n counter = 1\n for movie in movies:\n movie_ids[movie] = f'Movie/{counter}'\n counter += 1","def populate(json_response: list) -> list:\n output = []\n for movie in json_response:\n imdb_id = movie[\"imdbID\"]\n output.append(dict(\n title = movie[\"Title\"],\n imdbID = imdb_id,\n rottenTomatoesPercentage = rotten_rate_fetcher(imdb_id)\n ))\n return output","def add_ratings(self, ratings):\n # Convert ratings to an RDD\n new_ratings_RDD = self.sc.parallelize(ratings)\n # Add new ratings to the existing ones\n self.ratings_RDD = self.ratings_RDD.union(new_ratings_RDD)\n # Re-compute movie ratings count\n self.__count_and_average_ratings()\n # Re-train the ALS model with the new ratings\n self.__train_model()\n \n return ratings","def preprocess():\n\n # Read Training and Test Data\n train_df = pd.read_csv(configs.TRAIN_DATA_PATH)\n test_df = pd.read_csv(configs.TEST_DATA_PATH)\n\n # Data Exploration and Preprocessing\n user_ids = train_df['userId']\n movie_ids = train_df['movieId']\n ratings = train_df['rating']\n\n # Create the mapping and save it for later usage in testing\n all_users = create_mapping(pd.concat([train_df['userId'], test_df['userId']], axis = 0))\n all_movies = create_mapping(pd.concat([train_df['movieId'], test_df['movieId']], axis = 0))\n\n\n # Save the mapping arrays for users and movies\n with open(configs.USER_IDS_PATH, \"wb\") as f:\n np.save(f, all_users)\n\n with open(configs.MOVIE_IDS_PATH, \"wb\") as f:\n np.save(f, all_movies)\n\n\n # Resetting the ids of training data to [0-n]\n user_ids = map_ids(user_ids, users = True)\n movie_ids = map_ids(movie_ids, users = False)\n\n\n # Resetting the ids of test data\n test_user_ids = map_ids(test_df['userId'], users = True)\n test_movie_ids = map_ids(test_df['movieId'], users = False)\n test_ratings = test_df['rating']\n\n # Statistics of training data\n # Number of users and movies can be extracted from the array of mapped ids\n n_users = np.max(user_ids) + 1\n n_movies = np.max(movie_ids) + 1\n\n # Statistics of test data\n test_n_users = np.max(test_user_ids) + 1\n test_n_movies = np.max(test_movie_ids) + 1\n\n # Returning the indices back can be done using unmap_ids function\n # Example\n # unmap_ids(movie_ids, users = False)\n # unmap_ids(user_ids, users = True)\n\n # Define the training rating matrix as sparse matrix\n\n # Sparse rating matrix from training data\n R = sparse.coo_matrix(\n (ratings, (user_ids, movie_ids)),\n shape=(n_users, n_movies),\n dtype=np.float\n )\n\n\n\n # Save the rating matrix for training data\n sparse.save_npz(configs.R_TRAIN_MATRIX_PATH, R)\n\n # Sparse rating matrix from test data\n R2 = sparse.coo_matrix(\n (test_ratings, (test_user_ids, test_movie_ids)),\n shape=(test_n_users, test_n_movies),\n dtype=np.float\n )\n\n # Save the rating matrix for test data\n sparse.save_npz(configs.R_TEST_MATRIX_PATH, R2)\n\n # return user_ids, movie_ids, ratings, n_users, n_movies, R, R2\n return R, R2","def Probability(rating1, rating2):\n return 1.0 * 1.0 / (1 + 1.0 * math.pow(10, 1.0 * (rating1 - rating2) / 400))","def mrr(self):\n _test = self.drop_bad_ratings()\n merged = pd.merge(left=_test, right=self.predict, on=['user', 'item'], how='right')[\n ['user', 'item', 'rating_x', 'rating_y']]\n nott = np.vectorize(lambda x: not x)\n mrrs = []\n for user in merged.user.unique():\n frame = merged[merged.user == user].sort_values(by='rating_y', ascending=False)\n true_ratings = frame.rating_x.values\n positions = np.where(nott(np.isnan(true_ratings)))[0]\n if len(positions) > 0:\n mrrs.append(1 / (positions[0] + 1))\n else:\n mrrs.append(0)\n\n return sum(mrrs) / len(mrrs)","def _recommend_movie(user_id, movie_id, number_movies):\n #get the recommended movie ids from pickled model\n rec_movies = sparkrecommender.movie_recomendation(user_id,movie_id,number_movies)\n #get a list of movies ids used in model\n moviesdf = pd.read_csv('movies.csv',index_col='movieId')\n \n #build list of lists with [[imdb ID, movie title, post img link]]\n rec_movies_list = []\n for movie_id in rec_movies:\n temp_list = []\n imdbid_ = str(get_imdbId(movie_id))\n temp_list.append(imdbid_)\n temp_list.append(moviesdf.loc[movie_id,'title'])\n temp_list.append('http://img.omdbapi.com/?apikey=ae550a04&i=tt'+str(imdbid_))\n rec_movies_list.append(temp_list)\n return rec_movies_list","def _get_word_posteriors(self, seq_counts, genus_seqs, total_seqs):\n # n(wi) as a col vector\n word_seqs = c_[seq_counts.sum(1)]\n # p(wi) as a col vector\n word_priors = (word_seqs + 0.5) / (total_seqs + 1)\n # p(wi|G)\n word_posteriors = (seq_counts + word_priors) / (genus_seqs + 1)\n return word_posteriors","def rating_distribution( ratings, plot=True ):\n possible_ratings = np.unique( ratings )\n dist = []\n for pr in possible_ratings:\n dist.append( np.count_nonzero( ratings == pr ) )\n dist = np.array( dist )\n print( 'distribution of ratings', dist )\n if plot:\n plt.bar( possible_ratings, dist )\n plt.savefig( 'rating_distribution.pdf' )","def get_cold_start_rating(user_id, movie_id, user_df, u_clusters, ratings_df):\n\n # Load files \n #user_df = pd.read_csv('data/user_cluster.csv', index_col=0) \n #u_clusters = pd.read_csv('data/u_info.csv', index_col=0)\n #ratings_df = pd.read_csv('data/movie_cluster_avg.csv', index_col=0)\n \n # User Cluster\n user_cluster = u_clusters.loc[u_clusters['id'] == user_id]['cluster'].tolist()[0]\n \n # Get score components\n if len(ratings_df.loc[(ratings_df['cluster'] == user_cluster) & (ratings_df['movie_id'] == movie_id)]) > 0:\n# if (movie_id in ratings_df['movie_id'].tolist()):\n avg = ratings_df.loc[(ratings_df['cluster'] == user_cluster) & (ratings_df['movie_id'] == movie_id)]['rating'].tolist()\n else:\n cluster_rating = ratings_df.loc[ratings_df['cluster'] == user_cluster]['rating'].tolist()\n avg = sum(cluster_rating)/len(cluster_rating)\n if user_id in user_df['user_id'].tolist():\n u = user_bias(user_df, user_id)\n i = item_bias(user_df, movie_id)\n pred_rating = avg + u + i\n else:\n pred_rating = avg\n \n return pred_rating","def mostProfitableDirectors (movies, count):\n directors = {}\n for movieInfo in movies.values():\n key = movieInfo[0] # director's name\n if len(movieInfo) == 10:\n value = float(movieInfo[9]) # profit\n else:\n value = float(movieInfo[7]) # rating or profit\n if value > 100: # not a rating\n if key not in directors:\n directors[key] = 0\n directors[key] += int(value)\n return sorted([(v, k) for (k,v) in directors.items() ], reverse=True)[:count]"],"string":"[\n \"def predict_rating(self, movie):\\n\\n #\\n # option 1: SQLAlchemy ORM\\n #\\n UserMovies = db.aliased(Rating)\\n MovieUsers = db.aliased(Rating)\\n\\n query = (db.session.query(Rating.user_id, Rating.score, UserMovies.score, MovieUsers.score)\\n .join(UserMovies, UserMovies.movie_id == Rating.movie_id)\\n .join(MovieUsers, Rating.user_id == MovieUsers.user_id)\\n .filter(UserMovies.user_id == self.user_id)\\n .filter(MovieUsers.movie_id == movie.movie_id))\\n\\n #\\n # option 2: raw SQL\\n #\\n # sql = \\\"\\\"\\\"\\n # SELECT ratings.user_id, ratings.score, user_movies.score, movie_users.score\\n # FROM ratings AS user_movies\\n # JOIN ratings\\n # ON (user_movies.movie_id = ratings.movie_id)\\n # JOIN ratings AS movie_users\\n # ON (ratings.user_id = movie_users.user_id)\\n # WHERE user_movies.user_id = :user_id\\n # AND movie_users.movie_id = :movie_id\\n # \\\"\\\"\\\"\\n #\\n # query = db.session.execute(sql, dict(user_id=self.user_id, movie_id=movie.movie_id))\\n #\\n\\n known_ratings = {}\\n paired_ratings = defaultdict(list)\\n\\n for rating_user_id, rating_score, user_movie_score, movie_user_score in query:\\n paired_ratings[rating_user_id].append((user_movie_score, rating_score))\\n known_ratings[rating_user_id] = movie_user_score\\n\\n similarities = []\\n\\n for _id, score in known_ratings.items():\\n similarity = correlation.pearson(paired_ratings[_id])\\n if similarity > 0:\\n similarities.append((similarity, score))\\n\\n if not similarities:\\n return None\\n\\n numerator = sum([score * sim for sim, score in similarities])\\n denominator = sum([sim for sim, score in similarities])\\n\\n return numerator / denominator\",\n \"def estimate_movie_biases(self):\\n self.movie_biases = {}\\n for movie in self.movie_ratings:\\n # b_i = sum(r_ui - mu) / len(R(i))\\n movie_bias = [rating - self.global_mean for rating in self.movie_ratings[movie].values()]\\n movie_bias = sum(movie_bias) / len(movie_bias)\\n self.movie_biases[movie] = movie_bias\",\n \"def predictOnMovie(self,user,movie,neibor_list,user_rating,user_aver_rating):\\n predict = user_aver_rating[user]\\n numerator, denominator = 0.0,0.0\\n for sim, neighbor in neibor_list:\\n if movie in user_rating[neighbor]:\\n numerator += sim*(user_rating[neighbor][movie]-user_aver_rating[neighbor])\\n denominator += sim\\n predict += numerator/denominator\\n return predict\",\n \"def _aggregate_vectors(movies, feedback_list=[]):\\n movie_vec = []\\n for i in movies:\\n try:\\n m_vec = clf[i] # get the vector for each movie\\n if ratings_dict:\\n try:\\n r = ratings_dict[i] # get user_rating for each movie\\n # Use a polynomial to weight the movie by rating.\\n # This equation is totally arbitrary. I just fit a polynomial\\n # to some weights that look good. The effect is to raise\\n # the importance of 1, 9, and 10 star ratings.\\n w = ((r**3)*-0.00143) + ((r**2)*0.0533) + (r*-0.4695) + 2.1867\\n m_vec = m_vec * w\\n except KeyError:\\n continue\\n movie_vec.append(m_vec)\\n except KeyError:\\n continue\\n if feedback_list:\\n for i in feedback_list:\\n try:\\n f_vec = clf[i]\\n movie_vec.append(f_vec*1.8) # weight feedback by adding multiplier here\\n except KeyError:\\n continue\\n return np.mean(movie_vec, axis=0)\",\n \"def get_movie_scores(df, min_vote_count=1000):\\n ratings = {}\\n\\n for x in CREW_ATTRIBUTES:\\n ratings[x] = get_avg_scores_for_attribute(df, x, min_vote_count)\\n\\n df['production_score'] = df.apply(calculate_final_production_score, ratings=ratings, axis=1)\\n return df\",\n \"def recommend(self, u):\\n\\n sims = {} #similarities\\n recommendation = \\\"\\\"\\n topScore = None\\n start = time.time()\\n for movie_id, rating in enumerate(u):\\n if rating != 0:\\n sims[movie_id] = {}\\n for r_id, movie in enumerate(self.ratings):\\n sims[movie_id][r_id] = self.distance(movie,self.ratings[movie_id])\\n # print time.time() - start, \\\"distance time\\\"\\n\\n start = time.time()\\n for i, movieRating in enumerate(self.ratings):\\n iPrediction = 0\\n for movieName in self.ratedMovieList:\\n j = self.titlesOnly.index(movieName)\\n iPrediction += sims[j][i]*1.0 * self.userRatingVector[j]\\n if topScore is None or iPrediction > topScore:\\n movie = self.titlesOnly[i]\\n if movie not in self.ratedMovieList and movie not in self.recommendedMovies:\\n # print(\\\"prediction score for %s is %.5f\\\" % (movie, iPrediction))\\n topScore = iPrediction\\n recommendation = movie\\n # print time.time() - start, \\\"recommendation time\\\"\\n self.recommendedMovies.append(recommendation)\\n\\n articlePattern = re.match('(.*), (the|a|an|el|la)', recommendation)\\n if articlePattern is not None:\\n recommendation = articlePattern.group(2) + \\\" \\\" + articlePattern.group(1)\\n\\n return recommendation\",\n \"def predictRating(self, movieID):\\n\\t\\t\\n\\t\\treturn movieID\",\n \"def predict_rating(R, R_avg, S, u, m):\\n\\n # Users (ie. neighbours) that have rated this movie.\\n neighbours = R[m].dropna().index\\n\\n numer, denom = 0, 0\\n for v in neighbours:\\n numer += S.ix[u, v] * (R.ix[v, m] - R_avg[v])\\n denom += abs(S.ix[u, v])\\n\\n rating = R_avg[u] + (numer / denom)\\n\\n return rating\",\n \"def compute_movie_rating_likelihood(M):\\n\\n # define the size to begin with\\n likelihood = np.zeros((M, M))\\n\\n # -------------------------------------------------------------------------\\n # YOUR CODE GOES HERE FOR PART (c)\\n #\\n # Remember to normalize the likelihood, so that each column is a\\n # probability distribution.\\n \\n for i in range(M):\\n for j in range(M):\\n if i == j:\\n likelihood[i][j] = 2\\n else:\\n likelihood[i][j] = 1/abs(j-i)\\n \\n likelihood = likelihood / likelihood.sum(axis = 1)\\n \\n #\\n # END OF YOUR CODE FOR PART (c)\\n # -------------------------------------------------------------------------\\n\\n return likelihood\",\n \"def fit(self, ratings_mat):\\n self.logger.debug(\\\"starting fit\\\")\\n # self.n = ratings.max()['user']+1\\n # self.p = ratings.max()['movie']+1\\n self.ratings_mat = ratings_mat\\n self.k = ratings_mat.shape[0]//20\\n\\n #ratings_array = ratings[ratings.columns[:-1].values].values\\n\\n #self.ratings_mat = np.zeros((self.n, self.p))\\n\\n #for i, rating in ratings.iterrows():\\n # self.ratings_mat[( rating['user'], rating['movie'] )] = rating['rating']\\n\\n self.cosine_dists = squareform(pdist(ratings_mat, 'cosine'))\\n\\n #if a user has no ratings data, cosine dist will return a nan. In this case, we assume they are as different as possible, since we cannot predict using those users anyways\\n self.cosine_dists = 1 - np.nan_to_num(1 - self.cosine_dists)\\n\\n self.similarity_ranks = self.cosine_dists.argsort(axis = 1)\\n\\n # ...\\n\\n self.logger.debug(\\\"finishing fit\\\")\\n return(self)\",\n \"def movie_stats(movies):\\n def num_years():\\n \\\"\\\"\\\"number of years covered in the dataset\\\"\\\"\\\"\\n years = movies['Year']\\n return ('num_years', years.nunique())\\n\\n def tot_movies():\\n \\\"\\\"\\\"total number of movies over all years\\\"\\\"\\\"\\n total = movies['Number of Movies'].sum()\\n return ('tot_movies', total)\\n\\n def yr_fewest_movies():\\n \\\"\\\"\\\"year with fewest movies made (earliest)\\\"\\\"\\\"\\n copy = movies.copy()\\n year = copy.sort_values(['Number of Movies', 'Year']).reset_index(drop = True).Year.loc[0]\\n return ('yr_fewest_movies', year)\\n\\n def avg_gross():\\n \\\"\\\"\\\"average amount of money grossed over all years\\\"\\\"\\\"\\n avg = movies['Total Gross'].mean()\\n if avg is np.nan:\\n raise\\n return ('avg_gross', avg)\\n\\n def highest_per_movie():\\n \\\"\\\"\\\"The year with the highest gross per movie\\\"\\\"\\\"\\n copy = movies.copy()\\n copy['Gross Per Movie'] = copy['Total Gross'] / copy['Number of Movies'] #calculate gross per movie\\n year = copy.sort_values(['Gross Per Movie'], ascending = False).reset_index(drop = True).Year.loc[0]\\n return ('highest_per_movie', year)\\n\\n def second_lowest():\\n \\\"\\\"\\\"name of the top movie during the second lowest (total) grossing year\\\"\\\"\\\"\\n copy = movies.copy()\\n name = copy.sort_values(['Total Gross']).reset_index(drop = True)['#1 Movie'].loc[1]\\n return ('second_lowest', name)\\n\\n def avg_after_harry():\\n \\\"\\\"\\\"avg number of movies made the year after an HP movie was #1 movie\\\"\\\"\\\"\\n copy = movies.copy()\\n copy = copy.sort_values(['Year']).reset_index(drop = True) #years early to present\\n harry_years = copy[copy['#1 Movie'].str.contains('Harry')].Year #years where harry potter was #1\\n next_years = harry_years + 1\\n check = list(next_years.values)\\n next_years_df = copy[copy['Year'].isin(check)]\\n avg = next_years_df['Number of Movies'].mean()\\n if avg is np.nan:\\n raise\\n return ('avg_after_harry', avg)\\n\\n functions = [num_years(), tot_movies(), yr_fewest_movies(), avg_gross(), highest_per_movie(), second_lowest(), avg_after_harry()]\\n stats = {}\\n for fxn in functions:\\n try:\\n info = fxn\\n stats[info[0]] = info[1]\\n except:\\n continue\\n series = pd.Series(stats)\\n\\n return series\",\n \"def index_and_evaluate(movie_ids):\\n iindex = get_normalised_inverse_index(movie_ids)\\n user_ids = iindex.keys()\\n nn_index = CosineNN(max(movie_ids) + 1) # +1 since ids are 1-based\\n\\n # Add all movies to nn_index\\n for i, uid in enumerate(user_ids):\\n col = iindex[uid].uratings\\n nn_index.index(uid, col)\\n if i % 10 == 0:\\n print('index progress: {:.3%}'.format(i / len(user_ids)))\\n print('indexing and setup complete')\\n\\n # Find all test data instances for which we can predict a rating\\n probe_ratings = read_probe(movie_ids)\\n to_predict = []\\n for mid, mratings in probe_ratings.items():\\n for uid, rating in mratings.items():\\n if uid in user_ids:\\n to_predict.append((uid, mid, rating))\\n\\n # Predict ratings for test data instances and add up error\\n errors = []\\n for i, (uid, mid, actual) in enumerate(to_predict):\\n print('evaluation progress: {:.3%}'.format(i / len(to_predict)))\\n guess = guess_rating(nn_index, iindex, uid, mid)\\n errors.append((guess - actual)**2)\\n print('RMSE:', np.sqrt(np.mean(errors)))\",\n \"def compute_user_similarity(d1, d2, ave_rat1, ave_rat2):\\n \\n movie_1=set()\\n movie_2=set()\\n for movie,value in d1.items():\\n movie_1.add(movie) \\n for movie, value in d2.items():\\n movie_2.add(movie) \\n common_movie_rated=movie_1.intersection(movie_2)\\n if (len(common_movie_rated)==0):\\n return 0.0\\n num = 0\\n den1 = 0\\n den2 = 0\\n for common_movie in common_movie_rated:\\n num += (float(d1[common_movie])-ave_rat1)*(float(d2[common_movie])-ave_rat2)\\n den1 += ((float(d1[common_movie])-ave_rat1)**2)\\n den2 += ((float(d2[common_movie]) - ave_rat2) ** 2)\\n # When the user gives same rating to all the movies\\n try:\\n user_sim = num/((den1*den2)**0.5)\\n except ZeroDivisionError:\\n return 0.0\\n return user_sim\",\n \"def __count_and_average_ratings(self):\\n logger.info(\\\"Counting movie ratings...\\\")\\n movie_ID_with_ratings_RDD = self.ratings_RDD.map(lambda x: (x[1], x[2])).groupByKey()\\n movie_ID_with_avg_ratings_RDD = movie_ID_with_ratings_RDD.map(get_counts_and_averages)\\n self.movies_rating_counts_RDD = movie_ID_with_avg_ratings_RDD.map(lambda x: (x[0], x[1][0]))\",\n \"def __count_and_average_ratings(self):\\n logger.info(\\\"Counting movie ratings...\\\")\\n movie_ID_with_ratings_RDD = self.ratings_RDD.map(lambda x: (x[1], x[2])).groupByKey()\\n movie_ID_with_avg_ratings_RDD = movie_ID_with_ratings_RDD.map(get_counts_and_averages)\\n self.movies_rating_counts_RDD = movie_ID_with_avg_ratings_RDD.map(lambda x: (x[0], x[1][0]))\",\n \"def predict(self, input, bad_movies=[], hist_list=[], val_list=[],\\n ratings_dict = {}, checked_list=[], rejected_list=[],\\n n=50, harshness=1, rec_movies=True,\\n show_vibes=False, scoring=False):\\n\\n clf = self._get_model()\\n dupes = [] # list for storing duplicates for scoring\\n\\n def _aggregate_vectors(movies, feedback_list=[]):\\n \\\"\\\"\\\"Gets the vector average of a list of movies.\\\"\\\"\\\"\\n movie_vec = []\\n for i in movies:\\n try:\\n m_vec = clf[i] # get the vector for each movie\\n if ratings_dict:\\n try:\\n r = ratings_dict[i] # get user_rating for each movie\\n # Use a polynomial to weight the movie by rating.\\n # This equation is totally arbitrary. I just fit a polynomial\\n # to some weights that look good. The effect is to raise\\n # the importance of 1, 9, and 10 star ratings.\\n w = ((r**3)*-0.00143) + ((r**2)*0.0533) + (r*-0.4695) + 2.1867\\n m_vec = m_vec * w\\n except KeyError:\\n continue\\n movie_vec.append(m_vec)\\n except KeyError:\\n continue\\n if feedback_list:\\n for i in feedback_list:\\n try:\\n f_vec = clf[i]\\n movie_vec.append(f_vec*1.8) # weight feedback by adding multiplier here\\n except KeyError:\\n continue\\n return np.mean(movie_vec, axis=0)\\n\\n def _similar_movies(v, bad_movies=[], n=50):\\n \\\"\\\"\\\"Aggregates movies and finds n vectors with highest cosine similarity.\\\"\\\"\\\"\\n if bad_movies:\\n v = _remove_dislikes(bad_movies, v, harshness=harshness)\\n return clf.similar_by_vector(v, topn= n+1)[1:]\\n\\n def _remove_dupes(recs, input, bad_movies, hist_list=[], feedback_list=[]):\\n \\\"\\\"\\\"remove any recommended IDs that were in the input list\\\"\\\"\\\"\\n all_rated = input + bad_movies + hist_list + feedback_list\\n nonlocal dupes\\n dupes = [x for x in recs if x[0] in input]\\n return [x for x in recs if x[0] not in all_rated]\\n\\n def _remove_dislikes(bad_movies, good_movies_vec, rejected_list=[], harshness=1):\\n \\\"\\\"\\\"Takes a list of movies that the user dislikes.\\n Their embeddings are averaged,\\n and subtracted from the input.\\\"\\\"\\\"\\n bad_vec = _aggregate_vectors(bad_movies, rejected_list)\\n bad_vec = bad_vec / harshness\\n return good_movies_vec - bad_vec\\n\\n def _score_model(recs, val_list):\\n ids = [x[0] for x in recs]\\n return len(list(set(ids) & set(val_list)))\\n\\n aggregated = _aggregate_vectors(input, checked_list)\\n recs = _similar_movies(aggregated, bad_movies, n=n)\\n recs = _remove_dupes(recs, input, bad_movies, hist_list, checked_list + rejected_list)\\n formatted_recs = [self._get_info(x[0], x[1]) for x in recs]\\n if scoring and val_list:\\n print(f\\\"The model recommended {_score_model(recs, val_list)} movies that were on the watchlist!\\\\n\\\")\\n print(f\\\"\\\\t\\\\t Average Rating: {sum([i[3] for i in formatted_recs if i[3] is not None])/len(formatted_recs)}\\\\n\\\")\\n if show_vibes:\\n print(\\\"You'll get along with people who like: \\\\n\\\")\\n for x in dupes:\\n print(self._get_info(x[0], x[1]))\\n print('\\\\n')\\n if rec_movies:\\n return formatted_recs\",\n \"def __predict_ratings(self, user_and_movie_RDD):\\n predicted_RDD = self.model.predictAll(user_and_movie_RDD)\\n predicted_rating_RDD = predicted_RDD.map(lambda x: (x.product, x.rating))\\n predicted_rating_title_and_count_RDD = \\\\\\n predicted_rating_RDD.join(self.movies_titles_RDD).join(self.movies_rating_counts_RDD)\\n predicted_rating_title_and_count_RDD = \\\\\\n predicted_rating_title_and_count_RDD.map(lambda r: (r[1][0][1], r[1][0][0], r[1][1]))\\n \\n return predicted_rating_title_and_count_RDD\",\n \"def predictRating(toPredict, candidateList):\\n\\n ratingRelevantCandidates = []\\n\\n #Remove candidates with no rating specified\\n for candidate in candidateList:\\n currentCandidate = candidate[1]\\n\\n if float(currentCandidate['vote_avg']) > 0:\\n ratingRelevantCandidates.append((float(currentCandidate['vote_avg']), candidate))\\n\\n #print(\\\"ratings::::::::\\\",currentCandidate['vote_avg'])\\n\\n #Remove outlier candidates based on rating\\n ratingMean = np.mean([x[0] for x in ratingRelevantCandidates])\\n print(\\\"ratingMean\\\", ratingMean)\\n ratingSD = np.std([x[0] for x in ratingRelevantCandidates])\\n print(\\\"ratingSD\\\", ratingSD)\\n\\n finalRatings = [x for x in ratingRelevantCandidates if (float(x[0]) < ratingMean + ratingSD)]#1.5 *\\n finalRatings = [x for x in finalRatings if (float(x[0]) > ratingMean - ratingSD)]#.75 *\\n\\n finalRatingCandidatesWithWeight = []\\n\\n #Weight each candidate based on vote count, direct and actor popularity and matching score from part 1\\n for candidate in finalRatings:\\n directorPoints = compareDirectorPoints(toPredict['director'], candidate[1][1]['director'])\\n actorPoints = compareActorPoints(toPredict['cast'], candidate[1][1]['cast'])\\n voteCountPoints = int(candidate[1][1]['vote_count'])\\n matchPoints = candidate[1][0] / np.max([float(x[1][0]) for x in finalRatings]) * 100\\n candidateWeight = PREDICTION_MATCHPOINTS_WEIGHT * matchPoints \\\\\\n + PREDICTION_ACTOR_WEIGHT * actorPoints \\\\\\n + PREDICTION_DIRECTOR_WEIGHT * directorPoints \\\\\\n + PREDICTION_VOTECOUNT_WEIGHT * voteCountPoints\\n\\n finalRatingCandidatesWithWeight.append((candidateWeight, candidate[0]))\\n\\n #Calculate the prediction\\n sumRatingCandidateWeights = np.sum([float(x[0]) for x in finalRatingCandidatesWithWeight])\\n sumRatingTimesCandidateWeight = np.sum([float(x[0]) * float(x[1]) for x in finalRatingCandidatesWithWeight])\\n\\n ratingPrediction = float(sumRatingTimesCandidateWeight / sumRatingCandidateWeights)\\n\\n return ratingPrediction\",\n \"def __predict_ratings(self, user_and_movie_RDD):\\n predicted_RDD = self.model.predictAll(user_and_movie_RDD)\\n predicted_rating_RDD = predicted_RDD.map(lambda x: (x.product, x.rating))\\n\\n return predicted_rating_RDD\",\n \"def recommend_movies(target_rating: Rating,\\n movies: MovieDict,\\n user_ratings: UserRatingDict,\\n movie_users: MovieUserDict,\\n num_movies: int) -> List[int]:\\n similars = get_similar_users(target_rating, user_ratings, movie_users)\\n movie_lst = get_candidate_movies(target_rating, similars, user_ratings)\\n movies = {}\\n for m in movie_lst:\\n for u in movie_users[m]:\\n if u in similars:\\n score = similars[u]\\n num_user_movie = num_rated_above(movie_lst, user_ratings[u])\\n movie_popularity = total_rated(movie_users[m], m, user_ratings)\\n movies[m] = movies.get(m, 0) + score / (num_user_movie * movie_popularity)\\n lst = sorted(list(movies.items()))\\n result = [i[0] for i in\\n sorted(lst, key=lambda k: k[1], reverse=True)]\\n return result[:num_movies]\",\n \"def predict(user_id, item_id, ratings):\\n\\n # convert long to wide\\n ratings_wide = ratings.pivot(index='user', columns='movie', values='rating')\\n\\n # compute user similarities\\n similarities = compute_similarities(user_id, ratings_wide)\\n \\n prediction = predict_rating(item_id, ratings_wide, similarities, N=N_NEIGHBORS)\\n \\n return prediction\",\n \"def predict(self, user, movie, similarity):\\n bias = self.baseline_predictor(user, movie)\\n\\n numerator = 0.\\n denominator = 0.\\n for user_movie in self.user_ratings[user]:\\n if similarity == 'pearson':\\n numerator += self.pearson_correlation(movie, user_movie) * (\\n self.user_ratings[user][user_movie] - self.baseline_predictor(user, user_movie))\\n denominator += self.pearson_correlation(movie, user_movie)\\n elif similarity == 'content':\\n numerator += self.content_similarity(movie, user_movie) * (\\n self.user_ratings[user][user_movie] - self.baseline_predictor(user, user_movie))\\n denominator += self.content_similarity(movie, user_movie)\\n\\n return bias + numerator / denominator\",\n \"def netflix_predict(movie_id, customer_id):\\n\\n avg_mov_value = CACHE_AVG_MOVIE_RATING[movie_id]\\n avg_cust_value = CACHE_AVG_CUSTOMER_RATING[customer_id]\\n years_after_release = CACHE_YEARS_SINCE_RELEASE[movie_id][customer_id]\\n\\n # Equation from results gradient-descent/linRegResults.txt\\n res = 3.78699752 + (avg_mov_value - 3.72) * 0.91299576 \\\\\\n + (avg_cust_value - 3.72) * 0.90834816 \\\\\\n + years_after_release * 0.00196377\\n\\n # Actual ratings cannot be greater than 5 or less than 1\\n if res > 5.0:\\n res = 5.0\\n elif res < 1.0:\\n res = 1.0\\n\\n return res\",\n \"def calculate_final_production_score(row, ratings):\\n scores = {}\\n\\n for x in CREW_ATTRIBUTES:\\n data = row[x]\\n\\n # handle director case that isn't wrapped by []\\n data = get_literal_eval(data)\\n\\n total_score = calculate_total_score(data, ratings[x])\\n\\n # more famous actors usually means higher review (e.g. Ocean's 11)\\n if x == 'cast':\\n scores[x] = total_score\\n elif len(data):\\n scores[x] = (total_score / len(data))\\n\\n final_score = sum(scores.values())\\n\\n return final_score\",\n \"def get_movies(self):\\n\\n movies = {}\\n\\n for index, movie in self.movies.iterrows():\\n\\n id_movie = int(movie[0])\\n title = movie[1]\\n movie_tags = []\\n movie_ratings = []\\n\\n # Get tags for each movie\\n tags = self.movies_tags.loc[self.movies_tags[0] == id_movie]\\n\\n for index_movie, tag in tags.iterrows():\\n\\n movie_tags.append(tag[1])\\n\\n # Get ratings for each film\\n ratings = self.ratings.loc[self.ratings[1] == id_movie]\\n\\n # Get user ratings\\n for index_ratings, row_rating in ratings.iterrows():\\n movie_ratings.append((row_rating[0], float(row_rating[2]))) # (id_user, score)\\n\\n # Create Movie object\\n movie_object = Movie(id_movie=id_movie, title=title, tags=movie_tags, ratings=movie_ratings)\\n\\n # Append movie_object in dictionary\\n movies[id_movie] = movie_object\\n\\n return movies\",\n \"def ratings_best(Y, titles):\\n ratings_lists = data_proc.ratings_for_movies(Y)\\n\\n # Possible rating values\\n rating_values = list(range(1, 6))\\n\\n # avg_ratings[i] = average rating of movie i\\n # avg_ratings = [float(sum(ratings_list)) / len(ratings_list)\\n # for ratings_list in ratings_lists]\\n # Disfavor highly rated movies with few ratings:\\n # http://stats.stackexchange.com/a/6361\\n avg_ratings = [float(sum(ratings_list) + sum(rating_values))\\n / (len(ratings_list) + len(rating_values))\\n for ratings_list in ratings_lists]\\n best_ids = data_proc.top_indices(avg_ratings, 10)\\n best_titles = [titles[id] for id in best_ids]\\n\\n # ratings_table[i][j] is the number of rating_values[j] ratings for\\n # movie with id i\\n ratings_table = \\\\\\n [[sum([rating_list[1] == id and rating_list[2] == rating_val\\n for rating_list in Y])\\n for rating_val in rating_values]\\n for id in best_ids]\\n\\n sns.heatmap(ratings_table,\\n annot=True, fmt='d', # Annotate data values\\n yticklabels=best_titles, xticklabels=rating_values)\\n plt.yticks(rotation=0) # Rotate yticks horizontally\\n plt.xlabel('Rating')\\n plt.title('Ratings of highest rated movies')\\n plt.tight_layout() # Make room for long ytick labels\\n plt.show()\",\n \"def assign_rank_weight(self, data_frame):\\n groupby_movies = data_frame.groupby(\\\"movieid\\\")\\n movie_rank_weight_dict = {}\\n for movieid, info_df in groupby_movies:\\n max_rank = info_df.actor_movie_rank.max()\\n for rank in info_df.actor_movie_rank.unique():\\n movie_rank_weight_dict[(movieid, rank)] = (max_rank - rank + 1)/max_rank*100\\n return movie_rank_weight_dict\",\n \"def all_ratings(Y):\\n bar_count_ratings(Y, 'Rating distribution for all movies')\\n plt.show()\",\n \"def get_movielist_movie_attributes(self, movie_html, popularity=None, pagenr=None, nr_pages=None):\\n a = movie_html.find('a')\\n url = a.get('href')\\n id = int(movie_html.find('div', attrs={'class': 'fl_titlelist_rating'}).get('titleid'))\\n title = a.get('title')\\n year = self.get_year_from_movielist_title(a.text)\\n movie_info = {'crit_id': id,\\n 'crit_url': url,\\n 'title': title,\\n 'year': year,\\n 'date_added': arrow.now()}\\n if popularity is not None and pagenr is not None and nr_pages is not None:\\n movie_info.update({'crit_popularity': popularity - (pagenr - 1)/(nr_pages - 1)})\\n try:\\n psi = int(movie_html.find('div', attrs={'class': 'pti'}).text)\\n except AttributeError:\\n psi = None\\n try:\\n rating = int(movie_html.find('div', attrs={'title': 'Your Ranking'}).text)\\n except AttributeError:\\n rating = None\\n movie_info = self.add_psi_and_rating_to_movie_info(movie_info, rating=rating, psi=psi)\\n return movie_info\",\n \"def binarize(self):\\n total = 0\\n count = 0\\n avg_rating = 0\\n for movie_id, movie in enumerate(self.ratings):\\n for user_id, rating in enumerate(movie):\\n if rating != 0:\\n self.ratings[movie_id,user_id] = 1 if rating > 2.5 else -1\",\n \"def item_based_collaborative(new_ratings, movie_ratings=None, movies=None):\\n movie_ratings = movie_ratings if movie_ratings is not None else load_movie_ratings()\\n movies = movies if movies is not None else load_movies()\\n highest_rating = max(new_ratings.values())\\n rated_movies = [int(movie) for movie in new_ratings if int(movie) in movie_ratings.index]\\n index_list = movie_ratings.index.tolist()\\n favorite_movies = [index_list.index(movie) for movie in rated_movies if new_ratings[str(movie)] == highest_rating]\\n sims = cosine_similarity(movie_ratings)[favorite_movies,].mean(axis=0)\\n ranked = movies.join(pd.DataFrame({\\\"rating\\\": sims}, index=index_list)).sort_values(\\\"rating\\\", ascending=False)\\n ranked.drop(rated_movies, axis=0, inplace=True)\\n return ranked\",\n \"def make_predictions(movies, ratings_train, ratings_test):\\n ###TODO\\n \\n user_result = [] \\n \\n for index,row in ratings_test.iterrows():\\n userid_test = row['userId']\\n #print(\\\"userid_test::\\\",userid_test) \\n movieid_test = row['movieId'] \\n #print(\\\"movieid_test::\\\",movieid_test) \\n x = list(movies[movies.movieId==movieid_test]['features'])[0]\\n #print(\\\"CSR_GOTT+X::\\\",x)\\n #print(\\\"TYPE of CSR_GOTT_X::\\\",type(x))\\n subset_train = ratings_train[ratings_train.userId == userid_test]\\n #print(\\\"SUB MOVIE SET::\\\",subset_train)\\n #print(\\\"TYPE of SUB MOVIE SET::\\\",type(x))\\n total_if_zero=0\\n rating_if_zero=0\\n sum_main_result=0\\n sum_cosine=0 \\n for index1,row1 in subset_train.iterrows():\\n userid_train = row1['userId']\\n #print(\\\"userid_train::\\\",userid_train) \\n if(userid_test == userid_train ):\\n #print(\\\"HII IN IFFF:::\\\")\\n movieid_train = row1['movieId']\\n #print(\\\"movieid_train::\\\",movieid_train)\\n rating_train = row1['rating']\\n #print(\\\"rating_train::\\\",rating_train)\\n total_if_zero = total_if_zero + 1 \\n rating_if_zero = rating_if_zero + rating_train\\n y = list(movies[movies.movieId==movieid_train]['features'])[0]\\n #print(\\\"CSR_GOTT_Y::\\\",y)\\n #print(\\\"TYPE of CSR_GOTT_Y::\\\",type(y))\\n result_cos = cosine_sim(x,y)\\n sum_main_result += result_cos * rating_train\\n sum_cosine += result_cos \\n \\n if(sum_main_result != 0):\\n user_result.append(sum_main_result/sum_cosine)\\n #print(\\\"user_result::\\\",user_result) \\n else:\\n user_result.append(rating_if_zero / total_if_zero)\\n #print(\\\"user_result::\\\",user_result) \\n \\n return_result_arr = np.array(user_result) \\n \\n return return_result_arr\\n \\n pass\",\n \"def update_mean_movie_rating(self):\\n self.mean_movie_rating = self.ratings.groupby(['movie_id'])['rating'].mean().reset_index()\",\n \"def dist_by_rating(self):\\n return ratings_distribution\",\n \"def compute_average_user_ratings(user_ratings):\\n ave_ratings = {}\\n \\n for user,value in user_ratings.items():\\n sum = 0\\n movie_num=0\\n for movieId, rating in value.items():\\n sum += float(rating)\\n movie_num += 1\\n average = sum / movie_num\\n ave_ratings[user]=average\\n return ave_ratings\",\n \"def scrape_movie_page(dom):\\n # to save the information\\n info = []\\n\\n # find the information block needed\\n header = dom.find(\\\"div\\\", \\\"title_wrapper\\\")\\n\\n # find the title and strip the string\\n name_dom = header.h1.get_text().encode(\\\"utf-8\\\")\\n name = str(name_dom)[2:-16]\\n info.append(name)\\n\\n # find the year and strip the year\\n year_dom = header.h1.span.get_text().encode(\\\"utf-8\\\")\\n year = str(year_dom)[3:-2]\\n info.append(year)\\n\\n # find the duration and strip the string\\n duration_dom = dom.find(\\\"time\\\", itemprop=\\\"duration\\\").get_text().encode(\\\"utf-8\\\")\\n duration = str(duration_dom)[28:-23]\\n info.append(duration)\\n\\n # find all the genres and strip the string\\n genre_dom = dom.find(\\\"div\\\", itemprop=\\\"genre\\\").a.get_text().encode(\\\"utf-8\\\")\\n genre = find_genres(genre_dom, dom)\\n info.append(genre)\\n\\n # find all the directors and strip the string\\n director_dom = dom.find(\\\"span\\\", itemprop=\\\"director\\\").get_text().encode(\\\"utf-8\\\")\\n director = find_directors(director_dom, dom)\\n info.append(director)\\n\\n # find all the writers and strip the string\\n writer_dom = dom.find(\\\"span\\\", itemprop=\\\"creator\\\").a.get_text().encode(\\\"utf-8\\\")\\n writer = find_writers(writer_dom, dom)\\n info.append(writer)\\n\\n # find all the actors and strip the string\\n actor_dom = dom.find(\\\"span\\\", itemprop=\\\"actors\\\").a.get_text().encode(\\\"utf-8\\\")\\n actor = find_actors(actor_dom, dom)\\n info.append(actor)\\n\\n # find the rating and strip the string\\n rating_dom = dom.find(\\\"span\\\", itemprop=\\\"ratingValue\\\").get_text().encode(\\\"utf-8\\\")\\n rating = str(rating_dom)[2:-1]\\n info.append(rating)\\n\\n # find the number of ratings and strip the string\\n number_ratings_dom = dom.find(\\\"span\\\", itemprop=\\\"ratingCount\\\").get_text().encode(\\\"utf-8\\\")\\n number_ratings = str(number_ratings_dom)[2:-1]\\n info.append(number_ratings)\\n\\n return info\",\n \"def evaluate_model(predictions_table: pd.DataFrame, ratings_table: pd.DataFrame,\\n test_table: pd.DataFrame, viewed_table: pd.DataFrame,\\n all_predictions_table: pd.DataFrame) -> Dict:\\n\\n viewed = viewed_table.to_numpy()\\n predictions = predictions_table.to_numpy()\\n all_predictions = all_predictions_table.to_numpy()\\n ratings = ratings_table.to_numpy()\\n test = test_table.to_numpy(copy=True)\\n test_demeaned = test - np.mean(test, axis=1).reshape(-1, 1)\\n test_set = test_table.apply(lambda x: x != 0.0).astype(int).to_numpy()\\n\\n result = dict()\\n\\n # Test set evaluation\\n test_predictions = np.multiply(all_predictions, test_set)\\n diff = np.subtract(test_predictions, test_demeaned)\\n rmse = np.sqrt(np.mean(np.square(diff)))\\n result.update({\\\"RMSE\\\": rmse})\\n mae = np.mean(np.absolute(diff))\\n result.update({\\\"MAE\\\": mae})\\n\\n # overall evaluation\\n movies_recommended = set()\\n i = 0\\n for index, row in predictions_table.iterrows():\\n if i > 10000: break\\n else: i += 1\\n\\n labels = row.nlargest(20).keys().tolist()\\n for movie in labels:\\n movies_recommended.update(movie)\\n\\n result.update({\\\"Coverage\\\": len(movies_recommended)})\\n\\n return result\",\n \"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(ratings_file, sep=ratings_delim, names=ratings_names, header=0, encoding=encoding, engine=engine)\\n movies_df = pd.read_csv(movies_file, sep=movies_delim, names=movies_names, header=0, encoding=encoding, engine=engine)\\n all_users = list(set(ratings_df.user_id))\\n users_df = pd.DataFrame()\\n users_df['user_id'] = all_users\\n print(ratings_df.head())\\n\\n return {\\n 'ratings': ratings_df,\\n 'users': users_df,\\n 'movies': movies_df,\\n }\",\n \"def movies_to_users(user_ratings: UserRatingDict) -> MovieUserDict:\\n movie_user_dict = {}\\n for u in user_ratings:\\n for m in user_ratings[u]:\\n if m in movie_user_dict:\\n movie_user_dict[m].append(u)\\n else:\\n movie_user_dict[m] = [u]\\n return movie_user_dict\",\n \"def makeDictionary(self):\\n self.dictionary = {}\\n for i in range(len(self.movie)):\\n if self.movie[i] in self.dictionary:\\n vectors = self.dictionary[self.movie[i]]\\n vectors[self.user[i]] = self.rating[i]\\n self.dictionary[self.movie[i]] = vectors\\n else:\\n newMovie = dict([(self.user[i], self.rating[i])])\\n self.dictionary[self.movie[i]] = newMovie\\n return self.dictionary\",\n \"def get_user_ratings_by_movie(self, movie_id):\\r\\n return self.df_ratmat[self.df_ratmat.iloc[:, movie_id - 1] > 0]\",\n \"def get_movie_tag_matrix(self):\\n data_frame = genre_tag.get_genre_data()\\n tag_df = data_frame.reset_index()\\n unique_tags = tag_df.tag.unique()\\n idf_data = tag_df.groupby(['movieid'])['tag'].apply(set)\\n tf_df = tag_df.groupby(['movieid'])['tag'].apply(lambda x: ','.join(x)).reset_index()\\n movie_tag_dict = dict(zip(tf_df.movieid, tf_df.tag))\\n tf_weight_dict = {movie: genre_tag.assign_tf_weight(tags.split(',')) for movie, tags in\\n list(movie_tag_dict.items())}\\n idf_weight_dict = {}\\n idf_weight_dict = genre_tag.assign_idf_weight(idf_data, unique_tags)\\n tag_df = genre_tag.get_model_weight(tf_weight_dict, idf_weight_dict, tag_df, 'tfidf')\\n tag_df[\\\"total\\\"] = tag_df.groupby(['movieid','tag'])['value'].transform('sum')\\n temp_df = tag_df[[\\\"moviename\\\", \\\"tag\\\", \\\"total\\\"]].drop_duplicates().reset_index()\\n\\n\\n\\n genre_tag_tfidf_df = temp_df.pivot_table('total', 'moviename', 'tag')\\n genre_tag_tfidf_df = genre_tag_tfidf_df.fillna(0)\\n genre_tag_tfidf_df.to_csv('movie_tag_matrix1d.csv', index=True, encoding='utf-8')\\n return genre_tag_tfidf_df\",\n \"def __init__(self):\\n\\n try:\\n self.posFreqDict = self.load(\\\"posFreqDict\\\")\\n self.neuFreqDict = self.load(\\\"neuFreqDict\\\")\\n self.negFreqDict = self.load(\\\"negFreqDict\\\")\\n\\n except:\\n\\n lFileList = []\\n for fFileObj in os.walk(\\\"movies_reviews/\\\"): \\n lFileList = fFileObj[2]\\n break\\n random.shuffle(lFileList)\\n \\n self.train(lFileList)\\n Original_d = {}\\n d = {}\\n correct_positives =0\\n incorrect_positives=0\\n correct_negatives =0\\n incorrect_negatives = 0\\n for file in lFileList[int(float(len(lFileList))*.9):len(lFileList)+1]:\\n rating = int(file[7])\\n if rating in Original_d:\\n Original_d[rating] = Original_d[rating]+1\\n else:\\n Original_d[rating]=1\\n\\n fileText = self.loadFile(\\\"movies_reviews/\\\" + str(file))\\n result = self.classify(fileText)\\n if result in d:\\n d[result]=d[result]+1\\n else:\\n d[result]=1\\n if rating==5:\\n if result ==\\\"positive\\\":\\n correct_positives+=1\\n else:\\n incorrect_positives+=1\\n else:\\n if result == \\\"negative\\\":\\n correct_negatives+=1\\n else:\\n incorrect_negatives+=1\\n print Original_d\\n print d\\n print correct_positives #Actually positive, we said positive\\n print incorrect_positives #Actually positive, we said negative\\n print correct_negatives #Actually negative, we said negative\\n print incorrect_negatives #Actually negative, we said positive\\n \\n A = float(correct_positives)\\n B = float(incorrect_positives)\\n C = float(incorrect_negatives)\\n\\n Recall = (A / (A + B)) *100.0\\n Precision = (A / (A + C)) *100.0\\n FScore = 2 * (Recall*Precision) / (Recall+Precision)\\n\\n print Recall\\n print Precision\\n print FScore\",\n \"def check_ratings(self):\\n\\n self.browser.get('https://www.imdb.com/')\\n\\n for title in self.titles:\\n input_bar = self.browser.find_element_by_id('navbar-query')\\n input_bar.clear()\\n\\n input_bar.send_keys(title)\\n input_bar.send_keys(Keys.RETURN)\\n\\n time.sleep(3)\\n\\n # Click on the first suggestion\\n css_selector = \\\"div.findSection:nth-child(3) > table:nth-child(2) > tbody:nth-child(1) > tr:nth-child(1) > td:nth-child(2) > a:nth-child(1)\\\"\\n self.browser.find_element_by_css_selector(css_selector).click()\\n time.sleep(3)\\n\\n # Pull details that will always be available\\n score = str(self.browser.find_element_by_class_name('ratingValue').text)\\n score = score.split('/10')[0].replace(',', '.')\\n\\n time.sleep(3)\\n\\n summary = str(self.browser.find_element_by_class_name('summary_text').text)\\n subtext = str(self.browser.find_element_by_class_name('subtext').text)\\n\\n # Pull details that differ between movies and series\\n try:\\n duration = str(self.browser.find_element_by_class_name('bp_sub_heading').text) # Only for series\\n if 'episodes' not in duration:\\n duration = 'Some episodes'\\n except Exception:\\n # bp_sub_heading won't be found on a movie page\\n duration = 'movie'\\n\\n if subtext[0].isdigit():\\n # Split up the details from the subtext\\n subtext_list = subtext.split(' | ')\\n else:\\n # Some movies' subtext starts with 'R' / 'PG-13'\\n subtext_list = subtext.split(' | ')\\n del subtext_list[0]\\n\\n # Duration\\n if duration == 'movie':\\n show_type = 'Movie'\\n duration = subtext_list[0]\\n try:\\n year = datetime.datetime.strptime(subtext_list[2].split(' (')[0], '%d %B %Y').strftime('%Y')\\n except ValueError:\\n year = str(subtext_list[2].split(' (')[0][-4:])\\n\\n else: # series\\n show_type = 'Serie'\\n # Retrieve last season and its release date\\n season_tab = str(self.browser.find_element_by_class_name('seasons-and-year-nav').text).strip()\\n\\n numbers = re.findall('[0-9]+', season_tab)\\n latest_season = int(numbers[0])\\n latest_year = int(max(numbers, key=lambda x: int(x)))\\n\\n duration += ' (%d Seasons in %d), %s per episode' % (latest_season, latest_year, subtext_list[0])\\n\\n year = re.findall('[0-9]+', subtext_list[2])[0]\\n\\n # Pull some more data out from the subtext\\n genres = subtext_list[1].split(', ')\\n\\n # Pull details that are not always available\\n creds_list = []\\n creds = self.browser.find_elements_by_class_name('credit_summary_item')\\n for c in creds:\\n temp = str(c.text)\\n if '|' in temp:\\n temp = temp.split('|')[0]\\n\\n creds_list.append(temp)\\n\\n self.data_dict[title] = {\\n 'score': score,\\n 'summary': summary,\\n 'duration': duration,\\n 'credits': creds_list,\\n 'genres': genres,\\n 'released': year,\\n 'type': show_type,\\n }\",\n \"def get_average_ratings_of_movies(self, movie_ids):\\r\\n return self.df_data[self.df_data[\\\"item_id\\\"].isin(movie_ids)].groupby(\\\"item_id\\\").mean()\",\n \"def transform(self, requests):\\n self.logger.debug(\\\"starting predict\\\")\\n self.logger.debug(\\\"request count: {}\\\".format(requests.shape[0]))\\n\\n preds = [self.predict_one(row['user'], row['movie']) for i, row in requests.iterrows()]\\n\\n requests['rating'] = preds\\n return requests\",\n \"def most_similar_actors_lda(self, moviename):\\n data_frame = self.data_extractor.get_mlmovies_data()\\n tag_data_frame = self.data_extractor.get_genome_tags_data()\\n movie_data_frame = self.data_extractor.get_mltags_data()\\n movie_tag_data_frame = movie_data_frame.merge(tag_data_frame, how=\\\"left\\\", left_on=\\\"tagid\\\", right_on=\\\"tagId\\\")\\n movie_tag_data_frame = movie_tag_data_frame.merge(data_frame, how=\\\"left\\\", left_on=\\\"movieid\\\", right_on=\\\"movieid\\\")\\n tag_df = movie_tag_data_frame.groupby(['movieid'])['tag'].apply(list).reset_index()\\n\\n tag_df = tag_df.sort_values('movieid')\\n movies = tag_df.movieid.tolist()\\n tag_df = list(tag_df.iloc[:, 1])\\n\\n input_movieid = self.util.get_movie_id(moviename)\\n\\n (U, Vh) = self.util.LDA(tag_df, num_topics=5, num_features=1000)\\n\\n movie_topic_matrix = self.util.get_doc_topic_matrix(U, num_docs=len(movies), num_topics=5)\\n topic_movie_matrix = movie_topic_matrix.transpose()\\n movie_movie_matrix = numpy.dot(movie_topic_matrix, topic_movie_matrix)\\n\\n index_movie = None\\n for i, j in enumerate(movies):\\n if j == input_movieid:\\n index_movie = i\\n break\\n\\n if index_movie == None:\\n print(\\\"Movie Id not found.\\\")\\n return None\\n\\n movie_row = movie_movie_matrix[index_movie].tolist()\\n movie_movie_dict = dict(zip(movies, movie_row))\\n del movie_movie_dict[input_movieid]\\n\\n for key in movie_movie_dict.keys():\\n movie_movie_dict[key] = abs(movie_movie_dict[key])\\n\\n movie_movie_dict = sorted(movie_movie_dict.items(), key=operator.itemgetter(1), reverse=True)\\n\\n if movie_movie_dict == None:\\n return None\\n actors = []\\n for (movie, val) in movie_movie_dict:\\n if val <= 0:\\n break\\n actors = actors + self.sim_act_diff_mov_tf.get_actors_of_movie(self.util.get_movie_name_for_id(movie))\\n if len(actors) >= 10:\\n break\\n\\n actors_of_given_movie = self.sim_act_diff_mov_tf.get_actors_of_movie(moviename)\\n\\n actorsFinal = [x for x in actors if x not in actors_of_given_movie]\\n\\n actornames = []\\n for actorid in actorsFinal:\\n actor = self.util.get_actor_name_for_id(actorid)\\n actornames.append(actor)\\n\\n return actornames\",\n \"def movie_profile(movie_id):\\n\\n if not session.get('logged_in_user_email'):\\n flash(\\\"Please login or signup to see the movie details and rate the movie!\\\", \\\"danger\\\")\\n return redirect(\\\"/signup-login\\\")\\n\\n else:\\n\\n # import pdb; pdb.set_trace();\\n\\n # Query by movie id to return that record in database about movie info\\n # movie = Movie.query.filter(Movie.movie_id == movie_id).one()\\n movie = Movie.query.get(movie_id)\\n\\n user = User.query.filter(User.email == session.get(\\\"logged_in_user_email\\\")).one()\\n user_id = user.user_id\\n\\n if user_id:\\n user_rating = Rating.query.filter_by(movie_id=movie_id, user_id=user_id).first()\\n else:\\n user_rating = None\\n\\n # Prediction code: only predict if the user hasn't rated it\\n prediction = None\\n\\n if (not user_rating) and user_id:\\n user = User.query.get(user_id)\\n if user:\\n prediction = user.predict_rating(movie)\\n\\n # Either use the prediction or their real rating\\n if prediction:\\n # User hasn't scored; use our prediction if we made one\\n effective_rating = prediction\\n\\n elif user_rating:\\n # User has already scored for real; use that\\n effective_rating = user_rating.score\\n\\n else:\\n # User hasn't scored and we couldn't get a prediction\\n effective_rating = None\\n\\n # Get the wizard's rating, either by predicting or using real rating\\n wizard = User.query.filter_by(email=\\\"wizard@gmail.com\\\").one()\\n wizard_rating = Rating.query.filter_by(user_id=wizard.user_id, movie_id=movie.movie_id).first()\\n\\n if wizard_rating is None:\\n wizard_rating = wizard.predict_rating(movie)\\n else:\\n wizard_rating = wizard_rating.score\\n\\n if wizard_rating and effective_rating:\\n difference = abs(wizard_rating - effective_rating)\\n else:\\n # We couldn't get a wizard rating, so we'll skip difference\\n difference = None\\n\\n # Depending on how different we are from the Wizard, choose a message\\n BERATEMENT_MESSAGES = [\\n \\\"I suppose you don't have such bad taste after all.\\\",\\n \\\"I regret every decision that I've ever made that has brought me to listen to your opinion.\\\",\\n \\\"Words fail me, as your taste in movies has clearly failed you.\\\",\\n \\\"That movie is great. For a clown to watch. Idiot.\\\",\\n \\\"Words cannot express the awfulness of your taste.\\\"\\n ]\\n\\n if difference is not None:\\n beratement = BERATEMENT_MESSAGES[int(difference)]\\n else:\\n beratement = None\\n\\n # Tallies score of each rating (how many people rated this score per rating)\\n # Returns list of tuples for count_score\\n unordered_ratings = db.session.query(Rating.score, func.count(Rating.score)).filter(Rating.movie_id == movie_id).group_by(Rating.score)\\n ordered_movies = unordered_ratings.order_by(Rating.score)\\n count_score = ordered_movies.all()\\n\\n # Get average score, which returns a tuple-like object, so need to access index 0 to return the number and pass through jinja\\n avg_rating = db.session.query(func.avg(Rating.score)).filter(Rating.movie_id == movie_id).one()\\n\\n # Query to get all ratings for a specific movie\\n # Needed to join Rating and Movie tables and filter by user id\\n # Sort movie titles alphabetically\\n ratings = db.session.query(Rating.movie_id,\\n Rating.score,\\n Movie.title).join(Movie).filter(Rating.movie_id == movie_id).all()\\n\\n # # Pass user info into jinja and called on its attributes\\n # # Pass count_score, avg_rating, and ratings into jinja\\n # return render_template(\\\"movie_profile.html\\\", movie=movie, count_score=count_score, avg_rating=avg_rating[0], ratings=ratings)\\n\\n return render_template(\\n \\\"movie_profile.html\\\",\\n movie=movie,\\n user_rating=user_rating,\\n avg_rating=avg_rating[0],\\n count_score=count_score,\\n prediction=prediction,\\n ratings=ratings,\\n beratement=beratement)\",\n \"def movielens_1m_to_df(ratings_file, users_file, movies_file):\\n ratings_names = ['user_id', 'movie_id', 'rating', 'unix_timestamp']\\n ratings_delim = '::'\\n users_names = ['user_id', 'gender', 'age', 'occupation', 'zip_code']\\n users_delim = '::'\\n movies_names = [ 'movie_id', 'movie_title', 'genres']\\n movies_delim = '::'\\n encoding = 'latin-1'\\n engine = 'python'\\n\\n ratings_df = pd.read_csv(ratings_file, sep=ratings_delim, names=ratings_names, encoding=encoding, engine=engine)\\n users_df = pd.read_csv(users_file, sep=users_delim, names=users_names, encoding=encoding, engine=engine)\\n movies_df = pd.read_csv(movies_file, sep=movies_delim, names=movies_names, encoding=encoding, engine=engine)\\n\\n return {\\n 'ratings': ratings_df,\\n 'users': users_df,\\n 'movies': movies_df,\\n }\",\n \"def makePrediction(toPredict,candidateList):\\n\\n print(\\\"Predicting for: \\\" + toPredict['title'])\\n\\n if PREDICT_RATING:\\n actualRating = float(toPredict['actual_imdb_rating'])\\n predictedRating = round(predictRating(toPredict, candidateList),1)\\n percentDiff = round((actualRating - predictedRating) / actualRating * 100, 2)\\n print(\\\"Predicted rating: \\\" + str(predictedRating) + \\\" Actual Rating: \\\" + str(actualRating))\\n print(\\\"Difference in rating prediction: \\\" + str(percentDiff) + \\\"%\\\")\\n else:\\n predictedRating = round(predictRating(toPredict, candidateList), 1) # using rating to prune unrelated movies.\\n actualRevenue = int(toPredict['actual_revenue'])\\n predictedRevenue = int(predictRevenue(toPredict,candidateList,predictedRating) * float(toPredict['budget'])) #PredictRevenue method return mean RoR\\n percentDiff = round((actualRevenue - predictedRevenue) / actualRevenue * 100, 2)\\n print(str(\\\"Predicted revenue: \\\" + str(predictedRevenue) + \\\" Actual Revenue: \\\" + str(actualRevenue)))\\n print(\\\"Difference in revenue prediction: \\\" + str(percentDiff) + \\\"%\\\")\\n\\n #Tabulate how close the prediction was based on percent difference\\n if abs(percentDiff) <= 5:\\n withinFive.append(0)\\n\\n if abs(percentDiff) <= 10:\\n withinTen.append(0)\\n\\n if abs(percentDiff) <= 15:\\n withinFifteen.append(0)\\n\\n if abs(percentDiff) <= 20:\\n withinTwenty.append(0)\\n\\n if abs(percentDiff) <= 30:\\n withinThirty.append(0)\",\n \"def build_recommendations(sc, myRatings, model):\\n #myRatedMovieIds = set([x[1] for x in myRatings])\\n uid = get_uid_from_ratings(myRatings)\\n #print \\\"uid:\\\", uid\\n myRatedMovieIds = set([x[1] for x in myRatings.collect()])\\n #print \\\"myRatedMovieIds:\\\", myRatedMovieIds\\n candidates = sc.parallelize([m for m in movies if m not in myRatedMovieIds]).cache()\\n #print candidates\\n predictions = model.predictAll(candidates.map(lambda x: (uid, x))).collect()\\n #print predictions\\n recommendations = sorted(predictions, key = lambda x: x.product)\\n return recommendations\",\n \"def __init__(self,\\n path,\\n initial_affinity=0.5,\\n update_rate=0.1,\\n alpha=0.20,\\n beta=0.10,\\n gamma=0.40,\\n theta=0.25,\\n omega=0.10,\\n train_ratio=0.9,\\n ratings_ratio=1.0):\\n # Case base structures\\n self.user_affinity = AffinityCaseBase(initial_preference=initial_affinity,\\n modifier=update_rate) # User recommendation feedback\\n self.genre_willigness = AffinityCaseBase(initial_preference=initial_affinity,\\n modifier=update_rate) # Recommendations feedback\\n\\n # Pandas datasets\\n self.movies, self.users = None, None\\n self.all_ratings, self.ratings, self.test_ratings = None, None, None\\n\\n # Case base global structures\\n self.popular = None # Popular movies\\n self.mean_movie_rating = None # Mean score for each movie\\n self.mean_user_rating = None # Mean rating for each user\\n\\n # Movie score parameters\\n self.alpha = alpha\\n self.beta = beta\\n self.gamma = gamma\\n self.theta = theta\\n self.omega = omega\\n\\n # Counter for test_rating set\\n self.count = 0\\n\\n # User similarity caching\\n self.user_cache = {}\\n # Check ratios are in correct interval to avoid unexpected behaviors\\n check_ratio('Initial affinity', initial_affinity)\\n check_ratio('Update rate', update_rate)\\n check_ratio('Alpha', alpha)\\n check_ratio('Beta', beta)\\n check_ratio('Gamma', gamma)\\n check_ratio('Thetha', theta)\\n check_ratio(\\\"Training ratio\\\", train_ratio)\\n check_ratio(\\\"Ratings ratio\\\", ratings_ratio)\\n\\n # Read data\\n self._read_data(path, ratings_ratio)\",\n \"def extract_movies(dom):\\n\\n # extract data per movie\\n movies = dom.find_all('div', class_ = 'lister-item mode-advanced')\\n\\n # list to store scraped data\\n movielist = []\\n\\n for movie in movies:\\n\\n # append extracted data to this dict\\n moviedict = {}\\n\\n # scrape titles and add to dict\\n moviedict['title'] = movie.h3.a.text\\n\\n # scrape ratings and add to dict\\n moviedict['rating'] = float(movie.strong.text)\\n\\n # scrape year of release and add to dict\\n year = movie.h3.find('span', class_ = 'lister-item-year text-muted unbold')\\n moviedict['year'] = re.findall('\\\\d+', year.text.strip('()'))[0]\\n\\n # scrape actors and add to dict\\n actors = movie.find_all(href=re.compile(\\\"adv_li_st\\\"))\\n actorlist = []\\n for actor in actors:\\n actorlist.append(actor.text)\\n actorstring = ', '.join(actorlist)\\n moviedict['actors'] = actorstring\\n\\n # scrape runtime and add to dict\\n moviedict['runtime'] = movie.p.find('span', class_ = 'runtime').text.split(' ')[0]\\n movielist.append(moviedict)\\n\\n\\n # ADD YOUR CODE HERE TO EXTRACT THE ABOVE INFORMATION ABOUT THE\\n # HIGHEST RATED MOVIES\\n # NOTE: FOR THIS EXERCISE YOU ARE ALLOWED (BUT NOT REQUIRED) TO IGNORE\\n # UNICODE CHARACTERS AND SIMPLY LEAVE THEM OUT OF THE OUTPUT.\\n\\n return movielist # REPLACE THIS LINE AS WELL IF APPROPRIATE\",\n \"def get_rating(text):\\n movie = text\\n page = requests.get('http://www.imdb.com/find?ref_=nv_sr_fn&q=' + movie + '&s=tt')\\n soup1 = BeautifulSoup(page.content, 'html.parser')\\n movieid = soup1.select(\\\".findList tr a\\\")[0].get('href')\\n movielink = \\\"http://www.imdb.com\\\" + movieid\\n mlinkpage = requests.get(movielink)\\n soup2 = BeautifulSoup(mlinkpage.content, 'html.parser')\\n movierating = soup2.select(\\\".ratingValue span\\\")[0].text\\n metascore = soup2.select(\\\".metacriticScore\\\")\\n reviewlink = movielink + 'reviews'\\n linkpage = requests.get(reviewlink)\\n soup3 = BeautifulSoup(linkpage.content, 'html.parser')\\n \\n return soup3, movierating\",\n \"def download_imdb_ratings():\\n print(\\\"Option not implemented\\\")\\n sys.exit(1)\\n return {}\",\n \"def get_mean_movie_rating(self, movie_id):\\n return self.mean_movie_rating[self.mean_movie_rating['movie_id'] == movie_id]['rating'].item()\",\n \"def get_similar_users(target_rating: Rating,\\n user_ratings: UserRatingDict,\\n movie_users: MovieUserDict) -> Dict[int, float]:\\n dic = {}\\n watched = get_users_who_watched(list(target_rating.keys()), movie_users)\\n for u in watched:\\n dic[u] = get_similarity(target_rating, user_ratings[u])\\n return dic\",\n \"def recommend(title, cosine_sim, indices, df):\\n\\n recommended_papers = {}\\n\\n # getting the index of the movie that matches the title\\n try:\\n idx = indices[indices == title].index[0]\\n except:\\n # return dummy values if indices doesn't behave (?)\\n return {}, 0.0\\n\\n # creating a Series with the similarity scores in descending order\\n score_series = pd.Series(cosine_sim[idx]).sort_values(ascending = False)\\n #print(type(score_series))\\n #print(len(score_series))\\n\\n # getting the indexes of the 5 most similar papers\\n top_5_indexes = list(score_series.iloc[1:5].index)\\n average_score = mean(score_series)\\n #print('avg:', average_score)\\n #highest_score = float(score_series.iloc[1])\\n #print(score_series.iloc[1:5].index)\\n #print(score_series.iloc[1:5])\\n\\n # populating the list with the titles of the best 5 matching papers\\n for i in top_5_indexes:\\n recommended_papers[list(df.index)[i]] = df['Link'][i]\\n\\n return recommended_papers, average_score\",\n \"def pred_movies(movie_list):\\r\\n # Store the id of users\\r\\n id_store = []\\r\\n # For each movie selected by a user of the app,\\r\\n # predict a corresponding user within the dataset with the highest rating\\r\\n for i in movie_list:\\r\\n movieID = movies_df[movies_df['title'] == i]['movieId'].values[0]\\r\\n predictions = prediction_item(item_id=movieID)\\r\\n predictions.sort(key=lambda x: x.est, reverse=True)\\r\\n # Take the top 10 user id's from each movie with highest rankings\\r\\n for pred in predictions[:10]:\\r\\n id_store.append(pred.uid)\\r\\n # Return a list of user id's\\r\\n return id_store\",\n \"def update_suggestions(ratings, tmdb_obj, status=True):\\n seen = []\\n suggs = {}\\n ratings_count = len(ratings)\\n i = 0\\n for title, data in ratings.items():\\n # Print progress\\n if status:\\n text = \\\"\\\\r{}/{} processed\\\".format(i, ratings_count)\\n sys.stdout.flush()\\n sys.stdout.write(text)\\n i += 1\\n\\n movs = tmdb_obj.search_by_imdb_id(data.imdb_id) if data.type == tmdb_obj.media_type else None\\n if movs:\\n movie_id = movs[0][\\\"id\\\"]\\n seen.append(movie_id)\\n for sugg in similar_search(tmdb_obj, movie_id):\\n # Different key if tv or movie\\n title = sugg[\\\"title\\\"] if \\\"title\\\" in sugg else sugg[\\\"name\\\"]\\n if title in suggs:\\n suggs[title][0].append(data.user_rating)\\n else:\\n suggs[title] = ([data.user_rating], sugg)\\n\\n # Calculate movie scores\\n # personalized suggestions\\n res = {}\\n res_p = {}\\n for title, (scores, data) in suggs.items():\\n if not data[\\\"id\\\"] in seen:\\n s, s_p = suggest_score(data[\\\"popularity\\\"], data[\\\"vote_average\\\"], scores)\\n res_p[title] = s_p, len(scores), data\\n res[title] = s, len(scores), data\\n\\n # Sort on score\\n res = sorted(res.items(), key=lambda item: item[1][0])\\n res_p = sorted(res_p.items(), key=lambda item: item[1][0])\\n\\n if not os.path.exists(SUGGESTIONS_FOLDER):\\n os.makedirs(SUGGESTIONS_FOLDER)\\n # Write result to file\\n with open(SUGGESTIONS_FOLDER + \\\"/\\\" + tmdb_obj.media_type + \\\"_\\\" + SUGGESTIONS_PATH, \\\"w\\\") as file:\\n #for title, (score, relations, data) in res:\\n file.write(json.dumps(res))\\n with open(SUGGESTIONS_FOLDER + \\\"/\\\" + tmdb_obj.media_type + \\\"_\\\" + SUGGESTIONS_PERSONALIZED_PATH, \\\"w\\\") as file_p:\\n #for title, (score, relations, data) in res:\\n file_p.write(json.dumps(res_p))\\n\\n print()\\n return res, res_p\",\n \"def _imdb_score(title, min_votes=0):\\n info = imdb_info(title)\\n if info:\\n if min_votes and info.get('votes', 0) < min_votes:\\n return 0\\n return info['rating']\\n return 0\",\n \"def _get_user_movie_rating(self, user_id, movie_id):\\n rating = self.ratings[(self.ratings['user_id'] == user_id) &\\n (self.ratings['movie_id'] == movie_id)]['rating'].iloc[0]\\n user_mean = self.get_mean_user_rating(user_id)\\n return rating - user_mean\",\n \"def ready_movies():\\n troy = Movie(movie_title=\\\"Troy\\\",\\n poster_image=\\\"https://upload.wikimedia.org/wikipedia/en/b/b8/Troy2004Poster.jpg\\\",\\n trailer_youtube=\\\"https://www.youtube.com/watch?v=znTLzRJimeY\\\")\\n\\n kingdom_of_heaven = Movie(movie_title=\\\"Kingdom of Heaven\\\",\\n poster_image=\\\"https://upload.wikimedia.org/wikipedia/en/9/9e/KoHposter.jpg\\\",\\n trailer_youtube=\\\"https://www.youtube.com/watch?v=moNH4N44D28\\\")\\n\\n warrior = Movie(movie_title=\\\"Warrior\\\",\\n poster_image=\\\"https://upload.wikimedia.org/wikipedia/en/e/e3/Warrior_Poster.jpg\\\",\\n trailer_youtube=\\\"https://www.youtube.com/watch?v=I5kzcwcQA1Q\\\")\\n\\n pulp_fiction = Movie(movie_title=\\\"Pulp Fiction\\\",\\n poster_image=\\\"https://upload.wikimedia.org/wikipedia/en/3/3b/Pulp_Fiction_%281994%29_poster.jpg\\\",\\n trailer_youtube=\\\"https://www.youtube.com/watch?v=s7EdQ4FqbhY\\\")\\n\\n fight_club = Movie(movie_title=\\\"Fight Club\\\",\\n poster_image=\\\"https://upload.wikimedia.org/wikipedia/en/f/fc/Fight_Club_poster.jpg\\\",\\n trailer_youtube=\\\"https://www.youtube.com/watch?v=SUXWAEX2jlg\\\")\\n\\n the_matrix = Movie(movie_title=\\\"The Matrix\\\",\\n poster_image=\\\"https://upload.wikimedia.org/wikipedia/en/c/c1/The_Matrix_Poster.jpg\\\",\\n trailer_youtube=\\\"https://www.youtube.com/watch?v=vKQi3bBA1y8\\\")\\n\\n the_dark_knight = Movie(movie_title=\\\"The Dark Knight\\\",\\n poster_image=\\\"https://upload.wikimedia.org/wikipedia/en/8/8a/Dark_Knight.jpg\\\",\\n trailer_youtube=\\\"https://www.youtube.com/watch?v=vKQi3bBA1y8\\\")\\n\\n whiplash = Movie(movie_title=\\\"Whiplash\\\",\\n poster_image=\\\"https://upload.wikimedia.org/wikipedia/en/0/01/Whiplash_poster.jpg\\\",\\n trailer_youtube=\\\"https://www.youtube.com/watch?v=7d_jQycdQGo\\\")\\n\\n dredd = Movie(movie_title=\\\"Dredd\\\",\\n poster_image=\\\"https://upload.wikimedia.org/wikipedia/en/1/16/Dredd2012Poster.jpg\\\",\\n trailer_youtube=\\\"https://www.youtube.com/watch?v=qv-6dNqqnMA\\\")\\n\\n ai_artificial_intelligence = Movie(movie_title=\\\"A.I. Artificial Intelligence\\\",\\n poster_image=\\\"https://upload.wikimedia.org/wikipedia/en/e/e6/AI_Poster.jpg\\\",\\n trailer_youtube=\\\"https://www.youtube.com/watch?v=_19pRsZRiz4\\\")\\n\\n watchmen = Movie(movie_title=\\\"Watchmen\\\",\\n poster_image=\\\"https://upload.wikimedia.org/wikipedia/en/b/bc/Watchmen_film_poster.jpg\\\",\\n trailer_youtube=\\\"https://www.youtube.com/watch?v=PVjA0y78_EQ\\\")\\n\\n the_rock = Movie(movie_title=\\\"The Rock\\\",\\n poster_image=\\\"https://upload.wikimedia.org/wikipedia/en/8/82/The_Rock_%28movie%29.jpg\\\",\\n trailer_youtube=\\\"https://www.youtube.com/watch?v=jGVJx5mOtL8\\\")\\n\\n movies = [troy, kingdom_of_heaven, warrior, pulp_fiction, fight_club, the_matrix,\\n the_dark_knight, whiplash, dredd, ai_artificial_intelligence,\\n watchmen, the_rock]\\n\\n return movies\",\n \"def main():\\n directors = get_movies_by_director()\\n directors = get_average_scores(directors)\\n print_results(directors)\",\n \"def get_ratings_for_movie_ids(self, user_id, movie_ids):\\n requested_movies_RDD = self.sc.parallelize(movie_ids).map(lambda x: (user_id, x))\\n # Get predicted ratings\\n ratings = self.__predict_ratings(requested_movies_RDD).collect()\\n return ratings\",\n \"def evaluate():\\n global dictionary, wv\\n count = 0\\n # To save the scores by distance and similarity\\n scores = np.zeros(6)\\n similar = np.zeros(6)\\n itr = len(dictionary)\\n logging.info('running evaluation for {0} samples'.format(itr))\\n for key in dictionary:\\n progress = (count / itr) * 100\\n d = dictionary[key].split('resource/')\\n d = [idx.split()[0].translate(table).lower() for idx in d[1:]]\\n try:\\n r = np.array(list(map(lambda x: wv.get_vector(x), d)),\\n dtype=np.float32)\\n except KeyError:\\n itr -= 1\\n continue\\n if np.any(np.isnan(r)):\\n itr -= 1\\n continue\\n else:\\n if r.ndim == 2:\\n try:\\n # Mean of vector containing all word vectors\\n # obtained from abstract.\\n r = r.mean(axis=0).reshape(1, -1)\\n \\n # Obtain the vectors for the entity\\n mean_vec = mean_encoder(dictionary[key])\\n mean_vec = mean_vec.reshape(1, -1) / norm(mean_vec)\\n mean_dist_vec = distance_encoder(dictionary[key])\\n mean_dist_vec = mean_dist_vec.reshape(1, -1)\\n mean_dist_vec = mean_dist_vec / norm(mean_dist_vec)\\n title_vec = title_mean(key)\\n title_vec = title_vec.reshape(1, -1) / norm(title_vec)\\n abstract_vec = abstract_encoder(key)\\n abstract_vec = abstract_vec.reshape(1, -1)\\n abstract_vec = abstract_vec / norm(abstract_vec)\\n random_vec = np.random.randn(100).reshape(1, -1)\\n zero_vec = np.zeros(100).reshape(1, -1)\\n \\n # Score the entity vectors\\n scores[0] += norm(r - mean_vec)\\n scores[1] += norm(r - mean_dist_vec)\\n scores[2] += norm(r - title_vec)\\n scores[3] += norm(r - abstract_vec)\\n scores[4] += norm(r - random_vec)\\n scores[5] += norm(r - zero_vec)\\n similar[0] += cosine_similarity(r, mean_vec)\\n similar[1] += cosine_similarity(r, mean_dist_vec)\\n similar[2] += cosine_similarity(r, title_vec)\\n similar[3] += cosine_similarity(r, abstract_vec)\\n similar[4] += cosine_similarity(r, random_vec)\\n similar[5] += cosine_similarity(r, zero_vec)\\n count += 1\\n print(count, end='\\\\r')\\n except (ValueError, KeyError) as _:\\n itr -= 1\\n continue\\n else:\\n itr -= 1\\n continue\\n # Normalize the scores to get a better\\n # comparison against the baselines.\\n scores = scores / norm(scores)\\n similar = similar / norm(similar)\\n print_summary(scores, similar)\",\n \"def update_posterior_probs(vars_):\\n vars_.weighted_sums += np.power(vars_.dprime_map[vars_.focus],2) * vars_.visual_field\\n vars_.post_probs = np.exp(vars_.weighted_sums) * vars_.prior_prob\\n vars_.post_probs /= np.sum(vars_.post_probs)\",\n \"def __tags_to_movies(mlens_to_tmdb, movies_to_titles, tags_to_names,\\n genomeFile='ml-latest/genome-scores.csv'):\\n rdr = csv.reader(open(genomeFile))\\n next(rdr, None)\\n\\n tagsToMovies = {}\\n\\n for row in rdr:\\n movieLensId = row[0]; tagId = row[1]; score=row[2]\\n tmdb_id = mlens_to_tmdb[movieLensId]\\n tagName = tags_to_names[tagId]\\n if tagName not in tagsToMovies:\\n tagsToMovies[tagName] = []\\n\\n title = movies_to_titles[tmdb_id]\\n tagsToMovies[tagName].append( (tmdb_id, title, score) )\\n\\n # Sort each by score\\n for tagId, scoredMovies in tagsToMovies.items():\\n scoredMovies.sort(key=lambda x: x[2], reverse=True)\\n\\n return tagsToMovies\",\n \"def get_average_scores(directors):\\n records = {\\n director: movies\\n for director, movies in directors.items()\\n if len(movies) >= MIN_MOVIES\\n }\\n return {\\n (director, _calc_mean(movies)): movies for director, movies in records.items()\\n }\",\n \"def update_popularity(self):\\n ratings_count = self.ratings.groupby(['movie_id'])['rating'].count().reset_index()\\n sorted_ids = ratings_count.sort_values(['rating'], ascending=[False])\\n self.popular = pd.merge(sorted_ids, self.movies, left_on=['movie_id'], right_on=['movie_id'])\",\n \"def predict_rating(item_id, ratings, similarities, N=10):\\n \\n # get the ratings of all users for the specific item\\n users_ratings = ratings.loc[:, item_id]\\n \\n # only keep users who rated the given item, otherwise you won't be able to generate a prediction based on the users ratings\\n most_similar_users_who_rated_item = similarities.loc[~users_ratings.isnull()]\\n \\n # keep N users with highest similarities to given user who also rated the given item\\n N_most_similar_users = most_similar_users_who_rated_item.head(N)\\n \\n # find ratings item for most similar users:\\n ratings_for_item = ratings.loc[N_most_similar_users.index, item_id]\\n \\n # predict the rating of the item by averaging the ratings of that item of the most similar users\\n return ratings_for_item.mean()\",\n \"def main():\\n args = parse_argument()\\n train_file = args['train'][0]\\n test_file = args['test'][0]\\n print train_file, test_file\\n \\n user_ratings_train, movie_ratings_train=parse_file(train_file)\\n ave_ratings=compute_average_user_ratings(user_ratings_train)\\n user_train=list(user_ratings_train.keys())\\n with open(test_file,'r') as test:\\n with open('predictions.txt', 'w') as pred:\\n writer = csv.writer(pred)\\n prediction=list()\\n actual=list()\\n for row in csv.reader(test):\\n num_sum=0.0\\n sim_sum=0.0\\n user=int(row[1])\\n movie=int(row[0])\\n other_users_ratings=movie_ratings_train[movie]\\n other_users=other_users_ratings.keys()\\n for i in range(len(other_users)): \\n other_user=other_users[i]\\n similar=compute_user_similarity(user_ratings_train[user],user_ratings_train[other_user],ave_ratings[user],ave_ratings[other_user])\\n num_sum=num_sum+similar*(float(movie_ratings_train[movie][other_user])-float(ave_ratings[other_user]))\\n sim_sum = sim_sum+abs(similar)\\n #No similar users\\n try:\\n pred_rating=ave_ratings[user]+num_sum/sim_sum\\n except ZeroDivisionError:\\n pred_rating=ave_ratings[user]\\n prediction.append(pred_rating)\\n actual.append(row[2])\\n writer.writerow(row+[pred_rating])\\n actual_np=np.array(map(float, actual))\\n prediction_np=np.array(prediction)\\n rmse=np.sqrt(((prediction_np - actual_np)** 2).mean())\\n mae=np.absolute(prediction_np - actual_np).mean()\\n print \\\"RMSE\\\",round(rmse,4)\\n print \\\"MAE\\\",round(mae,4)\",\n \"def calculate_recommendations(self, vote_list, itemMatch, itemIgnored):\\n #print \\\"--------------------------------------------------\\\"\\n #print \\\"calculate_recommendations\\\"\\n #print \\\"--------------------------------------------------\\\"\\n\\n # http://www.quuxlabs.com/blog/2010/09/matrix-factorization-a-simple-tutorial-and-implementation-in-python/\\n\\n # U = np.array('users')\\n # D = np.array('video_games')\\n\\n # R = |U| cross |D|\\n\\n # We want to discover K latent features\\n\\n # Find\\n # P(a | |U| corss K matrix)\\n # Q(a | |D| cross K matrix)\\n # Such that their product approximates R\\n # R approx= P cross transpose(Q) = hat(R)\\n #\\n\\n # r[i][j] = transpose(p)[i] * q[j]\\n # = sum( 1..k, p[i][k] * q[k][j] )\\n\\n # e[i][j]**2 = (r[i][j] - hat(r)[i][j])**2\\n # = (r[i][j] - sum( 1..K, p[i][k] * q[k][j]))**2\\n # squared error, estimated rating can be either higher or lower than the real thing\\n\\n # find the gradient\\n # diff(e[i][j]**2, p[i][k]) = -2*(r[i][j] - hat(r)[i][j]) * (q[k][j]) = -2*e[i][j] * q[k][j]\\n # diff(e[i][j]**2, q[k][j]) = -2*(r[i][j] - hat(r)[i][j]) * (p[i][k]) = -2*e[i][j] * p[i][k]\\n\\n # update rules\\n # alpha = settings.alpha # learning_rate\\n # alpha = 0.0002 # learning_rate\\n # p[i][k]' = p[i][k] + alpha * diff(e[i][j]**2, p[i][k])\\n # = p[i][k] + 2 * alpha * e[i][j] * q[k][j]\\n # q[k][j]' = q[k][j] + alpha * diff(e[i][j]**2, q[k][j])\\n # = q[k][j] + 2 * alpha * e[i][j] * p[i][k]\\n\\n # training data\\n # T = (u[i], d[j], r[i][j])\\n # np.array()\\n\\n # iterate until convergance\\n # E = sum((u[i], d[j], r[i][j]) in T, e[i][j])\\n # = sum((u[i], d[j], r[i][j]) in T, r[i][j]\\n # - sum(1..k, p[i][k]*q[k][j]))**2\\n\\n # regularization\\n # beta = 0.02\\n # e[i][j]**2 = (r[i][j] - sum(1..K, p[i][j]*q[k][j]))**2\\n # + ((beta/2) * sum(1..K, norm(P)**2 + norm(Q)**2))\\n #\\n # p[i][k]' = p[i][k] + alpha * (2 * e[i][j] * q[k][j] - beta * p[i][k])\\n # q[k][j]' = q[k][j] + alpha * (2 * e[i][j] * p[i][k] - beta * q[k][j])\\n\\n data = np.array(vote_list)\\n\\n encoder = OneHotEncoder()\\n\\n users = data[:,0]\\n unique_users = list(set(users))\\n for i in range(len(users)):\\n users[i] = unique_users.index(users[i])\\n\\n video_games = data[:,1]\\n unique_games = list(set(video_games))\\n for i in range(len(video_games)):\\n video_games[i] = unique_games.index(video_games[i])\\n\\n ratings = data[:,2]\\n M = len(set(video_games))\\n N = len(set(users))\\n R = np.zeros((N,M))\\n for i in range(len(users)):\\n user = users[i]\\n game = video_games[i]\\n rating = ratings[i]\\n R[user][game] = rating\\n\\n K = 2\\n\\n P = np.random.rand(N,K)\\n Q = np.random.rand(M,K)\\n\\n nP, nQ = self.matrix_factorization(R, P, Q, K)\\n nR = np.dot(nP, nQ.T)\\n\\n itemMatch = {}\\n for i in range(N):\\n user = unique_users[i]\\n itemMatch[user] = []\\n for j in range(M):\\n if R[i][j] == 0:\\n video_game = unique_games[j]\\n recommendation = (video_game, nR[i][j])\\n itemMatch[user].append(recommendation)\\n itemMatch[None] = []\\n print 'pmf recommendations', itemMatch.items()\\n print '\\\\n'\\n recommendations = itemMatch.items()\\n\\n # returns\\n # [\\n # (<user1>, [\\n # (\\\"<object_identifier1>\\\", <score>),\\n # (\\\"<object_identifier2>\\\", <score>),\\n # ]),\\n # (<user2>, [\\n # (\\\"<object_identifier1>\\\", <score>),\\n # (\\\"<object_identifier2>\\\", <score>),\\n # ]),\\n # ]\\n\\n return recommendations\",\n \"def recommend_NMF(new_user,movies_num,movies_ratings):\\n list_id_movies = movies_ratings['movieId'].unique()\\n nmf,Q = load_NMF_model()\\n new_user_vector = pd.DataFrame(new_user, index=list_id_movies).T\\n new_user_vector_filled = new_user_vector.fillna(3)\\n #calculate Matrix P (Genres)\\n P = nmf.transform(new_user_vector_filled)\\n #make predictions\\n predictions = np.dot(P,Q)\\n recommendations = pd.DataFrame(predictions.reshape(-1), index=list_id_movies).T\\n #Remove already watched movies:\\n not_watched_movies_mask = np.isnan(new_user_vector)\\n not_watched = recommendations[not_watched_movies_mask]\\n\\n top_movies_ids = not_watched.T.sort_values(by=[0], ascending=False).index[:movies_num]\\n\\n Top_recommended = movieId_to_title(top_movies_ids,movies_ratings) \\n return Top_recommended\",\n \"def get_ratings_for_movie_ids(self, user_id, movie_ids):\\n requested_movies_RDD = self.sc.parallelize(movie_ids).map(lambda x: (user_id, x))\\n # Get predicted ratings\\n ratings = self.__predict_ratings(requested_movies_RDD).collect()\\n\\n return ratings\",\n \"def weight_distribution(self):\\n all_scores = []\\n for zettel in self.lemma_tokens:\\n scores = []\\n for word in zettel:\\n cur_tf_idf = self.tf_idf_scores[word[0]] / 3 #range: 0-3+\\n if word[1] == 'NG':\\n word_list = re.split(\\\" \\\", word[0])\\n cur_word_score = 0\\n i = 0\\n for new_word in word_list:\\n cur_word_score += self.word_scores[new_word]\\n i += 1\\n cur_word_score = cur_word_score / i / 2 #range: 0-2+\\n else:\\n cur_word_score = self.word_scores[word[0]] / 2 #range: 0-2+\\n cur_keyword_score = self.keyword_scores[word[0]] / 4 #0-4+\\n cur_text_rank = self.text_ranks[word[0]] / 10 #range: 0-12+\\n cur_pos_score = self.pos_scores[word[0]]\\n cur_area_score = self.z_area_scores[word[0]]\\n cur_total_score = ((cur_tf_idf * self.score_weights[0]) + (cur_word_score * self.score_weights[1]) +\\n (cur_keyword_score * self.score_weights[2]) + (cur_text_rank * self.score_weights[3]) +\\n (cur_pos_score * self.score_weights[4]) + (cur_area_score * self.score_weights[5])) / 6\\n scores.append(cur_total_score)\\n all_scores.append(scores)\\n return all_scores\",\n \"def getRating(movieInfo):\\n if \\\"vote_average\\\" in movieInfo:\\n return movieInfo[\\\"vote_average\\\"] \\n else:\\n raise AttributeError(\\\"%s instance has no attribute vote_average (rating)\\\" % movieInfo)\",\n \"def getRecommendations(prefs,person,similarity=sim_pearson):\\n weighted_similarities = dict((\\n (other, similarity(prefs, person, other)) \\n for other in prefs.keys() if other != person))\\n # Eliminate critics with negative correlation (I'm not sure why\\n # this is a good idea)\\n for critic, sim in weighted_similarities.items():\\n if sim <= 0:\\n del weighted_similarities[critic]\\n sum_ratings = defaultdict(int) # int() initializes to 0\\n sum_weights = defaultdict(int)\\n for other, weight in weighted_similarities.items():\\n for movie, rating in prefs[other].items():\\n sum_ratings[movie] += rating * weight\\n sum_weights[movie] += weight\\n recommendations = [(sum_ratings[movie]/sum_weights[movie], movie)\\n for movie in sum_ratings.keys()\\n if movie not in prefs[person].keys()]\\n recommendations.sort()\\n recommendations.reverse()\\n return recommendations\",\n \"def mostHighlyRatedCastMembers (movies, count, minAppearances):\\n def getAverage (allMovies, castMovies):\\n # return average rating for all movies in list castMovies\\n ratings = [ float(allMovies[key][8]) for key in castMovies if float(allMovies[key][8]) < 10 ]\\n numMovies = len(ratings)\\n if numMovies > 0:\\n return sum(ratings) / numMovies\\n else:\\n return 0\\n # OR:\\n # totalRating = 0\\n # numMovies = 0\\n # for key in castMovies: \\n # rating = float(allMovies[key][8]) # rating or profit\\n # if rating < 10: # is a rating\\n # totalRating += rating\\n # numMovies += 1\\n # if numMovies > 0:\\n # return totalRating / numMovies\\n # else:\\n # return 0\\n\\n cast = castFilmography(movies, minAppearances)\\n ratings = [ (getAverage(movies, castInfo[1:]), castInfo[0]) for castInfo in cast ]\\n return sorted(ratings, reverse=True)[:count]\",\n \"def get_global_mean(self, ratings):\\n total_ratings = []\\n for user, movie, rating in ratings:\\n total_ratings.append(rating)\\n return sum(total_ratings) / len(total_ratings)\",\n \"def parse_movie_page(movie_url: str) -> Dict[str, str]:\\n movie_page = get_soup_for_page(movie_url)\\n\\n # title and id\\n movie_id = movie_url.split(\\\"/\\\")[-2]\\n title = movie_page.find(\\\"div\\\", class_=\\\"title_wrapper\\\").find(\\\"h1\\\").get_text(\\\";\\\", strip=True).split(\\\";\\\")[0]\\n\\n # director and stars\\n credit_summary_elements = movie_page.find_all(\\\"div\\\", class_=\\\"credit_summary_item\\\")\\n director = credit_summary_elements[0].find(\\\"a\\\").text if len(credit_summary_elements) > 0 else \\\"\\\"\\n if len(credit_summary_elements) > 2:\\n stars_links = credit_summary_elements[2].find_all(\\\"a\\\")\\n stars = [str(elem.text) for elem in stars_links[:-1]]\\n else:\\n stars = []\\n movie_data = {\\n \\\"id\\\": movie_id,\\n \\\"title\\\": title,\\n \\\"director\\\": director,\\n \\\"stars\\\": stars,\\n }\\n print(movie_data)\\n return movie_data\",\n \"def get_movielens():\\n\\n filename = os.path.join(_download.LOCAL_CACHE_DIR, \\\"movielens_20m.hdf5\\\")\\n if not os.path.isfile(filename):\\n log.info(\\\"Downloading dataset to '%s'\\\", filename)\\n _download.download_file(URL, filename)\\n else:\\n log.info(\\\"Using cached dataset at '%s'\\\", filename)\\n\\n with h5py.File(filename, 'r') as f:\\n m = f.get('movie_user_ratings')\\n plays = csr_matrix((m.get('data'), m.get('indices'), m.get('indptr')))\\n return np.array(f['movie']), plays\",\n \"def train_nmf(movies_ratings):\\n \\n #pivot the dataframe\\n movies_ratings = movies_ratings.pivot_table(index='userId', columns='movieId', values='rating')\\n #Fill Nan with 3.0 rating:\\n movies_ratings.fillna(3.0, inplace=True)\\n\\n nmf_model = NMF(\\n n_components=20,\\n init='random',\\n random_state=10,\\n max_iter=10000\\n )\\n nmf_model.fit(movies_ratings)\\n\\n #save nmf model\\n pickle.dump(nmf_model,open(\\\"models/nmf_model.sav\\\", 'wb'))\",\n \"def ratings_genre(Y, genres, genre_id):\\n # Filter Y for only ratings of movies in the genre.\\n genre_Y = filter(\\n lambda user_movie_rating: genres[user_movie_rating[1]][genre_id], Y\\n )\\n bar_count_ratings(genre_Y, 'Rating distribution for {} movies'.format(\\n data_proc.GENRE_NAMES[genre_id]\\n ))\",\n \"def cache_produce () :\\n\\n \\\"\\\"\\\"\\n list for movie\\n each entry is the sum and count of all ratings received by each movie, which will be used later to calculate the user offset\\n \\\"\\\"\\\"\\n mcache = movie_read(open('/u/downing/cs/netflix/movie_titles.txt', 'r', encoding = \\\"ISO-8859-1\\\"))\\n\\n \\\"\\\"\\\"\\n dictionaries for user caches\\n each entry contain the sum and count of all ratings given by each user, which will be used later to calculate the user offset\\n mean is the average of all ratings from all movies\\n \\\"\\\"\\\"\\n ucache, mean = user_read(mcache, \\\"/u/downing/cs/netflix/training_set\\\")\\n\\n cal_offset(mcache, mean)\\n cal_offset(ucache, mean)\\n\\n mcache.append(mean)\\n\\n output_cache(ucache, open('/u/wc6892/Documents/cs373-netflix/wc6892-ucacheoff.txt', 'w'))\\n output_cache(mcache, open('/u/wc6892/Documents/cs373-netflix/wc6892-mcacheoff.txt', 'w'))\",\n \"def preprocess_movie_json(json_dict: Dict) -> Dict:\\n json_dict['Ratings'] = list(map(lambda elem: {elem['Source']: elem['Value']}, json_dict['Ratings']))\\n for obj in json_dict['Ratings']:\\n if 'Metacritic' in obj:\\n obj['Metacritic'] = ' / '.join(obj['Metacritic'].split('/'))\\n return json_dict\",\n \"def collab_model(movie_list, top_n=10):\\r\\n user_ids = pred_movies(movie_list)\\r\\n\\r\\n temp = get_user_movies(ratings, user_ids)\\r\\n\\r\\n movie_ids = []\\r\\n for i in movie_list:\\r\\n \\\"\\\"\\\" get movieId from title\\\"\\\"\\\"\\r\\n movieID = movies_df[movies_df['title'] == i]['movieId'].values[0]\\r\\n movie_ids.append(movieID)\\r\\n\\r\\n # Add new user with ratings to userlist\\r\\n new_user_row1 = {'userId': 1000000, 'movieId': movie_ids[0], 'rating': 5.0, 'title': movie_list[0]}\\r\\n new_user_row2 = {'userId': 1000000, 'movieId': movie_ids[1], 'rating': 5.0, 'title': movie_list[1]}\\r\\n new_user_row3 = {'userId': 1000000, 'movieId': movie_ids[2], 'rating': 5.0, 'title': movie_list[2]}\\r\\n temp = temp.append([new_user_row1, new_user_row2, new_user_row3], ignore_index=True)\\r\\n\\r\\n # create pivot table\\r\\n user_ratings = temp.pivot_table(index='userId', columns='title', values='rating').fillna(0)\\r\\n # compute correlations from pivot table\\r\\n item_similarity_df = user_ratings.corr(method='pearson')\\r\\n\\r\\n def get_similar_movies(movie_name, user_rating=5):\\r\\n \\\"\\\"\\\"\\r\\n :param movie_name:\\r\\n :param user_rating: optional\\r\\n :return: list of similar movies\\r\\n \\\"\\\"\\\"\\r\\n similar_score = item_similarity_df[movie_name] * user_rating\\r\\n similar_score = similar_score.sort_values(ascending=False)\\r\\n return similar_score\\r\\n\\r\\n similar_movies = pd.DataFrame()\\r\\n\\r\\n # get similar movies of fav movies\\r\\n for movie in movie_list:\\r\\n similar_movies = similar_movies.append(get_similar_movies(movie, 5), ignore_index=True)\\r\\n\\r\\n recommended_movies = []\\r\\n # sum similarities together append highest values\\r\\n for i in similar_movies.sum().sort_values(ascending=False).index:\\r\\n if i in movie_list:\\r\\n pass\\r\\n else:\\r\\n recommended_movies.append(i)\\r\\n\\r\\n return recommended_movies[:10]\",\n \"def ratings_most_popular(Y, titles):\\n # Movies\\n movie_ids = [rating_list[1] for rating_list in Y]\\n\\n # 10 most popular movie ids\\n result = Counter(movie_ids).most_common(10)\\n popular_ids = [elt_and_count[0] for elt_and_count in result]\\n popular_titles = [titles[id] for id in popular_ids]\\n\\n # Possible rating values\\n rating_values = list(range(1, 6))\\n\\n # popular_ratings[i][j] is the number of rating_values[j] ratings for\\n # movie with id i\\n popular_ratings = \\\\\\n [[sum([rating_list[1] == id and rating_list[2] == rating_val\\n for rating_list in Y])\\n for rating_val in rating_values]\\n for id in popular_ids]\\n\\n sns.heatmap(popular_ratings,\\n annot=True, fmt='d', # Annotate data values\\n yticklabels=popular_titles, xticklabels=rating_values)\\n plt.yticks(rotation=0) # Rotate yticks horizontally\\n plt.xlabel('Rating')\\n plt.title('Ratings of most popular movies')\\n plt.tight_layout() # Make room for long ytick labels\\n plt.show()\",\n \"def main():\\n users = [i.id for i in list(User.select())]\\n sample_users = random.sample(users, _SAMPLE_NUMBER)\\n actual_result = []\\n average_result = []\\n nearest_neighbour_result = []\\n slope_one_result = []\\n hybird_result = []\\n for user_id in sample_users:\\n print('Current user:', get_user_by_id(user_id))\\n movie_id = random.choice(get_movie_rating_by_user(user_id)).movie_id\\n print('Current movie:', get_movie_by_id(movie_id))\\n actual = get_user_movie_rating(user_id, movie_id)\\n print('Actual Rating:', actual)\\n actual_result.append(actual)\\n avg = average_rating(movie_id, True)\\n print('Average Rating:', avg)\\n average_result.append(avg)\\n nearest = nearest_neighbour(user_id, movie_id, True)\\n print('Nearest Neighbour Rating:', nearest)\\n nearest_neighbour_result.append(nearest)\\n slope = slope_one(user_id, movie_id, True)\\n print('Slope One Rating:', slope)\\n slope_one_result.append(parse_result(slope))\\n hybrid = hybrid_algorithm(avg, nearest, slope, True)\\n print('Hybrid Algorithm Rating:', hybrid)\\n hybird_result.append(parse_result(hybrid))\\n print()\\n\\n if _DEBUG:\\n print(actual_result)\\n print(average_result)\\n print(nearest_neighbour_result)\\n print(slope_one_result)\\n print(hybird_result)\\n\\n print('RMSD of each recommender system')\\n print(' Average Rating '.center(80, '#'))\\n print(rmsd(actual_result, average_result))\\n print(' Nearest Neighbour '.center(80, '#'))\\n print(rmsd(actual_result, nearest_neighbour_result))\\n print(' Slope One '.center(80, '#'))\\n print(rmsd(actual_result, slope_one_result))\\n print(' Hybrid Algorithm '.center(80, '#'))\\n print(rmsd(actual_result, hybird_result))\",\n \"def generate_movies(nr):\\n for n in range(int(nr)):\\n d6 = random.randint(1, 6)\\n #A movie cannot be generated with the same name in different genres due to the nature of the data.\\n if d6 <= 4:\\n movie = generate_fantasy_title()\\n movie_genres[movie] = \\\"FANTASY\\\"\\n #if movie is a book, take author of book as producer\\n if movie in books:\\n movie_producers[movie] = authors[books[movie][0]]\\n else:\\n d20 = random.randint(1, 20)\\n if d20 == 1:\\n movie_producers[movie] = None\\n elif d20 > 1:\\n movie_producers[movie] = random.choice(list(readers.values()))\\n elif d6 == 5:\\n movie = generate_romance_title()\\n movie_genres[movie] = \\\"ROMANCE\\\"\\n d20 = random.randint(1, 20)\\n if d20 == 1:\\n movie_producers[movie] = None\\n elif d20 > 1:\\n movie_producers[movie] = random.choice(list(readers.values()))\\n elif d6 == 6:\\n movie = generate_horror_title()\\n movie_genres[movie] = \\\"HORROR\\\"\\n d20 = random.randint(1, 20)\\n if d20 == 1:\\n movie_producers[movie] = None\\n elif d20 > 1:\\n movie_producers[movie] = random.choice(list(readers.values()))\\n movies.append(movie)\\n counter = 1\\n for movie in movies:\\n movie_ids[movie] = f'Movie/{counter}'\\n counter += 1\",\n \"def populate(json_response: list) -> list:\\n output = []\\n for movie in json_response:\\n imdb_id = movie[\\\"imdbID\\\"]\\n output.append(dict(\\n title = movie[\\\"Title\\\"],\\n imdbID = imdb_id,\\n rottenTomatoesPercentage = rotten_rate_fetcher(imdb_id)\\n ))\\n return output\",\n \"def add_ratings(self, ratings):\\n # Convert ratings to an RDD\\n new_ratings_RDD = self.sc.parallelize(ratings)\\n # Add new ratings to the existing ones\\n self.ratings_RDD = self.ratings_RDD.union(new_ratings_RDD)\\n # Re-compute movie ratings count\\n self.__count_and_average_ratings()\\n # Re-train the ALS model with the new ratings\\n self.__train_model()\\n \\n return ratings\",\n \"def preprocess():\\n\\n # Read Training and Test Data\\n train_df = pd.read_csv(configs.TRAIN_DATA_PATH)\\n test_df = pd.read_csv(configs.TEST_DATA_PATH)\\n\\n # Data Exploration and Preprocessing\\n user_ids = train_df['userId']\\n movie_ids = train_df['movieId']\\n ratings = train_df['rating']\\n\\n # Create the mapping and save it for later usage in testing\\n all_users = create_mapping(pd.concat([train_df['userId'], test_df['userId']], axis = 0))\\n all_movies = create_mapping(pd.concat([train_df['movieId'], test_df['movieId']], axis = 0))\\n\\n\\n # Save the mapping arrays for users and movies\\n with open(configs.USER_IDS_PATH, \\\"wb\\\") as f:\\n np.save(f, all_users)\\n\\n with open(configs.MOVIE_IDS_PATH, \\\"wb\\\") as f:\\n np.save(f, all_movies)\\n\\n\\n # Resetting the ids of training data to [0-n]\\n user_ids = map_ids(user_ids, users = True)\\n movie_ids = map_ids(movie_ids, users = False)\\n\\n\\n # Resetting the ids of test data\\n test_user_ids = map_ids(test_df['userId'], users = True)\\n test_movie_ids = map_ids(test_df['movieId'], users = False)\\n test_ratings = test_df['rating']\\n\\n # Statistics of training data\\n # Number of users and movies can be extracted from the array of mapped ids\\n n_users = np.max(user_ids) + 1\\n n_movies = np.max(movie_ids) + 1\\n\\n # Statistics of test data\\n test_n_users = np.max(test_user_ids) + 1\\n test_n_movies = np.max(test_movie_ids) + 1\\n\\n # Returning the indices back can be done using unmap_ids function\\n # Example\\n # unmap_ids(movie_ids, users = False)\\n # unmap_ids(user_ids, users = True)\\n\\n # Define the training rating matrix as sparse matrix\\n\\n # Sparse rating matrix from training data\\n R = sparse.coo_matrix(\\n (ratings, (user_ids, movie_ids)),\\n shape=(n_users, n_movies),\\n dtype=np.float\\n )\\n\\n\\n\\n # Save the rating matrix for training data\\n sparse.save_npz(configs.R_TRAIN_MATRIX_PATH, R)\\n\\n # Sparse rating matrix from test data\\n R2 = sparse.coo_matrix(\\n (test_ratings, (test_user_ids, test_movie_ids)),\\n shape=(test_n_users, test_n_movies),\\n dtype=np.float\\n )\\n\\n # Save the rating matrix for test data\\n sparse.save_npz(configs.R_TEST_MATRIX_PATH, R2)\\n\\n # return user_ids, movie_ids, ratings, n_users, n_movies, R, R2\\n return R, R2\",\n \"def Probability(rating1, rating2):\\n return 1.0 * 1.0 / (1 + 1.0 * math.pow(10, 1.0 * (rating1 - rating2) / 400))\",\n \"def mrr(self):\\n _test = self.drop_bad_ratings()\\n merged = pd.merge(left=_test, right=self.predict, on=['user', 'item'], how='right')[\\n ['user', 'item', 'rating_x', 'rating_y']]\\n nott = np.vectorize(lambda x: not x)\\n mrrs = []\\n for user in merged.user.unique():\\n frame = merged[merged.user == user].sort_values(by='rating_y', ascending=False)\\n true_ratings = frame.rating_x.values\\n positions = np.where(nott(np.isnan(true_ratings)))[0]\\n if len(positions) > 0:\\n mrrs.append(1 / (positions[0] + 1))\\n else:\\n mrrs.append(0)\\n\\n return sum(mrrs) / len(mrrs)\",\n \"def _recommend_movie(user_id, movie_id, number_movies):\\n #get the recommended movie ids from pickled model\\n rec_movies = sparkrecommender.movie_recomendation(user_id,movie_id,number_movies)\\n #get a list of movies ids used in model\\n moviesdf = pd.read_csv('movies.csv',index_col='movieId')\\n \\n #build list of lists with [[imdb ID, movie title, post img link]]\\n rec_movies_list = []\\n for movie_id in rec_movies:\\n temp_list = []\\n imdbid_ = str(get_imdbId(movie_id))\\n temp_list.append(imdbid_)\\n temp_list.append(moviesdf.loc[movie_id,'title'])\\n temp_list.append('http://img.omdbapi.com/?apikey=ae550a04&i=tt'+str(imdbid_))\\n rec_movies_list.append(temp_list)\\n return rec_movies_list\",\n \"def _get_word_posteriors(self, seq_counts, genus_seqs, total_seqs):\\n # n(wi) as a col vector\\n word_seqs = c_[seq_counts.sum(1)]\\n # p(wi) as a col vector\\n word_priors = (word_seqs + 0.5) / (total_seqs + 1)\\n # p(wi|G)\\n word_posteriors = (seq_counts + word_priors) / (genus_seqs + 1)\\n return word_posteriors\",\n \"def rating_distribution( ratings, plot=True ):\\n possible_ratings = np.unique( ratings )\\n dist = []\\n for pr in possible_ratings:\\n dist.append( np.count_nonzero( ratings == pr ) )\\n dist = np.array( dist )\\n print( 'distribution of ratings', dist )\\n if plot:\\n plt.bar( possible_ratings, dist )\\n plt.savefig( 'rating_distribution.pdf' )\",\n \"def get_cold_start_rating(user_id, movie_id, user_df, u_clusters, ratings_df):\\n\\n # Load files \\n #user_df = pd.read_csv('data/user_cluster.csv', index_col=0) \\n #u_clusters = pd.read_csv('data/u_info.csv', index_col=0)\\n #ratings_df = pd.read_csv('data/movie_cluster_avg.csv', index_col=0)\\n \\n # User Cluster\\n user_cluster = u_clusters.loc[u_clusters['id'] == user_id]['cluster'].tolist()[0]\\n \\n # Get score components\\n if len(ratings_df.loc[(ratings_df['cluster'] == user_cluster) & (ratings_df['movie_id'] == movie_id)]) > 0:\\n# if (movie_id in ratings_df['movie_id'].tolist()):\\n avg = ratings_df.loc[(ratings_df['cluster'] == user_cluster) & (ratings_df['movie_id'] == movie_id)]['rating'].tolist()\\n else:\\n cluster_rating = ratings_df.loc[ratings_df['cluster'] == user_cluster]['rating'].tolist()\\n avg = sum(cluster_rating)/len(cluster_rating)\\n if user_id in user_df['user_id'].tolist():\\n u = user_bias(user_df, user_id)\\n i = item_bias(user_df, movie_id)\\n pred_rating = avg + u + i\\n else:\\n pred_rating = avg\\n \\n return pred_rating\",\n \"def mostProfitableDirectors (movies, count):\\n directors = {}\\n for movieInfo in movies.values():\\n key = movieInfo[0] # director's name\\n if len(movieInfo) == 10:\\n value = float(movieInfo[9]) # profit\\n else:\\n value = float(movieInfo[7]) # rating or profit\\n if value > 100: # not a rating\\n if key not in directors:\\n directors[key] = 0\\n directors[key] += int(value)\\n return sorted([(v, k) for (k,v) in directors.items() ], reverse=True)[:count]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6833105","0.67717224","0.65626323","0.62562567","0.6245194","0.6105975","0.60951227","0.60900235","0.6040918","0.5983867","0.59045374","0.58595026","0.5855716","0.5835745","0.5835745","0.58348227","0.5734984","0.5729565","0.57091314","0.5681885","0.5681117","0.56721","0.56487906","0.5627591","0.5600329","0.5594688","0.55773777","0.5540202","0.5518316","0.55126935","0.5490202","0.5488489","0.5463113","0.5440768","0.54318595","0.54221827","0.5421661","0.5399742","0.5388731","0.53880334","0.53878504","0.5376793","0.53629094","0.5361865","0.5344106","0.53386784","0.5336654","0.532741","0.5304571","0.5303109","0.53020966","0.5296657","0.52848387","0.5273834","0.5269938","0.52671397","0.526402","0.52582556","0.52485776","0.52450955","0.52382594","0.5225538","0.5218905","0.52143574","0.5213138","0.5210118","0.5209196","0.520268","0.5194619","0.5183865","0.5172848","0.5171735","0.5166865","0.5163769","0.5163389","0.51627743","0.5162026","0.5159072","0.5158733","0.515426","0.513893","0.5132784","0.51326764","0.51320773","0.51317066","0.51254183","0.5117275","0.5108176","0.51039815","0.5100292","0.5095427","0.5089597","0.508684","0.5078379","0.507604","0.50753945","0.50746804","0.50738496","0.50652766","0.5058236"],"string":"[\n \"0.6833105\",\n \"0.67717224\",\n \"0.65626323\",\n \"0.62562567\",\n \"0.6245194\",\n \"0.6105975\",\n \"0.60951227\",\n \"0.60900235\",\n \"0.6040918\",\n \"0.5983867\",\n \"0.59045374\",\n \"0.58595026\",\n \"0.5855716\",\n \"0.5835745\",\n \"0.5835745\",\n \"0.58348227\",\n \"0.5734984\",\n \"0.5729565\",\n \"0.57091314\",\n \"0.5681885\",\n \"0.5681117\",\n \"0.56721\",\n \"0.56487906\",\n \"0.5627591\",\n \"0.5600329\",\n \"0.5594688\",\n \"0.55773777\",\n \"0.5540202\",\n \"0.5518316\",\n \"0.55126935\",\n \"0.5490202\",\n \"0.5488489\",\n \"0.5463113\",\n \"0.5440768\",\n \"0.54318595\",\n \"0.54221827\",\n \"0.5421661\",\n \"0.5399742\",\n \"0.5388731\",\n \"0.53880334\",\n \"0.53878504\",\n \"0.5376793\",\n \"0.53629094\",\n \"0.5361865\",\n \"0.5344106\",\n \"0.53386784\",\n \"0.5336654\",\n \"0.532741\",\n \"0.5304571\",\n \"0.5303109\",\n \"0.53020966\",\n \"0.5296657\",\n \"0.52848387\",\n \"0.5273834\",\n \"0.5269938\",\n \"0.52671397\",\n \"0.526402\",\n \"0.52582556\",\n \"0.52485776\",\n \"0.52450955\",\n \"0.52382594\",\n \"0.5225538\",\n \"0.5218905\",\n \"0.52143574\",\n \"0.5213138\",\n \"0.5210118\",\n \"0.5209196\",\n \"0.520268\",\n \"0.5194619\",\n \"0.5183865\",\n \"0.5172848\",\n \"0.5171735\",\n \"0.5166865\",\n \"0.5163769\",\n \"0.5163389\",\n \"0.51627743\",\n \"0.5162026\",\n \"0.5159072\",\n \"0.5158733\",\n \"0.515426\",\n \"0.513893\",\n \"0.5132784\",\n \"0.51326764\",\n \"0.51320773\",\n \"0.51317066\",\n \"0.51254183\",\n \"0.5117275\",\n \"0.5108176\",\n \"0.51039815\",\n \"0.5100292\",\n \"0.5095427\",\n \"0.5089597\",\n \"0.508684\",\n \"0.5078379\",\n \"0.507604\",\n \"0.50753945\",\n \"0.50746804\",\n \"0.50738496\",\n \"0.50652766\",\n \"0.5058236\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7685785"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":89596,"cells":{"query":{"kind":"string","value":"Called when the Player object is initialized. You can use this to store any persistent data you want to store for the game."},"document":{"kind":"string","value":"def __init__(self):\n \tself.transposition = {}\n \tself.currentDepthLimit = 0\n\tself.counter = 0\t\n pass"},"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 __init__(self):\r\n self.players = {}","def __init__(self):\n self.games = {} # Dict from gameIDs to game objects. Initially empty.\n self.players = {} # Dict from playerID to player name\n self._version = __version__ # Used in version check during un-pickling\n\n # Log initialization\n TournamentSystem._logger.debug(\"Initialized\")","def load(cls):\n playerdata = Data.raw_load(\"savedata.dat\")\n for key in playerdata:\n cls.name = playerdata[\"name\"]\n cls.max_hp = playerdata[\"max_hp\"]\n cls.hp = playerdata[\"hp\"]\n cls.lv = playerdata[\"lv\"]\n cls.exp = playerdata[\"exp\"]\n cls.atk = playerdata[\"atk\"]\n cls._def = playerdata[\"_def\"]\n cls.inventory = playerdata[\"inventory\"]\n cls.pin = playerdata[\"pin\"]","def setUp(self):\n self.player = Player()","def __init__(self, players):\n\n self._players = players\n self._game = None","def start(self):\n self.__init__()\n self.set_n_players()\n self.init_players()\n self.init_territory_selection_phase()\n self.init_troop_deployment_phase()\n # self.game_phase()","def on_load(self):\n self.__init__()","def __init__(self, players):\n\n self._players = players\n self._current_player = players.get()","def load_players(self):\n\n self.player_layer = MousePlayerController()\n self.player_layer.player.push_handlers(self)\n self.add(self.player_layer)\n\n if self.saved_player is not None:\n self.player_layer.player.set_params(self.saved_player)","def __init__(self, player):\n\t\tself.player = player","def on_initialize(self) -> None:\n pass","def __init__(self, player):\n self.player = player","def load(self):\n Logger.info(\"VLCPlayer: Entering load\")\n self._load_player(self.source)\n self._set_volume(self.volume)","def __init__(self, player1, player2, state_machine, restore = False):\r\n super().__init__()\r\n self.__players[0] = player1\r\n self.__players[1] = player2\r\n self.__player_names[player1] = 'Human'\r\n self.__player_names[player2] = 'Bot'\r\n self.__state_machine = state_machine","def on_init(self):\n self.controller = gameController.Controller()","def setup_new_game(self):\r\n self._player = Player()\r\n self._stats = GameStats(self._bb_settings)\r\n self._scoreboard = Scoreboard(self._bb_settings, self._screen)","def at_start(self):\n if not self.db.started:\n self.player.start()\n self.db.started = True","def init_game_setting(self):\r\n pass","def set_player(self, char_data):\n self.player = self.server.object_manager.add_player(char_data)","def __init__(self):\n \n self.player = None\n self.brick_list = None\n self.coin_list = None\n self.physics_engine = None\n self.num_coins = None","def __init__(self, player_id, difficulty_level):\n self.player_id = player_id\n self.difficulty_level = difficulty_level\n global our_player\n our_player = player_id","def __init__(self):\n super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)\n self.player_count: int = None\n self.player_hand_0: arcade.SpriteList = None\n self.player_hand_1: arcade.SpriteList = None\n self.deck: arcade.SpriteList = None\n self.pile: arcade.SpriteList = None","def __init__(self, *args, **kwargs):\n super(Player, self).__init__(*args, **kwargs)","def set_player(self, player_params):\n\n self.saved_player = player_params","def onInit(self):\n pass","def __init__(self, gameStateData):\r\n self.data = gameStateData","def __init__(self):\n GameObject.__init__(self)\n\n # private attributes to hold the properties so they appear read only\n self._client_type = \"\"\n self._creatures = []\n self._lost = False\n self._name = \"Anonymous\"\n self._opponent = None\n self._reason_lost = \"\"\n self._reason_won = \"\"\n self._time_remaining = 0\n self._total_health = 0\n self._won = False","def _init_game(self):\n state, player_id = self.game.init_game()\n if self.record_action:\n self.action_recorder = []\n return self._extract_state(state), player_id","def __init__(self, game, player):\n self.game = game\n self.player = player","def init_players(self):\n self.spaceships.append(self.player)\n SoundManager.add_sfx(\n self.player.states['exploded']['sfx'],\n self.player\n )","def __init__(self):\n self._datastore = dict()","def initialise(self):\n self.set_up()","def user_init(self):\n pass","def init_playdata(self, data_file):\n if 'destined_pos' not in self.json_data:\n if self.my_player == 0:\n self.json_data['destined_pos'] = destination_lookup[1]\n else:\n self.json_data['destined_pos'] = destination_lookup[0]\n json.dump(self.json_data, data_file)","def __init__(self, player, gamestate):\n self.player = player\n self.gamestate = gamestate","def __init__(self, player_control, players=None):\r\n self.player_control = player_control\r\n self.players = {} # copy for restoration\r\n if players is not None:\r\n for player in players.values():\r\n self.add_player(player)","def post_init(self):\n\t\tpass","def player_data(self):\n return self._player","def on_load(self, bot):\n self.bot = bot\n self.connection = bot.get_connection()\n self.plugin_manager = bot.get_plugin_manager()\n self.config = bot.get_config_manager()\n self.data_manager = bot.get_data_manager()","def start(self):\n self.player = Player()\n self.dealer = Dealer()\n self.pot = 0\n self.side_bet = 0\n start_game()","def _init_storage(self):\n if self._ is None:\n self._ = Parameters(self)","def init(cls):\n\n cls.configs = yaml.load( file('../local/config.yaml') )\n cls.is_online = False\n cls.state = State.playing\n cls.classes = classes\n cls.guiclasses = guiclasses\n\n # set up pygame and init\n pygame.init()\n\n # Set up the window\n cls.screen = pygame.display.set_mode(\n tuple(cls.configs['options']['resolution']),\n 0,\n 32)\n classes.screen = cls.screen\n guiclasses.screen = cls.screen","def _post_init(self):\n pass","def __init__(self, guild):\r\n self.guild = guild\r\n self.usercharacters = {}\r\n self.npcs = {}\r\n wg.log.info(f'Guild {debug_id(guild=guild)} created')\r\n self.load()","def on_init(self):\n pygame.init()\n self.background.load_from_file()\n self.hero.load_from_file()\n self.enemy.load_from_file()\n\n # Some music and sound fx\n # frequency, size, channels, buffersize\n # pygame.mixer.pre_init(44100, 16, 2, 4096)\n self.effect = pygame.mixer.Sound('sounds/bounce.wav')\n pygame.mixer.music.load('sounds/music.wav')\n pygame.mixer.music.play(-1)\n\n self.hero.screen = self.background.screen\n self.enemy.screen = self.background.screen\n self.clock = pygame.time.Clock()\n pygame.display.set_caption(\n 'Angry Floating Guy! World: {} (w to change world, arrows to move, Esc to quit).'.format(self.current_world.name))\n\n self._running = True","def bot_init():\n client.Console.Say('Hello World')\n global player\n player = client.GetPlayer()","def __post_init__(self):\n self._session = Session()\n self._post_hooks()","def _handler_init(self):\r\n\t\tself._handlers[\"player-join\"] = FunctionDelegate()\r\n\t\tself._handlers[\"player-quit\"] = FunctionDelegate()\r\n\t\tself._handlers[\"game-start\"] = FunctionDelegate()\r\n\t\tself._handlers[\"game-stop\"] = FunctionDelegate()","def initialize(self):\n\n # --------- BEGIN YOUR CODE ----------\n\n # This is exactly the same as Human.initialize, just copy the code over\n\n # --------- END YOUR CODE ----------\n pass","def post_config_initialization(self):\n \n # dynamic data that survives through sessions\n # XXX make the filename a config option?\n persist_base = 'persist'\n if self.rc.profile:\n persist_base += '_%s' % self.rc.profile\n self.persist_fname = os.path.join(self.rc.ipythondir,persist_base)\n\n try:\n self.persist = pickle.load(file(self.persist_fname))\n except:\n self.persist = {}","def __init__(self, players):\n\n # Instantiate a Players object with the players queue\n self._players = Players(players)\n # Instantiate the Die to be used for the current game\n self._die = Die()\n # Track the game status\n self._active_turn = True\n self._end_game = False","def __init__(self, player_name, player_number, player_position):\n self.name = player_name\n self.number = player_number\n self.position = player_position","def _initialize_player_stats(self):\r\n self.reset()\r\n for x in range(self.num_players):\r\n self.player_draws[f'{x}']=[]\r\n self.player_points[f'{x}']= 0","def initGame(self):\n self.map = {}\n self.blocks = Group()\n self.Coins =Group()\n self.players = Group()\n self.player1 = Player(1525,75,2)\n self.players.add(self.player1)\n if self.playernum == 2:\n self.player2 = Player(75,825,1)\n self.players.add(self.player2)\n else:\n self.player2 = False","def initialize(self):\n\n db = dict()\n\n db['meta'] = Meta(None)\n db['race'] = Race(None, None, None, None, None)\n db['track'] = Track(None, None)\n db['classes'] = set([])\n db['teams'] = set([])\n db['drivers'] = set([])\n\n self.db = db","def __init__(self):\r\n self.__storage = {}","def initialize(self):\n self.population.initialize()\n self.cache.initialize()\n if self.storage:\n self.storage.initialize()","def _prepare_start(self, client, player_id, game_info, game_data, realtime: bool = False):\n self._client: Client = client\n self.player_id: int = player_id\n self._game_info: GameInfo = game_info\n self._game_data: GameData = game_data\n self.realtime: bool = realtime","def on_load(self):\n pass","def on_load(self):\n pass","def _init(self):\n if os.path.exists(self.fname):\n with open(self.fname, \"rb\") as fh:\n self.db = pickle.load(fh)\n else:\n self.db = {}\n print(\"DB loaded, len\", len(self.db))","def init(self):\n # IMPORTANT: create a new gob database model entry for this object\n self.gobify()","def game_setup(self):\n self.deck = Shoe(6)\n self.initial_draw()\n self.pot = ask_for_bet(self.player.money)\n show_table(self.player, self.dealer, self.pot)\n self.surrender_and_insurance()","def _post_init(self) -> None:\n return","def __init__(self):\n # Wipe the db\n self.wipe_db()\n\n # Set some global things\n try:\n dashboard_configuration = DashboardConfiguration(type=\"default\")\n dashboard_configuration.save()\n except IntegrityError:\n dashboard_configuration = DashboardConfiguration.objects.filter(type=\"default\").first()\n\n # Add all players from dataset\n group = self.add_players(dashboard_configuration)\n\n # Add all games from the dataset\n self.add_games()\n\n # Create the games played for this group\n self.add_game_played(group)","def __init__( self, prevState = None ): ###PLEASE NOTE THIS THAT THE __init__ method is here and this is where GameState() starts\n if prevState != None: # Initial state\n self.data = GameStateData(prevState.data) ##This statement imports the GameStateData object from the GameStateData class in game.py. This object contains a data packet documenting the state of the game.\n\n else:\n self.data = GameStateData()\n \"\"\"\n self._foodEaten = None\n self._capsuleEaten = None\n self._agentMoved = None\n self._lose = False\n self._win = False\n self.scoreChange = 0\n \"\"\"","def on_init(self):\n self.engineer_list = []\n self.list_items = []\n self.selected_items = []\n self.log_info(self.name + \" initialized\")\n self.bind('PUB', alias='main')","def __init__(self):\n with open('data.json') as data_file:\n self.data = json.load(data_file)\n self.game_over = False","def save(cls):\n playerdata = getAttributes(cls)\n Data.object_dump(playerdata, \"savedata.dat\")\n del playerdata","def initGameState(self):\n print(\"Setting game state: \")\n self.playGUI = GUI()\n self.playGUI.drawBoard(self.player)","def _initialize(self):\n self.send_init_command()","def __init__(self):\n\n super().__init__()\n self.setup_janggi_game()\n self._game_state = 'UNFINISHED'\n self._player_turn = 'BLUE'","def before_turn(self, playerInfo):\n self.PlayerInfo = playerInfo","def at_object_creation(self):\n self.db.max_hp = 100 # Set maximum HP to 100\n self.db.hp = self.db.max_hp # Set current HP to maximum\n self.db.spells_known = [] # Set empty spells known list\n self.db.max_mp = 20 # Set maximum MP to 20\n self.db.mp = self.db.max_mp # Set current MP to maximum","def startup(self):\n self.prev_gray = None\n self.frame_idx = 1\n self.tracks = []\n self.fps = []\n self.vid_info = None\n self.track_new_points_count = 0","def on_start(self):\n self.init()","def __init__(self, settings):\n super().__init__(settings, self.player_info_url, Player)","def __init__(self, player_name):\n self._player_name = player_name\n self._hand = Deck() \n self._coder = Deck()","def initialise(self):\n logging.debug(\"TrackerPlugin.initialise\")","def init_player():\n global active_track_idx\n global track_last_slided_pos\n global track_last_paused_pos\n global track_total_play_time \n\n # INITIALIZE Player\n active_track_idx = -1\n cancel_update_play_time_loop()\n cancel_track_end_event_loop()\n track_status.set(\"---\")\n track_title.set(\"--- : \")\n play_pause_btn.configure(image=play_img)\n track_last_slided_pos = 0\n track_last_paused_pos = 0\n track_total_play_time = 0\n track_pos_label.configure(text=\"00:00\")\n track_length_label.configure(text=\"00:00\")\n track_pos_slider.configure(state=\"disabled\")\n track_pos.set(0)","def init(self):\n self.data_dir = self.data_dir or default_data_path / self._name_\n self.cache_dir = self.data_dir / \"cache\"\n assert self.level in [\n \"word\",\n \"char\",\n ], f\"level {self.level} not supported\"","def setup_game(self):","def __init__(self, persistent=True):\n super().__init__()\n self.name_cache = {}\n self.run_cache = {}\n self.row_cache = {}\n self.persistent = persistent\n\n if self.persistent:\n self.load_cache()","def on_init(self):\n self.write_log(\"策略初始化\")","def on_init(self):\n self.write_log(\"策略初始化\")","def initializeGame(self):\n # Fill deck with cards and shuffle it\n self.deck.fill(104)\n self.deck.shuffle()\n #print \"Deck initialized\"\n\n # Initialize the field\n self.field.initialize(self.deck.draw(4))\n self.field.sortField()\n #self.field.printField()\n\n # Set players to initial state again\n # Distribute cards and set bulls to 0\n for p in self.players:\n p.bulls = 0\n p.setHand(self.deck.draw(10))","def __init__(self):\n self.screen = pg.display.get_surface()\n self.screen_rect = self.screen.get_rect()\n self.clock = pg.time.Clock()\n self.fps = 60\n self.keys = pg.key.get_pressed()\n self.done = False\n # ship = random.choice(list(prepare.GFX[\"ships\"].values()))\n ship = list(prepare.GFX[\"ships\"].values())[7] # pick first ship available\n self.player = actors.Player((0, 0), ship)\n self.level = level.Level(self.screen_rect.copy(), self.player)\n\n self.energyloss_counter = 0\n self.energygain_counter = 0","def _setup(self):\n\n # Get user data\n self.symbols = self._get_symbols()\n self.data_dict = self._get_data()\n self.portfolio = self.initialize_portfolio()\n\n if 'slippage' in self.portfolio:\n self.slippage = self.portfolio['slippage']\n else:\n self.slippage = None\n\n # Keep track of all trades\n self.trade_manager = TradeManager(\n self.symbols, self.portfolio, self.sql_config\n )\n\n # Initialize state variables that are updated each iteration\n self.date = None\n self.data = None\n self.symbol = None\n self.currency = None\n self.last_buy = None\n self.num_unresolved = 0\n self.unresolved_trade = False","def __post_init__(self):\n # ------------------------------------------------------------ 01\n # if path exists load data dict from it\n # that is sync with contents on disk\n if self.path.exists():\n _hashable_dict_from_disk = \\\n m.FrozenDict.from_yaml(self.path.read_text())\n # update internal dict from HashableDict loaded from disk\n self.__dict__.update(\n _hashable_dict_from_disk.get()\n )\n\n # ------------------------------------------------------------ 02\n # start syncing i.e. any updates via __setattr__ will be synced\n # to disc\n self.internal.start_syncing = True","def __init__(self):\n self._game_state = \"UNFINISHED\"\n self._current_player = \"BLACK\"\n self._game_board = Board()","def save_player(self, serialized_player):\n self.player_table.insert(serialized_player)","def init2(self):\n self.skill_points = self.count_skill_points()\n self.count_saves()\n self.lives = self.count_lives()\n self.base_attack = fetch_data.get_base_attack(self.BASE_ATTACK_LVLS, self.lvl)","def __init__(self):\n self.secret = None\n self.on_hook_init()","def __init__(self, player_id, player_name, chat_id):\n\n # find player info in a database\n with Player.client as client:\n db = client.game_db\n user = db.players.find_one({\"id\": player_id})\n if user is None:\n # add user to database\n user = {\"id\": player_id,\n \"name\": player_name,\n \"chat_id\": chat_id,\n \"games_num\": 0,\n \"rating\": Player.default_rating}\n db.players.insert(user)\n \n self.id = user[\"id\"]\n self.name = user[\"name\"]\n self.chat_id = user[\"chat_id\"]\n self.rating = user[\"rating\"]\n self.game = None\n self.balance = None\n self.stake = None\n self.timer = None\n self.out_of_time = False\n self.searching = False","def init_new_game(self):\n self.game = get_new_game(self.game_config)","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def to_json(self):\n player = {\n 'name': self.name,\n 'colour': self.colour,\n 'gender': self.gender,\n 'uid': self.UID,\n 'position': self.position,\n 'money': self.money,\n 'ready': self.is_ready(),\n }\n return player"],"string":"[\n \"def __init__(self):\\r\\n self.players = {}\",\n \"def __init__(self):\\n self.games = {} # Dict from gameIDs to game objects. Initially empty.\\n self.players = {} # Dict from playerID to player name\\n self._version = __version__ # Used in version check during un-pickling\\n\\n # Log initialization\\n TournamentSystem._logger.debug(\\\"Initialized\\\")\",\n \"def load(cls):\\n playerdata = Data.raw_load(\\\"savedata.dat\\\")\\n for key in playerdata:\\n cls.name = playerdata[\\\"name\\\"]\\n cls.max_hp = playerdata[\\\"max_hp\\\"]\\n cls.hp = playerdata[\\\"hp\\\"]\\n cls.lv = playerdata[\\\"lv\\\"]\\n cls.exp = playerdata[\\\"exp\\\"]\\n cls.atk = playerdata[\\\"atk\\\"]\\n cls._def = playerdata[\\\"_def\\\"]\\n cls.inventory = playerdata[\\\"inventory\\\"]\\n cls.pin = playerdata[\\\"pin\\\"]\",\n \"def setUp(self):\\n self.player = Player()\",\n \"def __init__(self, players):\\n\\n self._players = players\\n self._game = None\",\n \"def start(self):\\n self.__init__()\\n self.set_n_players()\\n self.init_players()\\n self.init_territory_selection_phase()\\n self.init_troop_deployment_phase()\\n # self.game_phase()\",\n \"def on_load(self):\\n self.__init__()\",\n \"def __init__(self, players):\\n\\n self._players = players\\n self._current_player = players.get()\",\n \"def load_players(self):\\n\\n self.player_layer = MousePlayerController()\\n self.player_layer.player.push_handlers(self)\\n self.add(self.player_layer)\\n\\n if self.saved_player is not None:\\n self.player_layer.player.set_params(self.saved_player)\",\n \"def __init__(self, player):\\n\\t\\tself.player = player\",\n \"def on_initialize(self) -> None:\\n pass\",\n \"def __init__(self, player):\\n self.player = player\",\n \"def load(self):\\n Logger.info(\\\"VLCPlayer: Entering load\\\")\\n self._load_player(self.source)\\n self._set_volume(self.volume)\",\n \"def __init__(self, player1, player2, state_machine, restore = False):\\r\\n super().__init__()\\r\\n self.__players[0] = player1\\r\\n self.__players[1] = player2\\r\\n self.__player_names[player1] = 'Human'\\r\\n self.__player_names[player2] = 'Bot'\\r\\n self.__state_machine = state_machine\",\n \"def on_init(self):\\n self.controller = gameController.Controller()\",\n \"def setup_new_game(self):\\r\\n self._player = Player()\\r\\n self._stats = GameStats(self._bb_settings)\\r\\n self._scoreboard = Scoreboard(self._bb_settings, self._screen)\",\n \"def at_start(self):\\n if not self.db.started:\\n self.player.start()\\n self.db.started = True\",\n \"def init_game_setting(self):\\r\\n pass\",\n \"def set_player(self, char_data):\\n self.player = self.server.object_manager.add_player(char_data)\",\n \"def __init__(self):\\n \\n self.player = None\\n self.brick_list = None\\n self.coin_list = None\\n self.physics_engine = None\\n self.num_coins = None\",\n \"def __init__(self, player_id, difficulty_level):\\n self.player_id = player_id\\n self.difficulty_level = difficulty_level\\n global our_player\\n our_player = player_id\",\n \"def __init__(self):\\n super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)\\n self.player_count: int = None\\n self.player_hand_0: arcade.SpriteList = None\\n self.player_hand_1: arcade.SpriteList = None\\n self.deck: arcade.SpriteList = None\\n self.pile: arcade.SpriteList = None\",\n \"def __init__(self, *args, **kwargs):\\n super(Player, self).__init__(*args, **kwargs)\",\n \"def set_player(self, player_params):\\n\\n self.saved_player = player_params\",\n \"def onInit(self):\\n pass\",\n \"def __init__(self, gameStateData):\\r\\n self.data = gameStateData\",\n \"def __init__(self):\\n GameObject.__init__(self)\\n\\n # private attributes to hold the properties so they appear read only\\n self._client_type = \\\"\\\"\\n self._creatures = []\\n self._lost = False\\n self._name = \\\"Anonymous\\\"\\n self._opponent = None\\n self._reason_lost = \\\"\\\"\\n self._reason_won = \\\"\\\"\\n self._time_remaining = 0\\n self._total_health = 0\\n self._won = False\",\n \"def _init_game(self):\\n state, player_id = self.game.init_game()\\n if self.record_action:\\n self.action_recorder = []\\n return self._extract_state(state), player_id\",\n \"def __init__(self, game, player):\\n self.game = game\\n self.player = player\",\n \"def init_players(self):\\n self.spaceships.append(self.player)\\n SoundManager.add_sfx(\\n self.player.states['exploded']['sfx'],\\n self.player\\n )\",\n \"def __init__(self):\\n self._datastore = dict()\",\n \"def initialise(self):\\n self.set_up()\",\n \"def user_init(self):\\n pass\",\n \"def init_playdata(self, data_file):\\n if 'destined_pos' not in self.json_data:\\n if self.my_player == 0:\\n self.json_data['destined_pos'] = destination_lookup[1]\\n else:\\n self.json_data['destined_pos'] = destination_lookup[0]\\n json.dump(self.json_data, data_file)\",\n \"def __init__(self, player, gamestate):\\n self.player = player\\n self.gamestate = gamestate\",\n \"def __init__(self, player_control, players=None):\\r\\n self.player_control = player_control\\r\\n self.players = {} # copy for restoration\\r\\n if players is not None:\\r\\n for player in players.values():\\r\\n self.add_player(player)\",\n \"def post_init(self):\\n\\t\\tpass\",\n \"def player_data(self):\\n return self._player\",\n \"def on_load(self, bot):\\n self.bot = bot\\n self.connection = bot.get_connection()\\n self.plugin_manager = bot.get_plugin_manager()\\n self.config = bot.get_config_manager()\\n self.data_manager = bot.get_data_manager()\",\n \"def start(self):\\n self.player = Player()\\n self.dealer = Dealer()\\n self.pot = 0\\n self.side_bet = 0\\n start_game()\",\n \"def _init_storage(self):\\n if self._ is None:\\n self._ = Parameters(self)\",\n \"def init(cls):\\n\\n cls.configs = yaml.load( file('../local/config.yaml') )\\n cls.is_online = False\\n cls.state = State.playing\\n cls.classes = classes\\n cls.guiclasses = guiclasses\\n\\n # set up pygame and init\\n pygame.init()\\n\\n # Set up the window\\n cls.screen = pygame.display.set_mode(\\n tuple(cls.configs['options']['resolution']),\\n 0,\\n 32)\\n classes.screen = cls.screen\\n guiclasses.screen = cls.screen\",\n \"def _post_init(self):\\n pass\",\n \"def __init__(self, guild):\\r\\n self.guild = guild\\r\\n self.usercharacters = {}\\r\\n self.npcs = {}\\r\\n wg.log.info(f'Guild {debug_id(guild=guild)} created')\\r\\n self.load()\",\n \"def on_init(self):\\n pygame.init()\\n self.background.load_from_file()\\n self.hero.load_from_file()\\n self.enemy.load_from_file()\\n\\n # Some music and sound fx\\n # frequency, size, channels, buffersize\\n # pygame.mixer.pre_init(44100, 16, 2, 4096)\\n self.effect = pygame.mixer.Sound('sounds/bounce.wav')\\n pygame.mixer.music.load('sounds/music.wav')\\n pygame.mixer.music.play(-1)\\n\\n self.hero.screen = self.background.screen\\n self.enemy.screen = self.background.screen\\n self.clock = pygame.time.Clock()\\n pygame.display.set_caption(\\n 'Angry Floating Guy! World: {} (w to change world, arrows to move, Esc to quit).'.format(self.current_world.name))\\n\\n self._running = True\",\n \"def bot_init():\\n client.Console.Say('Hello World')\\n global player\\n player = client.GetPlayer()\",\n \"def __post_init__(self):\\n self._session = Session()\\n self._post_hooks()\",\n \"def _handler_init(self):\\r\\n\\t\\tself._handlers[\\\"player-join\\\"] = FunctionDelegate()\\r\\n\\t\\tself._handlers[\\\"player-quit\\\"] = FunctionDelegate()\\r\\n\\t\\tself._handlers[\\\"game-start\\\"] = FunctionDelegate()\\r\\n\\t\\tself._handlers[\\\"game-stop\\\"] = FunctionDelegate()\",\n \"def initialize(self):\\n\\n # --------- BEGIN YOUR CODE ----------\\n\\n # This is exactly the same as Human.initialize, just copy the code over\\n\\n # --------- END YOUR CODE ----------\\n pass\",\n \"def post_config_initialization(self):\\n \\n # dynamic data that survives through sessions\\n # XXX make the filename a config option?\\n persist_base = 'persist'\\n if self.rc.profile:\\n persist_base += '_%s' % self.rc.profile\\n self.persist_fname = os.path.join(self.rc.ipythondir,persist_base)\\n\\n try:\\n self.persist = pickle.load(file(self.persist_fname))\\n except:\\n self.persist = {}\",\n \"def __init__(self, players):\\n\\n # Instantiate a Players object with the players queue\\n self._players = Players(players)\\n # Instantiate the Die to be used for the current game\\n self._die = Die()\\n # Track the game status\\n self._active_turn = True\\n self._end_game = False\",\n \"def __init__(self, player_name, player_number, player_position):\\n self.name = player_name\\n self.number = player_number\\n self.position = player_position\",\n \"def _initialize_player_stats(self):\\r\\n self.reset()\\r\\n for x in range(self.num_players):\\r\\n self.player_draws[f'{x}']=[]\\r\\n self.player_points[f'{x}']= 0\",\n \"def initGame(self):\\n self.map = {}\\n self.blocks = Group()\\n self.Coins =Group()\\n self.players = Group()\\n self.player1 = Player(1525,75,2)\\n self.players.add(self.player1)\\n if self.playernum == 2:\\n self.player2 = Player(75,825,1)\\n self.players.add(self.player2)\\n else:\\n self.player2 = False\",\n \"def initialize(self):\\n\\n db = dict()\\n\\n db['meta'] = Meta(None)\\n db['race'] = Race(None, None, None, None, None)\\n db['track'] = Track(None, None)\\n db['classes'] = set([])\\n db['teams'] = set([])\\n db['drivers'] = set([])\\n\\n self.db = db\",\n \"def __init__(self):\\r\\n self.__storage = {}\",\n \"def initialize(self):\\n self.population.initialize()\\n self.cache.initialize()\\n if self.storage:\\n self.storage.initialize()\",\n \"def _prepare_start(self, client, player_id, game_info, game_data, realtime: bool = False):\\n self._client: Client = client\\n self.player_id: int = player_id\\n self._game_info: GameInfo = game_info\\n self._game_data: GameData = game_data\\n self.realtime: bool = realtime\",\n \"def on_load(self):\\n pass\",\n \"def on_load(self):\\n pass\",\n \"def _init(self):\\n if os.path.exists(self.fname):\\n with open(self.fname, \\\"rb\\\") as fh:\\n self.db = pickle.load(fh)\\n else:\\n self.db = {}\\n print(\\\"DB loaded, len\\\", len(self.db))\",\n \"def init(self):\\n # IMPORTANT: create a new gob database model entry for this object\\n self.gobify()\",\n \"def game_setup(self):\\n self.deck = Shoe(6)\\n self.initial_draw()\\n self.pot = ask_for_bet(self.player.money)\\n show_table(self.player, self.dealer, self.pot)\\n self.surrender_and_insurance()\",\n \"def _post_init(self) -> None:\\n return\",\n \"def __init__(self):\\n # Wipe the db\\n self.wipe_db()\\n\\n # Set some global things\\n try:\\n dashboard_configuration = DashboardConfiguration(type=\\\"default\\\")\\n dashboard_configuration.save()\\n except IntegrityError:\\n dashboard_configuration = DashboardConfiguration.objects.filter(type=\\\"default\\\").first()\\n\\n # Add all players from dataset\\n group = self.add_players(dashboard_configuration)\\n\\n # Add all games from the dataset\\n self.add_games()\\n\\n # Create the games played for this group\\n self.add_game_played(group)\",\n \"def __init__( self, prevState = None ): ###PLEASE NOTE THIS THAT THE __init__ method is here and this is where GameState() starts\\n if prevState != None: # Initial state\\n self.data = GameStateData(prevState.data) ##This statement imports the GameStateData object from the GameStateData class in game.py. This object contains a data packet documenting the state of the game.\\n\\n else:\\n self.data = GameStateData()\\n \\\"\\\"\\\"\\n self._foodEaten = None\\n self._capsuleEaten = None\\n self._agentMoved = None\\n self._lose = False\\n self._win = False\\n self.scoreChange = 0\\n \\\"\\\"\\\"\",\n \"def on_init(self):\\n self.engineer_list = []\\n self.list_items = []\\n self.selected_items = []\\n self.log_info(self.name + \\\" initialized\\\")\\n self.bind('PUB', alias='main')\",\n \"def __init__(self):\\n with open('data.json') as data_file:\\n self.data = json.load(data_file)\\n self.game_over = False\",\n \"def save(cls):\\n playerdata = getAttributes(cls)\\n Data.object_dump(playerdata, \\\"savedata.dat\\\")\\n del playerdata\",\n \"def initGameState(self):\\n print(\\\"Setting game state: \\\")\\n self.playGUI = GUI()\\n self.playGUI.drawBoard(self.player)\",\n \"def _initialize(self):\\n self.send_init_command()\",\n \"def __init__(self):\\n\\n super().__init__()\\n self.setup_janggi_game()\\n self._game_state = 'UNFINISHED'\\n self._player_turn = 'BLUE'\",\n \"def before_turn(self, playerInfo):\\n self.PlayerInfo = playerInfo\",\n \"def at_object_creation(self):\\n self.db.max_hp = 100 # Set maximum HP to 100\\n self.db.hp = self.db.max_hp # Set current HP to maximum\\n self.db.spells_known = [] # Set empty spells known list\\n self.db.max_mp = 20 # Set maximum MP to 20\\n self.db.mp = self.db.max_mp # Set current MP to maximum\",\n \"def startup(self):\\n self.prev_gray = None\\n self.frame_idx = 1\\n self.tracks = []\\n self.fps = []\\n self.vid_info = None\\n self.track_new_points_count = 0\",\n \"def on_start(self):\\n self.init()\",\n \"def __init__(self, settings):\\n super().__init__(settings, self.player_info_url, Player)\",\n \"def __init__(self, player_name):\\n self._player_name = player_name\\n self._hand = Deck() \\n self._coder = Deck()\",\n \"def initialise(self):\\n logging.debug(\\\"TrackerPlugin.initialise\\\")\",\n \"def init_player():\\n global active_track_idx\\n global track_last_slided_pos\\n global track_last_paused_pos\\n global track_total_play_time \\n\\n # INITIALIZE Player\\n active_track_idx = -1\\n cancel_update_play_time_loop()\\n cancel_track_end_event_loop()\\n track_status.set(\\\"---\\\")\\n track_title.set(\\\"--- : \\\")\\n play_pause_btn.configure(image=play_img)\\n track_last_slided_pos = 0\\n track_last_paused_pos = 0\\n track_total_play_time = 0\\n track_pos_label.configure(text=\\\"00:00\\\")\\n track_length_label.configure(text=\\\"00:00\\\")\\n track_pos_slider.configure(state=\\\"disabled\\\")\\n track_pos.set(0)\",\n \"def init(self):\\n self.data_dir = self.data_dir or default_data_path / self._name_\\n self.cache_dir = self.data_dir / \\\"cache\\\"\\n assert self.level in [\\n \\\"word\\\",\\n \\\"char\\\",\\n ], f\\\"level {self.level} not supported\\\"\",\n \"def setup_game(self):\",\n \"def __init__(self, persistent=True):\\n super().__init__()\\n self.name_cache = {}\\n self.run_cache = {}\\n self.row_cache = {}\\n self.persistent = persistent\\n\\n if self.persistent:\\n self.load_cache()\",\n \"def on_init(self):\\n self.write_log(\\\"策略初始化\\\")\",\n \"def on_init(self):\\n self.write_log(\\\"策略初始化\\\")\",\n \"def initializeGame(self):\\n # Fill deck with cards and shuffle it\\n self.deck.fill(104)\\n self.deck.shuffle()\\n #print \\\"Deck initialized\\\"\\n\\n # Initialize the field\\n self.field.initialize(self.deck.draw(4))\\n self.field.sortField()\\n #self.field.printField()\\n\\n # Set players to initial state again\\n # Distribute cards and set bulls to 0\\n for p in self.players:\\n p.bulls = 0\\n p.setHand(self.deck.draw(10))\",\n \"def __init__(self):\\n self.screen = pg.display.get_surface()\\n self.screen_rect = self.screen.get_rect()\\n self.clock = pg.time.Clock()\\n self.fps = 60\\n self.keys = pg.key.get_pressed()\\n self.done = False\\n # ship = random.choice(list(prepare.GFX[\\\"ships\\\"].values()))\\n ship = list(prepare.GFX[\\\"ships\\\"].values())[7] # pick first ship available\\n self.player = actors.Player((0, 0), ship)\\n self.level = level.Level(self.screen_rect.copy(), self.player)\\n\\n self.energyloss_counter = 0\\n self.energygain_counter = 0\",\n \"def _setup(self):\\n\\n # Get user data\\n self.symbols = self._get_symbols()\\n self.data_dict = self._get_data()\\n self.portfolio = self.initialize_portfolio()\\n\\n if 'slippage' in self.portfolio:\\n self.slippage = self.portfolio['slippage']\\n else:\\n self.slippage = None\\n\\n # Keep track of all trades\\n self.trade_manager = TradeManager(\\n self.symbols, self.portfolio, self.sql_config\\n )\\n\\n # Initialize state variables that are updated each iteration\\n self.date = None\\n self.data = None\\n self.symbol = None\\n self.currency = None\\n self.last_buy = None\\n self.num_unresolved = 0\\n self.unresolved_trade = False\",\n \"def __post_init__(self):\\n # ------------------------------------------------------------ 01\\n # if path exists load data dict from it\\n # that is sync with contents on disk\\n if self.path.exists():\\n _hashable_dict_from_disk = \\\\\\n m.FrozenDict.from_yaml(self.path.read_text())\\n # update internal dict from HashableDict loaded from disk\\n self.__dict__.update(\\n _hashable_dict_from_disk.get()\\n )\\n\\n # ------------------------------------------------------------ 02\\n # start syncing i.e. any updates via __setattr__ will be synced\\n # to disc\\n self.internal.start_syncing = True\",\n \"def __init__(self):\\n self._game_state = \\\"UNFINISHED\\\"\\n self._current_player = \\\"BLACK\\\"\\n self._game_board = Board()\",\n \"def save_player(self, serialized_player):\\n self.player_table.insert(serialized_player)\",\n \"def init2(self):\\n self.skill_points = self.count_skill_points()\\n self.count_saves()\\n self.lives = self.count_lives()\\n self.base_attack = fetch_data.get_base_attack(self.BASE_ATTACK_LVLS, self.lvl)\",\n \"def __init__(self):\\n self.secret = None\\n self.on_hook_init()\",\n \"def __init__(self, player_id, player_name, chat_id):\\n\\n # find player info in a database\\n with Player.client as client:\\n db = client.game_db\\n user = db.players.find_one({\\\"id\\\": player_id})\\n if user is None:\\n # add user to database\\n user = {\\\"id\\\": player_id,\\n \\\"name\\\": player_name,\\n \\\"chat_id\\\": chat_id,\\n \\\"games_num\\\": 0,\\n \\\"rating\\\": Player.default_rating}\\n db.players.insert(user)\\n \\n self.id = user[\\\"id\\\"]\\n self.name = user[\\\"name\\\"]\\n self.chat_id = user[\\\"chat_id\\\"]\\n self.rating = user[\\\"rating\\\"]\\n self.game = None\\n self.balance = None\\n self.stake = None\\n self.timer = None\\n self.out_of_time = False\\n self.searching = False\",\n \"def init_new_game(self):\\n self.game = get_new_game(self.game_config)\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def to_json(self):\\n player = {\\n 'name': self.name,\\n 'colour': self.colour,\\n 'gender': self.gender,\\n 'uid': self.UID,\\n 'position': self.position,\\n 'money': self.money,\\n 'ready': self.is_ready(),\\n }\\n return player\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.687386","0.6623529","0.64238656","0.6392974","0.63051546","0.62751853","0.6266884","0.62623644","0.62329775","0.6226287","0.62254786","0.6207377","0.6186291","0.6179973","0.61705506","0.6159125","0.6156226","0.6151657","0.6132384","0.61177516","0.6095638","0.60848933","0.6074475","0.60736173","0.6062877","0.60543567","0.60209185","0.6015256","0.6005717","0.6003336","0.60017127","0.59947914","0.59892595","0.5970875","0.59647053","0.5953425","0.5940126","0.5925809","0.59244525","0.5908215","0.5893242","0.5887459","0.5886656","0.5878919","0.58652043","0.5859388","0.5846751","0.5846099","0.58365476","0.5834983","0.58314943","0.58314234","0.58303064","0.5828819","0.58215064","0.5815632","0.581552","0.5810947","0.57945824","0.57945824","0.5791887","0.5789035","0.577906","0.57767206","0.5776495","0.5776158","0.577298","0.57720584","0.577067","0.5766667","0.57562286","0.5754027","0.57499605","0.5735246","0.5730541","0.57270694","0.57175577","0.57084876","0.5698752","0.5685174","0.5666693","0.5665361","0.56620705","0.5657874","0.5657874","0.56553245","0.5650905","0.56442493","0.564354","0.5634522","0.5634347","0.5625572","0.56212413","0.56203854","0.5609299","0.56037545","0.56037545","0.56037545","0.56037545","0.56037545","0.56032264"],"string":"[\n \"0.687386\",\n \"0.6623529\",\n \"0.64238656\",\n \"0.6392974\",\n \"0.63051546\",\n \"0.62751853\",\n \"0.6266884\",\n \"0.62623644\",\n \"0.62329775\",\n \"0.6226287\",\n \"0.62254786\",\n \"0.6207377\",\n \"0.6186291\",\n \"0.6179973\",\n \"0.61705506\",\n \"0.6159125\",\n \"0.6156226\",\n \"0.6151657\",\n \"0.6132384\",\n \"0.61177516\",\n \"0.6095638\",\n \"0.60848933\",\n \"0.6074475\",\n \"0.60736173\",\n \"0.6062877\",\n \"0.60543567\",\n \"0.60209185\",\n \"0.6015256\",\n \"0.6005717\",\n \"0.6003336\",\n \"0.60017127\",\n \"0.59947914\",\n \"0.59892595\",\n \"0.5970875\",\n \"0.59647053\",\n \"0.5953425\",\n \"0.5940126\",\n \"0.5925809\",\n \"0.59244525\",\n \"0.5908215\",\n \"0.5893242\",\n \"0.5887459\",\n \"0.5886656\",\n \"0.5878919\",\n \"0.58652043\",\n \"0.5859388\",\n \"0.5846751\",\n \"0.5846099\",\n \"0.58365476\",\n \"0.5834983\",\n \"0.58314943\",\n \"0.58314234\",\n \"0.58303064\",\n \"0.5828819\",\n \"0.58215064\",\n \"0.5815632\",\n \"0.581552\",\n \"0.5810947\",\n \"0.57945824\",\n \"0.57945824\",\n \"0.5791887\",\n \"0.5789035\",\n \"0.577906\",\n \"0.57767206\",\n \"0.5776495\",\n \"0.5776158\",\n \"0.577298\",\n \"0.57720584\",\n \"0.577067\",\n \"0.5766667\",\n \"0.57562286\",\n \"0.5754027\",\n \"0.57499605\",\n \"0.5735246\",\n \"0.5730541\",\n \"0.57270694\",\n \"0.57175577\",\n \"0.57084876\",\n \"0.5698752\",\n \"0.5685174\",\n \"0.5666693\",\n \"0.5665361\",\n \"0.56620705\",\n \"0.5657874\",\n \"0.5657874\",\n \"0.56553245\",\n \"0.5650905\",\n \"0.56442493\",\n \"0.564354\",\n \"0.5634522\",\n \"0.5634347\",\n \"0.5625572\",\n \"0.56212413\",\n \"0.56203854\",\n \"0.5609299\",\n \"0.56037545\",\n \"0.56037545\",\n \"0.56037545\",\n \"0.56037545\",\n \"0.56037545\",\n \"0.56032264\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89597,"cells":{"query":{"kind":"string","value":"You're free to implement the move(self, state) however you want. Be run time efficient and innovative."},"document":{"kind":"string","value":"def move(self, state):\n result = None\n self.currentDepthLimit = 0\t\n\tself.transposition = {}\n\tself.counter = 0\n\n\twhile True:\n u = float(\"inf\")\n\t v = float(\"-inf\")\n\t self.counter = 0\n\t result = None\n\t self.transposition = {}\n\t for a in state.actions():\n new = self.min_value(state.result(a), float(\"-inf\"), float(\"inf\"),self.currentDepthLimit)\n\t if new > v:\n\t v = new\n\t result = a\n\n\t elif new == v:\n\t if a.index < result.index:\n\t result = a\n\t if self.is_time_up():\n\t return result\n\t \n\t self.currentDepthLimit += 1\n\t \"\"\"If we never use evaluate function, it means all state are terminated, so return whatever the result is\"\"\"\n\t if self.counter == 0:\n\t break\n\t if self.is_time_up():\n \t return result\n\treturn result"},"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 move(self, state):\n raise NotImplementedError(\"Need to implement this method\")","def move(self):\n pass","def move(self):\n raise NotImplementedError","def move(self, move):\n raise NotImplementedError()","def play_move(self,state):\n raise AIError(\"Must be implemented for child class!\")","def move(state, pos, rel_pos):\n new_state = state.copy()\n return swap(new_state, pos, pos + rel_pos)","def move(self, state, move_cmd, i, j):\r\n new_state = self.clone_state(state)\r\n coordinate_change = self.action_dic[self.reflection_dic[move_cmd]]\r\n new_state[i][j], new_state[i + coordinate_change[0]][j + coordinate_change[1]] = \\\r\n new_state[i + coordinate_change[0]][j + coordinate_change[1]]\\\r\n , new_state[i][j]\r\n return new_state","def move(self, move):\n out = ''\n for val in self.moves[move]:\n out += self.state[val]\n self.state = out","def make_move(self, state):\r\n # intially set drop phase to true\r\n drop_phase = True\r\n move = [] # list to make moves with to return\r\n succ = self.succ(state) # get the successor of this state\r\n # intial postion of board to set up most advantagous spot if its empty\r\n if sum(x.count(self.my_piece) for x in self.board) == 0 and self.board[2][2] == ' ':\r\n move.insert(0, (2, 2))\r\n return move\r\n \r\n # check the number of 'r' and 'b' on board if theres 4 of each drop phase is false\r\n if sum(x.count('r') for x in self.board) == 4 and sum(x.count('b') for x in self.board) == 4:\r\n drop_phase = False\r\n\r\n # if not during drop phase use minimax to make next move from one postion to next\r\n if not drop_phase:\r\n move = []\r\n d = self.Max_value(state, 0)\r\n val = d['val']\r\n m = d['move']\r\n p = d['pos']\r\n f = d['from']\r\n s = sorted(succ, key=lambda e: e['f'])\r\n moveto = s[-1]\r\n move.insert(1, (moveto['from'][0], moveto['from'][1]))\r\n move.insert(0, (moveto['pos'][0], moveto['pos'][1]))\r\n return move # return the from, to move\r\n\r\n else: #else use minimax and to make move during drop phase selecting spot to place AI piece\r\n d = self.Max_value(state, 0)\r\n val = d['val']\r\n m = d['move']\r\n p = d['pos']\r\n hold = []\r\n move = []\r\n n = None\r\n hold = []\r\n for s in succ:\r\n p = s['pos'][0]\r\n p1 = s['pos'][1]\r\n if s['f'] == val and state[p][p1] == ' ':\r\n hold.append(s)\r\n if len(hold) == 1:\r\n row = hold[0]['pos'][0]\r\n col = hold[0]['pos'][1]\r\n else:\r\n f = sorted(hold, key=lambda e: e['pos'])\r\n row = f[0]['pos'][0]\r\n col = f[0]['pos'][1]\r\n\r\n move.insert(0, (row, col)) # return the move \r\n return move","def handleMove(self):\n pass","def move(state=None, actual_move=None):\n copy = state.copy()\n copy.push(chess.Move.from_uci(uci=actual_move))\n return copy","def move_state(self):\n return self._move_state","def move(self) -> None:\n\n if self.move_up:\n self.__moveUpIfPossible()\n if self.move_down:\n self.__moveDownIfPossible()","def move(self, t, s):\n raise NotImplementedError","def move(self, movement):\n index = self.state.index(0)\n\n new_state = self.state.copy()\n\n if movement == 'up':\n new_state[index], new_state[index - 3] = new_state[index - 3], new_state[index]\n elif movement == 'down':\n new_state[index], new_state[index + 3] = new_state[index + 3], new_state[index]\n elif movement == 'left':\n new_state[index], new_state[index - 1] = new_state[index - 1], new_state[index]\n else:\n # movement == 'right'\n new_state[index], new_state[index + 1] = new_state[index + 1], new_state[index]\n \n return new_state","def move(self, action: Action) -> State:\n new_state = State(self.size_h, self.size_v, self.wall_squares, self.boxes, self.storage_locations,\n self.current_location, action)\n\n if action == Action.DOWN:\n down_loc = (new_state.current_location[0] + 1, new_state.current_location[1])\n two_away = (down_loc[0] + 1, down_loc[1])\n new_state.current_location = down_loc\n if down_loc in new_state.boxes:\n new_state.boxes.remove(down_loc)\n new_state.boxes.append(two_away)\n\n elif action == Action.UP:\n up_loc = (new_state.current_location[0] - 1, new_state.current_location[1])\n two_away = (up_loc[0] - 1, up_loc[1])\n new_state.current_location = up_loc\n if up_loc in new_state.boxes:\n new_state.boxes.remove(up_loc)\n new_state.boxes.append(two_away)\n\n elif action == Action.RIGHT:\n right_loc = (new_state.current_location[0], new_state.current_location[1] + 1)\n two_away = (right_loc[0], right_loc[1] + 1)\n new_state.current_location = right_loc\n if right_loc in new_state.boxes:\n new_state.boxes.remove(right_loc)\n new_state.boxes.append(two_away)\n\n elif action == Action.LEFT:\n left_loc = (new_state.current_location[0], new_state.current_location[1] - 1)\n two_away = (left_loc[0], left_loc[1] - 1)\n new_state.current_location = left_loc\n if left_loc in new_state.boxes:\n new_state.boxes.remove(left_loc)\n new_state.boxes.append(two_away)\n\n new_state._validate() # TODO: Remove me for the final product.\n return new_state","def step(self, move):","def move(self, action):\n \n currentState = self.state\n\n if action == \"up\":\n newState = (self.state[0] - 1, self.state[1])\n elif action == \"down\":\n newState = (self.state[0] + 1, self.state[1])\n elif action == \"right\":\n newState = (self.state[0], self.state[1] + 1)\n elif action == \"left\":\n newState = (self.state[0], self.state[1] - 1)\n else:\n raise NameError(action, 'This is not a valid action!')\n\n # Need to check if the new state is a legal move\n if (newState[0] >= 0) & (newState[0] <= 1) & (newState[1] >= 0) & (newState[1] <= 2):\n return newState\n else:\n print('This move takes you off the board, you have not moved!')\n return currentState","def _move(self, dx, dy):\n pass # must override in subclass","def move(self, direction):\n # replace with your code\n pass","def move(self, direction):\n # replace with your code\n pass","def move(self, board):\n\n # We record all game positions to feed them into the NN for training with the corresponding updated Q\n # values.\n self.board_position_log.append(board.getState().copy())\n\n nn_input = self.board_state_to_nn_input(board.getState())\n probs, _ = self.get_valid_probs([nn_input], self.q_net, [board])\n probs = probs[0]\n # print(probs)\n # print(type(probs))\n # print(probs.shape)\n # input()\n # print(probs)\n # Most of the time our next move is the one with the highest probability after removing all illegal ones.\n # Occasionally, however we randomly chose a random move to encourage exploration\n if (self.training is True) and \\\n ((self.game_counter < self.pre_training_games) or (np.random.rand(1) < self.random_move_prob)):\n available = []\n for index in range(6):\n if probs[index] != -1.0:\n available.append(index)\n randomOne = random.randint(0,len(available)-1)\n move = available[randomOne]\n else:\n move = np.argmax(probs)\n # We record the action we selected as well as the Q values of the current state for later use when\n # adjusting NN weights.\n self.action_log.append(move)\n\n # We execute the move and return the result\n board.makeMove(move)\n return board.getState(), board.isOver()","def _move(self, d, event):\n\n actor = None\n if event.source in self._crates:\n actor = self._crates[event.source]\n else:\n actor = self._clones[event.source][0]\n\n if d == Direction.NO_ACT or not event.success:\n actor.animation = actor.do_nothing_animation()\n return\n pos = actor.pos\n target = pos.dir_pos(d)\n actor.direction = d\n actor.animation = actor.walk_animation()\n self.repaint()","def _move(self, move: Tile):\n if not self.game_state:\n raise RuntimeError(\"Cannot call move when the game has not started!\")\n # Adversaries are supposed to be notified of new info right before they move.\n if issubclass(type(self.current_turn), Enemy):\n current_enemy = next(enemy for enemy in self.enemy_list if enemy.entity.name == self.current_turn.entity.name)\n self._notify_adversary(current_enemy)\n # Players that are alive before this move\n pre_players = self.game_state.get_current_characters()\n completed_before_turn = self.game_state.get_completed_characters()\n if move != None:\n self._move_and_update(move)\n else:\n self.current_turn.notify(self._format_move_result_notification(None, Moveresult.OK))\n # Notify players and adversaries of changes to the gamestate, including players who were killed\n # on this turn. Note that this usually results in one rendering per move to all entities.\n self._update_players()\n self._update_adversaries()\n self._handle_completed_characters(completed_before_turn)\n self._handle_killed_players(pre_players)\n self.current_turn = self.turn_order.next()","def apply_move(self, move):\r\n next_board = copy.deepcopy(self.board)\r\n next_board.place(self.next_player, move)\r\n return GameState(next_board, self.next_player.other, move)","def select_move(self, game_state):\n raise NotImplementedError()","def move(x,y):\r\n pass","def movement(self):","def move(): #py:move\n RUR._move_()","def move(self, direction):\n pass","def move(self, action):\n \n self.counter += 1\n\n if action not in self.ACTIONS:\n raise Exception(\"Invalid action\")\n\n \n\n d_x, d_y = self.MOVEMENTS[action]\n x, y = self.position\n new_x, new_y = x + d_x, y + d_y\n new_X,new_Y=self.position_to_xy(new_x, new_y)\n \n\n if (new_x, new_y) not in self.cases:\n return self._get_state(), -3, False, self.ACTIONS\n \n \n \n elif (self.openGoal(new_x,new_y))&(new_X>-400):\n self.position = new_x, new_y\n self.positionxy = self.position_to_xy(new_x, new_y)\n \n return self._get_state(), 20, True, self.ACTIONS\n \n # elif not self.openGoal(new_x,new_y):\n # self.position = new_x, new_y\n # self.positionxy = self.position_to_xy(new_x, new_y)\n # return self._get_state(), -1, False, self.ACTIONS\n \n elif self.counter > 100:\n self.position = new_x, new_y\n self.positionxy = self.position_to_xy(new_x, new_y)\n return self._get_state(), -1, True, self.ACTIONS\n \n else:\n self.position = new_x, new_y\n self.positionxy = self.position_to_xy(new_x, new_y)\n return self._get_state(), -1, False, self.ACTIONS","def move(self, state):\n \n self.depth_limit=1\n self.best_utility=-2\n action=None\n while not self.is_time_up():\n self.terminal=True\n self.cache={}\n action=self.alpha_beta_search(state,0)\n if self.terminal==True:\n break\n self.depth_limit=self.depth_limit+1\n \n return action","def _move(self):\n self.pos += self.direction # add direction vector\n self.direction += self.gravity # add gravity to direction\n self.direction = self.direction.elementwise() * self.drag # apply drag to direction","def move(self, direction):\n try:\n\n if self.in_thing:\n print(\"You have to get out of the \" + str(*self.in_thing[-1]) +\n \" first\")\n return self\n if direction == 'north':\n if self.finished_places == 12:\n self.finished_places += 1\n return North(self.items, self.finished_places)\n if direction == 'up':\n if self.finished_places == 4:\n self.finished_places += 1\n return Up(self.items, self.finished_places)\n if direction == 'east':\n if self.finished_places == 2:\n self.finished_places += 1\n return East(self.items, self.finished_places)\n except AttributeError:\n self.items = []\n return self.move(direction)\n print(' you didn\\'t listen to my very subtle hints, i know it was hard'\n ' your lost now. if you remember the commands i told you you can'\n ' go back to where you left off and continue, just type \"QUIT\"')\n return Place(self.items, self.finished_places)\n\n # implement\n # return new instance on class","def move_agent(self, state):\n m = self.m\n n = self.n\n\n cur_env = deepcopy(state.grid)\n cur_env[m, n] = 0\n action = self.choose_action(state)\n\n if action == 'Right':\n if n + 1 >= grid_size or cur_env[m][n+1] != 0:\n Rew = -2 # Reward -5 if we move into wall or another agent\n self.collisions += 1\n else:\n n += 1\n Rew = -0.1 # Reward -1 otherwise\n a = 0 # Action number\n elif action == 'Left':\n if n - 1 < 0 or cur_env[m][n-1] != 0:\n Rew = -2\n self.collisions += 1\n else:\n n -= 1\n Rew = -0.1\n a = 1\n elif action == 'Up':\n if m - 1 < 0 or cur_env[m-1][n] != 0:\n Rew = -2\n self.collisions += 1\n else:\n m -= 1\n Rew = -0.1\n a = 2\n elif action == 'Down':\n if m + 1 >= grid_size or cur_env[m+1][n] != 0:\n Rew = -2\n self.collisions += 1\n else:\n m += 1\n Rew = -0.1\n a = 3\n\n m = m % grid_size\n n = n % grid_size\n self.m = m # Update position of agent\n self.n = n # Update position of agent\n cur_env[m][n] = 1 # Update grid\n new_state = State(cur_env, [m, n]) # Set new state\n terminal = False\n\n if [m, n] == self.end:\n Rew = 10\n terminal = True\n self.carry = True\n\n return new_state, a, Rew, terminal","def move(self, board):\n raise NotImplementedError","def result(self, state, move):\n new_state = state[:]\n new_state[move[0]], new_state[move[1]] = new_state[move[1]], new_state[move[0]]\n return new_state","def __move__(self):\n v = self.velocity\n p = self.position\n p += v\n self.rect.x = round(p.x)\n self.rect.y = round(p.y)","def move(self, *args, **kw):\n return self.execute_action('move', *args, **kw)","def move(self) -> bool:\n pass","def change_move_state(self, new_state):\n\n if new_state != self.move_state:\n print(\"Changing move state from \", states[self.move_state],\n \" to \", states[new_state])\n self.move_state = new_state\n print(\"move_state is now\", self.move_state)","def apply_move(self, move, state):\n x, y , heading, grid_data = state\n map_data = [row[:] for row in grid_data]\n if move == self.MOVE_FORWARD:\n # get coordinates for next cell\n if heading == self.UP:\n next_y = y - 1\n next_x = x\n elif heading == self.DOWN:\n next_y = y + 1\n next_x = x\n elif heading == self.LEFT:\n next_y = y\n next_x = x - 1\n else:\n next_y = y\n next_x = x + 1\n\n # handle special tile types\n if map_data[next_y][next_x] == self.ICE_SYMBOL:\n # handle ice tile - slide until first non-ice tile or blocked\n if heading == self.UP:\n for i in range(next_y, -1, -1):\n if map_data[i][next_x] != self.ICE_SYMBOL:\n if map_data[i][next_x] == self.WATER_SYMBOL:\n # slide into water - game over\n return self.GAME_OVER\n elif self.cell_is_blocked(i, next_x, map_data):\n # if blocked, stop on last ice cell\n next_y = i + 1\n break\n else:\n next_y = i\n break\n elif heading == self.DOWN:\n for i in range(next_y, self.y_size):\n if map_data[i][next_x] != self.ICE_SYMBOL:\n if map_data[i][next_x] == self.WATER_SYMBOL:\n # slide into water - game over\n return self.GAME_OVER\n elif self.cell_is_blocked(i, next_x, map_data):\n # if blocked, stop on last ice cell\n next_y = i - 1\n break\n else:\n next_y = i\n break\n elif heading == self.LEFT:\n for i in range(next_x, -1, -1):\n if map_data[next_y][i] != self.ICE_SYMBOL:\n if map_data[next_y][i] == self.WATER_SYMBOL:\n # slide into water - game over\n return self.GAME_OVER\n elif self.cell_is_blocked(next_y, i, map_data):\n # if blocked, stop on last ice cell\n next_x = i + 1\n break\n else:\n next_x = i\n break\n else:\n for i in range(next_x, self.x_size):\n if map_data[next_y][i] != self.ICE_SYMBOL:\n if map_data[next_y][i] == self.WATER_SYMBOL:\n # slide into water - game over\n return self.GAME_OVER\n elif self.cell_is_blocked(next_y, i, map_data):\n # if blocked, stop on last ice cell\n next_x = i - 1\n break\n else:\n next_x = i\n break\n if map_data[next_y][next_x] == self.TELEPORT_SYMBOL:\n # handle teleport - find the other teleporter\n tpy, tpx = (None, None)\n for i in range(self.y_size):\n for j in range(self.x_size):\n if map_data[i][j] == self.TELEPORT_SYMBOL and (i != next_y or j != next_x):\n tpy, tpx = (i, j)\n break\n if tpy is not None:\n break\n if tpy is None:\n raise Exception(\"LaserTank Map Error: Unmatched teleport symbol\")\n next_y, next_x = (tpy, tpx)\n else:\n # if not ice or teleport, perform collision check\n if self.cell_is_blocked(next_y, next_x, map_data):\n return self.COLLISION\n\n # check for game over conditions\n if self.cell_is_game_over(next_y, next_x, map_data):\n return self.GAME_OVER\n\n # no collision and no game over - update player position\n y = next_y\n x = next_x\n return (x, y, heading, map_data)\n\n elif move == self.TURN_LEFT:\n # no collision or game over possible\n if heading == self.UP:\n heading = self.LEFT\n elif heading == self.DOWN:\n heading = self.RIGHT\n elif heading == self.LEFT:\n heading = self.DOWN\n else:\n heading = self.UP\n return (x, y, heading, map_data)\n\n elif move == self.TURN_RIGHT:\n # no collision or game over possible\n if heading == self.UP:\n heading = self.RIGHT\n elif heading == self.DOWN:\n heading = self.LEFT\n elif heading == self.LEFT:\n heading = self.UP\n else:\n heading = self.DOWN\n return (x, y, heading, map_data)\n\n elif move == self.SHOOT_LASER:\n # set laser direction\n if heading == self.UP:\n laserheading = self.UP\n dy, dx = (-1, 0)\n elif heading == self.DOWN:\n laserheading = self.DOWN\n dy, dx = (1, 0)\n elif heading == self.LEFT:\n laserheading = self.LEFT\n dy, dx = (0, -1)\n else:\n laserheading = self.RIGHT\n dy, dx = (0, 1)\n\n # loop until laser blocking object reached\n ly, lx = (y, x)\n while True:\n ly += dy\n lx += dx\n\n # handle boundary and immovable obstacles\n if ly < 0 or ly >= self.y_size or \\\n lx < 0 or lx >= self.x_size or \\\n map_data[ly][lx] == self.OBSTACLE_SYMBOL:\n # laser stopped without effect\n return self.COLLISION\n\n # handle movable objects\n elif self.cell_is_laser_movable(ly, lx, laserheading, map_data):\n # check if tile can be moved without collision\n if self.cell_is_blocked(ly + dy, lx + dx, map_data) or \\\n map_data[ly + dy][lx + dx] == self.ICE_SYMBOL or \\\n map_data[ly + dy][lx + dx] == self.TELEPORT_SYMBOL or \\\n map_data[ly + dy][lx + dx] == self.FLAG_SYMBOL or \\\n (ly + dy == y and lx + dx == x):\n # tile cannot be moved\n return self.COLLISION\n else:\n old_symbol = map_data[ly][lx]\n map_data[ly][lx] = self.LAND_SYMBOL\n if map_data[ly + dy][lx + dx] == self.WATER_SYMBOL:\n # if new bridge position is water, convert to land tile\n if old_symbol == self.BRIDGE_SYMBOL:\n map_data[ly + dy][lx + dx] = self.LAND_SYMBOL\n # otherwise, do not replace the old symbol\n else:\n # otherwise, move the tile forward\n map_data[ly + dy][lx + dx] = old_symbol\n break\n\n # handle bricks\n elif map_data[ly][lx] == self.BRICK_SYMBOL:\n # remove brick, replace with land\n map_data[ly][lx] = self.LAND_SYMBOL\n break\n\n # handle facing anti-tanks\n elif (map_data[ly][lx] == self.ANTI_TANK_UP_SYMBOL and laserheading == self.DOWN) or \\\n (map_data[ly][lx] == self.ANTI_TANK_DOWN_SYMBOL and laserheading == self.UP) or \\\n (map_data[ly][lx] == self.ANTI_TANK_LEFT_SYMBOL and laserheading == self.RIGHT) or \\\n (map_data[ly][lx] == self.ANTI_TANK_RIGHT_SYMBOL and laserheading == self.LEFT):\n # mark anti-tank as destroyed\n map_data[ly][lx] = self.ANTI_TANK_DESTROYED_SYMBOL\n break\n\n # handle player laser collision\n elif ly == y and lx == x:\n return self.GAME_OVER\n\n # handle facing mirrors\n elif (map_data[ly][lx] == self.MIRROR_UL_SYMBOL and laserheading == self.RIGHT) or \\\n (map_data[ly][lx] == self.MIRROR_UR_SYMBOL and laserheading == self.LEFT):\n # new direction is up\n dy, dx = (-1, 0)\n laserheading = self.UP\n elif (map_data[ly][lx] == self.MIRROR_DL_SYMBOL and laserheading == self.RIGHT) or \\\n (self.grid_data[ly][lx] == self.MIRROR_DR_SYMBOL and laserheading == self.LEFT):\n # new direction is down\n dy, dx = (1, 0)\n laserheading = self.DOWN\n elif (map_data[ly][lx] == self.MIRROR_UL_SYMBOL and laserheading == self.DOWN) or \\\n (map_data[ly][lx] == self.MIRROR_DL_SYMBOL and laserheading == self.UP):\n # new direction is left\n dy, dx = (0, -1)\n laserheading = self.LEFT\n elif (map_data[ly][lx] == self.MIRROR_UR_SYMBOL and laserheading == self.DOWN) or \\\n (map_data[ly][lx] == self.MIRROR_DR_SYMBOL and laserheading == self.UP):\n # new direction is right\n dy, dx = (0, 1)\n laserheading = self.RIGHT\n # do not terminate laser on facing mirror - keep looping\n\n # check for game over condition after effect of laser\n if self.cell_is_game_over(y, x, map_data):\n return self.GAME_OVER\n return (x, y, heading, map_data)\n return self.SUCCESS","def move(self):\n c = self.get_position()\n\n f = c['f']\n if f == 'NORTH':\n c['y'] += 1\n elif f == 'EAST':\n c['x'] += 1\n elif f == 'SOUTH':\n c['y'] -= 1\n elif f == 'WEST':\n c['x'] -= 1\n\n if self.valid_position(c):\n self.update_position(c)\n else:\n raise ValueError('InvalidPosition')","def make_move(self, move: Any) -> 'StonehengeState':\n if type(move) == str:\n new_state = StonehengeState(not self.p1_turn, self.side_length)\n # copy the board information from current state\n # make copy of current state information\n hori_lst_copy = []\n for lst in self.hori_lst:\n temp = []\n for item in lst:\n temp.append(item)\n hori_lst_copy.append(temp)\n left_lst_copy = []\n for lst in self.left_lst:\n temp = []\n for item in lst:\n temp.append(item)\n left_lst_copy.append(temp)\n right_lst_copy = []\n for lst in self.right_lst:\n temp = []\n for item in lst:\n temp.append(item)\n right_lst_copy.append(temp)\n\n hori_result_copy = []\n for item in self.hori_result:\n hori_result_copy.append(item)\n left_result_copy = []\n for item in self.left_result:\n left_result_copy.append(item)\n right_result_copy = []\n for item in self.right_result:\n right_result_copy.append(item)\n\n new_state.hori_lst = hori_lst_copy\n new_state.hori_result = hori_result_copy\n new_state.left_lst = left_lst_copy\n new_state.left_result = left_result_copy\n new_state.right_lst = right_lst_copy\n new_state.right_result = right_result_copy\n # update the new state with str move\n # parallel nested list data structure\n lst = [new_state.hori_lst, new_state.left_lst, new_state.right_lst]\n result = [new_state.hori_result, new_state.left_result, new_state.right_result]\n # update the cell\n for i in range(len(lst)):\n for j in range(len(lst[i])):\n for k in range(len(lst[i][j])):\n if lst[i][j][k] == move:\n # should use the player name of last state, so opposite names\n if new_state.p1_turn:\n lst[i][j][k] = \"2\"\n else:\n lst[i][j][k] = \"1\"\n # update ley-line marks\n # the ley-line may belong to a player after this move\n p1_taken = 0\n p2_taken = 0\n if result[i][j] != \"@\":\n continue\n for item in lst[i][j]:\n if item == \"1\":\n p1_taken += 1\n if item == \"2\":\n p2_taken += 1\n if float(p1_taken) >= len(lst[i][j]) / 2:\n result[i][j] = \"1\"\n if float(p2_taken) >= len(lst[i][j]) / 2:\n result[i][j] = \"2\"\n ###### CHECK FOR SHALLOW COPY PROBLEM, IF ATTRIBUTE IS UPDATE IN NEW STATE\n return new_state","def _move_randomly(self):\n a, b = randint(0, len(self.state) - 1), randint(0, len(self.state) - 1)\n wiz1, wiz2 = self.state[a], self.state[b]\n self._swap_wizards(wiz1, wiz2)","def make_move(self, state):\n emptySpaces = 0\n for row in state:\n emptySpaces = emptySpaces + row.count(' ')\n if emptySpaces > 17:\n drop_phase = True\n else:\n drop_phase = False\n\n move = []\n if not drop_phase:\n best_value = float('-inf')\n best_state = None\n for s in self.succ(state, False, self.my_piece):\n if self.game_value(s) == -1 or self.game_value(s) == 1:\n best_state = s\n break\n currValue = self.Min_Value(state, 0)\n if currValue>best_value:\n best_value = currValue\n best_state = s\n for i in range(len(state)):\n for j in range(len(state[i])):\n if state[i][j]!= ' ' and best_state[i][j]== ' ':\n move.append((i,j))\n if state[i][j]== ' ' and best_state[i][j]!= ' ':\n move.insert(0, (i,j))\n \n # TODO: choose a piece to move and remove it from the board\n # (You may move this condition anywhere, just be sure to handle it)\n #\n # Until this part is implemented and the move list is updated\n # accordingly, the AI will not follow the rules after the drop phase!\n \n\n # select an unoccupied space randomly\n # TODO: implement a minimax algorithm to play better\n \n else:\n best_value = float('-inf')\n best_state = None\n for s in self.succ(state, True, self.my_piece):\n if self.game_value(s) == -1 or self.game_value(s) == 1:\n best_state = s\n break\n currValue = self.Min_Value(state, 0)\n if currValue>best_value:\n best_value = currValue\n best_state = s\n for i in range(len(state)):\n for j in range(len(state[i])):\n if state[i][j]== ' ' and best_state[i][j]!= ' ':\n move.insert(0, (i,j))\n \n return move","def move(self, board, move_dir):\n if move_dir == \"right\":\n # failsafe: do not move through other cars on board\n if board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 1)].isupper() or board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 1)] == 'r':\n print(\"No movement!\")\n return board\n \n # give board correct new positions (characters)\n else:\n board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 1)] = self.name[0]\n board.positions[self.get_rows()[0]][self.get_cols()[0]] = \"x\"\n\n # change car objects positions\n for i, col in enumerate(self.position):\n self.position[i] = str(self.get_rows()[0]) + \".\" + str(int(col[2]) + 1)\n return board\n elif move_dir == \"left\": \n if board.positions[self.get_rows()[0]][self.get_cols()[0] - 1].isupper() or board.positions[self.get_rows()[0]][self.get_cols()[0] - 1] == 'r':\n print(\"No movement!\")\n return board\n else: \n board.positions[self.get_rows()[0]][self.get_cols()[0] - 1] = self.name[0]\n board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 2)] = \"x\"\n\n for i, col in enumerate(self.position):\n self.position[i] = str(self.get_rows()[0]) + \".\" + str(int(col[2]) - 1)\n return board\n elif move_dir == \"up\":\n #print(board.positions[self.get_rows()[0] - 1][self.get_cols()[0]])\n if board.positions[self.get_rows()[0] - 1][self.get_cols()[0]].isupper() or board.positions[self.get_rows()[0] - 1][self.get_cols()[0]] == 'r':\n print(\"No movement!\")\n return board\n else:\n board.positions[self.get_rows()[0] - 1][self.get_cols()[0]] = self.name[0]\n board.positions[self.get_rows()[1] + (self.size - 2)][self.get_cols()[0]] = \"x\"\n\n for i, row in enumerate(self.position):\n self.position[i] = str(int(row[0]) - 1) + \".\" + str(self.get_cols()[0])\n\n #print(board)\n return board\n elif move_dir == \"down\": \n try: \n if board.positions[self.get_rows()[1] + (self.size - 1)][self.get_cols()[0]].isupper() or board.positions[self.get_rows()[1] + (self.size - 1)][self.get_cols()[0]] == 'r':\n print(\"No movement!\")\n return board\n except IndexError:\n return board\n else: \n board.positions[self.get_rows()[0]][self.get_cols()[0]] = \"x\" \n board.positions[self.get_rows()[1] + (self.size - 1)][self.get_cols()[0]] = self.name[0]\n\n for i, row in enumerate(self.position):\n self.position[i] = str(int(row[0]) + 1) + \".\" + str(self.get_cols()[0]) \n \n #print(self.position)\n #print(board)\n \n return board\n else:\n #print(\"NO MOVEMENT!\")\n return board","def move(self, direction):\n\n if direction == \"north\":\n self.go_and_update(-1, 0)\n\n elif direction == \"south\":\n self.go_and_update(1, 0)\n\n elif direction == \"east\":\n self.go_and_update(0, 1)\n\n elif direction == \"west\":\n self.go_and_update(0, -1)","def choose_move(self):\n raise NotImplementedError()","def play_move(self,state):\n self.__engine.set_state(state)\n result = self.__engine.getNextState()\n time_elapsed = self.__engine.get_time_elapsed()\n num_nodes = self.__engine.get_num_explored()\n if self.moves == 0:\n self.average_time = time_elapsed\n self.average_nodes = num_nodes\n else:\n self.average_time = ( (self.average_time * self.moves) + time_elapsed ) / (self.moves+1)\n self.average_nodes = ( (self.average_nodes * self.moves) + num_nodes ) / (self.moves+1)\n self.moves += 1\n return result","def execute_move(self, game_state):\n game_state.pacs_pos[self.pac_id] = self.next_move","def move(self, agent, action):\n\t\tpass","def move(self, state_prev, state, reward, selected):\n\n if state:\n if self.team_id == 1: # Set correct teams based on team id\n self_team = state['team1']\n other_team = state['team2']\n else:\n self_team = state['team2']\n other_team = state['team1']\n\n if state:\n if self.id == 0: # Special for the goal-keeper\n ai_gk_pass = self.gk_pass(\n other_team['players'], self_team['goal_x'])\n ai_gk_move = self.gk_move(self_team['goal_x'], state['ball'])\n # GK has the ball\n if selected == self.id and state['ball'].ball_stats['player'] == self.id:\n if ai_gk_pass != 'NOTHING':\n return ai_gk_pass\n else:\n return ai_gk_move\n else:\n return ai_gk_move\n\n # Selected player has the ball\n if selected == self.id and state['ball'].ball_stats['player'] == self.id:\n ai_shoot = self.ai_shoot(\n other_team['players'][0], other_team['goal_x'])\n ai_pass = self.ai_pass(\n self_team['players'], other_team['players'])\n # If shot is possible, take it\n if self.pos.dist(P(other_team['goal_x'], H//2)) <= AI_SHOOT_RADIUS and ai_shoot != 'NOTHING':\n return ai_shoot\n # Else, pass if possible (passes towards the enemy goal are prioritized)\n elif ai_pass != 'NOTHING' and random.random() >= AI_PASS_PROB:\n return ai_pass\n else:\n # Move towards the goal\n return self.ai_move_with_ball(other_team['players'], other_team['goal_x'])\n\n else: # Move towards the ball if posssbile, otherwise return to formation\n move = self.ai_move_without_ball(state['ball'])\n if move != 'NOTHING':\n return move\n else:\n return 'FORM' # Special action, not defined in ACT\n else:\n return 'NOTHING' # Otherwise do nothing","def move(self):\n \n self.position = self.explore()","def move(self, direction, cycles):\n\t\tpass","def move(self,p,intMove):\n gs = self.gameState.copy() #copy Board\n gs[p.pos.get()] = EMPTY #put position it was at as empty\n gs[self.movePos(p,intMove).get()] = p.color #set new position as filled\n return ((p,intMove),Board(gs,self.togglePlayer(self.whoseTurn)))","def make_move(self, move: Any) -> \"StonehengeState\":\n new_state = StonehengeState(self.p1_turn, self.length,\n self.letters[:], self.claim[:])\n state = new_state\n if new_state.length == 1:\n state = self.move_length_1(move, new_state)\n if new_state.length == 2:\n state = self.move_length_2(move, new_state)\n if new_state.length == 3:\n state = self.move_length_3(move, new_state)\n if new_state.length == 4:\n if move in [\"A\", \"B\", \"J\", \"O\", \"N\", \"R\",\n \"C\", \"F\", \"E\", \"I\", \"P\", \"Q\"]:\n state = self.move_length_4(move, new_state)\n else:\n state = self.move_length_41(move, new_state)\n if new_state.length == 5:\n if move in [\"A\", \"B\", \"U\", \"O\", \"T\", \"Y\",\n \"C\", \"J\", \"E\", \"N\", \"V\", \"X\"]:\n state = self.move_length_5(move, new_state)\n elif move in [\"F\", \"I\", \"W\"]:\n state = self.move_length_51(move, new_state)\n else:\n state = self.move_length_52(move, new_state)\n return state","def _next_state(self, state, action):\n\n # Transition table to define movement for each action\n if self.action_type == 'VonNeumann':\n transitions = {0: [-1, 0], 1: [+1, 0], 2: [0, -1], 3: [0, +1]}\n elif self.action_type == 'Moore':\n transitions = {0: [-1, 0], 1: [+1, 0], 2: [0, -1], 3: [0, +1],\n 4: [-1, +1], 5: [+1, +1], 6: [-1, -1], 7: [+1, -1]}\n\n new_state = [state[0] + transitions[action][0], state[1] + transitions[action][1]]\n if self.maze[new_state[0]][new_state[1]] == 1: # Hit wall, stay there\n return state\n else: # Valid move for 0, 2, 3, 4\n return new_state","def move(self, x, y):\n self.x = x\n self.y = y\n self.call('move', x, y)","def makeMove(self, move, player):","def execute_move(self, game_state):\n # Set new location based on which ghost this is\n game_state.ghosts_pos[self.ghost_id] = self.next_move","def execute_move(self, game_state):\n # Set new location based on which ghost this is\n game_state.ghosts_pos[self.ghost_id] = self.next_move","def act(state: Tree) -> None:\n cur_state = state.value\n state.children = [Tree(cur_state.make_move(m)) for m in\n cur_state.get_possible_moves()]","def decide_next_move(self):\n pass","def process_IN_MOVE_SELF(self, event):","def _move(self, direction, difference):\n future_tile_number = self.get_number() + difference\n if future_tile_number in range(1, Tile.total_tiles + 1):\n future_tile = Tile.get_tile(future_tile_number)\n if future_tile.walkable:\n self.set_target(future_tile)\n self.rotate(direction)","def _onmove(self, event):","def virtual_move_to(self,path):\n #print path\n temp_state=self.state\n temp_data=self.data\n temp_current_node=self.current_node\n temp_node_names=self.node_names\n for index,edge in enumerate(path):\n #print edge\n edge_pattern='edge_(?P<begin_node>\\w+)_(?P<end_node>\\w+)_(?P<iterator>\\w+)'\n match=re.match(edge_pattern,edge)\n begin_node=match.groupdict()['begin_node']\n end_node=match.groupdict()['end_node']\n #print(\"moving {0} -> {1}\".format(begin_node,end_node))\n #print self.data\n temp_data=self.__dict__[edge](temp_data)\n #print self.data\n temp_current_node=match.groupdict()['end_node']\n temp_state=[0 for i in range(len(temp_node_names))]\n position=temp_node_names.index(temp_current_node)\n temp_state[position]=1\n #print temp_state\n #print self.state\n #print self.current_node","def get_move(self, game_state: BotGameState) -> BotMove:\n return","def update(self):\n if not self._move:\n self.get_next_move()\n if self._move:\n self._move.update()","def move(self, board):\n # first, make your turn:\n currentState = board[self.x,self.y]\n turnDir = self.rule[(currentState + 1) % len(self.rule)]\n self.turn( int(turnDir) )\n # next, let's change this cell's state:\n if currentState >= len(self.rule) - 1:\n board[self.x,self.y] = 0\n else:\n board[self.x,self.y] = currentState + 1\n # and let's move:\n offsets = self.nextPositionOffset() # based on x, y, and dir\n self.x, self.y = board.move(self.x, self.y, offsets[0], offsets[1])","def result(self, board_state, move):\n # Create a copy of the current board state\n output_state = BoardState(other_state=board_state)\n # Swap pieces\n output_state.move_piece(move)\n # Eliminate pieces\n output_state.eliminate_piece()\n return output_state","def make_move(state, action, player, rewarding_move=False): # TODO : done and next_is_reward can be removed as\n # they are in the state object\n board = state.get_board()\n json_action = action.get_json_action()\n action = action.get_action_as_dict()\n captured = None\n reward = 0\n next_is_reward = False\n previous_is_reward = False\n if rewarding_move:\n state.boring_moves = 0\n previous_is_reward = True\n if action['action_type'] == YoteActionType.STEAL_FROM_HAND:\n reward += 1\n state.in_hand[player * -1] -= 1\n elif action['action_type'] == YoteActionType.STEAL_FROM_BOARD:\n board.empty_cell(action['action']['at'])\n reward += 1\n else:\n if action['action_type'] == YoteActionType.ADD:\n state.boring_moves += 1\n state.in_hand[player] -= 1\n board.fill_cell(action['action']['to'], Color(player))\n elif action['action_type'] == YoteActionType.MOVE:\n at = action['action']['at']\n to = action['action']['to']\n\n def distance(cell_1, cell_2):\n import math\n return math.sqrt((cell_1[0] - cell_2[0]) ** 2 + (cell_1[1] - cell_2[1]) ** 2)\n\n board.empty_cell(at)\n board.fill_cell(to, Color(player))\n if int(distance(at, to)) == 1:\n state.boring_moves += 1\n elif int(distance(at, to)) > 1:\n state.boring_moves = 0\n next_is_reward = True\n board.fill_cell(to, Color(player))\n if at[0] == to[0] and at[1] < to[1]:\n board.empty_cell((at[0], at[1] + 1))\n captured = (at[0], at[1] + 1)\n elif at[0] == to[0] and at[1] > to[1]:\n board.empty_cell((at[0], at[1] - 1))\n captured = (at[0], at[1] - 1)\n elif at[1] == to[1] and at[0] < to[0]:\n board.empty_cell((at[0] + 1, at[1]))\n captured = (at[0] + 1, at[1])\n elif at[1] == to[1] and at[0] > to[0]:\n board.empty_cell((at[0] - 1, at[1]))\n captured = (at[0] - 1, at[1])\n reward += 1\n\n state.set_board(board)\n state.score[player] += reward\n state.captured = captured\n state.rewarding_move = next_is_reward\n state.previous_is_reward = previous_is_reward\n state.set_latest_player(player)\n state.set_latest_move(json_action)\n if next_is_reward:\n state.set_next_player(player)\n else:\n state.set_next_player(player * -1)\n\n done = YoteRules.is_end_game(state)\n return state, done, next_is_reward","def move(self) -> None:\n\n new_x = self.getX() + self.speed[0]\n new_y = self.getY() + self.speed[1]\n self.setX(new_x)\n self.setY(new_y)","def move(self,dt):\n raise NotImplementedError(\"Robot.move\")","def move_forward():\n pass","def move(self):\n \n self.position = self.wander()","def move(self):\n a = random.randint(0, len(self.state) - 1)\n b = random.randint(0, len(self.state) - 1)\n self.state[a], self.state[b] = self.state[b], self.state[a]\n\n # change type of restoration for one state\n c = random.choice(self.restoration_types)\n self.state[a] = (self.state[a][0], c)","def move(self):\r\n if self.last_op_move is None:\r\n return rockyman.move(self)\r\n else:\r\n return self.last_op_move","def _ispinnedmove(self, from_, to_):\n return False","def handle_state(self):\r\n if self.state == 'walk':\r\n self.walking()\r\n elif self.state == 'fall':\r\n self.falling()\r\n elif self.state == 'jumped on':\r\n self.jumped_on()\r\n elif self.state == 'shell slide':\r\n self.shell_sliding()\r\n elif self.state == 'death jump':\r\n self.death_jumping()","def make_move(self, current_state):\n\n\t\tbatch_size = 192\n\n\t\ttest_board = np.zeros((batch_size, 3, 3, 3))\n\t\ttest_cows = np.zeros((batch_size, 2))\n\t\ttest_labels = np.zeros((batch_size, 1)) \n\n\t\tnew_states = current_state.expand_states()\n\n\t\tif len(new_states) == 0:\n\t\t\treturn None\n\n\t\tfor i, state in enumerate(new_states):\n\n\t\t\tdesc = self.state_descriptor(state, self.player_index)\n\t\t\ttest_board[i] = np.asarray(desc[0])\n\t\t\ttest_cows[i] = np.asarray([desc[1], desc[2]])\n\n\t\treturn new_states[self.train_value_function_approximation(\n\t\t\tTrue, (test_board, test_cows, test_labels), len(new_states))]","def move(self,x,y):\n self.pos.x = x\n self.pos.y = y","def move(self, coordinates, direction):\n pass","def solveOneStep(self):\n ### Student code goes here\n # Mark this move as explored\n self.visited[self.currentState] = True\n self.visited_states.append(self.currentState.state)\n\n # Get move to make\n movables = self.gm.getMovables()\n # print(\"EXPLORING GAME STATE \" + str(self.gm.getGameState()) + \"---------------------------------------------------------\")\n to_move = self.currentState.nextChildToVisit # movables index\n # print(\"depth \", self.currentState.depth)\n\n # Return if done\n if self.currentState.state == self.victoryCondition:\n # print(\"DONE\")\n return True\n\n # If current state has no children, make children\n if not self.currentState.children:\n for movable_statement in movables:\n # Make the move\n # print(\"implementing move \", movable_statement)\n self.gm.makeMove(movable_statement)\n\n # Create a new state with this move made\n new_state = self.gm.getGameState()\n # print (\"new state \", new_state)\n\n # If the new state hasn't been visited and isn't in the queue then add it as a child and to the queue\n if (new_state not in self.visited_states):\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\n new_gs.parent = self.currentState\n self.currentState.children.append(new_gs)\n self.currentState.nextChildToVisit = to_move + 1\n self.visited[new_gs] = True\n self.visited_states.append(new_state)\n self.gs_queue.append(new_gs)\n\n self.gm.reverseMove(movable_statement)\n\n # Return false if no more to explore\n if not self.gs_queue:\n return False\n\n # Revert to state at when current and next start to change\n root_curr = self.currentState\n self.currentState = self.gs_queue.popleft()\n root_new = self.currentState\n\n # Backtrack to when current node and new node start to diverge\n if root_new.depth == root_curr.depth:\n while root_curr.state != root_new.state:\n self.gm.reverseMove(root_curr.requiredMovable)\n root_curr = root_curr.parent\n root_new = root_new.parent\n else:\n while root_curr.requiredMovable:\n self.gm.reverseMove(root_curr.requiredMovable)\n root_curr = root_curr.parent\n\n # Return game master to state that we are exploring\n # Find path between root and current state\n path = []\n currNode = self.currentState\n while currNode != root_curr:\n path.append(currNode.requiredMovable)\n currNode = currNode.parent\n\n # Created backwards path, now make moves from root to current state\n path.reverse()\n for movable_statement in path:\n self.gm.makeMove(movable_statement)\n\n return False","def apply_move(self, start_move, move):\n\t\t# check that the start move and the move are Move objects\n\t\tif not isinstance(move, Move):\n\t\t\tmove = Move(move)\n\t\tif not isinstance(start_move, Move):\n\t\t\tstart_move = Move(start_move)\n\t\t# copy the board\n\t\tnext_board = copy.deepcopy(self.board)\n\t\t# place the move on the next board\n\t\tnext_board.place(self.next_player, start_move.point, move.point)\n\t\treturn GameState(next_board, self.next_player.other, move)","def move(self):\n # This block is used to move into the living room.\n if self.room_name == \"living\" or self.room_name == \"Living\":\n self.living_room()\n # This block is used to open the door.\n elif self.room_name == \"Door\" or self.room_name == \"door\":\n self.door()\n # This block is used to move into the kitchen.\n elif self.room_name == \"Kitchen\" or self.room_name == \"kitchen\":\n self.kitchen()\n # This block is used to move into the hallway.\n elif self.room_name == \"Hallway\" or self.room_name == \"hallway\":\n self.hallway()\n # This block is used to move into the bathroom.\n elif self.room_name == \"Bathroom\" or self.room_name == \"bathroom\":\n self.bathroom()\n # This block is used to move into the basement.\n elif self.room_name == \"Basement\" or self.room_name == \"basement\":\n self.basement()\n # This block is used to move into the bedroom.\n elif self.room_name == \"Bedroom\" or self.room_name == \"bedroom\":\n self.bedroom()\n # This block is used to move into the attic.\n elif self.room_name == \"Attic\" or \"attic\":\n self.attic()","def move(self, x, y):\n\n #log.info(\"MOVE x:%s y:%s\", x, y)","def step(self, state):","def update_to_state(self, game_state):\n pass","def move_toward(state, location):\n return move_relative(state, location, True)","def move(self):\n self.position += self.speed","def decide_move(self, action):\n x1, y1 = action['xy1']\n x2, y2 = action['xy2']\n self.__state.push(action)","def update_pos(self, move):\n change = Maze.moves[move]\n self.current_pos[0] += change[0]\n self.current_pos[1] += change[1]","def move(self, *step):\n self.x += step[0]\n self.y += step[1]","def successor(self, state):\n pass # abstract","def request_move(self, board):\n pass","def move(self, p):\r\n self.position.setvalue(p)","def solveOneStep(self):\n ### Student code goes here\n # Mark this move as explored\n self.visited[self.currentState] = True\n\n # Get move to make\n movables = self.gm.getMovables()\n # print(\"EXPLORING GAME STATE \" + str(self.gm.getGameState()) + \"---------------------------------------------------------\")\n to_move = self.currentState.nextChildToVisit # movables index\n # print(\"depth \", self.currentState.depth)\n\n # Return if done\n if self.currentState.state == self.victoryCondition:\n # print(\"DONE\")\n return True\n\n while to_move < len(movables):\n # Make the move\n movable_statement = movables[to_move]\n # print(\"implementing move \", movable_statement)\n self.gm.makeMove(movable_statement)\n\n # Create a new state with this move made\n new_state = self.gm.getGameState()\n\n # Find out if this state has already been explored\n visited = False\n for visited_state in self.visited.keys():\n if visited_state.state == new_state:\n visited = True\n\n # If the new state hasn't been visited then add it as a child then move down to this child\n if not visited:\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\n new_gs.parent = self.currentState\n self.currentState.children.append(new_gs)\n self.currentState.nextChildToVisit = to_move + 1\n self.currentState = new_gs\n break\n\n # Else skip this state and try going to the next movable statement\n else:\n # print(\"SKIP THIS STATE\")\n self.gm.reverseMove(movable_statement)\n to_move += 1\n\n # Went all the way down to a leaf, backtrack\n if (to_move >= len(movables)):\n self.gm.reverseMove(self.currentState.requiredMovable)\n self.currentState = self.currentState.parent\n\n return False","def move(self, step):\n\n status = self.read()\n Logger.getLogger().debug(\"Status in move method: %s\", status)\n # while the motors are moving we don't want to start another movement\n if status > CurtainsStatus.OPEN or self.motor.value:\n return\n\n self.target = step\n\n # deciding the movement direction\n if self.steps() < self.target:\n self.__open__()\n elif self.steps() > self.target:\n self.__close__()"],"string":"[\n \"def move(self, state):\\n raise NotImplementedError(\\\"Need to implement this method\\\")\",\n \"def move(self):\\n pass\",\n \"def move(self):\\n raise NotImplementedError\",\n \"def move(self, move):\\n raise NotImplementedError()\",\n \"def play_move(self,state):\\n raise AIError(\\\"Must be implemented for child class!\\\")\",\n \"def move(state, pos, rel_pos):\\n new_state = state.copy()\\n return swap(new_state, pos, pos + rel_pos)\",\n \"def move(self, state, move_cmd, i, j):\\r\\n new_state = self.clone_state(state)\\r\\n coordinate_change = self.action_dic[self.reflection_dic[move_cmd]]\\r\\n new_state[i][j], new_state[i + coordinate_change[0]][j + coordinate_change[1]] = \\\\\\r\\n new_state[i + coordinate_change[0]][j + coordinate_change[1]]\\\\\\r\\n , new_state[i][j]\\r\\n return new_state\",\n \"def move(self, move):\\n out = ''\\n for val in self.moves[move]:\\n out += self.state[val]\\n self.state = out\",\n \"def make_move(self, state):\\r\\n # intially set drop phase to true\\r\\n drop_phase = True\\r\\n move = [] # list to make moves with to return\\r\\n succ = self.succ(state) # get the successor of this state\\r\\n # intial postion of board to set up most advantagous spot if its empty\\r\\n if sum(x.count(self.my_piece) for x in self.board) == 0 and self.board[2][2] == ' ':\\r\\n move.insert(0, (2, 2))\\r\\n return move\\r\\n \\r\\n # check the number of 'r' and 'b' on board if theres 4 of each drop phase is false\\r\\n if sum(x.count('r') for x in self.board) == 4 and sum(x.count('b') for x in self.board) == 4:\\r\\n drop_phase = False\\r\\n\\r\\n # if not during drop phase use minimax to make next move from one postion to next\\r\\n if not drop_phase:\\r\\n move = []\\r\\n d = self.Max_value(state, 0)\\r\\n val = d['val']\\r\\n m = d['move']\\r\\n p = d['pos']\\r\\n f = d['from']\\r\\n s = sorted(succ, key=lambda e: e['f'])\\r\\n moveto = s[-1]\\r\\n move.insert(1, (moveto['from'][0], moveto['from'][1]))\\r\\n move.insert(0, (moveto['pos'][0], moveto['pos'][1]))\\r\\n return move # return the from, to move\\r\\n\\r\\n else: #else use minimax and to make move during drop phase selecting spot to place AI piece\\r\\n d = self.Max_value(state, 0)\\r\\n val = d['val']\\r\\n m = d['move']\\r\\n p = d['pos']\\r\\n hold = []\\r\\n move = []\\r\\n n = None\\r\\n hold = []\\r\\n for s in succ:\\r\\n p = s['pos'][0]\\r\\n p1 = s['pos'][1]\\r\\n if s['f'] == val and state[p][p1] == ' ':\\r\\n hold.append(s)\\r\\n if len(hold) == 1:\\r\\n row = hold[0]['pos'][0]\\r\\n col = hold[0]['pos'][1]\\r\\n else:\\r\\n f = sorted(hold, key=lambda e: e['pos'])\\r\\n row = f[0]['pos'][0]\\r\\n col = f[0]['pos'][1]\\r\\n\\r\\n move.insert(0, (row, col)) # return the move \\r\\n return move\",\n \"def handleMove(self):\\n pass\",\n \"def move(state=None, actual_move=None):\\n copy = state.copy()\\n copy.push(chess.Move.from_uci(uci=actual_move))\\n return copy\",\n \"def move_state(self):\\n return self._move_state\",\n \"def move(self) -> None:\\n\\n if self.move_up:\\n self.__moveUpIfPossible()\\n if self.move_down:\\n self.__moveDownIfPossible()\",\n \"def move(self, t, s):\\n raise NotImplementedError\",\n \"def move(self, movement):\\n index = self.state.index(0)\\n\\n new_state = self.state.copy()\\n\\n if movement == 'up':\\n new_state[index], new_state[index - 3] = new_state[index - 3], new_state[index]\\n elif movement == 'down':\\n new_state[index], new_state[index + 3] = new_state[index + 3], new_state[index]\\n elif movement == 'left':\\n new_state[index], new_state[index - 1] = new_state[index - 1], new_state[index]\\n else:\\n # movement == 'right'\\n new_state[index], new_state[index + 1] = new_state[index + 1], new_state[index]\\n \\n return new_state\",\n \"def move(self, action: Action) -> State:\\n new_state = State(self.size_h, self.size_v, self.wall_squares, self.boxes, self.storage_locations,\\n self.current_location, action)\\n\\n if action == Action.DOWN:\\n down_loc = (new_state.current_location[0] + 1, new_state.current_location[1])\\n two_away = (down_loc[0] + 1, down_loc[1])\\n new_state.current_location = down_loc\\n if down_loc in new_state.boxes:\\n new_state.boxes.remove(down_loc)\\n new_state.boxes.append(two_away)\\n\\n elif action == Action.UP:\\n up_loc = (new_state.current_location[0] - 1, new_state.current_location[1])\\n two_away = (up_loc[0] - 1, up_loc[1])\\n new_state.current_location = up_loc\\n if up_loc in new_state.boxes:\\n new_state.boxes.remove(up_loc)\\n new_state.boxes.append(two_away)\\n\\n elif action == Action.RIGHT:\\n right_loc = (new_state.current_location[0], new_state.current_location[1] + 1)\\n two_away = (right_loc[0], right_loc[1] + 1)\\n new_state.current_location = right_loc\\n if right_loc in new_state.boxes:\\n new_state.boxes.remove(right_loc)\\n new_state.boxes.append(two_away)\\n\\n elif action == Action.LEFT:\\n left_loc = (new_state.current_location[0], new_state.current_location[1] - 1)\\n two_away = (left_loc[0], left_loc[1] - 1)\\n new_state.current_location = left_loc\\n if left_loc in new_state.boxes:\\n new_state.boxes.remove(left_loc)\\n new_state.boxes.append(two_away)\\n\\n new_state._validate() # TODO: Remove me for the final product.\\n return new_state\",\n \"def step(self, move):\",\n \"def move(self, action):\\n \\n currentState = self.state\\n\\n if action == \\\"up\\\":\\n newState = (self.state[0] - 1, self.state[1])\\n elif action == \\\"down\\\":\\n newState = (self.state[0] + 1, self.state[1])\\n elif action == \\\"right\\\":\\n newState = (self.state[0], self.state[1] + 1)\\n elif action == \\\"left\\\":\\n newState = (self.state[0], self.state[1] - 1)\\n else:\\n raise NameError(action, 'This is not a valid action!')\\n\\n # Need to check if the new state is a legal move\\n if (newState[0] >= 0) & (newState[0] <= 1) & (newState[1] >= 0) & (newState[1] <= 2):\\n return newState\\n else:\\n print('This move takes you off the board, you have not moved!')\\n return currentState\",\n \"def _move(self, dx, dy):\\n pass # must override in subclass\",\n \"def move(self, direction):\\n # replace with your code\\n pass\",\n \"def move(self, direction):\\n # replace with your code\\n pass\",\n \"def move(self, board):\\n\\n # We record all game positions to feed them into the NN for training with the corresponding updated Q\\n # values.\\n self.board_position_log.append(board.getState().copy())\\n\\n nn_input = self.board_state_to_nn_input(board.getState())\\n probs, _ = self.get_valid_probs([nn_input], self.q_net, [board])\\n probs = probs[0]\\n # print(probs)\\n # print(type(probs))\\n # print(probs.shape)\\n # input()\\n # print(probs)\\n # Most of the time our next move is the one with the highest probability after removing all illegal ones.\\n # Occasionally, however we randomly chose a random move to encourage exploration\\n if (self.training is True) and \\\\\\n ((self.game_counter < self.pre_training_games) or (np.random.rand(1) < self.random_move_prob)):\\n available = []\\n for index in range(6):\\n if probs[index] != -1.0:\\n available.append(index)\\n randomOne = random.randint(0,len(available)-1)\\n move = available[randomOne]\\n else:\\n move = np.argmax(probs)\\n # We record the action we selected as well as the Q values of the current state for later use when\\n # adjusting NN weights.\\n self.action_log.append(move)\\n\\n # We execute the move and return the result\\n board.makeMove(move)\\n return board.getState(), board.isOver()\",\n \"def _move(self, d, event):\\n\\n actor = None\\n if event.source in self._crates:\\n actor = self._crates[event.source]\\n else:\\n actor = self._clones[event.source][0]\\n\\n if d == Direction.NO_ACT or not event.success:\\n actor.animation = actor.do_nothing_animation()\\n return\\n pos = actor.pos\\n target = pos.dir_pos(d)\\n actor.direction = d\\n actor.animation = actor.walk_animation()\\n self.repaint()\",\n \"def _move(self, move: Tile):\\n if not self.game_state:\\n raise RuntimeError(\\\"Cannot call move when the game has not started!\\\")\\n # Adversaries are supposed to be notified of new info right before they move.\\n if issubclass(type(self.current_turn), Enemy):\\n current_enemy = next(enemy for enemy in self.enemy_list if enemy.entity.name == self.current_turn.entity.name)\\n self._notify_adversary(current_enemy)\\n # Players that are alive before this move\\n pre_players = self.game_state.get_current_characters()\\n completed_before_turn = self.game_state.get_completed_characters()\\n if move != None:\\n self._move_and_update(move)\\n else:\\n self.current_turn.notify(self._format_move_result_notification(None, Moveresult.OK))\\n # Notify players and adversaries of changes to the gamestate, including players who were killed\\n # on this turn. Note that this usually results in one rendering per move to all entities.\\n self._update_players()\\n self._update_adversaries()\\n self._handle_completed_characters(completed_before_turn)\\n self._handle_killed_players(pre_players)\\n self.current_turn = self.turn_order.next()\",\n \"def apply_move(self, move):\\r\\n next_board = copy.deepcopy(self.board)\\r\\n next_board.place(self.next_player, move)\\r\\n return GameState(next_board, self.next_player.other, move)\",\n \"def select_move(self, game_state):\\n raise NotImplementedError()\",\n \"def move(x,y):\\r\\n pass\",\n \"def movement(self):\",\n \"def move(): #py:move\\n RUR._move_()\",\n \"def move(self, direction):\\n pass\",\n \"def move(self, action):\\n \\n self.counter += 1\\n\\n if action not in self.ACTIONS:\\n raise Exception(\\\"Invalid action\\\")\\n\\n \\n\\n d_x, d_y = self.MOVEMENTS[action]\\n x, y = self.position\\n new_x, new_y = x + d_x, y + d_y\\n new_X,new_Y=self.position_to_xy(new_x, new_y)\\n \\n\\n if (new_x, new_y) not in self.cases:\\n return self._get_state(), -3, False, self.ACTIONS\\n \\n \\n \\n elif (self.openGoal(new_x,new_y))&(new_X>-400):\\n self.position = new_x, new_y\\n self.positionxy = self.position_to_xy(new_x, new_y)\\n \\n return self._get_state(), 20, True, self.ACTIONS\\n \\n # elif not self.openGoal(new_x,new_y):\\n # self.position = new_x, new_y\\n # self.positionxy = self.position_to_xy(new_x, new_y)\\n # return self._get_state(), -1, False, self.ACTIONS\\n \\n elif self.counter > 100:\\n self.position = new_x, new_y\\n self.positionxy = self.position_to_xy(new_x, new_y)\\n return self._get_state(), -1, True, self.ACTIONS\\n \\n else:\\n self.position = new_x, new_y\\n self.positionxy = self.position_to_xy(new_x, new_y)\\n return self._get_state(), -1, False, self.ACTIONS\",\n \"def move(self, state):\\n \\n self.depth_limit=1\\n self.best_utility=-2\\n action=None\\n while not self.is_time_up():\\n self.terminal=True\\n self.cache={}\\n action=self.alpha_beta_search(state,0)\\n if self.terminal==True:\\n break\\n self.depth_limit=self.depth_limit+1\\n \\n return action\",\n \"def _move(self):\\n self.pos += self.direction # add direction vector\\n self.direction += self.gravity # add gravity to direction\\n self.direction = self.direction.elementwise() * self.drag # apply drag to direction\",\n \"def move(self, direction):\\n try:\\n\\n if self.in_thing:\\n print(\\\"You have to get out of the \\\" + str(*self.in_thing[-1]) +\\n \\\" first\\\")\\n return self\\n if direction == 'north':\\n if self.finished_places == 12:\\n self.finished_places += 1\\n return North(self.items, self.finished_places)\\n if direction == 'up':\\n if self.finished_places == 4:\\n self.finished_places += 1\\n return Up(self.items, self.finished_places)\\n if direction == 'east':\\n if self.finished_places == 2:\\n self.finished_places += 1\\n return East(self.items, self.finished_places)\\n except AttributeError:\\n self.items = []\\n return self.move(direction)\\n print(' you didn\\\\'t listen to my very subtle hints, i know it was hard'\\n ' your lost now. if you remember the commands i told you you can'\\n ' go back to where you left off and continue, just type \\\"QUIT\\\"')\\n return Place(self.items, self.finished_places)\\n\\n # implement\\n # return new instance on class\",\n \"def move_agent(self, state):\\n m = self.m\\n n = self.n\\n\\n cur_env = deepcopy(state.grid)\\n cur_env[m, n] = 0\\n action = self.choose_action(state)\\n\\n if action == 'Right':\\n if n + 1 >= grid_size or cur_env[m][n+1] != 0:\\n Rew = -2 # Reward -5 if we move into wall or another agent\\n self.collisions += 1\\n else:\\n n += 1\\n Rew = -0.1 # Reward -1 otherwise\\n a = 0 # Action number\\n elif action == 'Left':\\n if n - 1 < 0 or cur_env[m][n-1] != 0:\\n Rew = -2\\n self.collisions += 1\\n else:\\n n -= 1\\n Rew = -0.1\\n a = 1\\n elif action == 'Up':\\n if m - 1 < 0 or cur_env[m-1][n] != 0:\\n Rew = -2\\n self.collisions += 1\\n else:\\n m -= 1\\n Rew = -0.1\\n a = 2\\n elif action == 'Down':\\n if m + 1 >= grid_size or cur_env[m+1][n] != 0:\\n Rew = -2\\n self.collisions += 1\\n else:\\n m += 1\\n Rew = -0.1\\n a = 3\\n\\n m = m % grid_size\\n n = n % grid_size\\n self.m = m # Update position of agent\\n self.n = n # Update position of agent\\n cur_env[m][n] = 1 # Update grid\\n new_state = State(cur_env, [m, n]) # Set new state\\n terminal = False\\n\\n if [m, n] == self.end:\\n Rew = 10\\n terminal = True\\n self.carry = True\\n\\n return new_state, a, Rew, terminal\",\n \"def move(self, board):\\n raise NotImplementedError\",\n \"def result(self, state, move):\\n new_state = state[:]\\n new_state[move[0]], new_state[move[1]] = new_state[move[1]], new_state[move[0]]\\n return new_state\",\n \"def __move__(self):\\n v = self.velocity\\n p = self.position\\n p += v\\n self.rect.x = round(p.x)\\n self.rect.y = round(p.y)\",\n \"def move(self, *args, **kw):\\n return self.execute_action('move', *args, **kw)\",\n \"def move(self) -> bool:\\n pass\",\n \"def change_move_state(self, new_state):\\n\\n if new_state != self.move_state:\\n print(\\\"Changing move state from \\\", states[self.move_state],\\n \\\" to \\\", states[new_state])\\n self.move_state = new_state\\n print(\\\"move_state is now\\\", self.move_state)\",\n \"def apply_move(self, move, state):\\n x, y , heading, grid_data = state\\n map_data = [row[:] for row in grid_data]\\n if move == self.MOVE_FORWARD:\\n # get coordinates for next cell\\n if heading == self.UP:\\n next_y = y - 1\\n next_x = x\\n elif heading == self.DOWN:\\n next_y = y + 1\\n next_x = x\\n elif heading == self.LEFT:\\n next_y = y\\n next_x = x - 1\\n else:\\n next_y = y\\n next_x = x + 1\\n\\n # handle special tile types\\n if map_data[next_y][next_x] == self.ICE_SYMBOL:\\n # handle ice tile - slide until first non-ice tile or blocked\\n if heading == self.UP:\\n for i in range(next_y, -1, -1):\\n if map_data[i][next_x] != self.ICE_SYMBOL:\\n if map_data[i][next_x] == self.WATER_SYMBOL:\\n # slide into water - game over\\n return self.GAME_OVER\\n elif self.cell_is_blocked(i, next_x, map_data):\\n # if blocked, stop on last ice cell\\n next_y = i + 1\\n break\\n else:\\n next_y = i\\n break\\n elif heading == self.DOWN:\\n for i in range(next_y, self.y_size):\\n if map_data[i][next_x] != self.ICE_SYMBOL:\\n if map_data[i][next_x] == self.WATER_SYMBOL:\\n # slide into water - game over\\n return self.GAME_OVER\\n elif self.cell_is_blocked(i, next_x, map_data):\\n # if blocked, stop on last ice cell\\n next_y = i - 1\\n break\\n else:\\n next_y = i\\n break\\n elif heading == self.LEFT:\\n for i in range(next_x, -1, -1):\\n if map_data[next_y][i] != self.ICE_SYMBOL:\\n if map_data[next_y][i] == self.WATER_SYMBOL:\\n # slide into water - game over\\n return self.GAME_OVER\\n elif self.cell_is_blocked(next_y, i, map_data):\\n # if blocked, stop on last ice cell\\n next_x = i + 1\\n break\\n else:\\n next_x = i\\n break\\n else:\\n for i in range(next_x, self.x_size):\\n if map_data[next_y][i] != self.ICE_SYMBOL:\\n if map_data[next_y][i] == self.WATER_SYMBOL:\\n # slide into water - game over\\n return self.GAME_OVER\\n elif self.cell_is_blocked(next_y, i, map_data):\\n # if blocked, stop on last ice cell\\n next_x = i - 1\\n break\\n else:\\n next_x = i\\n break\\n if map_data[next_y][next_x] == self.TELEPORT_SYMBOL:\\n # handle teleport - find the other teleporter\\n tpy, tpx = (None, None)\\n for i in range(self.y_size):\\n for j in range(self.x_size):\\n if map_data[i][j] == self.TELEPORT_SYMBOL and (i != next_y or j != next_x):\\n tpy, tpx = (i, j)\\n break\\n if tpy is not None:\\n break\\n if tpy is None:\\n raise Exception(\\\"LaserTank Map Error: Unmatched teleport symbol\\\")\\n next_y, next_x = (tpy, tpx)\\n else:\\n # if not ice or teleport, perform collision check\\n if self.cell_is_blocked(next_y, next_x, map_data):\\n return self.COLLISION\\n\\n # check for game over conditions\\n if self.cell_is_game_over(next_y, next_x, map_data):\\n return self.GAME_OVER\\n\\n # no collision and no game over - update player position\\n y = next_y\\n x = next_x\\n return (x, y, heading, map_data)\\n\\n elif move == self.TURN_LEFT:\\n # no collision or game over possible\\n if heading == self.UP:\\n heading = self.LEFT\\n elif heading == self.DOWN:\\n heading = self.RIGHT\\n elif heading == self.LEFT:\\n heading = self.DOWN\\n else:\\n heading = self.UP\\n return (x, y, heading, map_data)\\n\\n elif move == self.TURN_RIGHT:\\n # no collision or game over possible\\n if heading == self.UP:\\n heading = self.RIGHT\\n elif heading == self.DOWN:\\n heading = self.LEFT\\n elif heading == self.LEFT:\\n heading = self.UP\\n else:\\n heading = self.DOWN\\n return (x, y, heading, map_data)\\n\\n elif move == self.SHOOT_LASER:\\n # set laser direction\\n if heading == self.UP:\\n laserheading = self.UP\\n dy, dx = (-1, 0)\\n elif heading == self.DOWN:\\n laserheading = self.DOWN\\n dy, dx = (1, 0)\\n elif heading == self.LEFT:\\n laserheading = self.LEFT\\n dy, dx = (0, -1)\\n else:\\n laserheading = self.RIGHT\\n dy, dx = (0, 1)\\n\\n # loop until laser blocking object reached\\n ly, lx = (y, x)\\n while True:\\n ly += dy\\n lx += dx\\n\\n # handle boundary and immovable obstacles\\n if ly < 0 or ly >= self.y_size or \\\\\\n lx < 0 or lx >= self.x_size or \\\\\\n map_data[ly][lx] == self.OBSTACLE_SYMBOL:\\n # laser stopped without effect\\n return self.COLLISION\\n\\n # handle movable objects\\n elif self.cell_is_laser_movable(ly, lx, laserheading, map_data):\\n # check if tile can be moved without collision\\n if self.cell_is_blocked(ly + dy, lx + dx, map_data) or \\\\\\n map_data[ly + dy][lx + dx] == self.ICE_SYMBOL or \\\\\\n map_data[ly + dy][lx + dx] == self.TELEPORT_SYMBOL or \\\\\\n map_data[ly + dy][lx + dx] == self.FLAG_SYMBOL or \\\\\\n (ly + dy == y and lx + dx == x):\\n # tile cannot be moved\\n return self.COLLISION\\n else:\\n old_symbol = map_data[ly][lx]\\n map_data[ly][lx] = self.LAND_SYMBOL\\n if map_data[ly + dy][lx + dx] == self.WATER_SYMBOL:\\n # if new bridge position is water, convert to land tile\\n if old_symbol == self.BRIDGE_SYMBOL:\\n map_data[ly + dy][lx + dx] = self.LAND_SYMBOL\\n # otherwise, do not replace the old symbol\\n else:\\n # otherwise, move the tile forward\\n map_data[ly + dy][lx + dx] = old_symbol\\n break\\n\\n # handle bricks\\n elif map_data[ly][lx] == self.BRICK_SYMBOL:\\n # remove brick, replace with land\\n map_data[ly][lx] = self.LAND_SYMBOL\\n break\\n\\n # handle facing anti-tanks\\n elif (map_data[ly][lx] == self.ANTI_TANK_UP_SYMBOL and laserheading == self.DOWN) or \\\\\\n (map_data[ly][lx] == self.ANTI_TANK_DOWN_SYMBOL and laserheading == self.UP) or \\\\\\n (map_data[ly][lx] == self.ANTI_TANK_LEFT_SYMBOL and laserheading == self.RIGHT) or \\\\\\n (map_data[ly][lx] == self.ANTI_TANK_RIGHT_SYMBOL and laserheading == self.LEFT):\\n # mark anti-tank as destroyed\\n map_data[ly][lx] = self.ANTI_TANK_DESTROYED_SYMBOL\\n break\\n\\n # handle player laser collision\\n elif ly == y and lx == x:\\n return self.GAME_OVER\\n\\n # handle facing mirrors\\n elif (map_data[ly][lx] == self.MIRROR_UL_SYMBOL and laserheading == self.RIGHT) or \\\\\\n (map_data[ly][lx] == self.MIRROR_UR_SYMBOL and laserheading == self.LEFT):\\n # new direction is up\\n dy, dx = (-1, 0)\\n laserheading = self.UP\\n elif (map_data[ly][lx] == self.MIRROR_DL_SYMBOL and laserheading == self.RIGHT) or \\\\\\n (self.grid_data[ly][lx] == self.MIRROR_DR_SYMBOL and laserheading == self.LEFT):\\n # new direction is down\\n dy, dx = (1, 0)\\n laserheading = self.DOWN\\n elif (map_data[ly][lx] == self.MIRROR_UL_SYMBOL and laserheading == self.DOWN) or \\\\\\n (map_data[ly][lx] == self.MIRROR_DL_SYMBOL and laserheading == self.UP):\\n # new direction is left\\n dy, dx = (0, -1)\\n laserheading = self.LEFT\\n elif (map_data[ly][lx] == self.MIRROR_UR_SYMBOL and laserheading == self.DOWN) or \\\\\\n (map_data[ly][lx] == self.MIRROR_DR_SYMBOL and laserheading == self.UP):\\n # new direction is right\\n dy, dx = (0, 1)\\n laserheading = self.RIGHT\\n # do not terminate laser on facing mirror - keep looping\\n\\n # check for game over condition after effect of laser\\n if self.cell_is_game_over(y, x, map_data):\\n return self.GAME_OVER\\n return (x, y, heading, map_data)\\n return self.SUCCESS\",\n \"def move(self):\\n c = self.get_position()\\n\\n f = c['f']\\n if f == 'NORTH':\\n c['y'] += 1\\n elif f == 'EAST':\\n c['x'] += 1\\n elif f == 'SOUTH':\\n c['y'] -= 1\\n elif f == 'WEST':\\n c['x'] -= 1\\n\\n if self.valid_position(c):\\n self.update_position(c)\\n else:\\n raise ValueError('InvalidPosition')\",\n \"def make_move(self, move: Any) -> 'StonehengeState':\\n if type(move) == str:\\n new_state = StonehengeState(not self.p1_turn, self.side_length)\\n # copy the board information from current state\\n # make copy of current state information\\n hori_lst_copy = []\\n for lst in self.hori_lst:\\n temp = []\\n for item in lst:\\n temp.append(item)\\n hori_lst_copy.append(temp)\\n left_lst_copy = []\\n for lst in self.left_lst:\\n temp = []\\n for item in lst:\\n temp.append(item)\\n left_lst_copy.append(temp)\\n right_lst_copy = []\\n for lst in self.right_lst:\\n temp = []\\n for item in lst:\\n temp.append(item)\\n right_lst_copy.append(temp)\\n\\n hori_result_copy = []\\n for item in self.hori_result:\\n hori_result_copy.append(item)\\n left_result_copy = []\\n for item in self.left_result:\\n left_result_copy.append(item)\\n right_result_copy = []\\n for item in self.right_result:\\n right_result_copy.append(item)\\n\\n new_state.hori_lst = hori_lst_copy\\n new_state.hori_result = hori_result_copy\\n new_state.left_lst = left_lst_copy\\n new_state.left_result = left_result_copy\\n new_state.right_lst = right_lst_copy\\n new_state.right_result = right_result_copy\\n # update the new state with str move\\n # parallel nested list data structure\\n lst = [new_state.hori_lst, new_state.left_lst, new_state.right_lst]\\n result = [new_state.hori_result, new_state.left_result, new_state.right_result]\\n # update the cell\\n for i in range(len(lst)):\\n for j in range(len(lst[i])):\\n for k in range(len(lst[i][j])):\\n if lst[i][j][k] == move:\\n # should use the player name of last state, so opposite names\\n if new_state.p1_turn:\\n lst[i][j][k] = \\\"2\\\"\\n else:\\n lst[i][j][k] = \\\"1\\\"\\n # update ley-line marks\\n # the ley-line may belong to a player after this move\\n p1_taken = 0\\n p2_taken = 0\\n if result[i][j] != \\\"@\\\":\\n continue\\n for item in lst[i][j]:\\n if item == \\\"1\\\":\\n p1_taken += 1\\n if item == \\\"2\\\":\\n p2_taken += 1\\n if float(p1_taken) >= len(lst[i][j]) / 2:\\n result[i][j] = \\\"1\\\"\\n if float(p2_taken) >= len(lst[i][j]) / 2:\\n result[i][j] = \\\"2\\\"\\n ###### CHECK FOR SHALLOW COPY PROBLEM, IF ATTRIBUTE IS UPDATE IN NEW STATE\\n return new_state\",\n \"def _move_randomly(self):\\n a, b = randint(0, len(self.state) - 1), randint(0, len(self.state) - 1)\\n wiz1, wiz2 = self.state[a], self.state[b]\\n self._swap_wizards(wiz1, wiz2)\",\n \"def make_move(self, state):\\n emptySpaces = 0\\n for row in state:\\n emptySpaces = emptySpaces + row.count(' ')\\n if emptySpaces > 17:\\n drop_phase = True\\n else:\\n drop_phase = False\\n\\n move = []\\n if not drop_phase:\\n best_value = float('-inf')\\n best_state = None\\n for s in self.succ(state, False, self.my_piece):\\n if self.game_value(s) == -1 or self.game_value(s) == 1:\\n best_state = s\\n break\\n currValue = self.Min_Value(state, 0)\\n if currValue>best_value:\\n best_value = currValue\\n best_state = s\\n for i in range(len(state)):\\n for j in range(len(state[i])):\\n if state[i][j]!= ' ' and best_state[i][j]== ' ':\\n move.append((i,j))\\n if state[i][j]== ' ' and best_state[i][j]!= ' ':\\n move.insert(0, (i,j))\\n \\n # TODO: choose a piece to move and remove it from the board\\n # (You may move this condition anywhere, just be sure to handle it)\\n #\\n # Until this part is implemented and the move list is updated\\n # accordingly, the AI will not follow the rules after the drop phase!\\n \\n\\n # select an unoccupied space randomly\\n # TODO: implement a minimax algorithm to play better\\n \\n else:\\n best_value = float('-inf')\\n best_state = None\\n for s in self.succ(state, True, self.my_piece):\\n if self.game_value(s) == -1 or self.game_value(s) == 1:\\n best_state = s\\n break\\n currValue = self.Min_Value(state, 0)\\n if currValue>best_value:\\n best_value = currValue\\n best_state = s\\n for i in range(len(state)):\\n for j in range(len(state[i])):\\n if state[i][j]== ' ' and best_state[i][j]!= ' ':\\n move.insert(0, (i,j))\\n \\n return move\",\n \"def move(self, board, move_dir):\\n if move_dir == \\\"right\\\":\\n # failsafe: do not move through other cars on board\\n if board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 1)].isupper() or board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 1)] == 'r':\\n print(\\\"No movement!\\\")\\n return board\\n \\n # give board correct new positions (characters)\\n else:\\n board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 1)] = self.name[0]\\n board.positions[self.get_rows()[0]][self.get_cols()[0]] = \\\"x\\\"\\n\\n # change car objects positions\\n for i, col in enumerate(self.position):\\n self.position[i] = str(self.get_rows()[0]) + \\\".\\\" + str(int(col[2]) + 1)\\n return board\\n elif move_dir == \\\"left\\\": \\n if board.positions[self.get_rows()[0]][self.get_cols()[0] - 1].isupper() or board.positions[self.get_rows()[0]][self.get_cols()[0] - 1] == 'r':\\n print(\\\"No movement!\\\")\\n return board\\n else: \\n board.positions[self.get_rows()[0]][self.get_cols()[0] - 1] = self.name[0]\\n board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 2)] = \\\"x\\\"\\n\\n for i, col in enumerate(self.position):\\n self.position[i] = str(self.get_rows()[0]) + \\\".\\\" + str(int(col[2]) - 1)\\n return board\\n elif move_dir == \\\"up\\\":\\n #print(board.positions[self.get_rows()[0] - 1][self.get_cols()[0]])\\n if board.positions[self.get_rows()[0] - 1][self.get_cols()[0]].isupper() or board.positions[self.get_rows()[0] - 1][self.get_cols()[0]] == 'r':\\n print(\\\"No movement!\\\")\\n return board\\n else:\\n board.positions[self.get_rows()[0] - 1][self.get_cols()[0]] = self.name[0]\\n board.positions[self.get_rows()[1] + (self.size - 2)][self.get_cols()[0]] = \\\"x\\\"\\n\\n for i, row in enumerate(self.position):\\n self.position[i] = str(int(row[0]) - 1) + \\\".\\\" + str(self.get_cols()[0])\\n\\n #print(board)\\n return board\\n elif move_dir == \\\"down\\\": \\n try: \\n if board.positions[self.get_rows()[1] + (self.size - 1)][self.get_cols()[0]].isupper() or board.positions[self.get_rows()[1] + (self.size - 1)][self.get_cols()[0]] == 'r':\\n print(\\\"No movement!\\\")\\n return board\\n except IndexError:\\n return board\\n else: \\n board.positions[self.get_rows()[0]][self.get_cols()[0]] = \\\"x\\\" \\n board.positions[self.get_rows()[1] + (self.size - 1)][self.get_cols()[0]] = self.name[0]\\n\\n for i, row in enumerate(self.position):\\n self.position[i] = str(int(row[0]) + 1) + \\\".\\\" + str(self.get_cols()[0]) \\n \\n #print(self.position)\\n #print(board)\\n \\n return board\\n else:\\n #print(\\\"NO MOVEMENT!\\\")\\n return board\",\n \"def move(self, direction):\\n\\n if direction == \\\"north\\\":\\n self.go_and_update(-1, 0)\\n\\n elif direction == \\\"south\\\":\\n self.go_and_update(1, 0)\\n\\n elif direction == \\\"east\\\":\\n self.go_and_update(0, 1)\\n\\n elif direction == \\\"west\\\":\\n self.go_and_update(0, -1)\",\n \"def choose_move(self):\\n raise NotImplementedError()\",\n \"def play_move(self,state):\\n self.__engine.set_state(state)\\n result = self.__engine.getNextState()\\n time_elapsed = self.__engine.get_time_elapsed()\\n num_nodes = self.__engine.get_num_explored()\\n if self.moves == 0:\\n self.average_time = time_elapsed\\n self.average_nodes = num_nodes\\n else:\\n self.average_time = ( (self.average_time * self.moves) + time_elapsed ) / (self.moves+1)\\n self.average_nodes = ( (self.average_nodes * self.moves) + num_nodes ) / (self.moves+1)\\n self.moves += 1\\n return result\",\n \"def execute_move(self, game_state):\\n game_state.pacs_pos[self.pac_id] = self.next_move\",\n \"def move(self, agent, action):\\n\\t\\tpass\",\n \"def move(self, state_prev, state, reward, selected):\\n\\n if state:\\n if self.team_id == 1: # Set correct teams based on team id\\n self_team = state['team1']\\n other_team = state['team2']\\n else:\\n self_team = state['team2']\\n other_team = state['team1']\\n\\n if state:\\n if self.id == 0: # Special for the goal-keeper\\n ai_gk_pass = self.gk_pass(\\n other_team['players'], self_team['goal_x'])\\n ai_gk_move = self.gk_move(self_team['goal_x'], state['ball'])\\n # GK has the ball\\n if selected == self.id and state['ball'].ball_stats['player'] == self.id:\\n if ai_gk_pass != 'NOTHING':\\n return ai_gk_pass\\n else:\\n return ai_gk_move\\n else:\\n return ai_gk_move\\n\\n # Selected player has the ball\\n if selected == self.id and state['ball'].ball_stats['player'] == self.id:\\n ai_shoot = self.ai_shoot(\\n other_team['players'][0], other_team['goal_x'])\\n ai_pass = self.ai_pass(\\n self_team['players'], other_team['players'])\\n # If shot is possible, take it\\n if self.pos.dist(P(other_team['goal_x'], H//2)) <= AI_SHOOT_RADIUS and ai_shoot != 'NOTHING':\\n return ai_shoot\\n # Else, pass if possible (passes towards the enemy goal are prioritized)\\n elif ai_pass != 'NOTHING' and random.random() >= AI_PASS_PROB:\\n return ai_pass\\n else:\\n # Move towards the goal\\n return self.ai_move_with_ball(other_team['players'], other_team['goal_x'])\\n\\n else: # Move towards the ball if posssbile, otherwise return to formation\\n move = self.ai_move_without_ball(state['ball'])\\n if move != 'NOTHING':\\n return move\\n else:\\n return 'FORM' # Special action, not defined in ACT\\n else:\\n return 'NOTHING' # Otherwise do nothing\",\n \"def move(self):\\n \\n self.position = self.explore()\",\n \"def move(self, direction, cycles):\\n\\t\\tpass\",\n \"def move(self,p,intMove):\\n gs = self.gameState.copy() #copy Board\\n gs[p.pos.get()] = EMPTY #put position it was at as empty\\n gs[self.movePos(p,intMove).get()] = p.color #set new position as filled\\n return ((p,intMove),Board(gs,self.togglePlayer(self.whoseTurn)))\",\n \"def make_move(self, move: Any) -> \\\"StonehengeState\\\":\\n new_state = StonehengeState(self.p1_turn, self.length,\\n self.letters[:], self.claim[:])\\n state = new_state\\n if new_state.length == 1:\\n state = self.move_length_1(move, new_state)\\n if new_state.length == 2:\\n state = self.move_length_2(move, new_state)\\n if new_state.length == 3:\\n state = self.move_length_3(move, new_state)\\n if new_state.length == 4:\\n if move in [\\\"A\\\", \\\"B\\\", \\\"J\\\", \\\"O\\\", \\\"N\\\", \\\"R\\\",\\n \\\"C\\\", \\\"F\\\", \\\"E\\\", \\\"I\\\", \\\"P\\\", \\\"Q\\\"]:\\n state = self.move_length_4(move, new_state)\\n else:\\n state = self.move_length_41(move, new_state)\\n if new_state.length == 5:\\n if move in [\\\"A\\\", \\\"B\\\", \\\"U\\\", \\\"O\\\", \\\"T\\\", \\\"Y\\\",\\n \\\"C\\\", \\\"J\\\", \\\"E\\\", \\\"N\\\", \\\"V\\\", \\\"X\\\"]:\\n state = self.move_length_5(move, new_state)\\n elif move in [\\\"F\\\", \\\"I\\\", \\\"W\\\"]:\\n state = self.move_length_51(move, new_state)\\n else:\\n state = self.move_length_52(move, new_state)\\n return state\",\n \"def _next_state(self, state, action):\\n\\n # Transition table to define movement for each action\\n if self.action_type == 'VonNeumann':\\n transitions = {0: [-1, 0], 1: [+1, 0], 2: [0, -1], 3: [0, +1]}\\n elif self.action_type == 'Moore':\\n transitions = {0: [-1, 0], 1: [+1, 0], 2: [0, -1], 3: [0, +1],\\n 4: [-1, +1], 5: [+1, +1], 6: [-1, -1], 7: [+1, -1]}\\n\\n new_state = [state[0] + transitions[action][0], state[1] + transitions[action][1]]\\n if self.maze[new_state[0]][new_state[1]] == 1: # Hit wall, stay there\\n return state\\n else: # Valid move for 0, 2, 3, 4\\n return new_state\",\n \"def move(self, x, y):\\n self.x = x\\n self.y = y\\n self.call('move', x, y)\",\n \"def makeMove(self, move, player):\",\n \"def execute_move(self, game_state):\\n # Set new location based on which ghost this is\\n game_state.ghosts_pos[self.ghost_id] = self.next_move\",\n \"def execute_move(self, game_state):\\n # Set new location based on which ghost this is\\n game_state.ghosts_pos[self.ghost_id] = self.next_move\",\n \"def act(state: Tree) -> None:\\n cur_state = state.value\\n state.children = [Tree(cur_state.make_move(m)) for m in\\n cur_state.get_possible_moves()]\",\n \"def decide_next_move(self):\\n pass\",\n \"def process_IN_MOVE_SELF(self, event):\",\n \"def _move(self, direction, difference):\\n future_tile_number = self.get_number() + difference\\n if future_tile_number in range(1, Tile.total_tiles + 1):\\n future_tile = Tile.get_tile(future_tile_number)\\n if future_tile.walkable:\\n self.set_target(future_tile)\\n self.rotate(direction)\",\n \"def _onmove(self, event):\",\n \"def virtual_move_to(self,path):\\n #print path\\n temp_state=self.state\\n temp_data=self.data\\n temp_current_node=self.current_node\\n temp_node_names=self.node_names\\n for index,edge in enumerate(path):\\n #print edge\\n edge_pattern='edge_(?P<begin_node>\\\\w+)_(?P<end_node>\\\\w+)_(?P<iterator>\\\\w+)'\\n match=re.match(edge_pattern,edge)\\n begin_node=match.groupdict()['begin_node']\\n end_node=match.groupdict()['end_node']\\n #print(\\\"moving {0} -> {1}\\\".format(begin_node,end_node))\\n #print self.data\\n temp_data=self.__dict__[edge](temp_data)\\n #print self.data\\n temp_current_node=match.groupdict()['end_node']\\n temp_state=[0 for i in range(len(temp_node_names))]\\n position=temp_node_names.index(temp_current_node)\\n temp_state[position]=1\\n #print temp_state\\n #print self.state\\n #print self.current_node\",\n \"def get_move(self, game_state: BotGameState) -> BotMove:\\n return\",\n \"def update(self):\\n if not self._move:\\n self.get_next_move()\\n if self._move:\\n self._move.update()\",\n \"def move(self, board):\\n # first, make your turn:\\n currentState = board[self.x,self.y]\\n turnDir = self.rule[(currentState + 1) % len(self.rule)]\\n self.turn( int(turnDir) )\\n # next, let's change this cell's state:\\n if currentState >= len(self.rule) - 1:\\n board[self.x,self.y] = 0\\n else:\\n board[self.x,self.y] = currentState + 1\\n # and let's move:\\n offsets = self.nextPositionOffset() # based on x, y, and dir\\n self.x, self.y = board.move(self.x, self.y, offsets[0], offsets[1])\",\n \"def result(self, board_state, move):\\n # Create a copy of the current board state\\n output_state = BoardState(other_state=board_state)\\n # Swap pieces\\n output_state.move_piece(move)\\n # Eliminate pieces\\n output_state.eliminate_piece()\\n return output_state\",\n \"def make_move(state, action, player, rewarding_move=False): # TODO : done and next_is_reward can be removed as\\n # they are in the state object\\n board = state.get_board()\\n json_action = action.get_json_action()\\n action = action.get_action_as_dict()\\n captured = None\\n reward = 0\\n next_is_reward = False\\n previous_is_reward = False\\n if rewarding_move:\\n state.boring_moves = 0\\n previous_is_reward = True\\n if action['action_type'] == YoteActionType.STEAL_FROM_HAND:\\n reward += 1\\n state.in_hand[player * -1] -= 1\\n elif action['action_type'] == YoteActionType.STEAL_FROM_BOARD:\\n board.empty_cell(action['action']['at'])\\n reward += 1\\n else:\\n if action['action_type'] == YoteActionType.ADD:\\n state.boring_moves += 1\\n state.in_hand[player] -= 1\\n board.fill_cell(action['action']['to'], Color(player))\\n elif action['action_type'] == YoteActionType.MOVE:\\n at = action['action']['at']\\n to = action['action']['to']\\n\\n def distance(cell_1, cell_2):\\n import math\\n return math.sqrt((cell_1[0] - cell_2[0]) ** 2 + (cell_1[1] - cell_2[1]) ** 2)\\n\\n board.empty_cell(at)\\n board.fill_cell(to, Color(player))\\n if int(distance(at, to)) == 1:\\n state.boring_moves += 1\\n elif int(distance(at, to)) > 1:\\n state.boring_moves = 0\\n next_is_reward = True\\n board.fill_cell(to, Color(player))\\n if at[0] == to[0] and at[1] < to[1]:\\n board.empty_cell((at[0], at[1] + 1))\\n captured = (at[0], at[1] + 1)\\n elif at[0] == to[0] and at[1] > to[1]:\\n board.empty_cell((at[0], at[1] - 1))\\n captured = (at[0], at[1] - 1)\\n elif at[1] == to[1] and at[0] < to[0]:\\n board.empty_cell((at[0] + 1, at[1]))\\n captured = (at[0] + 1, at[1])\\n elif at[1] == to[1] and at[0] > to[0]:\\n board.empty_cell((at[0] - 1, at[1]))\\n captured = (at[0] - 1, at[1])\\n reward += 1\\n\\n state.set_board(board)\\n state.score[player] += reward\\n state.captured = captured\\n state.rewarding_move = next_is_reward\\n state.previous_is_reward = previous_is_reward\\n state.set_latest_player(player)\\n state.set_latest_move(json_action)\\n if next_is_reward:\\n state.set_next_player(player)\\n else:\\n state.set_next_player(player * -1)\\n\\n done = YoteRules.is_end_game(state)\\n return state, done, next_is_reward\",\n \"def move(self) -> None:\\n\\n new_x = self.getX() + self.speed[0]\\n new_y = self.getY() + self.speed[1]\\n self.setX(new_x)\\n self.setY(new_y)\",\n \"def move(self,dt):\\n raise NotImplementedError(\\\"Robot.move\\\")\",\n \"def move_forward():\\n pass\",\n \"def move(self):\\n \\n self.position = self.wander()\",\n \"def move(self):\\n a = random.randint(0, len(self.state) - 1)\\n b = random.randint(0, len(self.state) - 1)\\n self.state[a], self.state[b] = self.state[b], self.state[a]\\n\\n # change type of restoration for one state\\n c = random.choice(self.restoration_types)\\n self.state[a] = (self.state[a][0], c)\",\n \"def move(self):\\r\\n if self.last_op_move is None:\\r\\n return rockyman.move(self)\\r\\n else:\\r\\n return self.last_op_move\",\n \"def _ispinnedmove(self, from_, to_):\\n return False\",\n \"def handle_state(self):\\r\\n if self.state == 'walk':\\r\\n self.walking()\\r\\n elif self.state == 'fall':\\r\\n self.falling()\\r\\n elif self.state == 'jumped on':\\r\\n self.jumped_on()\\r\\n elif self.state == 'shell slide':\\r\\n self.shell_sliding()\\r\\n elif self.state == 'death jump':\\r\\n self.death_jumping()\",\n \"def make_move(self, current_state):\\n\\n\\t\\tbatch_size = 192\\n\\n\\t\\ttest_board = np.zeros((batch_size, 3, 3, 3))\\n\\t\\ttest_cows = np.zeros((batch_size, 2))\\n\\t\\ttest_labels = np.zeros((batch_size, 1)) \\n\\n\\t\\tnew_states = current_state.expand_states()\\n\\n\\t\\tif len(new_states) == 0:\\n\\t\\t\\treturn None\\n\\n\\t\\tfor i, state in enumerate(new_states):\\n\\n\\t\\t\\tdesc = self.state_descriptor(state, self.player_index)\\n\\t\\t\\ttest_board[i] = np.asarray(desc[0])\\n\\t\\t\\ttest_cows[i] = np.asarray([desc[1], desc[2]])\\n\\n\\t\\treturn new_states[self.train_value_function_approximation(\\n\\t\\t\\tTrue, (test_board, test_cows, test_labels), len(new_states))]\",\n \"def move(self,x,y):\\n self.pos.x = x\\n self.pos.y = y\",\n \"def move(self, coordinates, direction):\\n pass\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n # Mark this move as explored\\n self.visited[self.currentState] = True\\n self.visited_states.append(self.currentState.state)\\n\\n # Get move to make\\n movables = self.gm.getMovables()\\n # print(\\\"EXPLORING GAME STATE \\\" + str(self.gm.getGameState()) + \\\"---------------------------------------------------------\\\")\\n to_move = self.currentState.nextChildToVisit # movables index\\n # print(\\\"depth \\\", self.currentState.depth)\\n\\n # Return if done\\n if self.currentState.state == self.victoryCondition:\\n # print(\\\"DONE\\\")\\n return True\\n\\n # If current state has no children, make children\\n if not self.currentState.children:\\n for movable_statement in movables:\\n # Make the move\\n # print(\\\"implementing move \\\", movable_statement)\\n self.gm.makeMove(movable_statement)\\n\\n # Create a new state with this move made\\n new_state = self.gm.getGameState()\\n # print (\\\"new state \\\", new_state)\\n\\n # If the new state hasn't been visited and isn't in the queue then add it as a child and to the queue\\n if (new_state not in self.visited_states):\\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\\n new_gs.parent = self.currentState\\n self.currentState.children.append(new_gs)\\n self.currentState.nextChildToVisit = to_move + 1\\n self.visited[new_gs] = True\\n self.visited_states.append(new_state)\\n self.gs_queue.append(new_gs)\\n\\n self.gm.reverseMove(movable_statement)\\n\\n # Return false if no more to explore\\n if not self.gs_queue:\\n return False\\n\\n # Revert to state at when current and next start to change\\n root_curr = self.currentState\\n self.currentState = self.gs_queue.popleft()\\n root_new = self.currentState\\n\\n # Backtrack to when current node and new node start to diverge\\n if root_new.depth == root_curr.depth:\\n while root_curr.state != root_new.state:\\n self.gm.reverseMove(root_curr.requiredMovable)\\n root_curr = root_curr.parent\\n root_new = root_new.parent\\n else:\\n while root_curr.requiredMovable:\\n self.gm.reverseMove(root_curr.requiredMovable)\\n root_curr = root_curr.parent\\n\\n # Return game master to state that we are exploring\\n # Find path between root and current state\\n path = []\\n currNode = self.currentState\\n while currNode != root_curr:\\n path.append(currNode.requiredMovable)\\n currNode = currNode.parent\\n\\n # Created backwards path, now make moves from root to current state\\n path.reverse()\\n for movable_statement in path:\\n self.gm.makeMove(movable_statement)\\n\\n return False\",\n \"def apply_move(self, start_move, move):\\n\\t\\t# check that the start move and the move are Move objects\\n\\t\\tif not isinstance(move, Move):\\n\\t\\t\\tmove = Move(move)\\n\\t\\tif not isinstance(start_move, Move):\\n\\t\\t\\tstart_move = Move(start_move)\\n\\t\\t# copy the board\\n\\t\\tnext_board = copy.deepcopy(self.board)\\n\\t\\t# place the move on the next board\\n\\t\\tnext_board.place(self.next_player, start_move.point, move.point)\\n\\t\\treturn GameState(next_board, self.next_player.other, move)\",\n \"def move(self):\\n # This block is used to move into the living room.\\n if self.room_name == \\\"living\\\" or self.room_name == \\\"Living\\\":\\n self.living_room()\\n # This block is used to open the door.\\n elif self.room_name == \\\"Door\\\" or self.room_name == \\\"door\\\":\\n self.door()\\n # This block is used to move into the kitchen.\\n elif self.room_name == \\\"Kitchen\\\" or self.room_name == \\\"kitchen\\\":\\n self.kitchen()\\n # This block is used to move into the hallway.\\n elif self.room_name == \\\"Hallway\\\" or self.room_name == \\\"hallway\\\":\\n self.hallway()\\n # This block is used to move into the bathroom.\\n elif self.room_name == \\\"Bathroom\\\" or self.room_name == \\\"bathroom\\\":\\n self.bathroom()\\n # This block is used to move into the basement.\\n elif self.room_name == \\\"Basement\\\" or self.room_name == \\\"basement\\\":\\n self.basement()\\n # This block is used to move into the bedroom.\\n elif self.room_name == \\\"Bedroom\\\" or self.room_name == \\\"bedroom\\\":\\n self.bedroom()\\n # This block is used to move into the attic.\\n elif self.room_name == \\\"Attic\\\" or \\\"attic\\\":\\n self.attic()\",\n \"def move(self, x, y):\\n\\n #log.info(\\\"MOVE x:%s y:%s\\\", x, y)\",\n \"def step(self, state):\",\n \"def update_to_state(self, game_state):\\n pass\",\n \"def move_toward(state, location):\\n return move_relative(state, location, True)\",\n \"def move(self):\\n self.position += self.speed\",\n \"def decide_move(self, action):\\n x1, y1 = action['xy1']\\n x2, y2 = action['xy2']\\n self.__state.push(action)\",\n \"def update_pos(self, move):\\n change = Maze.moves[move]\\n self.current_pos[0] += change[0]\\n self.current_pos[1] += change[1]\",\n \"def move(self, *step):\\n self.x += step[0]\\n self.y += step[1]\",\n \"def successor(self, state):\\n pass # abstract\",\n \"def request_move(self, board):\\n pass\",\n \"def move(self, p):\\r\\n self.position.setvalue(p)\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n # Mark this move as explored\\n self.visited[self.currentState] = True\\n\\n # Get move to make\\n movables = self.gm.getMovables()\\n # print(\\\"EXPLORING GAME STATE \\\" + str(self.gm.getGameState()) + \\\"---------------------------------------------------------\\\")\\n to_move = self.currentState.nextChildToVisit # movables index\\n # print(\\\"depth \\\", self.currentState.depth)\\n\\n # Return if done\\n if self.currentState.state == self.victoryCondition:\\n # print(\\\"DONE\\\")\\n return True\\n\\n while to_move < len(movables):\\n # Make the move\\n movable_statement = movables[to_move]\\n # print(\\\"implementing move \\\", movable_statement)\\n self.gm.makeMove(movable_statement)\\n\\n # Create a new state with this move made\\n new_state = self.gm.getGameState()\\n\\n # Find out if this state has already been explored\\n visited = False\\n for visited_state in self.visited.keys():\\n if visited_state.state == new_state:\\n visited = True\\n\\n # If the new state hasn't been visited then add it as a child then move down to this child\\n if not visited:\\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\\n new_gs.parent = self.currentState\\n self.currentState.children.append(new_gs)\\n self.currentState.nextChildToVisit = to_move + 1\\n self.currentState = new_gs\\n break\\n\\n # Else skip this state and try going to the next movable statement\\n else:\\n # print(\\\"SKIP THIS STATE\\\")\\n self.gm.reverseMove(movable_statement)\\n to_move += 1\\n\\n # Went all the way down to a leaf, backtrack\\n if (to_move >= len(movables)):\\n self.gm.reverseMove(self.currentState.requiredMovable)\\n self.currentState = self.currentState.parent\\n\\n return False\",\n \"def move(self, step):\\n\\n status = self.read()\\n Logger.getLogger().debug(\\\"Status in move method: %s\\\", status)\\n # while the motors are moving we don't want to start another movement\\n if status > CurtainsStatus.OPEN or self.motor.value:\\n return\\n\\n self.target = step\\n\\n # deciding the movement direction\\n if self.steps() < self.target:\\n self.__open__()\\n elif self.steps() > self.target:\\n self.__close__()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8853466","0.7574632","0.7553293","0.7552819","0.7345882","0.7279182","0.72217304","0.7157332","0.7038979","0.70239437","0.70111984","0.70072323","0.70054066","0.696469","0.69503534","0.69253767","0.690871","0.6824246","0.6807558","0.6804139","0.6804139","0.6791101","0.67861617","0.6785438","0.67832106","0.675546","0.67534935","0.66748255","0.66617686","0.66541386","0.6638315","0.66110617","0.6601155","0.6595488","0.6572221","0.6563101","0.65620714","0.6539991","0.6538489","0.65286446","0.6523502","0.65207005","0.65180993","0.6509517","0.6496153","0.64564097","0.64546216","0.6452073","0.6450604","0.64487743","0.64287454","0.64209014","0.6407224","0.6405115","0.6401834","0.63952726","0.6391814","0.6388449","0.6385774","0.63831913","0.6382396","0.6382396","0.6380348","0.6377269","0.6369642","0.6368664","0.6365388","0.63422704","0.6341516","0.63280237","0.6323968","0.62995404","0.6297362","0.6282531","0.6281444","0.62724304","0.62672156","0.62607026","0.62548226","0.6246455","0.6245296","0.6242789","0.62357503","0.62347","0.6226353","0.6202847","0.6192587","0.619024","0.6179825","0.61745685","0.61709243","0.6170918","0.61676574","0.6165583","0.6161451","0.61592084","0.61568654","0.6154769","0.614837","0.6137337"],"string":"[\n \"0.8853466\",\n \"0.7574632\",\n \"0.7553293\",\n \"0.7552819\",\n \"0.7345882\",\n \"0.7279182\",\n \"0.72217304\",\n \"0.7157332\",\n \"0.7038979\",\n \"0.70239437\",\n \"0.70111984\",\n \"0.70072323\",\n \"0.70054066\",\n \"0.696469\",\n \"0.69503534\",\n \"0.69253767\",\n \"0.690871\",\n \"0.6824246\",\n \"0.6807558\",\n \"0.6804139\",\n \"0.6804139\",\n \"0.6791101\",\n \"0.67861617\",\n \"0.6785438\",\n \"0.67832106\",\n \"0.675546\",\n \"0.67534935\",\n \"0.66748255\",\n \"0.66617686\",\n \"0.66541386\",\n \"0.6638315\",\n \"0.66110617\",\n \"0.6601155\",\n \"0.6595488\",\n \"0.6572221\",\n \"0.6563101\",\n \"0.65620714\",\n \"0.6539991\",\n \"0.6538489\",\n \"0.65286446\",\n \"0.6523502\",\n \"0.65207005\",\n \"0.65180993\",\n \"0.6509517\",\n \"0.6496153\",\n \"0.64564097\",\n \"0.64546216\",\n \"0.6452073\",\n \"0.6450604\",\n \"0.64487743\",\n \"0.64287454\",\n \"0.64209014\",\n \"0.6407224\",\n \"0.6405115\",\n \"0.6401834\",\n \"0.63952726\",\n \"0.6391814\",\n \"0.6388449\",\n \"0.6385774\",\n \"0.63831913\",\n \"0.6382396\",\n \"0.6382396\",\n \"0.6380348\",\n \"0.6377269\",\n \"0.6369642\",\n \"0.6368664\",\n \"0.6365388\",\n \"0.63422704\",\n \"0.6341516\",\n \"0.63280237\",\n \"0.6323968\",\n \"0.62995404\",\n \"0.6297362\",\n \"0.6282531\",\n \"0.6281444\",\n \"0.62724304\",\n \"0.62672156\",\n \"0.62607026\",\n \"0.62548226\",\n \"0.6246455\",\n \"0.6245296\",\n \"0.6242789\",\n \"0.62357503\",\n \"0.62347\",\n \"0.6226353\",\n \"0.6202847\",\n \"0.6192587\",\n \"0.619024\",\n \"0.6179825\",\n \"0.61745685\",\n \"0.61709243\",\n \"0.6170918\",\n \"0.61676574\",\n \"0.6165583\",\n \"0.6161451\",\n \"0.61592084\",\n \"0.61568654\",\n \"0.6154769\",\n \"0.614837\",\n \"0.6137337\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69629246"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":89598,"cells":{"query":{"kind":"string","value":"Evaluates the state for the player with the given row"},"document":{"kind":"string","value":"def evaluate(self, state, my_row):\n\tstoneonmyside = 0.00\n\tstoneonopside = 0.00\n\tresult = 0.00\n\tfor a in range(0,state.M+1):\n\t stoneonmyside += state.board[a]\n \n\tfor a in range(state.M+1, 2*(state.M)+1):\n\t stoneonopside += state.board[a]\n\n\tif my_row == 0:\n\t result = (stoneonmyside - stoneonopside) / (2*(state.M)*(state.N))\n\telse:\n\t result = (stoneonopside - stoneonmyside) / (2*(state.M)*(state.N))\n\t\n\treturn result"},"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 evaluate(self, state, my_row):\n myStones = 0.0\n opponentStones = 0.0\n for i in range(len(state.board)):\n if my_row == 0:\n if i <= State.M:\n myStones += state.board[i]\n else:\n opponentStones += state.board[i]\n else:\n if i <= State.M:\n opponentStones += state.board[i]\n else:\n myStones += state.board[i]\n return (myStones - opponentStones)/(2*State.M*State.N)","def game_value(self, state):\n # check horizontal wins\n for row in state:\n for i in range(2):\n if row[i] != ' ' and row[i] == row[i+1] == row[i+2] == row[i+3]:\n return 1 if row[i]==self.my_piece else -1\n\n # check vertical wins\n for col in range(5):\n for i in range(2):\n if state[i][col] != ' ' and state[i][col] == state[i+1][col] == state[i+2][col] == state[i+3][col]:\n return 1 if state[i][col]==self.my_piece else -1\n\n # TODO: check \\ diagonal wins\n for col in range(2):\n for i in range(2):\n if state[i][col] != ' ' and state[i][col] == state[i+1][col+1] == state[i+2][col+2] == state[i+3][col+3]:\n return 1 if state[i][col]==self.my_piece else -1\n # TODO: check / diagonal wins\n for col in range(2):\n for i in range(2):\n if state[i][col+3] != ' ' and state[i][col+3] == state[i+1][col+2] == state[i+2][col+1] == state[i+3][col]:\n return 1 if state[i][col]==self.my_piece else -1\n # TODO: check 2x2 box wins\n for col in range(4):\n for i in range(4):\n if state[i][col] != ' ' and state[i][col] == state[i+1][col] == state[i][col+1] == state[i+1][col+1]:\n return 1 if state[i][col]==self.my_piece else -1\n \n return 0 # no winner yet","def game_value(self, state):\r\n # check horizontal wins\r\n for row in state:\r\n for i in range(2):\r\n if row[i] != ' ' and row[i] == row[i+1] == row[i+2] == row[i+3]:\r\n return 1 if row[i] == self.my_piece else -1\r\n # check col wins\r\n for col in range(5):\r\n for i in range(2):\r\n if state[i][col] != ' ' and state[i][col] == state[i+1][col] == state[i+2][col] == state[i+3][col]:\r\n return 1 if state[i][col] == self.my_piece else -1\r\n #check diag up wins\r\n for x in range(2):\r\n for y in range(2):\r\n if state[x][y] != ' ' and state[x][y] == state[x+1][y+1] == state[x+2][y+2] == state[x+3][y+3]:\r\n return 1 if state[x][y] == self.my_piece else -1\r\n #check diag down wins\r\n for x in range(2):\r\n for y in range(3, 5):\r\n if state[x][y] != ' ' and state[x][y] == state[x+1][y-1] == state[x+2][y-2] == state[x+3][y-3]:\r\n return 1 if state[x][y] == self.my_piece else -1\r\n #check square box wins \r\n for x in range(4):\r\n for y in range(4):\r\n if state[x][y] != ' ' and state[x][y] == state[x+1][y] == state[x][y+1] == state[x+1][y+1]:\r\n return 1 if state[x][y] == self.my_piece else -1\r\n\r\n return 0 # no winner yet\r","def evaluate(self, state):\n\t\ttranspose = state.board.transpose()\t\t# columns in state.board = rows in transpose\n\t\tcount = []\n\t\topponentcount = []\n\t\tfor row, column in zip(state.board, transpose):\n\t\t\trowcounter = collections.Counter(row)\n\t\t\tcolumncounter = collections.Counter(column)\n\t\t\tcount.append(rowcounter.get(state.current_player, 0))\n\t\t\tcount.append(columncounter.get(state.current_player, 0))\n\t\t\topponentcount.append(rowcounter.get(state.current_player * - 1, 0))\n\t\t\topponentcount.append(columncounter.get(state.current_player * -1 , 0))\n\n\t\tY = state.board[:, ::-1]\n\t\tdiagonals = [np.diagonal(state.board), np.diagonal(Y)]\n\t\tmain_diagonal_count = collections.Counter(diagonals[0])\n\t\tsecond_diagonal_count = collections.Counter(diagonals[1])\n\t\tcount.append(main_diagonal_count.get(state.current_player, 0))\n\t\tcount.append(second_diagonal_count.get(state.current_player, 0))\n\t\topponentcount.append(main_diagonal_count.get(state.current_player * - 1, 0))\n\t\topponentcount.append(second_diagonal_count.get(state.current_player * -1, 0))\n\n\t\t# max(count): maximum number of player's tiles in a row, column, or a diagonal (the highest value is 5)\n\t\t# max(opponentcount): maximum number of opponent's tiles in a row, column, or a diagonal (the highest value is 5)\n\t\tscoremax = 5 ** max(count)\n\t\tscoremin = 5 ** max(opponentcount)\n\n\t\treturn scoremax - scoremin","def game_value(self, state):\n # check horizontal wins\n for row in state:\n for i in range(2):\n if row[i] != ' ' and row[i] == row[i+1] == row[i+2] == row[i+3]:\n return 1 if row[i]==self.my_piece else -1\n\n # check vertical wins\n for col in range(5):\n for i in range(2):\n if state[i][col] != ' ' and state[i][col] == state[i+1][col] == state[i+2][col] == state[i+3][col]:\n return 1 if state[i][col]==self.my_piece else -1\n\n # check \\ diagonal wins\n for i in range(2):\n for j in range(2):\n if state[i][j]!= ' ' and state[i][j] == state[i+1][j+1] == state[i+2][j+2] == state[i+3][j+3]:\n return 1 if state[i][j]==self.my_piece else -1\n # check / diagonal wins\n for i in range(3,5):\n for j in range(2):\n if state[i][j]!= ' ' and state[i][j] == state[i-1][j+1] == state[i-2][j+2] == state[i-3][j+3]:\n return 1 if state[i][j]==self.my_piece else -1\n # check diamond wins\n for i in range(3):\n for j in range(1,4):\n if state[i+1][j] == ' ' and state[i][j]!= ' ' and state[i][j] == state[i+1][j-1] == state[i+1][j+1] == state[i+2][j]:\n return 1 if state[i][j]==self.my_piece else -1\n\n return 0 # no winner yet","def row_win(board, player):\n for row in board:\n if check_row(row, player):\n return True\n return False","def check_row(row, player):\n for marker in row:\n if marker != player:\n return False\n return True","def win_row(playerid):\n if board[0][0] is playerid and board[0][1] is playerid and board[0][2] is playerid:\n return (True, \"Row 1\")\n\n if board[1][0] is playerid and board[1][1] is playerid and board[1][2] is playerid:\n return (True, \"Row 2\")\n\n if board[2][0] is playerid and board[2][1] is playerid and board[2][2] is playerid:\n return (True, \"Row 3\")\n\n return False","def evaluate(self, state, player, random_state):\n raise NotImplementedError","def check_row(self, row, symbol):\r\n\r\n tally = 0\r\n for column in range(3):\r\n if self.board[row][column][1] == symbol:\r\n tally += 1\r\n if tally == 3:\r\n self.winner = symbol","def next_state_rowcol(self):\n # state before and after propagation\n self.state_before = self.state_after\n transition_probs = list(Customer.TPM.loc[Customer.TPM.index==self.state_before].values[0])\n self.state_after = random.choices(Customer.STATES, weights=transition_probs)[0]\n # row and col before and after propagation\n self.row_before = self.row_after\n self.col_before = self.col_after\n\n # randomly chose row_after, col_after depending on the state_after\n if self.state_after == 'fruit':\n self.row_after = random.choice(Customer.STATE_ROW_COL['fruit'][0])\n self.col_after = random.choice(Customer.STATE_ROW_COL['fruit'][1])\n elif self.state_after == 'spices':\n self.row_after = random.choice(Customer.STATE_ROW_COL['spices'][0])\n self.col_after = random.choice(Customer.STATE_ROW_COL['spices'][1])\n elif self.state_after == 'dairy':\n self.row_after = random.choice(Customer.STATE_ROW_COL['dairy'][0])\n self.col_after = random.choice(Customer.STATE_ROW_COL['dairy'][1])\n elif self.state_after == 'drinks':\n self.row_after = random.choice(Customer.STATE_ROW_COL['drinks'][0])\n self.col_after= random.choice(Customer.STATE_ROW_COL['drinks'][1])\n elif self.state_after == 'checkout':\n self.row_after = random.choice(Customer.STATE_ROW_COL['checkout'][0])\n self.col_after = random.choice(Customer.STATE_ROW_COL['checkout'][1])","def row_wise_checking(player_):\n if board[0] == board[1] == player_:\n return 2\n elif board[1] == board[2] == player_:\n return 0\n elif board[3] == board[4] == player_:\n return 5\n elif board[4] == board[5] == player_:\n return 3\n elif board[6] == board[7] == player_:\n return 8\n elif board[7] == board[8] == player_:\n return 6\n else:\n return -1","def move(self, row: int, col: int, player: int) -> int:\n self.board[row][col] = 1 if player == 1 else -1\n rowsum = sum(self.board[row])\n colsum = sum([self.board[r][col] for r in range(self.n)])\n diagsum1 = sum([self.board[i][i] for i in range(self.n)])\n diagsum2 = sum([self.board[i][-i-1] for i in range(self.n)])\n if player == 1:\n if rowsum == self.n or colsum == self.n or diagsum1 == self.n or diagsum2 == self.n:\n return 1\n else:\n if rowsum == -self.n or colsum == -self.n or diagsum1 == -self.n or diagsum2 == -self.n:\n return 2\n return 0","def move(self, row, col, player):\n if self.winning == True:\n return\n self.matrix[row][col] = player\n n = len(self.matrix)\n indicator = True\n for i in range(n):\n if self.matrix[row][i] != player:\n indicator = False\n break\n if indicator == True:\n self.winning = True\n return player\n \n indicator = True\n for i in range(n):\n if self.matrix[i][col] != player:\n indicator = False\n break\n if indicator == True:\n self.winning = True\n return player\n \n if row == col:\n indicator = True\n for i in range(n):\n if self.matrix[i][i] != player:\n indicator = False\n break\n if indicator == True:\n self.winning = True\n return player\n if row + col == n - 1:\n indicator = True\n for i in range(n):\n if self.matrix[i][n - 1 - i] != player:\n indicator = False\n break\n if indicator == True:\n self.winning = True\n return player\n return 0","def who_won(in_a_row, board_size, cur_player):\n if in_a_row == board_size:\n return 1 if cur_player == 'X' else 2\n else:\n return 0","def evaluate(self, board):","def move(self, row, col, player):\n value = (1.5 - player) * 2\n self.rows[row] += value\n self.colums[col] += value\n if row == col:\n self.diag[0] += value\n if row + col == self.n-1:\n self.diag[1] += value\n if abs(self.rows[row]) == self.n or abs(self.colums[col]) == self.n or abs(self.diag[0]) == self.n or abs(self.diag[1]) == self.n:\n return player\n return 0","def move(self, row: int, col: int, player: int) -> int:\n if not self.winner:\n p = player - 1\n \n self.rows[p][row] += 1\n self.cols[p][col] += 1\n if row == col:\n self.d[p] += 1\n if row + col + 1 == self.n:\n self.subd[p] += 1 \n \n if self.n in [self.rows[p][row], self.cols[p][col], self.d[p], self.subd[p]]:\n self.winner = player\n \n return self.winner","def check_win(self, player):\n def check_row_win(player):\n for row in self.game_state:\n if player == row[0] == row[1] == row[2]:\n return True\n return False\n\n def check_column_win(player):\n # For doing a column check, transpose the grid and do a row check\n trans_game_state = numpy.transpose(self.game_state)\n for row in trans_game_state:\n if player == row[0] == row[1] == row[2]:\n return True\n return False\n\n def check_diag_win(player):\n # Left to right diagonal\n if player == self.game_state[0][0] == self.game_state[1][1] == self.game_state[2][2]:\n return True\n # Right to left diagonal\n if player == self.game_state[0][2] == self.game_state[1][1] == self.game_state[2][0]:\n return True\n return False\n\n if check_column_win(player) or check_diag_win(player) or check_row_win(player):\n return True\n return False","def switch(self, col, row, player):\n\n if self._out_of_range(col, row):\n return 0\n if self._check_occupied(col, row):\n return 1\n else:\n self.board[row - 1][col - 1] = player","def check_four_in_a_row(self, player_symbol, row, col, step_row_1, step_col_1, step_row_2, step_col_2):\n num_connected = 1 # Tally of how many game pieces were found matching thus far\n\n def increment_connected(step_row, step_col):\n \"\"\"\n Checks to see if the game is over. This occurs if a player has four pieces in a row, or if the board is full.\n :param step_row: The amount to move in the Y direction\n :param step_col: The amount to move in the X direction\n :return: The number of adjacent matching tiles found by the function\n \"\"\"\n connected = 0\n current_row = row + step_row\n current_col = col + step_col\n\n while self.board[current_row][current_col] == player_symbol:\n connected += 1\n current_row += step_row\n current_col += step_col\n\n return connected\n\n num_connected += increment_connected(step_row_1, step_col_1)\n num_connected += increment_connected(step_row_2, step_col_2)\n\n if num_connected >= 4:\n self.game_over = True","def evaluate(board, player):\n score = 0\n for i in range(3):\n row = i * 3\n score += evaluate_line(board, player, i, i + 3, i + 6)\n score += evaluate_line(board, player, row, row + 1, row + 2)\n score += evaluate_line(board, player, 0, 4, 8)\n score += evaluate_line(board, player, 2, 4, 6)\n return score","def move(self, row, col, player):\r\n if player == 1:\r\n self.mat[row][col] = 1\r\n else:\r\n self.mat[row][col] = -1\r\n if self.checkrow(player,row) or self.checkcol(player,col):\r\n return player\r\n if row == col or row + col == self.size-1:\r\n if self.checkdiag(player):\r\n return player\r\n return 0","def look_through_rows(board, column, player):\n if board.shape[1] > column:\n count = board.shape[0] - 1\n count2 = 1\n while count >= 0 and count2 == 1:\n if board[count,column] == 0:\n board[count,column] = player\n count2 = count2 - 1\n else:\n count = count - 1\n return board\n else:\n print('Improper Column Given')","def game_state(matrix):\n\n \"\"\"\n # To set winning tile\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n if matrix[i][j] == 2048:\n # return 'win'\n # return 'not over'\n \"\"\"\n for i in range(len(matrix)-1):\n # intentionally reduced to check the row on the right and below\n # more elegant to use exceptions but most likely this will be their solution\n for j in range(len(matrix[0])-1):\n if matrix[i][j] == matrix[i+1][j] or matrix[i][j+1] == matrix[i][j]:\n return 'not over'\n for i in range(len(matrix)): # check for any zero entries\n for j in range(len(matrix[0])):\n if matrix[i][j] == 0:\n return 'not over'\n for k in range(len(matrix)-1): # to check the left/right entries on the last row\n if matrix[len(matrix)-1][k] == matrix[len(matrix)-1][k+1]:\n return 'not over'\n for j in range(len(matrix)-1): # check up/down entries on last column\n if matrix[j][len(matrix)-1] == matrix[j+1][len(matrix)-1]:\n return 'not over'\n return 'lose'","def step(self, row):\r\n\r\n t = torch.tensor(row)\r\n choice = torch.argmax(self.tn(t).squeeze(0)).item()\r\n\r\n # The plan was to never have to use constants...\r\n # Yeah, we're assuming consistency in buy=0, sell=1, and hold=2\r\n if choice == 0:\r\n return (Action.BUY, 1)\r\n elif choice == 1:\r\n return (Action.SELL, 1)\r\n\r\n return (Action.HOLD, 0)","def col_win(board, player):\n for row in board.T:\n if check_row(row, player):\n return True\n return False","def play(self):\n\n value = 0 #player dictionary key\n player = {0: 'O', 1: 'X'}\n\n moveCount = 0 #how many moves have occurred. also doubles as the self.order index.\n turn = \"\"\n while moveCount < self.n**2 and self.go == \"Tie\":\n value = not value\n turn = player[value] #X starts\n key = self.order[moveCount]\n i = key[0]\n j = key[1]\n\n\n# self.rows[i][0] == homogenous?\n# self.rows[i][1] == X/O?\n# self.rows[i][2] == count of X's/O's?\n\n# Check to see if row i is 'homogenous' (contains only X's or O's):\n if self.rows[i][0]:\n\n# Check to see if any square in row i has been played. If it has been played,\n# check to see if it was the same person who's current turn it is.\n if self.rows[i][1] == \"\" or player[value] == self.rows[i][1]:\n\n# Mark the column with the current person's token (X or O).\n# Admittedly, this could be improved to not update every time.\n self.rows[i][1] = turn\n\n# Update the count by one.\n self.rows[i][2] += 1\n\n# If the count is equal to the board size, end the game and return who won and how.\n if self.rows[i][2] == self.n:\n self.go = (turn, 'row ' + str(i))\n\n# If the current person who's turn it is,\n# is not the same as the previous player who played this row,\n# set this row's 'homogenous' attribute to false.\n else:\n self.rows[i][0] = False\n\n if self.cols[j][0]:\n if self.cols[j][1] == \"\" or player[value] == self.cols[j][1]:\n self.cols[j][1] = turn\n self.cols[j][2] += 1\n if self.cols[j][2] == self.n:\n self.go = (turn, 'column ' + str(j))\n else:\n self.cols[j][0] = False\n\n# On boards of odd-sized 'n' (n = 3,5,7,etc...)\n# the middle square is part of both diagonals: 'step' and 'same':\n if i == j:\n if self.diags['same'][0]:\n if self.diags['same'][1] == \"\" or player[value] == self.diags['same'][1]:\n self.diags['same'][1] = turn\n self.diags['same'][2] += 1\n if self.diags['same'][2] == self.n:\n self.go = (turn, 'diagonal from 0,0 to n-1,n-1')\n else:\n self.diags['same'][0] = False\n\n if i + j + 1 == self.n:\n if self.diags['step'][0]:\n if self.diags['step'][1] == \"\" or player[value] == self.diags['step'][1]:\n self.diags['step'][1] = turn\n self.diags['step'][2] += 1\n if self.diags['step'][2] == self.n:\n self.go = (turn, 'diagonal from n-1,0 to 0,n-1')\n else:\n self.diags['step'][0] = False\n\n moveCount += 1\n print(turn, key)\n else:\n return self.go","def check_rows():\n global game_still_going\n # Check if any of the rows have all the same value.\n row1 = board[0] == board[1] == board[2] != '_'\n row2 = board[3] == board[4] == board[5] != '_'\n row3 = board[6] == board[7] == board[8] != '_'\n # If any row does have a match, then game still going to False.\n if row1 or row2 or row3:\n game_still_going = False\n # Return winner 'X' or 'O'.\n if row1:\n return board[0]\n if row2:\n return board[3]\n if row3:\n return board[6]","def move(self, row, col, player):\n if self.winning == True:\n return\n if player == 1:\n val = 1\n else:\n val = -1\n self.row[row] += val\n self.col[col] += val\n if row == col:\n self.diagonal += val\n n = len(self.row)\n if row + col == n - 1:\n self.antidiagonal += val\n if abs(self.row[row]) == n or abs(self.col[col]) == n or abs(self.diagonal) == n or abs(self.antidiagonal) == n:\n self.winning = True\n return player\n return 0","def win_condition(self, player):\n\n row_list = []\n column_list = []\n constant_condition = False\n row_sequential_condition = False\n column_sequential_condition = False\n\n # Loop through positions on board for player\n for position_key, position_obj in sorted(self.board.positions.items()):\n if position_obj.value == player.value:\n row_list.append(position_obj.row)\n column_list.append(position_obj.column)\n\n # Either row keys or column keys must stay constant\n row_set = set(row_list)\n column_set = set(column_list)\n if len(row_set) == 1 or len(column_set) == 1:\n constant_condition = True\n\n # The other row keys or column keys must be sequential for number of row or columns\n row_seq_list = [n for n in range(1, self.board.rows + 1)]\n column_seq_list = [n for n in range(1, self.board.columns + 1)]\n if row_list == row_seq_list:\n row_sequential_condition = True\n if column_list == column_seq_list:\n column_sequential_condition = True\n\n if constant_condition and (row_sequential_condition or column_sequential_condition):\n return True\n elif row_sequential_condition and column_sequential_condition:\n return True\n else:\n return False","def check_rows():\n global ongoing_game\n row_1 = board[0] == board[1] == board[2] != \"*\"\n row_2 = board[3] == board[4] == board[5] != \"*\"\n row_3 = board[6] == board[7] == board[8] != \"*\"\n if row_1 or row_2 or row_3:\n ongoing_game = False\n if row_1:\n return board[0]\n elif row_2:\n return board[3]\n elif row_3:\n return board[6]\n else:\n return None","def test_row_col(board, rows):\n for i in range(len(board)):\n cur_player = board[i][0] if rows else board[0][i]\n in_a_row = 0\n for j in range(len(board)):\n symbol = board[i][j] if rows else board[j][i]\n if (not symbol == '-') and (symbol == cur_player):\n in_a_row += 1\n else:\n break\n winner = who_won(in_a_row, len(board), cur_player)\n if not winner == 0:\n return winner\n return 0","def check_game_over(self, row, col):\n player_symbol = self.board[row][col]\n\n # Top Right: Row -1 Col 1\n # Bottom Left: Row 1 Col -1\n self.check_four_in_a_row(player_symbol, row, col, -1, 1, 1, -1)\n\n # Top Left: Row -1 Col -1\n # Bottom Right Row 1 Col 1\n self.check_four_in_a_row(player_symbol, row, col, -1, -1, 1, 1)\n\n # Horizontal: Row 0 Col 1, Row 0 Col -1\n self.check_four_in_a_row(player_symbol, row, col, 0, 1, 0, -1)\n\n # Vertical: Row 1 Col 0, Row -1 Col 0\n self.check_four_in_a_row(player_symbol, row, col, 1, 0, -1, 0)\n\n if self.turns >= self.num_playable_rows * self.num_playable_columns:\n self.game_over = True\n self.board_full = True","def move(self, row, col, player):\n score = self.score[player]\n win_score = self.win[player]\n self.rows[row] += score\n if self.rows[row] == win_score:\n return player\n\n self.columns[col] += score\n if self.columns[col] == win_score:\n return player\n if col - row == 0:\n self.diagonal[1] += score\n if self.diagonal[1] == win_score:\n return player\n if col + row == self.size - 1:\n self.diagonal[0] += score\n if self.diagonal[0] == win_score:\n return player\n return 0","def evaluateBoardState(self, board):\n\n \"\"\"\n These are the variables and functions for board objects which may be helpful when creating your Agent.\n Look into board.py for more information/descriptions of each, or to look for any other definitions which may help you.\n\n Board Variables:\n board.width \n board.height\n board.last_move\n board.num_to_connect\n board.winning_zones\n board.score_array \n board.current_player_score\n\n Board Functions:\n get_cell_value(row, col)\n try_move(col)\n valid_move(row, col)\n valid_moves()\n terminal(self)\n legal_moves()\n next_state(turn)\n winner()\n \"\"\"\n\n # print the valid moves on board for current player\n move = board.last_move\n\n # enemy agent's id\n enemy = self.id % 2 + 1\n\n value = self.evaluateRows(board, enemy) + self.evaluateCols(board, enemy) + self.evaluateBackwardDiagonals(board, enemy) + self.evaluateForwardDiagonals(board, enemy)\n return value","def winner(row):\r\n x=0\r\n o=0\r\n win=False\r\n winner='X'\r\n empty=False #Better not to do '.' in row\r\n \r\n for char in row:\r\n if char=='X':\r\n x+=1\r\n o=0\r\n if char=='O':\r\n o+=1\r\n x=0\r\n if char=='T':\r\n x+=1\r\n o+=1\r\n if char=='.':\r\n x=0\r\n o=0\r\n empty=True\r\n\r\n #Check Winner\r\n if x==4:\r\n win=True\r\n winner='X'\r\n if o==4:\r\n win=True\r\n winner='O'\r\n return (win,winner,empty)\r\n #Done\r","def rushing_success(row):\n success = 0\n if row.down == 1:\n if row.yards_gained >= 6:\n success = 1\n elif row.yards_gained >= row.ydstogo * .4:\n success = 1\n elif row.down == 2:\n if row.yards_gained >= 6:\n success = 1\n elif row.yards_gained >= row.ydstogo * .5:\n success = 1\n elif row.down > 3:\n if row.yards_gained >= row.ydstogo:\n success = 1\n return success","def move(self, row, col, player):\n score = 1 if player == 1 else -1\n self.rows[row] += score\n self.cols[col] += score\n if row == col:\n self.diagonal1 += score\n if row + col == self.n - 1:\n self.diagonal2 += score\n win = {self.rows[row], self.cols[col], self.diagonal1, self.diagonal2}\n if self.n in win or -self.n in win:\n return player\n return 0","def is_posssible_row(self,row,user_value):\n for col in range(9):\n if self.arr[row][col] == user_value:\n logging.debug(f\"is_posssible_row(): (False) row: {row} col: {col} arr{self.arr[row][col]} == {user_value}\")\n return False\n logging.debug(f\"is_posssible_row(): (True) row: {row} col: {col} arr{self.arr[row][col]} != {user_value}\")\n return True","def anyone_won(self, state):\r\n # Checking all the rows\r\n for row_values in state:\r\n if row_values.count('x') == 3:\r\n return True, 'x'\r\n if row_values.count('o') == 3:\r\n return True, 'o'\r\n\r\n # Checking all the columns\r\n for i in range(3):\r\n if state[0][i] == 'x' and state[1][i] == 'x' and state[2][i] == 'x':\r\n return True, 'x'\r\n if state[0][i] == 'o' and state[1][i] == 'o' and state[2][i] == 'o':\r\n return True, 'o'\r\n\r\n return False, None","def get_state_from_row(self, row: int):\n index = [0, 1, 2, 3]\n blue_location = index[row // 16]\n green_location = index[(row % 16) // 4]\n red_location = index[row % 4]\n return (row, red_location, green_location, blue_location)","def move(self, row: int, col: int, player: int) -> int:\n if player == 1:\n self.newList[row][col] = 1\n self.colSum[col] += 1\n self.rowSum[row] += 1\n if row == col:\n self.diag += 1\n if row + col == (self.n - 1):\n self.revDiag += 1\n if self.rowSum[row] == self.n or self.colSum[col] == self.n or self.diag == self.n or self.revDiag == self.n:\n return 1\n if player == 2:\n self.newList[row][col] = -1\n self.colSum[col] -= 1\n self.rowSum[row] -= 1\n if row == col:\n self.diag -= 1\n if row + col == (self.n - 1):\n self.revDiag -= 1\n if self.rowSum[row] == -self.n or self.colSum[col] == -self.n or self.diag == -self.n or self.revDiag == -self.n:\n return 2\n \n return 0","def evaluate(board):\n winner = 0\n for player in [1, 2]:\n if row_win(board, player) or col_win(board, player) or diag_win(board, player):\n winner = player\n \n if np.all(board != 0) and winner == 0:\n winner = -1\n return winner","def move(self, row: int, col: int, player: int):\n def addup(dict_name, invalid_set, another_invalid, locx, locy):\n if locx == locy:\n diag_name = (1,1)\n if diag_name not in invalid_set:\n dict_name[diag_name] += 1\n if dict_name[diag_name] == self.tar:\n return player\n another_invalid.add(diag_name)\n if locx == self.tar-1-locy:\n diag_name = (-1, -1)\n if diag_name not in invalid_set:\n dict_name[diag_name] += 1\n if dict_name[diag_name] == self.tar:\n return player\n another_invalid.add(diag_name)\n curcol = (locy, None)\n currow = (None, locx)\n if curcol not in invalid_set:\n dict_name[curcol] += 1\n if dict_name[curcol] == self.tar:\n return player\n another_invalid.add(curcol)\n if currow not in invalid_set:\n dict_name[currow] += 1\n if dict_name[currow] == self.tar:\n return player\n another_invalid.add(currow)\n return 0\n res = 0\n if (row, col) not in self.walked:\n if player == 1:\n res = addup(self.p1, self.invalid_1, self.invalid_2, row, col)\n if player == 2:\n res = addup(self.p2, self.invalid_2, self.invalid_1, row, col)\n self.walked.add((row, col))\n return res","def eval(self, state):\n valueOfPlayers = 0\n valueOfRebelAdvancments = 0\n valueOfLocations = 0\n\n\n\n for coordinate in state.gameState:\n if state.gameState[coordinate]==state.blank:\n continue\n elif state.gameState[coordinate]==state.rebel:\n valueOfRebelAdvancments = -coordinate[0]\n elif state.gameState[coordinate]==state.jedi:\n continue\n elif state.gameState[coordinate]==state.sith:\n continue\n \n valueOfLocations += valueOfRebelAdvancments\n\n \n valueOfPlayers = state.numRebels + 4*state.numJedi - 4*state.numSith\n \n return valueOfPlayers*4 + valueOfLocations","def makeEvalTable(table):\n\n def score(game, player):\n row, col = game.get_player_location(player)\n return table[row][col]\n\n return score","def getGameState(self):\n ### Student code goes here\n #print(\":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::\")\n row1_tuple = ()\n row1_list = {}\n ask1 = parse_input(\"fact: (on ?X ?Y pos1)\")\n answer1 = self.kb.kb_ask(ask1)\n if answer1 != False:\n for ans in answer1.list_of_bindings:\n tile = ans[0].bindings[0].constant.element\n if len(tile.split('tile',1)) > 1:\n tile = int(tile.split('tile',1)[1])\n else:\n tile = -1\n pos = (ans[0].bindings[1].constant.element).split('pos',1)[1]\n row1_list[int(pos)] = tile\n #print(\"ROW1: \", len(row1_list))\n for i in range(len(row1_list)):\n val = row1_list[i+1]\n #print(val)\n row1_tuple = row1_tuple + (val,)\n\n row2_tuple = ()\n row2_list = {}\n ask2 = parse_input(\"fact: (on ?X ?Y pos2)\")\n answer2 = self.kb.kb_ask(ask2)\n if answer2 != False:\n for ans in answer2.list_of_bindings:\n tile = ans[0].bindings[0].constant.element\n if len(tile.split('tile',1)) > 1:\n tile = int(tile.split('tile',1)[1])\n else:\n tile = -1\n pos = (ans[0].bindings[1].constant.element).split('pos',1)[1]\n row2_list[int(pos)] = tile\n #print(\"ROW2: \", len(row2_list))\n for i in range(len(row2_list)):\n val = row2_list[i+1]\n row2_tuple = row2_tuple + (val,)\n\n row3_tuple = ()\n row3_list = {}\n ask3 = parse_input(\"fact: (on ?X ?Y pos3)\")\n answer3 = self.kb.kb_ask(ask3)\n if answer3 != False:\n for ans in answer3.list_of_bindings:\n tile = ans[0].bindings[0].constant.element\n if len(tile.split('tile',1)) > 1:\n tile = int(tile.split('tile',1)[1])\n else:\n tile = -1\n pos = (ans[0].bindings[1].constant.element).split('pos',1)[1]\n row3_list[int(pos)] = tile\n #print(\"ROW3: \", len(row3_list))\n for i in range(len(row3_list)):\n val = row3_list[i+1]\n row3_tuple = row3_tuple + (val,)\n #print(\"-----------------------------------------------------------------------------------------------\")\n\n\n state_tuple = (row1_tuple,row2_tuple,row3_tuple)\n #print(state_tuple)\n return state_tuple","def move(self, row: int, col: int, player: int) -> int:\n s = -1 if player == 1 else 1\n\n self.rows[row] += s\n if abs(self.rows[row]) == self.n:\n return player\n\n self.cols[col] += s\n if abs(self.cols[col]) == self.n:\n return player\n\n if row == col:\n self.diagonals[0] += s\n if abs(self.diagonals[0]) == self.n:\n return player\n\n if (row + col) == self.n - 1:\n self.diagonals[1] += s\n if abs(self.diagonals[1]) == self.n:\n return player\n\n return 0","def in_row(row, x, y,\n input_suduko_3d):\n value_in_row = np.in1d(np.asarray(input_suduko_3d[x, y, 0:]), np.asarray(input_suduko_3d[row, :, 0]))\n for i, value in enumerate(value_in_row):\n if value_in_row[i] == True and i != 0:\n input_suduko_3d[x, y, i] = 0","def _check_row(self, col, board) -> int:\n score = 0\n for row in range(len(board)):\n if board[col][row] == self.colour:\n score += 1\n return score","def check_for_win(self, row, col, player): \n\n count = 0\n for i in range(0, len(self.board[0])):\n # Check vertical\n if self.board[row][i] == player:\n count += 1\n else:\n count = 0\n \n if count == self.max_count:\n return True\n\n count = 0\n for i in range(0, len(self.board)):\n # Check horisontal\n if self.board[:, col][i] == player:\n count += 1\n else:\n count = 0\n \n if count == self.max_count:\n return True\n \n count = 0\n totoffset = col - row\n for i in np.diagonal(self.board, offset=totoffset):\n # Check diagonal\n if i == player:\n count += 1\n else:\n count = 0\n\n if count == self.max_count:\n return True\n\n count = 0\n mirrorboard = np.fliplr(self.board)\n col = self.colswitch[col]\n totoffset = col - row\n for i in np.diagonal(mirrorboard, offset=totoffset):\n # Check other diagonal\n if i == player:\n count += 1\n else:\n count = 0\n\n if count == self.max_count:\n return True","def checkForResult(self):\n values = np.array([self.extractValuesColumn(0)])\n for i in range(1, self.shapeRow):\n values = np.vstack((values, self.extractValuesColumn(i)))\n\n\n for i in range(self.shapeRow):\n if(values[i, ::] == 'x').all() or \\\n (values[::, i] == 'x').all():\n return (True, \"Player x won.\")\n\n if (values.diagonal() == 'x').all() or \\\n (np.diag(np.fliplr(values)) == 'x').all():\n return (True, \"Player x won.\")\n\n\n #check for 0\n for i in range(self.shapeRow):\n if (values[i, ::] == '0').all() or \\\n (values[::, i] == '0').all():\n return (True, \"Player 0 won.\")\n\n if (values.diagonal() == '0').all() or \\\n (np.diag(np.fliplr(values)) == '0').all():\n return (True, \"Player 0 won.\")\n\n\n return (False, \"\")","def move(self, row: int, col: int, player: int) -> int:\n n = self.n\n if player == 1:\n self.rows_1[row] += 1\n self.cols_1[col] += 1\n if player == 2:\n self.rows_2[row] += 1\n self.cols_2[col] += 1\n if row == col:\n self.diag1[row] = player\n if row + col + 1 == n:\n self.diag2[row] = player\n f = 0\n g = 0\n for i in range(n):\n if self.rows_1[row] == n or self.cols_1[col] == n:\n return 1\n if self.rows_2[row] == n or self.cols_2[col] == n:\n return 2 \n if self.diag1[i] != self.diag1[0]:\n f = 1\n if self.diag2[i] != self.diag2[0]:\n g = 1\n if f == 0:\n return self.diag1[0]\n if g == 0:\n return self.diag2[0]\n return 0","def move(self, row, col, player):\n toadd = 1 if player == 1 else -1\n \n self.row[row] += toadd\n self.col[col] += toadd\n if row == col: self.diagonal += toadd\n if col == self.n - row -1 : self.antidiag += toadd\n \n if abs(self.row[row]) == self.n or abs(self.col[col]) == self.n or abs(self.diagonal) == self.n or abs(self.antidiag) == self.n:\n return player\n else:\n return 0","def evaluate(self) :\n if self.inStates[0].getState() == self.inStates[1].getState(): return 0\n return 1","def move(self, row, col, player):","def val_in_row(self, table, val, row_index): \n\n #Get column names of table\n columns = self.table_col_names(table)\n \n\n all_rows=self.all_rows(table)\n flag=False\n for col in columns:\n if val==all_rows[row_index][col]:\n flag=True\n return flag","def test_case_if_row_is_about_to_be_foobar(self, mock_game):\n test_game = Game(3, \"playerX\", \"playerO\")\n test_game.game_id = 1002\n test_game.board_size = 3\n test_game.your_move = \"X\"\n test_game.board_blob = json.dumps(['X', '', 'O',\n 'X', '', '',\n 'X', 'X', ''])\n assert(test_game.is_row_in_danger(0, \"X\") is False)\n assert(test_game.is_row_in_danger(1, \"X\") == [4, 5])\n assert(test_game.is_row_in_danger(2, \"X\") == [8])","def update_game(board, row, col, player_mark, turn_counter):\n\tif board[row][col] != EMPTY:\n\t\tprint(\"You can't go there!\")\n\t\tplayer_mark = switch_player(player_mark) # Because upcoming check_status will switch it back\n\t\treturn (board, player_mark)","def is_in_check(self, player):\n # List of coords in board\n col = ['a','b','c','d','e','f','g','h','i'] # the columns\n a = []\n for i in range(10):\n a.append([j + str(i+1) for j in col])\n \n # Flatten the list\n board_coords = []\n for sublist in a:\n for coord in sublist:\n board_coords.append(coord)\n \n # getting each object in the board for a player\n pieces_coords = []\n pieces_left = []\n for row in range(10):\n for column in range(9):\n if self.get_board()[row][column] is not None and self.get_board()[row][column].get_color() == player.upper():\n # pieces left on the board for the player\n pieces_coords.append((row, column))\n pieces_left.append(self.get_board()[row][column])\n \n p_b_coord = (pieces_coords, board_coords)\n \n counter = 0 \n for piece_coord in pieces_coords: \n for board_coord in board_coords: \n translated_index = self.column_to_letter(piece_coord[1]) + str(piece_coord[0]) \n piece = self.get_piece_type(translated_index)\n if piece is not None:\n if piece.check_legal(translated_index, board_coord, self.get_board(), self.get_game_state()) == True:\n counter += 1\n print(counter)\n if counter == 0:\n self._current_state = upper(player) + '_WON'\n return True \n return False","def evaluate(self) :\n for inp in self.inStates :\n if inp.getState() == 1 : return 1\n return 0","def evaluate(self, player):\n evaluation = 0\n\n # Takes into account the number of pieces for each side in play.\n self._evaluate_num_pieces(player)\n\n # Evaluates the position of each piece\n evaluation += self._evaluate_pieces_position(player)\n evaluation -= self._evaluate_pieces_position(player.other)\n\n # Random extra point used to randomize plays that are equal\n evaluation += random.randint(0, 1)\n\n return evaluation","def check_score(self) -> None:\n self.player_1, self.player_2 = 0, 0\n for cell in self.cells:\n if cell.player == 1:\n self.player_1 += 1\n elif cell.player == 2:\n self.player_2 += 1","def simul_move(self, column, player):\n\n new_rack = [x[:] for x in self.layout] #copy this state's layout\n #travel down this column\n r = 0\n while new_rack[column][r] !=0:\n r+=1\n if r >= self.height:\n return None\n new_rack[column][r] = player\n new_state = State(new_rack, player)\n return new_state","def calcUpdateByRow(self, row):\n\n # a) positive phase\n poshp = self.rbm.activate(row)\t# compute the posterior probability\n pos = outer(row, poshp) \t# fraction from the positive phase\n poshb = poshp\n posvb = row\n\n # b) the sampling & reconstruction\n sampled = self.sampler(poshp)\n recon = self.invRbm.activate(sampled)\t# the re-construction of data\n\n # c) negative phase\n neghp = self.rbm.activate(recon)\n neg = outer(recon, neghp)\n neghb = neghp\n negvb = recon\n\n # compute the raw delta\n # !!! note that this delta is only the 'theoretical' delta\n return self.updater(pos, neg, poshb, neghb, posvb, negvb)","def player(board):\n if board == initial_state():\n return X\n \n # if board has lesser or eual X(s) than O(s)\n if sum([row.count(X) for row in board]) <= sum([row.count(O) for row in board]):\n return X\n else:\n return O","def getGameState(self):\n ### Student code goes here\n row1 = ()\n row2 = ()\n row3 = ()\n for currRow in range(1,4):\n for currCol in range(1,4):\n tileFound = False\n for fact in self.kb.facts:\n if fact.statement.predicate == \"located\":\n tile = fact.statement.terms[0].term.element\n column = fact.statement.terms[1].term.element\n row = fact.statement.terms[2].term.element\n\n tileNumber = int(tile[-1])\n columnNumber = int(column[-1])\n rowNumber = int(row[-1])\n\n if rowNumber == currRow and columnNumber == currCol:\n tileFound = True\n if rowNumber == 1:\n row1 += tuple([tileNumber])\n elif rowNumber == 2:\n row2 += tuple([tileNumber])\n elif rowNumber == 3:\n row3 += tuple([tileNumber])\n \n break\n\n if not tileFound:\n if currRow == 1:\n row1 += tuple([-1])\n elif currRow == 2:\n row2 += tuple([-1])\n elif currRow == 3:\n row3 += tuple([-1])\n\n\n return (row1, row2, row3)","def __get_row(self, index):\n counts = {\n self.player_char: 0,\n self.opponent_char: 0,\n 'empty': []\n }\n for i in range(0, 3):\n if self.state[(index*3)+i] is self.player_char:\n counts[self.player_char] += 1\n elif self.state[(index*3)+i] is self.opponent_char:\n counts[self.opponent_char] += 1\n else:\n counts['empty'].append((index*3)+i)\n return counts","def winning_event(self, player):\n # vertical check\n for col in range(GameData.columns):\n if self.board[0][col] == player and self.board[1][col] == player and self.board[2][col] == player:\n self.draw_vertical_winning_line(col, player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # horizontal check\n for row in range(GameData.rows):\n if self.board[row][0] == player and self.board[row][1] == player and self.board[row][2] == player:\n self.draw_horizontal_winning_line(row, player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # ascending diagonal heck\n if self.board[2][0] == player and self.board[1][1] == player and self.board[0][2] == player:\n self.draw_asc_diagonal(player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # descending diagonal win chek\n if self.board[0][0] == player and self.board[1][1] == player and self.board[2][2] == player:\n self.draw_desc_diagonal(player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n return False","def check_game_status(self):\n for player in (\"1\", \"2\"):\n row_win = np.apply_along_axis(\n lambda x: set(x) == {player}, 1, self.board\n ).any()\n col_win = np.apply_along_axis(\n lambda x: set(x) == {player}, 0, self.board\n ).any()\n d1_win = set(self.data[[0, 4, 8]]) == {player}\n d2_win = set(self.data[[2, 4, 6]]) == {player}\n if any([row_win, col_win, d1_win, d2_win]):\n return (\"win\", player)\n\n if self.counter[\"_\"] == 0:\n return (\"tie\", None)\n else:\n return (\"turn\", \"1\" if self.counter[\"1\"] == self.counter[\"2\"] else \"2\")","def exitsinrow(self,rows,row,num):\r\n for i in range(9):\r\n if(rows[row][i] == num):\r\n return True\r\n return False","def move(self, row, col, player):\n offset = player * 2 - 3 # 1 or -1\n self.row[row] += offset\n self.col[col] += offset\n if row == col:\n self.diag += offset\n if row + col == self.n - 1:\n self.anti_diag += offset\n if self.n in [self.row[row], self.col[col], self.diag, self.anti_diag]:\n return 2\n if -self.n in [self.row[row], self.col[col], self.diag, self.anti_diag]:\n return 1\n return 0","def evaluateBoardState(self, board):\n\n \"\"\"\n These are the variables and functions for board objects which may be helpful when creating your Agent.\n Look into board.py for more information/descriptions of each, or to look for any other definitions which may help you.\n\n Board Variables:\n board.width \n board.height\n board.last_move\n board.num_to_connect\n board.winning_zones\n board.score_array \n board.current_player_score\n\n Board Functions:\n get_cell_value(row, col)\n try_move(col)\n valid_move(row, col)\n valid_moves()\n terminal(self)\n legal_moves()\n next_state(turn)\n winner()\n \"\"\"\n if self.id == 1:\n opponent_id = 2\n else:\n opponent_id = 1\n\n maxvalue = 100000\n minvalue = -maxvalue\n winner = board.winner()\n if winner == self.id:\n return maxvalue\n elif winner == opponent_id:\n return minvalue\n size_y = board.height\n size_x = board.width\n map_ = []\n num_to_connect = board.num_to_connect\n total_points = 0\n\n multiply_reachable = 1\n multiply_oddeven = 1\n # basically this function is calculating all the possible win positions\n # more pieces in a possible win position will be counted with more weights\n # a win position with X pieces in it will be counted as X^2 points\n # initialise the zones maps\n for i in range(size_y):\n map_.append([])\n for j in range(size_x):\n map_[i].append([])\n\n # Fill in the horizontal win positions\n for i in range(size_y):\n for j in range(size_x - num_to_connect + 1):\n points = 0\n self_pieces_count = 0\n opponent_pieces_count = 0\n for k in range(num_to_connect):\n if board.board[i][j + k] == opponent_id:\n opponent_pieces_count += 1\n elif board.board[i][j + k] == self.id:\n points += len(board.winning_zones[j+k][i])\n if (self.id == 1 and i % 2 == 1) or (self.id == 2 and i%2 == 0):\n points *= multiply_oddeven\n self_pieces_count += 1\n if self_pieces_count == 3 and opponent_pieces_count == 0:\n if j - 1 >= 0 and board.board[i][j + 3] == 0 and board.board[i][j - 1] == 0 \\\n and board.try_move(j + 3) == i and board.try_move(j - 1) == i:\n return maxvalue\n elif j + 4 < size_y and board.board[i][j + 4] == 0 and board.board[i][j] == 0 \\\n and board.try_move(j + 4) == i and board.try_move(j) == i:\n return maxvalue\n else:\n for k in range(num_to_connect):\n if board.board[i][j + k] == 0 and board.try_move(j + k) == i:\n points *= multiply_reachable\n elif opponent_pieces_count == 3 and self_pieces_count == 0:\n if j - 1 >= 0 and board.board[i][j + 3] == 0 and board.board[i][j - 1] == 0 \\\n and board.try_move(j + 3) == i and board.try_move(j - 1) == i:\n return minvalue\n elif j + 4 < size_y and board.board[i][j + 4] == 0 and board.board[i][j] == 0 \\\n and board.try_move(j + 4) == i and board.try_move(j) == i:\n return minvalue\n # else:\n # for k in range(num_to_connect):\n # if board.board[i][j + k] == 0 and board.try_move(j + k) == i:\n # points *= -multiply_reachable\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\n total_points += points\n\n # Fill in the vertical win positions\n for i in range(size_x):\n for j in range(size_y - num_to_connect + 1):\n points = 0\n self_pieces_count = 0\n for k in range(num_to_connect):\n if board.board[j + k][i] == opponent_id:\n opponent_pieces_count += 1\n elif board.board[j + k][i] == self.id:\n points += len(board.winning_zones[i][j+k])\n if (self.id == 1 and (j+k) % 2 == 1) or (self.id == 2 and (j+k)%2 == 0):\n points *= multiply_oddeven\n self_pieces_count += 1\n points *= multiply_reachable\n # if opponent_pieces_count == 3 and self_pieces_count == 0:\n # points *= -1\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\n total_points += points\n\n # Fill in the forward diagonal win positions\n for i in range(size_y - num_to_connect + 1):\n for j in range(size_x - num_to_connect + 1):\n points = 0\n self_pieces_count = 0\n opponent_pieces_count = 0\n for k in range(num_to_connect):\n if board.board[i + k][j + k] == opponent_id:\n opponent_pieces_count += 1\n elif board.board[i + k][j + k] == self.id:\n points += len(board.winning_zones[j+k][i+k])\n if (self.id == 1 and (i+k) % 2 == 1) or (self.id == 2 and (i+k)%2 == 0):\n points *= multiply_oddeven\n self_pieces_count += 1\n if self_pieces_count == 3 and opponent_pieces_count == 0:\n if i - 1 >= 0 and j - 1 >= 0 and board.board[i + 3][j + 3] == 0 and board.board[i - 1][j - 1] == 0 \\\n and board.try_move(j + 3) == i + 3 and board.try_move(j - 1) == i - 1:\n return maxvalue\n elif i + 4 < size_y and j + 4 < size_x and board.board[i + 4][j + 4] == 0 and board.board[i][j] == 0 \\\n and board.try_move(j + 4) == i + 4 and board.try_move(j) == i:\n return maxvalue\n else:\n for k in range(num_to_connect):\n if board.board[i + k][j + k] == 0 and board.try_move(j + k) == i + k:\n points *= multiply_reachable\n elif opponent_pieces_count == 3 and self_pieces_count == 0:\n if i - 1 >= 0 and j - 1 >= 0 and board.board[i + 3][j + 3] == 0 and board.board[i - 1][j - 1] == 0 \\\n and board.try_move(j + 3) == i + 3 and board.try_move(j - 1) == i - 1:\n return minvalue\n elif i + 4 < size_y and j + 4 < size_x and board.board[i + 4][j + 4] == 0 and board.board[i][j] == 0 \\\n and board.try_move(j + 4) == i + 4 and board.try_move(j) == i:\n return minvalue\n # else:\n # for k in range(num_to_connect):\n # if board.board[i + k][j + k] == 0 and board.try_move(j + k) == i + k:\n # points *= -multiply_reachable\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\n total_points += points\n\n # Fill in the backward diagonal win positions\n for i in range(size_y - num_to_connect + 1):\n for j in range(size_x - 1, num_to_connect - 1 - 1, -1):\n points = 0\n self_pieces_count = 0\n opponent_pieces_count = 0\n for k in range(num_to_connect):\n if board.board[i + k][j - k] == opponent_id:\n opponent_pieces_count += 1\n elif board.board[i + k][j - k] == self.id:\n points += len(board.winning_zones[j-k][i+k])\n if (self.id == 1 and (i+k) % 2 == 1) or (self.id == 2 and (i+k)%2 == 0):\n points *= multiply_oddeven\n self_pieces_count += 1\n if self_pieces_count == 3 and self_pieces_count == 0:\n if board.board[i + 3][j - 3] == 0 and board.board[i - 1][j + 1] == 0 \\\n and board.try_move(j - 3) == i + 3 and board.try_move(j + 1) == i - 1:\n return maxvalue\n elif i + 4 < size_y and j - 4 >= 0 and board.board[i + 4][j - 4] == 0 and board.board[i][j] == 0 \\\n and board.try_move(j - 4) == i + 4 and board.try_move(j) == i:\n return maxvalue\n else:\n for k in range(num_to_connect):\n if board.board[i + k][j - k] == 0 and board.try_move(j - k) == i + k:\n points *= multiply_reachable\n\n elif opponent_pieces_count == 3 and self_pieces_count == 0:\n if board.board[i + 3][j - 3] == 0 and board.board[i - 1][j + 1] == 0 \\\n and board.try_move(j - 3) == i + 3 and board.try_move(j + 1) == i - 1:\n return minvalue\n elif i + 4 < size_y and j - 4 >= 0 and board.board[i + 4][j - 4] == 0 and board.board[i][j] == 0 \\\n and board.try_move(j - 4) == i + 4 and board.try_move(j) == i:\n return minvalue\n # else:\n # for k in range(num_to_connect):\n # if board.board[i + k][j - k] == 0 and board.try_move(j - k) == i + k:\n # points *= -multiply_reachable\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\n total_points += points\n return total_points","def update_state_v1(self, dbsession, state):\n moving_player = self.active_player()\n board = self.update(state)\n table_game = dbsession.query(TableGame).filter(\n TableGame.game == board.id).first()\n table_board = TableBoard(\n board_state=dumps(tuple(map(tuple, board.board))),\n move_num=board._board.move_count,\n player=board.active_player(),\n game=board.id)\n if table_game: # TODO(grandquista)\n table_board.game_link.append(table_game)\n dbsession.add(table_board)\n if board:\n board.poke_player(False)\n return {'end': False}\n board.poke_player(True, moving_player)\n if board._board.has_kings():\n table_game.one_won = False\n table_game.two_won = False\n elif moving_player == table_game.player_one:\n table_game.two_won = False\n else:\n table_game.one_won = False\n board.close()\n return {'end': True}","def answer_exercise():\n state = \"1212__21_\"\n ttt = TicTacToe(state)\n game_tree = gen_game_tree(state)\n print(\n f\"The value of game state:\\n{ttt.printable_board(' ', legend_hint=False)}\\n\"\n f\"is {game_tree[state]['value']}\"\n )\n return game_tree[state][\"value\"]","def __init__(self, n: int):\n self.rows = [[n, -1] for _ in range(n)]\n self.cols = [[n, -1] for _ in range(n)]\n self.diag = [[n, -1], [n, -1]] # 0 for normal, 1 for anti\n \n def move(self, row: int, col: int, player: int) -> int:\n r1, r2 = self.check(self.rows, row, player), self.check(self.cols, col, player)\n r3, r4 = 0, 0\n if(row == col):\n r3 = self.check(self.diag, 0, player)\n if(row + col == len(self.rows)-1):\n r4 = self.check(self.diag, 1, player)\n \n return max(r1,r2,r3,r4)\n def check(self, arr, i, player):\n arr[i][0] -= 1\n \n if(arr[i][1] == -1):\n arr[i][1] = player\n elif(arr[i][1] != player):\n arr[i][1] = 0\n \n if(arr[i][0] == 0 and arr[i][1] != 0):\n return player\n return 0\n \n \"\"\"\n Player {player} makes a move at ({row}, {col}).\n @param row The row of the board.\n @param col The column of the board.\n @param player The player, can be either 1 or 2.\n @return The current winning condition, can be either:\n 0: No one wins.\n 1: Player 1 wins.\n 2: Player 2 wins.\n \"\"\"\n ","def check_victory(board):\n\n for row in range(HEIGHT):\n for col in range(WIDTH):\n\n player = board[row][col]\n\n # not a player move\n if player == 0 or player == 9:\n continue\n\n # look right\n if col + 3 < WIDTH and player == board[row][col + 1] and player == board[row][col + 2]\\\n and player == board[row][col + 3]:\n if player == 1:\n return +1\n else:\n return -1\n\n if row + 3 < HEIGHT:\n\n # down\n if player == board[row + 1][col] and player == board[row + 2][col] and player == board[row + 3][col]:\n if player == 1:\n return +1\n else:\n return -1\n\n # down and right\n if col + 3 < WIDTH and player == board[row + 1][col + 1] and player == board[row + 2][col + 2]\\\n and player == board[row + 3][col + 3]:\n if player == 1:\n return +1\n else:\n return -1\n\n # down and left\n if col - 3 >= 0 and player == board[row + 1][col - 1] and player == board[row + 2][col - 2] \\\n and player == board[row + 3][col - 3]:\n if player == 1:\n return +1\n else:\n return -1\n\n\n # # if no one has won yet\n for row in range(HEIGHT):\n for col in range(WIDTH):\n if board[row][col] == 0 or board[row][col] == 9:\n return None\n\n return 0","def current_state(self):\n square_state = np.zeros((4, self.width, self.height))\n if self.states:\n for i in range(8):\n for j in range(8):\n if self.board_value[i][j]==self.current_player:\n square_state[0][i][j]=1\n elif self.board_value[i][j]!=self.current_player and self.board_value[i][j]!= 0:\n square_state[1][i][j]=1\n # indicate the last move location\n square_state[2][self.last_move // self.width, self.last_move % self.height] = 1.0\n if len(self.states) % 2 == 0:\n square_state[3][:, :] = 1.0 # indicate the colour to play\n return square_state[:, ::-1, :]","def win_column(playerid):\n\n if board[0][0] is playerid and board[1][0] is playerid and board[2][0] is playerid:\n return (True, \"Column 1\")\n\n if board[0][1] is playerid and board[1][1] is playerid and board[2][1] is playerid:\n return (True, \"Column 2\")\n\n if board[0][2] is playerid and board[1][2] is playerid and board[2][2] is playerid:\n return (True, \"Column 3\")\n\n return False","def update_cell(self, player: str, letter: str) -> 'Cell':\n if self.player == 0 and self.letter == letter:\n self.player = 1 if player == 'p1' else 2\n return self","def new_or_old_piece(self, state):\r\n x_moves, o_moves = 0, 0\r\n\r\n for row_values in state:\r\n x_moves += row_values.count('x')\r\n o_moves += row_values.count('o')\r\n\r\n if x_moves + o_moves < 6:\r\n if x_moves > o_moves:\r\n return True, 'o'\r\n elif o_moves < x_moves:\r\n return True, 'x'\r\n else:\r\n return True, 'x'\r\n\r\n return False, None","def evaluate_model_at_gamestate(gamestate, model):\n # Transform full board into 2 boards of 0s and 1s\n board = gamestate.board\n player1_board = np.array([\n [\n 0 if val == 0 or val == 2 else 1\n for val in row\n ]\n for row in board\n ])\n player2_board = np.array([\n [\n 0 if val == 0 or val == 1 else 1\n for val in row\n ]\n for row in board\n ])\n\n # Player is the player who created this state (NOT next)\n if other_player(gamestate.next_player) == 1:\n channels = [player1_board, player2_board]\n else:\n channels = [player2_board, player1_board]\n\n x_train = np.stack(channels).reshape(1, 2, 8, 8)\n\n value, policy = _evaluate(x_train, load_model(model))\n value_np = value.detach().numpy() # value.cpu().detach().numpy() when running remotely\n policy_np = policy.detach().numpy() # policy.cpu().detach().numpy() when running remotely\n\n return value_np[0], np.exp(policy_np.flatten().reshape(8, 8))","def result(self, state, action):\n state_after_act = [[0 for i in range(self.col)] for j in range(self.row)]\n for k in action:\n x = k[1][0]\n y = k[1][1]\n if k[0] == \"vaccinate\":\n state_after_act[x][y] = ('I', 1)\n else:\n state_after_act[x][y] = ('Q', 1)\n\n for i in range(self.row):\n for j in range(self.col):\n if state_after_act[i][j] == 0:\n if state[i][j][0] == 'U' or state[i][j][0] == 'I':\n state_after_act[i][j] = state[i][j]\n\n elif state[i][j][0] == 'S':\n if state[i][j][1] == 3:\n state_after_act[i][j] = ('H', 1)\n else:\n if state[i][j][1] == 1:\n state_after_act[i][j] = ('S', 2)\n elif state[i][j][1] == 2:\n state_after_act[i][j] = ('S', 3)\n\n elif state[i][j][0] == 'Q':\n if state[i][j][1] == 2:\n state_after_act[i][j] = ('H', 1)\n else:\n state_after_act[i][j] = ('Q', 2)\n\n elif state[i][j][0] == 'H':\n state_after_act[i][j] = self.healthy(i, j, state,state_after_act)\n state_after_act[i] = tuple(state_after_act[i])\n return tuple(state_after_act)","def check_board(board_state, player_symbol, display_message = False):\n\n is_board_completely_filled = board_state.isalpha()\n\n indices_set = set([ind+1 for ind, val in enumerate(board_state) if val == player_symbol])\n\n if {1, 2, 3}.issubset(indices_set) or {4, 5, 6}.issubset(indices_set) or {7, 8, 9}.issubset(indices_set):\n\n if display_message:\n print(\"Row completed..!!!\")\n print(\"Player \"+player_symbol+\" won the game.\")\n\n return True\n\n if {1, 4, 7}.issubset(indices_set) or {2, 5, 8}.issubset(indices_set) or {3, 6, 9}.issubset(indices_set):\n\n if display_message:\n print(\"Column completed..!!!\")\n print(\"Player \"+player_symbol+\" won the game.\")\n\n return True\n if {1, 5, 9}.issubset(indices_set) or {3, 5, 7}.issubset(indices_set):\n\n if display_message:\n print(\"Diagonal completed..!!!\")\n print(\"Player \"+player_symbol+\" won the game.\")\n\n return True\n\n if is_board_completely_filled:\n\n if display_message:\n print(\"Game is drawn...!\")\n\n return \"Draw\"\n\n return False","def column_wise_checking(player_):\n if board[0] == board[3] == player_:\n return 6\n elif board[3] == board[6] == player_:\n return 0\n elif board[1] == board[4] == player_:\n return 7\n elif board[4] == board[7] == player_:\n return 1\n elif board[2] == board[5] == player_:\n return 8\n elif board[5] == board[8] == player_:\n return 2\n else:\n return -1","def getGameState(self):\n row1 = [0, 0, 0]\n row2 = [0, 0, 0]\n row3 = [0, 0, 0]\n tilePosStatement = Statement()\n posTerm1 = Term('?x')\n posTerm2 = Term('?y')\n posTerm3 = Term('?tile')\n tilePosStatement.terms = (posTerm1, posTerm2, posTerm3)\n tilePosStatement.predicate = 'tilePos'\n for fact in self.kb.facts:\n if match(fact.statement, tilePosStatement):\n if fact.statement.terms[2] == Term(Constant('tile1')):\n term = 1\n if fact.statement.terms[2] == Term(Constant('tile2')):\n term = 2\n if fact.statement.terms[2] == Term(Constant('tile3')):\n term = 3\n if fact.statement.terms[2] == Term(Constant('tile4')):\n term = 4\n if fact.statement.terms[2] == Term(Constant('tile5')):\n term = 5\n if fact.statement.terms[2] == Term(Constant('tile6')):\n term = 6\n if fact.statement.terms[2] == Term(Constant('tile7')):\n term = 7\n if fact.statement.terms[2] == Term(Constant('tile8')):\n term = 8\n if fact.statement.terms[2] == Term(Constant('empty')):\n term = -1\n if fact.statement.terms[0] == Term(Constant('pos1')):\n col = 0\n elif fact.statement.terms[0] == Term(Constant('pos2')):\n col = 1\n elif fact.statement.terms[0] == Term(Constant('pos3')):\n col = 2\n if fact.statement.terms[1] == Term(Constant('pos1')):\n row1[col] = term\n\n elif fact.statement.terms[1] == Term(Constant('pos2')):\n row2[col] = term\n\n elif fact.statement.terms[1] == Term(Constant('pos3')):\n row3[col] = term\n\n row1 = tuple(row1)\n row2 = tuple(row2)\n row3 = tuple(row3)\n result = (row1, row2, row3)\n return result\n\n ### Student code goes here","def evaluate(self) :\n for inp in self.inStates :\n if inp.getState() == 0 : return 0\n return 1","def play(self, player: players.Player) -> int:\n # A player first look at the board\n player.peek(self)\n position = player.play()\n # print(position)\n row, col = utils.index2coordinate(position, self.game_board.size)\n self.put_piece(row, col)\n\n # Check status after move\n status_after_play = self.check_status(row, col)\n\n return status_after_play","def cell_entered(self, row: int, _):\n self.selectRow(row)","def player(board):\n\tif board == initial_state():\n\t\treturn X\n\n\tnumX=0\n\tnumO=0\n\n\tfor i in range(len(board)):\n\t\tfor j in range(len(board)):\n\t\t\tif(board[i][j]==X):\n\t\t\t\tnumX+=1\n\t\t\telif(board[i][j]==O):\n\t\t\t\tnumO+=1\n\n\tif numX > numO:\n\t\treturn O\n\telse:\n\t\treturn X","def evaluate_line(board, player, index1, index2, index3):\n opponent = utils.get_opponent(player)\n line_counts = Counter([board[index1], board[index2], board[index3]])\n if line_counts[player] > 0 and line_counts[opponent] > 0:\n return 0 # line has player and opponent values = dead line\n if line_counts[opponent] == 0:\n return int(pow(10, line_counts[player] - 1)) # line has only player values\n return -int(pow(10, line_counts[opponent] - 1)) # line has only opponent values","def stand_in_cell(self, player, board):\n\n if self.owner is None and player.money >= self.cost:\n return 1\n elif player.money < self.cost and self.owner is None:\n return -1\n elif self.owner == player:\n return -2\n elif self.owner is not None:\n return 3","def legitimateMoves(table,floor,X2,Y2,goes,csvX):\n scores = []\n legitimateColumns = []\n try:\n i = 0\n while True:\n if floor[i] != -1:\n legitimateColumns.append(i)\n i=i+1\n \n except IndexError:\n pass\n #print(legitimateColumns)\n for x in legitimateColumns:\n \n table[floor[x]][x] = \"x\"\n gameArray = []\n for z in range(7):\n for i in range(5,-1,-1):\n gameArray.append(table[i][z])\n \n \n gameArray = np.asarray(gameArray)\n gameArray = np.reshape(gameArray, (1,42))\n #print(gameArray)\n np.append(X2, gameArray)\n\n \n \n if checkWin(table,x,True,floor,\"x\") == \"win\":\n goes = goes+1\n finished(table,csvX,goes,X2,floor)\n\n elif checkWin(table,x,True,floor,\"o\") == \"win\":\n table[floor[x]][x] = \"b\"\n return(x)\n else:\n #print(\"norm\")\n #print(a[0][0])\n table[floor[x]][x] = \"b\"\n #scores.append(a[0][0])\n #print(gameArray)\n\n a = trainer(True,X2,-1,Y2,goes,csvX)\n\n for x in a:\n scores.append(x)\n \n #print(scores)\n scores2 = []\n for x in legitimateColumns:\n scores2.append(scores[x])\n scores = scores2\n best = max(scores) \n best_index = scores.index(best)\n col = legitimateColumns[best_index]\n #print(col)\n return(col)\n #floor[humanInput]=floor[humanInput]-1 ","def run_simulation(self, state):\n \"*** YOUR CODE HERE ***\"\n player = 0\n visited_states = [(player, state)]\n depth_limited = self.depth != -1\n depth = self.depth\n expand = True\n while not visited_states[-1][1].isWin() and not visited_states[-1][1].isLose():\n if depth_limited and depth == 0: break\n state = self.UCB1(state, player) # Selection & Simulation\n if expand and state not in self.plays: # Expansion\n expand = False\n self.plays[state] = 0\n self.wins[state] = 0\n visited_states.append((player, state))\n player = (player + 1) % state.getNumAgents()\n if not expand and depth_limited and player == 0: depth -= 1\n \n for player, state in visited_states:\n if state in self.plays: # Not simulated nodes\n self.plays[state] += 1\n eval = self.evaluationFunction(visited_states[-1][1])\n if depth_limited:\n if player == 0: self.wins[state] += eval\n if player != 0: self.wins[state] -= eval\n else:\n if player == 0: self.wins[state] += eval\n if player != 0: self.wins[state] += (1 - eval)","def scoreGame(self):\n # create valueLs[card1,card2,...], pass it to sumHandReturnPoints(valueLs) or twoCardReturnPoints(valueLs)\n scoreLs = []\n ### Score of row\n for rowKey in self.table:\n valueLs = self.table[rowKey]\n points = self.sumHandReturnPoints(valueLs)\n scoreLs.append(points)\n\n ### Score of 4-card column\n for offset in range(0,3): # 0,1,2\n tmpLs = []\n for rowKey in self.table:\n valueLs = self.table[rowKey]\n if len(valueLs) == 5:\n iterStart = 1\n else:\n iterStart = 0\n card = valueLs[iterStart+offset]\n tmpLs.append(card)\n points = self.sumHandReturnPoints(tmpLs)\n scoreLs.append(points) \n\n ### Score of 2-card column\n #(1) 1st column\n valueLs1 = self.table['row1']\n valueLs2 = self.table['row2']\n tmpLs = []\n tmpLs.append(valueLs1[0].get_rank())\n tmpLs.append(valueLs2[0].get_rank())\n points = self.twoCardReturnPoints(tmpLs)\n scoreLs.append(points)\n #(2) 5th column\n valueLs3 = self.table['row1']\n valueLs4 = self.table['row2']\n tmpLs = []\n tmpLs.append(valueLs3[-1].get_rank())\n tmpLs.append(valueLs4[-1].get_rank())\n points = self.twoCardReturnPoints(tmpLs)\n scoreLs.append(points) \n\n ### Add up scoreLs\n sumPoints = 0\n for points in scoreLs:\n sumPoints += points\n return sumPoints","def evaluate(self, state, player, random_state):\n result = 0.0\n for _ in range(self.n_rollouts):\n working_state = state.clone()\n while not working_state.is_terminal():\n if working_state.is_chance_node():\n outcomes = working_state.chance_outcomes()\n action_list, prob_list = zip(*outcomes)\n action = random_state.choice(action_list, p=prob_list)\n else:\n action = random_state.choice(working_state.legal_actions())\n working_state.apply_action(action)\n result += working_state.player_return(player)\n\n return result / self.n_rollouts","def outcome(self):\n if self.grid[0][0] == self.grid[1][0] == self.grid[2][0] and self.grid[0][0] != 0:\n return self.grid[0][0]\n if self.grid[0][1] == self.grid[1][1] == self.grid[2][1] and self.grid[0][1] != 0:\n return self.grid[0][1]\n if self.grid[0][2] == self.grid[1][2] == self.grid[2][2] and self.grid[0][2] != 0:\n return self.grid[0][2]\n if self.grid[0][0] == self.grid[0][1] == self.grid[0][2] and self.grid[0][0] != 0:\n return self.grid[0][0]\n if self.grid[1][0] == self.grid[1][1] == self.grid[1][2] and self.grid[1][0] != 0:\n return self.grid[1][0]\n if self.grid[2][0] == self.grid[2][1] == self.grid[2][2] and self.grid[2][0] != 0:\n return self.grid[2][0]\n if self.grid[0][0] == self.grid[1][1] == self.grid[2][2] and self.grid[0][0] != 0:\n return self.grid[0][0]\n if self.grid[0][2] == self.grid[1][1] == self.grid[2][0] and self.grid[0][2] != 0:\n return self.grid[0][2]\n return 0","def isSolved(board):\n for player in [1, 2]:\n if [player]*3 in chain(\n board, # Rows\n zip(board), # Columns\n [ # Diagonals\n [board[i][i] for i in range(len(board))],\n [board[len(board) - i - 1][i] for i in range(len(board))]\n ]\n ):\n return player\n return -1 if 0 in chain(*board) else 0","def apply_move(self, move, state):\n x, y , heading, grid_data = state\n map_data = [row[:] for row in grid_data]\n if move == self.MOVE_FORWARD:\n # get coordinates for next cell\n if heading == self.UP:\n next_y = y - 1\n next_x = x\n elif heading == self.DOWN:\n next_y = y + 1\n next_x = x\n elif heading == self.LEFT:\n next_y = y\n next_x = x - 1\n else:\n next_y = y\n next_x = x + 1\n\n # handle special tile types\n if map_data[next_y][next_x] == self.ICE_SYMBOL:\n # handle ice tile - slide until first non-ice tile or blocked\n if heading == self.UP:\n for i in range(next_y, -1, -1):\n if map_data[i][next_x] != self.ICE_SYMBOL:\n if map_data[i][next_x] == self.WATER_SYMBOL:\n # slide into water - game over\n return self.GAME_OVER\n elif self.cell_is_blocked(i, next_x, map_data):\n # if blocked, stop on last ice cell\n next_y = i + 1\n break\n else:\n next_y = i\n break\n elif heading == self.DOWN:\n for i in range(next_y, self.y_size):\n if map_data[i][next_x] != self.ICE_SYMBOL:\n if map_data[i][next_x] == self.WATER_SYMBOL:\n # slide into water - game over\n return self.GAME_OVER\n elif self.cell_is_blocked(i, next_x, map_data):\n # if blocked, stop on last ice cell\n next_y = i - 1\n break\n else:\n next_y = i\n break\n elif heading == self.LEFT:\n for i in range(next_x, -1, -1):\n if map_data[next_y][i] != self.ICE_SYMBOL:\n if map_data[next_y][i] == self.WATER_SYMBOL:\n # slide into water - game over\n return self.GAME_OVER\n elif self.cell_is_blocked(next_y, i, map_data):\n # if blocked, stop on last ice cell\n next_x = i + 1\n break\n else:\n next_x = i\n break\n else:\n for i in range(next_x, self.x_size):\n if map_data[next_y][i] != self.ICE_SYMBOL:\n if map_data[next_y][i] == self.WATER_SYMBOL:\n # slide into water - game over\n return self.GAME_OVER\n elif self.cell_is_blocked(next_y, i, map_data):\n # if blocked, stop on last ice cell\n next_x = i - 1\n break\n else:\n next_x = i\n break\n if map_data[next_y][next_x] == self.TELEPORT_SYMBOL:\n # handle teleport - find the other teleporter\n tpy, tpx = (None, None)\n for i in range(self.y_size):\n for j in range(self.x_size):\n if map_data[i][j] == self.TELEPORT_SYMBOL and (i != next_y or j != next_x):\n tpy, tpx = (i, j)\n break\n if tpy is not None:\n break\n if tpy is None:\n raise Exception(\"LaserTank Map Error: Unmatched teleport symbol\")\n next_y, next_x = (tpy, tpx)\n else:\n # if not ice or teleport, perform collision check\n if self.cell_is_blocked(next_y, next_x, map_data):\n return self.COLLISION\n\n # check for game over conditions\n if self.cell_is_game_over(next_y, next_x, map_data):\n return self.GAME_OVER\n\n # no collision and no game over - update player position\n y = next_y\n x = next_x\n return (x, y, heading, map_data)\n\n elif move == self.TURN_LEFT:\n # no collision or game over possible\n if heading == self.UP:\n heading = self.LEFT\n elif heading == self.DOWN:\n heading = self.RIGHT\n elif heading == self.LEFT:\n heading = self.DOWN\n else:\n heading = self.UP\n return (x, y, heading, map_data)\n\n elif move == self.TURN_RIGHT:\n # no collision or game over possible\n if heading == self.UP:\n heading = self.RIGHT\n elif heading == self.DOWN:\n heading = self.LEFT\n elif heading == self.LEFT:\n heading = self.UP\n else:\n heading = self.DOWN\n return (x, y, heading, map_data)\n\n elif move == self.SHOOT_LASER:\n # set laser direction\n if heading == self.UP:\n laserheading = self.UP\n dy, dx = (-1, 0)\n elif heading == self.DOWN:\n laserheading = self.DOWN\n dy, dx = (1, 0)\n elif heading == self.LEFT:\n laserheading = self.LEFT\n dy, dx = (0, -1)\n else:\n laserheading = self.RIGHT\n dy, dx = (0, 1)\n\n # loop until laser blocking object reached\n ly, lx = (y, x)\n while True:\n ly += dy\n lx += dx\n\n # handle boundary and immovable obstacles\n if ly < 0 or ly >= self.y_size or \\\n lx < 0 or lx >= self.x_size or \\\n map_data[ly][lx] == self.OBSTACLE_SYMBOL:\n # laser stopped without effect\n return self.COLLISION\n\n # handle movable objects\n elif self.cell_is_laser_movable(ly, lx, laserheading, map_data):\n # check if tile can be moved without collision\n if self.cell_is_blocked(ly + dy, lx + dx, map_data) or \\\n map_data[ly + dy][lx + dx] == self.ICE_SYMBOL or \\\n map_data[ly + dy][lx + dx] == self.TELEPORT_SYMBOL or \\\n map_data[ly + dy][lx + dx] == self.FLAG_SYMBOL or \\\n (ly + dy == y and lx + dx == x):\n # tile cannot be moved\n return self.COLLISION\n else:\n old_symbol = map_data[ly][lx]\n map_data[ly][lx] = self.LAND_SYMBOL\n if map_data[ly + dy][lx + dx] == self.WATER_SYMBOL:\n # if new bridge position is water, convert to land tile\n if old_symbol == self.BRIDGE_SYMBOL:\n map_data[ly + dy][lx + dx] = self.LAND_SYMBOL\n # otherwise, do not replace the old symbol\n else:\n # otherwise, move the tile forward\n map_data[ly + dy][lx + dx] = old_symbol\n break\n\n # handle bricks\n elif map_data[ly][lx] == self.BRICK_SYMBOL:\n # remove brick, replace with land\n map_data[ly][lx] = self.LAND_SYMBOL\n break\n\n # handle facing anti-tanks\n elif (map_data[ly][lx] == self.ANTI_TANK_UP_SYMBOL and laserheading == self.DOWN) or \\\n (map_data[ly][lx] == self.ANTI_TANK_DOWN_SYMBOL and laserheading == self.UP) or \\\n (map_data[ly][lx] == self.ANTI_TANK_LEFT_SYMBOL and laserheading == self.RIGHT) or \\\n (map_data[ly][lx] == self.ANTI_TANK_RIGHT_SYMBOL and laserheading == self.LEFT):\n # mark anti-tank as destroyed\n map_data[ly][lx] = self.ANTI_TANK_DESTROYED_SYMBOL\n break\n\n # handle player laser collision\n elif ly == y and lx == x:\n return self.GAME_OVER\n\n # handle facing mirrors\n elif (map_data[ly][lx] == self.MIRROR_UL_SYMBOL and laserheading == self.RIGHT) or \\\n (map_data[ly][lx] == self.MIRROR_UR_SYMBOL and laserheading == self.LEFT):\n # new direction is up\n dy, dx = (-1, 0)\n laserheading = self.UP\n elif (map_data[ly][lx] == self.MIRROR_DL_SYMBOL and laserheading == self.RIGHT) or \\\n (self.grid_data[ly][lx] == self.MIRROR_DR_SYMBOL and laserheading == self.LEFT):\n # new direction is down\n dy, dx = (1, 0)\n laserheading = self.DOWN\n elif (map_data[ly][lx] == self.MIRROR_UL_SYMBOL and laserheading == self.DOWN) or \\\n (map_data[ly][lx] == self.MIRROR_DL_SYMBOL and laserheading == self.UP):\n # new direction is left\n dy, dx = (0, -1)\n laserheading = self.LEFT\n elif (map_data[ly][lx] == self.MIRROR_UR_SYMBOL and laserheading == self.DOWN) or \\\n (map_data[ly][lx] == self.MIRROR_DR_SYMBOL and laserheading == self.UP):\n # new direction is right\n dy, dx = (0, 1)\n laserheading = self.RIGHT\n # do not terminate laser on facing mirror - keep looping\n\n # check for game over condition after effect of laser\n if self.cell_is_game_over(y, x, map_data):\n return self.GAME_OVER\n return (x, y, heading, map_data)\n return self.SUCCESS"],"string":"[\n \"def evaluate(self, state, my_row):\\n myStones = 0.0\\n opponentStones = 0.0\\n for i in range(len(state.board)):\\n if my_row == 0:\\n if i <= State.M:\\n myStones += state.board[i]\\n else:\\n opponentStones += state.board[i]\\n else:\\n if i <= State.M:\\n opponentStones += state.board[i]\\n else:\\n myStones += state.board[i]\\n return (myStones - opponentStones)/(2*State.M*State.N)\",\n \"def game_value(self, state):\\n # check horizontal wins\\n for row in state:\\n for i in range(2):\\n if row[i] != ' ' and row[i] == row[i+1] == row[i+2] == row[i+3]:\\n return 1 if row[i]==self.my_piece else -1\\n\\n # check vertical wins\\n for col in range(5):\\n for i in range(2):\\n if state[i][col] != ' ' and state[i][col] == state[i+1][col] == state[i+2][col] == state[i+3][col]:\\n return 1 if state[i][col]==self.my_piece else -1\\n\\n # TODO: check \\\\ diagonal wins\\n for col in range(2):\\n for i in range(2):\\n if state[i][col] != ' ' and state[i][col] == state[i+1][col+1] == state[i+2][col+2] == state[i+3][col+3]:\\n return 1 if state[i][col]==self.my_piece else -1\\n # TODO: check / diagonal wins\\n for col in range(2):\\n for i in range(2):\\n if state[i][col+3] != ' ' and state[i][col+3] == state[i+1][col+2] == state[i+2][col+1] == state[i+3][col]:\\n return 1 if state[i][col]==self.my_piece else -1\\n # TODO: check 2x2 box wins\\n for col in range(4):\\n for i in range(4):\\n if state[i][col] != ' ' and state[i][col] == state[i+1][col] == state[i][col+1] == state[i+1][col+1]:\\n return 1 if state[i][col]==self.my_piece else -1\\n \\n return 0 # no winner yet\",\n \"def game_value(self, state):\\r\\n # check horizontal wins\\r\\n for row in state:\\r\\n for i in range(2):\\r\\n if row[i] != ' ' and row[i] == row[i+1] == row[i+2] == row[i+3]:\\r\\n return 1 if row[i] == self.my_piece else -1\\r\\n # check col wins\\r\\n for col in range(5):\\r\\n for i in range(2):\\r\\n if state[i][col] != ' ' and state[i][col] == state[i+1][col] == state[i+2][col] == state[i+3][col]:\\r\\n return 1 if state[i][col] == self.my_piece else -1\\r\\n #check diag up wins\\r\\n for x in range(2):\\r\\n for y in range(2):\\r\\n if state[x][y] != ' ' and state[x][y] == state[x+1][y+1] == state[x+2][y+2] == state[x+3][y+3]:\\r\\n return 1 if state[x][y] == self.my_piece else -1\\r\\n #check diag down wins\\r\\n for x in range(2):\\r\\n for y in range(3, 5):\\r\\n if state[x][y] != ' ' and state[x][y] == state[x+1][y-1] == state[x+2][y-2] == state[x+3][y-3]:\\r\\n return 1 if state[x][y] == self.my_piece else -1\\r\\n #check square box wins \\r\\n for x in range(4):\\r\\n for y in range(4):\\r\\n if state[x][y] != ' ' and state[x][y] == state[x+1][y] == state[x][y+1] == state[x+1][y+1]:\\r\\n return 1 if state[x][y] == self.my_piece else -1\\r\\n\\r\\n return 0 # no winner yet\\r\",\n \"def evaluate(self, state):\\n\\t\\ttranspose = state.board.transpose()\\t\\t# columns in state.board = rows in transpose\\n\\t\\tcount = []\\n\\t\\topponentcount = []\\n\\t\\tfor row, column in zip(state.board, transpose):\\n\\t\\t\\trowcounter = collections.Counter(row)\\n\\t\\t\\tcolumncounter = collections.Counter(column)\\n\\t\\t\\tcount.append(rowcounter.get(state.current_player, 0))\\n\\t\\t\\tcount.append(columncounter.get(state.current_player, 0))\\n\\t\\t\\topponentcount.append(rowcounter.get(state.current_player * - 1, 0))\\n\\t\\t\\topponentcount.append(columncounter.get(state.current_player * -1 , 0))\\n\\n\\t\\tY = state.board[:, ::-1]\\n\\t\\tdiagonals = [np.diagonal(state.board), np.diagonal(Y)]\\n\\t\\tmain_diagonal_count = collections.Counter(diagonals[0])\\n\\t\\tsecond_diagonal_count = collections.Counter(diagonals[1])\\n\\t\\tcount.append(main_diagonal_count.get(state.current_player, 0))\\n\\t\\tcount.append(second_diagonal_count.get(state.current_player, 0))\\n\\t\\topponentcount.append(main_diagonal_count.get(state.current_player * - 1, 0))\\n\\t\\topponentcount.append(second_diagonal_count.get(state.current_player * -1, 0))\\n\\n\\t\\t# max(count): maximum number of player's tiles in a row, column, or a diagonal (the highest value is 5)\\n\\t\\t# max(opponentcount): maximum number of opponent's tiles in a row, column, or a diagonal (the highest value is 5)\\n\\t\\tscoremax = 5 ** max(count)\\n\\t\\tscoremin = 5 ** max(opponentcount)\\n\\n\\t\\treturn scoremax - scoremin\",\n \"def game_value(self, state):\\n # check horizontal wins\\n for row in state:\\n for i in range(2):\\n if row[i] != ' ' and row[i] == row[i+1] == row[i+2] == row[i+3]:\\n return 1 if row[i]==self.my_piece else -1\\n\\n # check vertical wins\\n for col in range(5):\\n for i in range(2):\\n if state[i][col] != ' ' and state[i][col] == state[i+1][col] == state[i+2][col] == state[i+3][col]:\\n return 1 if state[i][col]==self.my_piece else -1\\n\\n # check \\\\ diagonal wins\\n for i in range(2):\\n for j in range(2):\\n if state[i][j]!= ' ' and state[i][j] == state[i+1][j+1] == state[i+2][j+2] == state[i+3][j+3]:\\n return 1 if state[i][j]==self.my_piece else -1\\n # check / diagonal wins\\n for i in range(3,5):\\n for j in range(2):\\n if state[i][j]!= ' ' and state[i][j] == state[i-1][j+1] == state[i-2][j+2] == state[i-3][j+3]:\\n return 1 if state[i][j]==self.my_piece else -1\\n # check diamond wins\\n for i in range(3):\\n for j in range(1,4):\\n if state[i+1][j] == ' ' and state[i][j]!= ' ' and state[i][j] == state[i+1][j-1] == state[i+1][j+1] == state[i+2][j]:\\n return 1 if state[i][j]==self.my_piece else -1\\n\\n return 0 # no winner yet\",\n \"def row_win(board, player):\\n for row in board:\\n if check_row(row, player):\\n return True\\n return False\",\n \"def check_row(row, player):\\n for marker in row:\\n if marker != player:\\n return False\\n return True\",\n \"def win_row(playerid):\\n if board[0][0] is playerid and board[0][1] is playerid and board[0][2] is playerid:\\n return (True, \\\"Row 1\\\")\\n\\n if board[1][0] is playerid and board[1][1] is playerid and board[1][2] is playerid:\\n return (True, \\\"Row 2\\\")\\n\\n if board[2][0] is playerid and board[2][1] is playerid and board[2][2] is playerid:\\n return (True, \\\"Row 3\\\")\\n\\n return False\",\n \"def evaluate(self, state, player, random_state):\\n raise NotImplementedError\",\n \"def check_row(self, row, symbol):\\r\\n\\r\\n tally = 0\\r\\n for column in range(3):\\r\\n if self.board[row][column][1] == symbol:\\r\\n tally += 1\\r\\n if tally == 3:\\r\\n self.winner = symbol\",\n \"def next_state_rowcol(self):\\n # state before and after propagation\\n self.state_before = self.state_after\\n transition_probs = list(Customer.TPM.loc[Customer.TPM.index==self.state_before].values[0])\\n self.state_after = random.choices(Customer.STATES, weights=transition_probs)[0]\\n # row and col before and after propagation\\n self.row_before = self.row_after\\n self.col_before = self.col_after\\n\\n # randomly chose row_after, col_after depending on the state_after\\n if self.state_after == 'fruit':\\n self.row_after = random.choice(Customer.STATE_ROW_COL['fruit'][0])\\n self.col_after = random.choice(Customer.STATE_ROW_COL['fruit'][1])\\n elif self.state_after == 'spices':\\n self.row_after = random.choice(Customer.STATE_ROW_COL['spices'][0])\\n self.col_after = random.choice(Customer.STATE_ROW_COL['spices'][1])\\n elif self.state_after == 'dairy':\\n self.row_after = random.choice(Customer.STATE_ROW_COL['dairy'][0])\\n self.col_after = random.choice(Customer.STATE_ROW_COL['dairy'][1])\\n elif self.state_after == 'drinks':\\n self.row_after = random.choice(Customer.STATE_ROW_COL['drinks'][0])\\n self.col_after= random.choice(Customer.STATE_ROW_COL['drinks'][1])\\n elif self.state_after == 'checkout':\\n self.row_after = random.choice(Customer.STATE_ROW_COL['checkout'][0])\\n self.col_after = random.choice(Customer.STATE_ROW_COL['checkout'][1])\",\n \"def row_wise_checking(player_):\\n if board[0] == board[1] == player_:\\n return 2\\n elif board[1] == board[2] == player_:\\n return 0\\n elif board[3] == board[4] == player_:\\n return 5\\n elif board[4] == board[5] == player_:\\n return 3\\n elif board[6] == board[7] == player_:\\n return 8\\n elif board[7] == board[8] == player_:\\n return 6\\n else:\\n return -1\",\n \"def move(self, row: int, col: int, player: int) -> int:\\n self.board[row][col] = 1 if player == 1 else -1\\n rowsum = sum(self.board[row])\\n colsum = sum([self.board[r][col] for r in range(self.n)])\\n diagsum1 = sum([self.board[i][i] for i in range(self.n)])\\n diagsum2 = sum([self.board[i][-i-1] for i in range(self.n)])\\n if player == 1:\\n if rowsum == self.n or colsum == self.n or diagsum1 == self.n or diagsum2 == self.n:\\n return 1\\n else:\\n if rowsum == -self.n or colsum == -self.n or diagsum1 == -self.n or diagsum2 == -self.n:\\n return 2\\n return 0\",\n \"def move(self, row, col, player):\\n if self.winning == True:\\n return\\n self.matrix[row][col] = player\\n n = len(self.matrix)\\n indicator = True\\n for i in range(n):\\n if self.matrix[row][i] != player:\\n indicator = False\\n break\\n if indicator == True:\\n self.winning = True\\n return player\\n \\n indicator = True\\n for i in range(n):\\n if self.matrix[i][col] != player:\\n indicator = False\\n break\\n if indicator == True:\\n self.winning = True\\n return player\\n \\n if row == col:\\n indicator = True\\n for i in range(n):\\n if self.matrix[i][i] != player:\\n indicator = False\\n break\\n if indicator == True:\\n self.winning = True\\n return player\\n if row + col == n - 1:\\n indicator = True\\n for i in range(n):\\n if self.matrix[i][n - 1 - i] != player:\\n indicator = False\\n break\\n if indicator == True:\\n self.winning = True\\n return player\\n return 0\",\n \"def who_won(in_a_row, board_size, cur_player):\\n if in_a_row == board_size:\\n return 1 if cur_player == 'X' else 2\\n else:\\n return 0\",\n \"def evaluate(self, board):\",\n \"def move(self, row, col, player):\\n value = (1.5 - player) * 2\\n self.rows[row] += value\\n self.colums[col] += value\\n if row == col:\\n self.diag[0] += value\\n if row + col == self.n-1:\\n self.diag[1] += value\\n if abs(self.rows[row]) == self.n or abs(self.colums[col]) == self.n or abs(self.diag[0]) == self.n or abs(self.diag[1]) == self.n:\\n return player\\n return 0\",\n \"def move(self, row: int, col: int, player: int) -> int:\\n if not self.winner:\\n p = player - 1\\n \\n self.rows[p][row] += 1\\n self.cols[p][col] += 1\\n if row == col:\\n self.d[p] += 1\\n if row + col + 1 == self.n:\\n self.subd[p] += 1 \\n \\n if self.n in [self.rows[p][row], self.cols[p][col], self.d[p], self.subd[p]]:\\n self.winner = player\\n \\n return self.winner\",\n \"def check_win(self, player):\\n def check_row_win(player):\\n for row in self.game_state:\\n if player == row[0] == row[1] == row[2]:\\n return True\\n return False\\n\\n def check_column_win(player):\\n # For doing a column check, transpose the grid and do a row check\\n trans_game_state = numpy.transpose(self.game_state)\\n for row in trans_game_state:\\n if player == row[0] == row[1] == row[2]:\\n return True\\n return False\\n\\n def check_diag_win(player):\\n # Left to right diagonal\\n if player == self.game_state[0][0] == self.game_state[1][1] == self.game_state[2][2]:\\n return True\\n # Right to left diagonal\\n if player == self.game_state[0][2] == self.game_state[1][1] == self.game_state[2][0]:\\n return True\\n return False\\n\\n if check_column_win(player) or check_diag_win(player) or check_row_win(player):\\n return True\\n return False\",\n \"def switch(self, col, row, player):\\n\\n if self._out_of_range(col, row):\\n return 0\\n if self._check_occupied(col, row):\\n return 1\\n else:\\n self.board[row - 1][col - 1] = player\",\n \"def check_four_in_a_row(self, player_symbol, row, col, step_row_1, step_col_1, step_row_2, step_col_2):\\n num_connected = 1 # Tally of how many game pieces were found matching thus far\\n\\n def increment_connected(step_row, step_col):\\n \\\"\\\"\\\"\\n Checks to see if the game is over. This occurs if a player has four pieces in a row, or if the board is full.\\n :param step_row: The amount to move in the Y direction\\n :param step_col: The amount to move in the X direction\\n :return: The number of adjacent matching tiles found by the function\\n \\\"\\\"\\\"\\n connected = 0\\n current_row = row + step_row\\n current_col = col + step_col\\n\\n while self.board[current_row][current_col] == player_symbol:\\n connected += 1\\n current_row += step_row\\n current_col += step_col\\n\\n return connected\\n\\n num_connected += increment_connected(step_row_1, step_col_1)\\n num_connected += increment_connected(step_row_2, step_col_2)\\n\\n if num_connected >= 4:\\n self.game_over = True\",\n \"def evaluate(board, player):\\n score = 0\\n for i in range(3):\\n row = i * 3\\n score += evaluate_line(board, player, i, i + 3, i + 6)\\n score += evaluate_line(board, player, row, row + 1, row + 2)\\n score += evaluate_line(board, player, 0, 4, 8)\\n score += evaluate_line(board, player, 2, 4, 6)\\n return score\",\n \"def move(self, row, col, player):\\r\\n if player == 1:\\r\\n self.mat[row][col] = 1\\r\\n else:\\r\\n self.mat[row][col] = -1\\r\\n if self.checkrow(player,row) or self.checkcol(player,col):\\r\\n return player\\r\\n if row == col or row + col == self.size-1:\\r\\n if self.checkdiag(player):\\r\\n return player\\r\\n return 0\",\n \"def look_through_rows(board, column, player):\\n if board.shape[1] > column:\\n count = board.shape[0] - 1\\n count2 = 1\\n while count >= 0 and count2 == 1:\\n if board[count,column] == 0:\\n board[count,column] = player\\n count2 = count2 - 1\\n else:\\n count = count - 1\\n return board\\n else:\\n print('Improper Column Given')\",\n \"def game_state(matrix):\\n\\n \\\"\\\"\\\"\\n # To set winning tile\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == 2048:\\n # return 'win'\\n # return 'not over'\\n \\\"\\\"\\\"\\n for i in range(len(matrix)-1):\\n # intentionally reduced to check the row on the right and below\\n # more elegant to use exceptions but most likely this will be their solution\\n for j in range(len(matrix[0])-1):\\n if matrix[i][j] == matrix[i+1][j] or matrix[i][j+1] == matrix[i][j]:\\n return 'not over'\\n for i in range(len(matrix)): # check for any zero entries\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == 0:\\n return 'not over'\\n for k in range(len(matrix)-1): # to check the left/right entries on the last row\\n if matrix[len(matrix)-1][k] == matrix[len(matrix)-1][k+1]:\\n return 'not over'\\n for j in range(len(matrix)-1): # check up/down entries on last column\\n if matrix[j][len(matrix)-1] == matrix[j+1][len(matrix)-1]:\\n return 'not over'\\n return 'lose'\",\n \"def step(self, row):\\r\\n\\r\\n t = torch.tensor(row)\\r\\n choice = torch.argmax(self.tn(t).squeeze(0)).item()\\r\\n\\r\\n # The plan was to never have to use constants...\\r\\n # Yeah, we're assuming consistency in buy=0, sell=1, and hold=2\\r\\n if choice == 0:\\r\\n return (Action.BUY, 1)\\r\\n elif choice == 1:\\r\\n return (Action.SELL, 1)\\r\\n\\r\\n return (Action.HOLD, 0)\",\n \"def col_win(board, player):\\n for row in board.T:\\n if check_row(row, player):\\n return True\\n return False\",\n \"def play(self):\\n\\n value = 0 #player dictionary key\\n player = {0: 'O', 1: 'X'}\\n\\n moveCount = 0 #how many moves have occurred. also doubles as the self.order index.\\n turn = \\\"\\\"\\n while moveCount < self.n**2 and self.go == \\\"Tie\\\":\\n value = not value\\n turn = player[value] #X starts\\n key = self.order[moveCount]\\n i = key[0]\\n j = key[1]\\n\\n\\n# self.rows[i][0] == homogenous?\\n# self.rows[i][1] == X/O?\\n# self.rows[i][2] == count of X's/O's?\\n\\n# Check to see if row i is 'homogenous' (contains only X's or O's):\\n if self.rows[i][0]:\\n\\n# Check to see if any square in row i has been played. If it has been played,\\n# check to see if it was the same person who's current turn it is.\\n if self.rows[i][1] == \\\"\\\" or player[value] == self.rows[i][1]:\\n\\n# Mark the column with the current person's token (X or O).\\n# Admittedly, this could be improved to not update every time.\\n self.rows[i][1] = turn\\n\\n# Update the count by one.\\n self.rows[i][2] += 1\\n\\n# If the count is equal to the board size, end the game and return who won and how.\\n if self.rows[i][2] == self.n:\\n self.go = (turn, 'row ' + str(i))\\n\\n# If the current person who's turn it is,\\n# is not the same as the previous player who played this row,\\n# set this row's 'homogenous' attribute to false.\\n else:\\n self.rows[i][0] = False\\n\\n if self.cols[j][0]:\\n if self.cols[j][1] == \\\"\\\" or player[value] == self.cols[j][1]:\\n self.cols[j][1] = turn\\n self.cols[j][2] += 1\\n if self.cols[j][2] == self.n:\\n self.go = (turn, 'column ' + str(j))\\n else:\\n self.cols[j][0] = False\\n\\n# On boards of odd-sized 'n' (n = 3,5,7,etc...)\\n# the middle square is part of both diagonals: 'step' and 'same':\\n if i == j:\\n if self.diags['same'][0]:\\n if self.diags['same'][1] == \\\"\\\" or player[value] == self.diags['same'][1]:\\n self.diags['same'][1] = turn\\n self.diags['same'][2] += 1\\n if self.diags['same'][2] == self.n:\\n self.go = (turn, 'diagonal from 0,0 to n-1,n-1')\\n else:\\n self.diags['same'][0] = False\\n\\n if i + j + 1 == self.n:\\n if self.diags['step'][0]:\\n if self.diags['step'][1] == \\\"\\\" or player[value] == self.diags['step'][1]:\\n self.diags['step'][1] = turn\\n self.diags['step'][2] += 1\\n if self.diags['step'][2] == self.n:\\n self.go = (turn, 'diagonal from n-1,0 to 0,n-1')\\n else:\\n self.diags['step'][0] = False\\n\\n moveCount += 1\\n print(turn, key)\\n else:\\n return self.go\",\n \"def check_rows():\\n global game_still_going\\n # Check if any of the rows have all the same value.\\n row1 = board[0] == board[1] == board[2] != '_'\\n row2 = board[3] == board[4] == board[5] != '_'\\n row3 = board[6] == board[7] == board[8] != '_'\\n # If any row does have a match, then game still going to False.\\n if row1 or row2 or row3:\\n game_still_going = False\\n # Return winner 'X' or 'O'.\\n if row1:\\n return board[0]\\n if row2:\\n return board[3]\\n if row3:\\n return board[6]\",\n \"def move(self, row, col, player):\\n if self.winning == True:\\n return\\n if player == 1:\\n val = 1\\n else:\\n val = -1\\n self.row[row] += val\\n self.col[col] += val\\n if row == col:\\n self.diagonal += val\\n n = len(self.row)\\n if row + col == n - 1:\\n self.antidiagonal += val\\n if abs(self.row[row]) == n or abs(self.col[col]) == n or abs(self.diagonal) == n or abs(self.antidiagonal) == n:\\n self.winning = True\\n return player\\n return 0\",\n \"def win_condition(self, player):\\n\\n row_list = []\\n column_list = []\\n constant_condition = False\\n row_sequential_condition = False\\n column_sequential_condition = False\\n\\n # Loop through positions on board for player\\n for position_key, position_obj in sorted(self.board.positions.items()):\\n if position_obj.value == player.value:\\n row_list.append(position_obj.row)\\n column_list.append(position_obj.column)\\n\\n # Either row keys or column keys must stay constant\\n row_set = set(row_list)\\n column_set = set(column_list)\\n if len(row_set) == 1 or len(column_set) == 1:\\n constant_condition = True\\n\\n # The other row keys or column keys must be sequential for number of row or columns\\n row_seq_list = [n for n in range(1, self.board.rows + 1)]\\n column_seq_list = [n for n in range(1, self.board.columns + 1)]\\n if row_list == row_seq_list:\\n row_sequential_condition = True\\n if column_list == column_seq_list:\\n column_sequential_condition = True\\n\\n if constant_condition and (row_sequential_condition or column_sequential_condition):\\n return True\\n elif row_sequential_condition and column_sequential_condition:\\n return True\\n else:\\n return False\",\n \"def check_rows():\\n global ongoing_game\\n row_1 = board[0] == board[1] == board[2] != \\\"*\\\"\\n row_2 = board[3] == board[4] == board[5] != \\\"*\\\"\\n row_3 = board[6] == board[7] == board[8] != \\\"*\\\"\\n if row_1 or row_2 or row_3:\\n ongoing_game = False\\n if row_1:\\n return board[0]\\n elif row_2:\\n return board[3]\\n elif row_3:\\n return board[6]\\n else:\\n return None\",\n \"def test_row_col(board, rows):\\n for i in range(len(board)):\\n cur_player = board[i][0] if rows else board[0][i]\\n in_a_row = 0\\n for j in range(len(board)):\\n symbol = board[i][j] if rows else board[j][i]\\n if (not symbol == '-') and (symbol == cur_player):\\n in_a_row += 1\\n else:\\n break\\n winner = who_won(in_a_row, len(board), cur_player)\\n if not winner == 0:\\n return winner\\n return 0\",\n \"def check_game_over(self, row, col):\\n player_symbol = self.board[row][col]\\n\\n # Top Right: Row -1 Col 1\\n # Bottom Left: Row 1 Col -1\\n self.check_four_in_a_row(player_symbol, row, col, -1, 1, 1, -1)\\n\\n # Top Left: Row -1 Col -1\\n # Bottom Right Row 1 Col 1\\n self.check_four_in_a_row(player_symbol, row, col, -1, -1, 1, 1)\\n\\n # Horizontal: Row 0 Col 1, Row 0 Col -1\\n self.check_four_in_a_row(player_symbol, row, col, 0, 1, 0, -1)\\n\\n # Vertical: Row 1 Col 0, Row -1 Col 0\\n self.check_four_in_a_row(player_symbol, row, col, 1, 0, -1, 0)\\n\\n if self.turns >= self.num_playable_rows * self.num_playable_columns:\\n self.game_over = True\\n self.board_full = True\",\n \"def move(self, row, col, player):\\n score = self.score[player]\\n win_score = self.win[player]\\n self.rows[row] += score\\n if self.rows[row] == win_score:\\n return player\\n\\n self.columns[col] += score\\n if self.columns[col] == win_score:\\n return player\\n if col - row == 0:\\n self.diagonal[1] += score\\n if self.diagonal[1] == win_score:\\n return player\\n if col + row == self.size - 1:\\n self.diagonal[0] += score\\n if self.diagonal[0] == win_score:\\n return player\\n return 0\",\n \"def evaluateBoardState(self, board):\\n\\n \\\"\\\"\\\"\\n These are the variables and functions for board objects which may be helpful when creating your Agent.\\n Look into board.py for more information/descriptions of each, or to look for any other definitions which may help you.\\n\\n Board Variables:\\n board.width \\n board.height\\n board.last_move\\n board.num_to_connect\\n board.winning_zones\\n board.score_array \\n board.current_player_score\\n\\n Board Functions:\\n get_cell_value(row, col)\\n try_move(col)\\n valid_move(row, col)\\n valid_moves()\\n terminal(self)\\n legal_moves()\\n next_state(turn)\\n winner()\\n \\\"\\\"\\\"\\n\\n # print the valid moves on board for current player\\n move = board.last_move\\n\\n # enemy agent's id\\n enemy = self.id % 2 + 1\\n\\n value = self.evaluateRows(board, enemy) + self.evaluateCols(board, enemy) + self.evaluateBackwardDiagonals(board, enemy) + self.evaluateForwardDiagonals(board, enemy)\\n return value\",\n \"def winner(row):\\r\\n x=0\\r\\n o=0\\r\\n win=False\\r\\n winner='X'\\r\\n empty=False #Better not to do '.' in row\\r\\n \\r\\n for char in row:\\r\\n if char=='X':\\r\\n x+=1\\r\\n o=0\\r\\n if char=='O':\\r\\n o+=1\\r\\n x=0\\r\\n if char=='T':\\r\\n x+=1\\r\\n o+=1\\r\\n if char=='.':\\r\\n x=0\\r\\n o=0\\r\\n empty=True\\r\\n\\r\\n #Check Winner\\r\\n if x==4:\\r\\n win=True\\r\\n winner='X'\\r\\n if o==4:\\r\\n win=True\\r\\n winner='O'\\r\\n return (win,winner,empty)\\r\\n #Done\\r\",\n \"def rushing_success(row):\\n success = 0\\n if row.down == 1:\\n if row.yards_gained >= 6:\\n success = 1\\n elif row.yards_gained >= row.ydstogo * .4:\\n success = 1\\n elif row.down == 2:\\n if row.yards_gained >= 6:\\n success = 1\\n elif row.yards_gained >= row.ydstogo * .5:\\n success = 1\\n elif row.down > 3:\\n if row.yards_gained >= row.ydstogo:\\n success = 1\\n return success\",\n \"def move(self, row, col, player):\\n score = 1 if player == 1 else -1\\n self.rows[row] += score\\n self.cols[col] += score\\n if row == col:\\n self.diagonal1 += score\\n if row + col == self.n - 1:\\n self.diagonal2 += score\\n win = {self.rows[row], self.cols[col], self.diagonal1, self.diagonal2}\\n if self.n in win or -self.n in win:\\n return player\\n return 0\",\n \"def is_posssible_row(self,row,user_value):\\n for col in range(9):\\n if self.arr[row][col] == user_value:\\n logging.debug(f\\\"is_posssible_row(): (False) row: {row} col: {col} arr{self.arr[row][col]} == {user_value}\\\")\\n return False\\n logging.debug(f\\\"is_posssible_row(): (True) row: {row} col: {col} arr{self.arr[row][col]} != {user_value}\\\")\\n return True\",\n \"def anyone_won(self, state):\\r\\n # Checking all the rows\\r\\n for row_values in state:\\r\\n if row_values.count('x') == 3:\\r\\n return True, 'x'\\r\\n if row_values.count('o') == 3:\\r\\n return True, 'o'\\r\\n\\r\\n # Checking all the columns\\r\\n for i in range(3):\\r\\n if state[0][i] == 'x' and state[1][i] == 'x' and state[2][i] == 'x':\\r\\n return True, 'x'\\r\\n if state[0][i] == 'o' and state[1][i] == 'o' and state[2][i] == 'o':\\r\\n return True, 'o'\\r\\n\\r\\n return False, None\",\n \"def get_state_from_row(self, row: int):\\n index = [0, 1, 2, 3]\\n blue_location = index[row // 16]\\n green_location = index[(row % 16) // 4]\\n red_location = index[row % 4]\\n return (row, red_location, green_location, blue_location)\",\n \"def move(self, row: int, col: int, player: int) -> int:\\n if player == 1:\\n self.newList[row][col] = 1\\n self.colSum[col] += 1\\n self.rowSum[row] += 1\\n if row == col:\\n self.diag += 1\\n if row + col == (self.n - 1):\\n self.revDiag += 1\\n if self.rowSum[row] == self.n or self.colSum[col] == self.n or self.diag == self.n or self.revDiag == self.n:\\n return 1\\n if player == 2:\\n self.newList[row][col] = -1\\n self.colSum[col] -= 1\\n self.rowSum[row] -= 1\\n if row == col:\\n self.diag -= 1\\n if row + col == (self.n - 1):\\n self.revDiag -= 1\\n if self.rowSum[row] == -self.n or self.colSum[col] == -self.n or self.diag == -self.n or self.revDiag == -self.n:\\n return 2\\n \\n return 0\",\n \"def evaluate(board):\\n winner = 0\\n for player in [1, 2]:\\n if row_win(board, player) or col_win(board, player) or diag_win(board, player):\\n winner = player\\n \\n if np.all(board != 0) and winner == 0:\\n winner = -1\\n return winner\",\n \"def move(self, row: int, col: int, player: int):\\n def addup(dict_name, invalid_set, another_invalid, locx, locy):\\n if locx == locy:\\n diag_name = (1,1)\\n if diag_name not in invalid_set:\\n dict_name[diag_name] += 1\\n if dict_name[diag_name] == self.tar:\\n return player\\n another_invalid.add(diag_name)\\n if locx == self.tar-1-locy:\\n diag_name = (-1, -1)\\n if diag_name not in invalid_set:\\n dict_name[diag_name] += 1\\n if dict_name[diag_name] == self.tar:\\n return player\\n another_invalid.add(diag_name)\\n curcol = (locy, None)\\n currow = (None, locx)\\n if curcol not in invalid_set:\\n dict_name[curcol] += 1\\n if dict_name[curcol] == self.tar:\\n return player\\n another_invalid.add(curcol)\\n if currow not in invalid_set:\\n dict_name[currow] += 1\\n if dict_name[currow] == self.tar:\\n return player\\n another_invalid.add(currow)\\n return 0\\n res = 0\\n if (row, col) not in self.walked:\\n if player == 1:\\n res = addup(self.p1, self.invalid_1, self.invalid_2, row, col)\\n if player == 2:\\n res = addup(self.p2, self.invalid_2, self.invalid_1, row, col)\\n self.walked.add((row, col))\\n return res\",\n \"def eval(self, state):\\n valueOfPlayers = 0\\n valueOfRebelAdvancments = 0\\n valueOfLocations = 0\\n\\n\\n\\n for coordinate in state.gameState:\\n if state.gameState[coordinate]==state.blank:\\n continue\\n elif state.gameState[coordinate]==state.rebel:\\n valueOfRebelAdvancments = -coordinate[0]\\n elif state.gameState[coordinate]==state.jedi:\\n continue\\n elif state.gameState[coordinate]==state.sith:\\n continue\\n \\n valueOfLocations += valueOfRebelAdvancments\\n\\n \\n valueOfPlayers = state.numRebels + 4*state.numJedi - 4*state.numSith\\n \\n return valueOfPlayers*4 + valueOfLocations\",\n \"def makeEvalTable(table):\\n\\n def score(game, player):\\n row, col = game.get_player_location(player)\\n return table[row][col]\\n\\n return score\",\n \"def getGameState(self):\\n ### Student code goes here\\n #print(\\\":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::\\\")\\n row1_tuple = ()\\n row1_list = {}\\n ask1 = parse_input(\\\"fact: (on ?X ?Y pos1)\\\")\\n answer1 = self.kb.kb_ask(ask1)\\n if answer1 != False:\\n for ans in answer1.list_of_bindings:\\n tile = ans[0].bindings[0].constant.element\\n if len(tile.split('tile',1)) > 1:\\n tile = int(tile.split('tile',1)[1])\\n else:\\n tile = -1\\n pos = (ans[0].bindings[1].constant.element).split('pos',1)[1]\\n row1_list[int(pos)] = tile\\n #print(\\\"ROW1: \\\", len(row1_list))\\n for i in range(len(row1_list)):\\n val = row1_list[i+1]\\n #print(val)\\n row1_tuple = row1_tuple + (val,)\\n\\n row2_tuple = ()\\n row2_list = {}\\n ask2 = parse_input(\\\"fact: (on ?X ?Y pos2)\\\")\\n answer2 = self.kb.kb_ask(ask2)\\n if answer2 != False:\\n for ans in answer2.list_of_bindings:\\n tile = ans[0].bindings[0].constant.element\\n if len(tile.split('tile',1)) > 1:\\n tile = int(tile.split('tile',1)[1])\\n else:\\n tile = -1\\n pos = (ans[0].bindings[1].constant.element).split('pos',1)[1]\\n row2_list[int(pos)] = tile\\n #print(\\\"ROW2: \\\", len(row2_list))\\n for i in range(len(row2_list)):\\n val = row2_list[i+1]\\n row2_tuple = row2_tuple + (val,)\\n\\n row3_tuple = ()\\n row3_list = {}\\n ask3 = parse_input(\\\"fact: (on ?X ?Y pos3)\\\")\\n answer3 = self.kb.kb_ask(ask3)\\n if answer3 != False:\\n for ans in answer3.list_of_bindings:\\n tile = ans[0].bindings[0].constant.element\\n if len(tile.split('tile',1)) > 1:\\n tile = int(tile.split('tile',1)[1])\\n else:\\n tile = -1\\n pos = (ans[0].bindings[1].constant.element).split('pos',1)[1]\\n row3_list[int(pos)] = tile\\n #print(\\\"ROW3: \\\", len(row3_list))\\n for i in range(len(row3_list)):\\n val = row3_list[i+1]\\n row3_tuple = row3_tuple + (val,)\\n #print(\\\"-----------------------------------------------------------------------------------------------\\\")\\n\\n\\n state_tuple = (row1_tuple,row2_tuple,row3_tuple)\\n #print(state_tuple)\\n return state_tuple\",\n \"def move(self, row: int, col: int, player: int) -> int:\\n s = -1 if player == 1 else 1\\n\\n self.rows[row] += s\\n if abs(self.rows[row]) == self.n:\\n return player\\n\\n self.cols[col] += s\\n if abs(self.cols[col]) == self.n:\\n return player\\n\\n if row == col:\\n self.diagonals[0] += s\\n if abs(self.diagonals[0]) == self.n:\\n return player\\n\\n if (row + col) == self.n - 1:\\n self.diagonals[1] += s\\n if abs(self.diagonals[1]) == self.n:\\n return player\\n\\n return 0\",\n \"def in_row(row, x, y,\\n input_suduko_3d):\\n value_in_row = np.in1d(np.asarray(input_suduko_3d[x, y, 0:]), np.asarray(input_suduko_3d[row, :, 0]))\\n for i, value in enumerate(value_in_row):\\n if value_in_row[i] == True and i != 0:\\n input_suduko_3d[x, y, i] = 0\",\n \"def _check_row(self, col, board) -> int:\\n score = 0\\n for row in range(len(board)):\\n if board[col][row] == self.colour:\\n score += 1\\n return score\",\n \"def check_for_win(self, row, col, player): \\n\\n count = 0\\n for i in range(0, len(self.board[0])):\\n # Check vertical\\n if self.board[row][i] == player:\\n count += 1\\n else:\\n count = 0\\n \\n if count == self.max_count:\\n return True\\n\\n count = 0\\n for i in range(0, len(self.board)):\\n # Check horisontal\\n if self.board[:, col][i] == player:\\n count += 1\\n else:\\n count = 0\\n \\n if count == self.max_count:\\n return True\\n \\n count = 0\\n totoffset = col - row\\n for i in np.diagonal(self.board, offset=totoffset):\\n # Check diagonal\\n if i == player:\\n count += 1\\n else:\\n count = 0\\n\\n if count == self.max_count:\\n return True\\n\\n count = 0\\n mirrorboard = np.fliplr(self.board)\\n col = self.colswitch[col]\\n totoffset = col - row\\n for i in np.diagonal(mirrorboard, offset=totoffset):\\n # Check other diagonal\\n if i == player:\\n count += 1\\n else:\\n count = 0\\n\\n if count == self.max_count:\\n return True\",\n \"def checkForResult(self):\\n values = np.array([self.extractValuesColumn(0)])\\n for i in range(1, self.shapeRow):\\n values = np.vstack((values, self.extractValuesColumn(i)))\\n\\n\\n for i in range(self.shapeRow):\\n if(values[i, ::] == 'x').all() or \\\\\\n (values[::, i] == 'x').all():\\n return (True, \\\"Player x won.\\\")\\n\\n if (values.diagonal() == 'x').all() or \\\\\\n (np.diag(np.fliplr(values)) == 'x').all():\\n return (True, \\\"Player x won.\\\")\\n\\n\\n #check for 0\\n for i in range(self.shapeRow):\\n if (values[i, ::] == '0').all() or \\\\\\n (values[::, i] == '0').all():\\n return (True, \\\"Player 0 won.\\\")\\n\\n if (values.diagonal() == '0').all() or \\\\\\n (np.diag(np.fliplr(values)) == '0').all():\\n return (True, \\\"Player 0 won.\\\")\\n\\n\\n return (False, \\\"\\\")\",\n \"def move(self, row: int, col: int, player: int) -> int:\\n n = self.n\\n if player == 1:\\n self.rows_1[row] += 1\\n self.cols_1[col] += 1\\n if player == 2:\\n self.rows_2[row] += 1\\n self.cols_2[col] += 1\\n if row == col:\\n self.diag1[row] = player\\n if row + col + 1 == n:\\n self.diag2[row] = player\\n f = 0\\n g = 0\\n for i in range(n):\\n if self.rows_1[row] == n or self.cols_1[col] == n:\\n return 1\\n if self.rows_2[row] == n or self.cols_2[col] == n:\\n return 2 \\n if self.diag1[i] != self.diag1[0]:\\n f = 1\\n if self.diag2[i] != self.diag2[0]:\\n g = 1\\n if f == 0:\\n return self.diag1[0]\\n if g == 0:\\n return self.diag2[0]\\n return 0\",\n \"def move(self, row, col, player):\\n toadd = 1 if player == 1 else -1\\n \\n self.row[row] += toadd\\n self.col[col] += toadd\\n if row == col: self.diagonal += toadd\\n if col == self.n - row -1 : self.antidiag += toadd\\n \\n if abs(self.row[row]) == self.n or abs(self.col[col]) == self.n or abs(self.diagonal) == self.n or abs(self.antidiag) == self.n:\\n return player\\n else:\\n return 0\",\n \"def evaluate(self) :\\n if self.inStates[0].getState() == self.inStates[1].getState(): return 0\\n return 1\",\n \"def move(self, row, col, player):\",\n \"def val_in_row(self, table, val, row_index): \\n\\n #Get column names of table\\n columns = self.table_col_names(table)\\n \\n\\n all_rows=self.all_rows(table)\\n flag=False\\n for col in columns:\\n if val==all_rows[row_index][col]:\\n flag=True\\n return flag\",\n \"def test_case_if_row_is_about_to_be_foobar(self, mock_game):\\n test_game = Game(3, \\\"playerX\\\", \\\"playerO\\\")\\n test_game.game_id = 1002\\n test_game.board_size = 3\\n test_game.your_move = \\\"X\\\"\\n test_game.board_blob = json.dumps(['X', '', 'O',\\n 'X', '', '',\\n 'X', 'X', ''])\\n assert(test_game.is_row_in_danger(0, \\\"X\\\") is False)\\n assert(test_game.is_row_in_danger(1, \\\"X\\\") == [4, 5])\\n assert(test_game.is_row_in_danger(2, \\\"X\\\") == [8])\",\n \"def update_game(board, row, col, player_mark, turn_counter):\\n\\tif board[row][col] != EMPTY:\\n\\t\\tprint(\\\"You can't go there!\\\")\\n\\t\\tplayer_mark = switch_player(player_mark) # Because upcoming check_status will switch it back\\n\\t\\treturn (board, player_mark)\",\n \"def is_in_check(self, player):\\n # List of coords in board\\n col = ['a','b','c','d','e','f','g','h','i'] # the columns\\n a = []\\n for i in range(10):\\n a.append([j + str(i+1) for j in col])\\n \\n # Flatten the list\\n board_coords = []\\n for sublist in a:\\n for coord in sublist:\\n board_coords.append(coord)\\n \\n # getting each object in the board for a player\\n pieces_coords = []\\n pieces_left = []\\n for row in range(10):\\n for column in range(9):\\n if self.get_board()[row][column] is not None and self.get_board()[row][column].get_color() == player.upper():\\n # pieces left on the board for the player\\n pieces_coords.append((row, column))\\n pieces_left.append(self.get_board()[row][column])\\n \\n p_b_coord = (pieces_coords, board_coords)\\n \\n counter = 0 \\n for piece_coord in pieces_coords: \\n for board_coord in board_coords: \\n translated_index = self.column_to_letter(piece_coord[1]) + str(piece_coord[0]) \\n piece = self.get_piece_type(translated_index)\\n if piece is not None:\\n if piece.check_legal(translated_index, board_coord, self.get_board(), self.get_game_state()) == True:\\n counter += 1\\n print(counter)\\n if counter == 0:\\n self._current_state = upper(player) + '_WON'\\n return True \\n return False\",\n \"def evaluate(self) :\\n for inp in self.inStates :\\n if inp.getState() == 1 : return 1\\n return 0\",\n \"def evaluate(self, player):\\n evaluation = 0\\n\\n # Takes into account the number of pieces for each side in play.\\n self._evaluate_num_pieces(player)\\n\\n # Evaluates the position of each piece\\n evaluation += self._evaluate_pieces_position(player)\\n evaluation -= self._evaluate_pieces_position(player.other)\\n\\n # Random extra point used to randomize plays that are equal\\n evaluation += random.randint(0, 1)\\n\\n return evaluation\",\n \"def check_score(self) -> None:\\n self.player_1, self.player_2 = 0, 0\\n for cell in self.cells:\\n if cell.player == 1:\\n self.player_1 += 1\\n elif cell.player == 2:\\n self.player_2 += 1\",\n \"def simul_move(self, column, player):\\n\\n new_rack = [x[:] for x in self.layout] #copy this state's layout\\n #travel down this column\\n r = 0\\n while new_rack[column][r] !=0:\\n r+=1\\n if r >= self.height:\\n return None\\n new_rack[column][r] = player\\n new_state = State(new_rack, player)\\n return new_state\",\n \"def calcUpdateByRow(self, row):\\n\\n # a) positive phase\\n poshp = self.rbm.activate(row)\\t# compute the posterior probability\\n pos = outer(row, poshp) \\t# fraction from the positive phase\\n poshb = poshp\\n posvb = row\\n\\n # b) the sampling & reconstruction\\n sampled = self.sampler(poshp)\\n recon = self.invRbm.activate(sampled)\\t# the re-construction of data\\n\\n # c) negative phase\\n neghp = self.rbm.activate(recon)\\n neg = outer(recon, neghp)\\n neghb = neghp\\n negvb = recon\\n\\n # compute the raw delta\\n # !!! note that this delta is only the 'theoretical' delta\\n return self.updater(pos, neg, poshb, neghb, posvb, negvb)\",\n \"def player(board):\\n if board == initial_state():\\n return X\\n \\n # if board has lesser or eual X(s) than O(s)\\n if sum([row.count(X) for row in board]) <= sum([row.count(O) for row in board]):\\n return X\\n else:\\n return O\",\n \"def getGameState(self):\\n ### Student code goes here\\n row1 = ()\\n row2 = ()\\n row3 = ()\\n for currRow in range(1,4):\\n for currCol in range(1,4):\\n tileFound = False\\n for fact in self.kb.facts:\\n if fact.statement.predicate == \\\"located\\\":\\n tile = fact.statement.terms[0].term.element\\n column = fact.statement.terms[1].term.element\\n row = fact.statement.terms[2].term.element\\n\\n tileNumber = int(tile[-1])\\n columnNumber = int(column[-1])\\n rowNumber = int(row[-1])\\n\\n if rowNumber == currRow and columnNumber == currCol:\\n tileFound = True\\n if rowNumber == 1:\\n row1 += tuple([tileNumber])\\n elif rowNumber == 2:\\n row2 += tuple([tileNumber])\\n elif rowNumber == 3:\\n row3 += tuple([tileNumber])\\n \\n break\\n\\n if not tileFound:\\n if currRow == 1:\\n row1 += tuple([-1])\\n elif currRow == 2:\\n row2 += tuple([-1])\\n elif currRow == 3:\\n row3 += tuple([-1])\\n\\n\\n return (row1, row2, row3)\",\n \"def __get_row(self, index):\\n counts = {\\n self.player_char: 0,\\n self.opponent_char: 0,\\n 'empty': []\\n }\\n for i in range(0, 3):\\n if self.state[(index*3)+i] is self.player_char:\\n counts[self.player_char] += 1\\n elif self.state[(index*3)+i] is self.opponent_char:\\n counts[self.opponent_char] += 1\\n else:\\n counts['empty'].append((index*3)+i)\\n return counts\",\n \"def winning_event(self, player):\\n # vertical check\\n for col in range(GameData.columns):\\n if self.board[0][col] == player and self.board[1][col] == player and self.board[2][col] == player:\\n self.draw_vertical_winning_line(col, player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n # horizontal check\\n for row in range(GameData.rows):\\n if self.board[row][0] == player and self.board[row][1] == player and self.board[row][2] == player:\\n self.draw_horizontal_winning_line(row, player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n # ascending diagonal heck\\n if self.board[2][0] == player and self.board[1][1] == player and self.board[0][2] == player:\\n self.draw_asc_diagonal(player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n # descending diagonal win chek\\n if self.board[0][0] == player and self.board[1][1] == player and self.board[2][2] == player:\\n self.draw_desc_diagonal(player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n return False\",\n \"def check_game_status(self):\\n for player in (\\\"1\\\", \\\"2\\\"):\\n row_win = np.apply_along_axis(\\n lambda x: set(x) == {player}, 1, self.board\\n ).any()\\n col_win = np.apply_along_axis(\\n lambda x: set(x) == {player}, 0, self.board\\n ).any()\\n d1_win = set(self.data[[0, 4, 8]]) == {player}\\n d2_win = set(self.data[[2, 4, 6]]) == {player}\\n if any([row_win, col_win, d1_win, d2_win]):\\n return (\\\"win\\\", player)\\n\\n if self.counter[\\\"_\\\"] == 0:\\n return (\\\"tie\\\", None)\\n else:\\n return (\\\"turn\\\", \\\"1\\\" if self.counter[\\\"1\\\"] == self.counter[\\\"2\\\"] else \\\"2\\\")\",\n \"def exitsinrow(self,rows,row,num):\\r\\n for i in range(9):\\r\\n if(rows[row][i] == num):\\r\\n return True\\r\\n return False\",\n \"def move(self, row, col, player):\\n offset = player * 2 - 3 # 1 or -1\\n self.row[row] += offset\\n self.col[col] += offset\\n if row == col:\\n self.diag += offset\\n if row + col == self.n - 1:\\n self.anti_diag += offset\\n if self.n in [self.row[row], self.col[col], self.diag, self.anti_diag]:\\n return 2\\n if -self.n in [self.row[row], self.col[col], self.diag, self.anti_diag]:\\n return 1\\n return 0\",\n \"def evaluateBoardState(self, board):\\n\\n \\\"\\\"\\\"\\n These are the variables and functions for board objects which may be helpful when creating your Agent.\\n Look into board.py for more information/descriptions of each, or to look for any other definitions which may help you.\\n\\n Board Variables:\\n board.width \\n board.height\\n board.last_move\\n board.num_to_connect\\n board.winning_zones\\n board.score_array \\n board.current_player_score\\n\\n Board Functions:\\n get_cell_value(row, col)\\n try_move(col)\\n valid_move(row, col)\\n valid_moves()\\n terminal(self)\\n legal_moves()\\n next_state(turn)\\n winner()\\n \\\"\\\"\\\"\\n if self.id == 1:\\n opponent_id = 2\\n else:\\n opponent_id = 1\\n\\n maxvalue = 100000\\n minvalue = -maxvalue\\n winner = board.winner()\\n if winner == self.id:\\n return maxvalue\\n elif winner == opponent_id:\\n return minvalue\\n size_y = board.height\\n size_x = board.width\\n map_ = []\\n num_to_connect = board.num_to_connect\\n total_points = 0\\n\\n multiply_reachable = 1\\n multiply_oddeven = 1\\n # basically this function is calculating all the possible win positions\\n # more pieces in a possible win position will be counted with more weights\\n # a win position with X pieces in it will be counted as X^2 points\\n # initialise the zones maps\\n for i in range(size_y):\\n map_.append([])\\n for j in range(size_x):\\n map_[i].append([])\\n\\n # Fill in the horizontal win positions\\n for i in range(size_y):\\n for j in range(size_x - num_to_connect + 1):\\n points = 0\\n self_pieces_count = 0\\n opponent_pieces_count = 0\\n for k in range(num_to_connect):\\n if board.board[i][j + k] == opponent_id:\\n opponent_pieces_count += 1\\n elif board.board[i][j + k] == self.id:\\n points += len(board.winning_zones[j+k][i])\\n if (self.id == 1 and i % 2 == 1) or (self.id == 2 and i%2 == 0):\\n points *= multiply_oddeven\\n self_pieces_count += 1\\n if self_pieces_count == 3 and opponent_pieces_count == 0:\\n if j - 1 >= 0 and board.board[i][j + 3] == 0 and board.board[i][j - 1] == 0 \\\\\\n and board.try_move(j + 3) == i and board.try_move(j - 1) == i:\\n return maxvalue\\n elif j + 4 < size_y and board.board[i][j + 4] == 0 and board.board[i][j] == 0 \\\\\\n and board.try_move(j + 4) == i and board.try_move(j) == i:\\n return maxvalue\\n else:\\n for k in range(num_to_connect):\\n if board.board[i][j + k] == 0 and board.try_move(j + k) == i:\\n points *= multiply_reachable\\n elif opponent_pieces_count == 3 and self_pieces_count == 0:\\n if j - 1 >= 0 and board.board[i][j + 3] == 0 and board.board[i][j - 1] == 0 \\\\\\n and board.try_move(j + 3) == i and board.try_move(j - 1) == i:\\n return minvalue\\n elif j + 4 < size_y and board.board[i][j + 4] == 0 and board.board[i][j] == 0 \\\\\\n and board.try_move(j + 4) == i and board.try_move(j) == i:\\n return minvalue\\n # else:\\n # for k in range(num_to_connect):\\n # if board.board[i][j + k] == 0 and board.try_move(j + k) == i:\\n # points *= -multiply_reachable\\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\\n total_points += points\\n\\n # Fill in the vertical win positions\\n for i in range(size_x):\\n for j in range(size_y - num_to_connect + 1):\\n points = 0\\n self_pieces_count = 0\\n for k in range(num_to_connect):\\n if board.board[j + k][i] == opponent_id:\\n opponent_pieces_count += 1\\n elif board.board[j + k][i] == self.id:\\n points += len(board.winning_zones[i][j+k])\\n if (self.id == 1 and (j+k) % 2 == 1) or (self.id == 2 and (j+k)%2 == 0):\\n points *= multiply_oddeven\\n self_pieces_count += 1\\n points *= multiply_reachable\\n # if opponent_pieces_count == 3 and self_pieces_count == 0:\\n # points *= -1\\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\\n total_points += points\\n\\n # Fill in the forward diagonal win positions\\n for i in range(size_y - num_to_connect + 1):\\n for j in range(size_x - num_to_connect + 1):\\n points = 0\\n self_pieces_count = 0\\n opponent_pieces_count = 0\\n for k in range(num_to_connect):\\n if board.board[i + k][j + k] == opponent_id:\\n opponent_pieces_count += 1\\n elif board.board[i + k][j + k] == self.id:\\n points += len(board.winning_zones[j+k][i+k])\\n if (self.id == 1 and (i+k) % 2 == 1) or (self.id == 2 and (i+k)%2 == 0):\\n points *= multiply_oddeven\\n self_pieces_count += 1\\n if self_pieces_count == 3 and opponent_pieces_count == 0:\\n if i - 1 >= 0 and j - 1 >= 0 and board.board[i + 3][j + 3] == 0 and board.board[i - 1][j - 1] == 0 \\\\\\n and board.try_move(j + 3) == i + 3 and board.try_move(j - 1) == i - 1:\\n return maxvalue\\n elif i + 4 < size_y and j + 4 < size_x and board.board[i + 4][j + 4] == 0 and board.board[i][j] == 0 \\\\\\n and board.try_move(j + 4) == i + 4 and board.try_move(j) == i:\\n return maxvalue\\n else:\\n for k in range(num_to_connect):\\n if board.board[i + k][j + k] == 0 and board.try_move(j + k) == i + k:\\n points *= multiply_reachable\\n elif opponent_pieces_count == 3 and self_pieces_count == 0:\\n if i - 1 >= 0 and j - 1 >= 0 and board.board[i + 3][j + 3] == 0 and board.board[i - 1][j - 1] == 0 \\\\\\n and board.try_move(j + 3) == i + 3 and board.try_move(j - 1) == i - 1:\\n return minvalue\\n elif i + 4 < size_y and j + 4 < size_x and board.board[i + 4][j + 4] == 0 and board.board[i][j] == 0 \\\\\\n and board.try_move(j + 4) == i + 4 and board.try_move(j) == i:\\n return minvalue\\n # else:\\n # for k in range(num_to_connect):\\n # if board.board[i + k][j + k] == 0 and board.try_move(j + k) == i + k:\\n # points *= -multiply_reachable\\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\\n total_points += points\\n\\n # Fill in the backward diagonal win positions\\n for i in range(size_y - num_to_connect + 1):\\n for j in range(size_x - 1, num_to_connect - 1 - 1, -1):\\n points = 0\\n self_pieces_count = 0\\n opponent_pieces_count = 0\\n for k in range(num_to_connect):\\n if board.board[i + k][j - k] == opponent_id:\\n opponent_pieces_count += 1\\n elif board.board[i + k][j - k] == self.id:\\n points += len(board.winning_zones[j-k][i+k])\\n if (self.id == 1 and (i+k) % 2 == 1) or (self.id == 2 and (i+k)%2 == 0):\\n points *= multiply_oddeven\\n self_pieces_count += 1\\n if self_pieces_count == 3 and self_pieces_count == 0:\\n if board.board[i + 3][j - 3] == 0 and board.board[i - 1][j + 1] == 0 \\\\\\n and board.try_move(j - 3) == i + 3 and board.try_move(j + 1) == i - 1:\\n return maxvalue\\n elif i + 4 < size_y and j - 4 >= 0 and board.board[i + 4][j - 4] == 0 and board.board[i][j] == 0 \\\\\\n and board.try_move(j - 4) == i + 4 and board.try_move(j) == i:\\n return maxvalue\\n else:\\n for k in range(num_to_connect):\\n if board.board[i + k][j - k] == 0 and board.try_move(j - k) == i + k:\\n points *= multiply_reachable\\n\\n elif opponent_pieces_count == 3 and self_pieces_count == 0:\\n if board.board[i + 3][j - 3] == 0 and board.board[i - 1][j + 1] == 0 \\\\\\n and board.try_move(j - 3) == i + 3 and board.try_move(j + 1) == i - 1:\\n return minvalue\\n elif i + 4 < size_y and j - 4 >= 0 and board.board[i + 4][j - 4] == 0 and board.board[i][j] == 0 \\\\\\n and board.try_move(j - 4) == i + 4 and board.try_move(j) == i:\\n return minvalue\\n # else:\\n # for k in range(num_to_connect):\\n # if board.board[i + k][j - k] == 0 and board.try_move(j - k) == i + k:\\n # points *= -multiply_reachable\\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\\n total_points += points\\n return total_points\",\n \"def update_state_v1(self, dbsession, state):\\n moving_player = self.active_player()\\n board = self.update(state)\\n table_game = dbsession.query(TableGame).filter(\\n TableGame.game == board.id).first()\\n table_board = TableBoard(\\n board_state=dumps(tuple(map(tuple, board.board))),\\n move_num=board._board.move_count,\\n player=board.active_player(),\\n game=board.id)\\n if table_game: # TODO(grandquista)\\n table_board.game_link.append(table_game)\\n dbsession.add(table_board)\\n if board:\\n board.poke_player(False)\\n return {'end': False}\\n board.poke_player(True, moving_player)\\n if board._board.has_kings():\\n table_game.one_won = False\\n table_game.two_won = False\\n elif moving_player == table_game.player_one:\\n table_game.two_won = False\\n else:\\n table_game.one_won = False\\n board.close()\\n return {'end': True}\",\n \"def answer_exercise():\\n state = \\\"1212__21_\\\"\\n ttt = TicTacToe(state)\\n game_tree = gen_game_tree(state)\\n print(\\n f\\\"The value of game state:\\\\n{ttt.printable_board(' ', legend_hint=False)}\\\\n\\\"\\n f\\\"is {game_tree[state]['value']}\\\"\\n )\\n return game_tree[state][\\\"value\\\"]\",\n \"def __init__(self, n: int):\\n self.rows = [[n, -1] for _ in range(n)]\\n self.cols = [[n, -1] for _ in range(n)]\\n self.diag = [[n, -1], [n, -1]] # 0 for normal, 1 for anti\\n \\n def move(self, row: int, col: int, player: int) -> int:\\n r1, r2 = self.check(self.rows, row, player), self.check(self.cols, col, player)\\n r3, r4 = 0, 0\\n if(row == col):\\n r3 = self.check(self.diag, 0, player)\\n if(row + col == len(self.rows)-1):\\n r4 = self.check(self.diag, 1, player)\\n \\n return max(r1,r2,r3,r4)\\n def check(self, arr, i, player):\\n arr[i][0] -= 1\\n \\n if(arr[i][1] == -1):\\n arr[i][1] = player\\n elif(arr[i][1] != player):\\n arr[i][1] = 0\\n \\n if(arr[i][0] == 0 and arr[i][1] != 0):\\n return player\\n return 0\\n \\n \\\"\\\"\\\"\\n Player {player} makes a move at ({row}, {col}).\\n @param row The row of the board.\\n @param col The column of the board.\\n @param player The player, can be either 1 or 2.\\n @return The current winning condition, can be either:\\n 0: No one wins.\\n 1: Player 1 wins.\\n 2: Player 2 wins.\\n \\\"\\\"\\\"\\n \",\n \"def check_victory(board):\\n\\n for row in range(HEIGHT):\\n for col in range(WIDTH):\\n\\n player = board[row][col]\\n\\n # not a player move\\n if player == 0 or player == 9:\\n continue\\n\\n # look right\\n if col + 3 < WIDTH and player == board[row][col + 1] and player == board[row][col + 2]\\\\\\n and player == board[row][col + 3]:\\n if player == 1:\\n return +1\\n else:\\n return -1\\n\\n if row + 3 < HEIGHT:\\n\\n # down\\n if player == board[row + 1][col] and player == board[row + 2][col] and player == board[row + 3][col]:\\n if player == 1:\\n return +1\\n else:\\n return -1\\n\\n # down and right\\n if col + 3 < WIDTH and player == board[row + 1][col + 1] and player == board[row + 2][col + 2]\\\\\\n and player == board[row + 3][col + 3]:\\n if player == 1:\\n return +1\\n else:\\n return -1\\n\\n # down and left\\n if col - 3 >= 0 and player == board[row + 1][col - 1] and player == board[row + 2][col - 2] \\\\\\n and player == board[row + 3][col - 3]:\\n if player == 1:\\n return +1\\n else:\\n return -1\\n\\n\\n # # if no one has won yet\\n for row in range(HEIGHT):\\n for col in range(WIDTH):\\n if board[row][col] == 0 or board[row][col] == 9:\\n return None\\n\\n return 0\",\n \"def current_state(self):\\n square_state = np.zeros((4, self.width, self.height))\\n if self.states:\\n for i in range(8):\\n for j in range(8):\\n if self.board_value[i][j]==self.current_player:\\n square_state[0][i][j]=1\\n elif self.board_value[i][j]!=self.current_player and self.board_value[i][j]!= 0:\\n square_state[1][i][j]=1\\n # indicate the last move location\\n square_state[2][self.last_move // self.width, self.last_move % self.height] = 1.0\\n if len(self.states) % 2 == 0:\\n square_state[3][:, :] = 1.0 # indicate the colour to play\\n return square_state[:, ::-1, :]\",\n \"def win_column(playerid):\\n\\n if board[0][0] is playerid and board[1][0] is playerid and board[2][0] is playerid:\\n return (True, \\\"Column 1\\\")\\n\\n if board[0][1] is playerid and board[1][1] is playerid and board[2][1] is playerid:\\n return (True, \\\"Column 2\\\")\\n\\n if board[0][2] is playerid and board[1][2] is playerid and board[2][2] is playerid:\\n return (True, \\\"Column 3\\\")\\n\\n return False\",\n \"def update_cell(self, player: str, letter: str) -> 'Cell':\\n if self.player == 0 and self.letter == letter:\\n self.player = 1 if player == 'p1' else 2\\n return self\",\n \"def new_or_old_piece(self, state):\\r\\n x_moves, o_moves = 0, 0\\r\\n\\r\\n for row_values in state:\\r\\n x_moves += row_values.count('x')\\r\\n o_moves += row_values.count('o')\\r\\n\\r\\n if x_moves + o_moves < 6:\\r\\n if x_moves > o_moves:\\r\\n return True, 'o'\\r\\n elif o_moves < x_moves:\\r\\n return True, 'x'\\r\\n else:\\r\\n return True, 'x'\\r\\n\\r\\n return False, None\",\n \"def evaluate_model_at_gamestate(gamestate, model):\\n # Transform full board into 2 boards of 0s and 1s\\n board = gamestate.board\\n player1_board = np.array([\\n [\\n 0 if val == 0 or val == 2 else 1\\n for val in row\\n ]\\n for row in board\\n ])\\n player2_board = np.array([\\n [\\n 0 if val == 0 or val == 1 else 1\\n for val in row\\n ]\\n for row in board\\n ])\\n\\n # Player is the player who created this state (NOT next)\\n if other_player(gamestate.next_player) == 1:\\n channels = [player1_board, player2_board]\\n else:\\n channels = [player2_board, player1_board]\\n\\n x_train = np.stack(channels).reshape(1, 2, 8, 8)\\n\\n value, policy = _evaluate(x_train, load_model(model))\\n value_np = value.detach().numpy() # value.cpu().detach().numpy() when running remotely\\n policy_np = policy.detach().numpy() # policy.cpu().detach().numpy() when running remotely\\n\\n return value_np[0], np.exp(policy_np.flatten().reshape(8, 8))\",\n \"def result(self, state, action):\\n state_after_act = [[0 for i in range(self.col)] for j in range(self.row)]\\n for k in action:\\n x = k[1][0]\\n y = k[1][1]\\n if k[0] == \\\"vaccinate\\\":\\n state_after_act[x][y] = ('I', 1)\\n else:\\n state_after_act[x][y] = ('Q', 1)\\n\\n for i in range(self.row):\\n for j in range(self.col):\\n if state_after_act[i][j] == 0:\\n if state[i][j][0] == 'U' or state[i][j][0] == 'I':\\n state_after_act[i][j] = state[i][j]\\n\\n elif state[i][j][0] == 'S':\\n if state[i][j][1] == 3:\\n state_after_act[i][j] = ('H', 1)\\n else:\\n if state[i][j][1] == 1:\\n state_after_act[i][j] = ('S', 2)\\n elif state[i][j][1] == 2:\\n state_after_act[i][j] = ('S', 3)\\n\\n elif state[i][j][0] == 'Q':\\n if state[i][j][1] == 2:\\n state_after_act[i][j] = ('H', 1)\\n else:\\n state_after_act[i][j] = ('Q', 2)\\n\\n elif state[i][j][0] == 'H':\\n state_after_act[i][j] = self.healthy(i, j, state,state_after_act)\\n state_after_act[i] = tuple(state_after_act[i])\\n return tuple(state_after_act)\",\n \"def check_board(board_state, player_symbol, display_message = False):\\n\\n is_board_completely_filled = board_state.isalpha()\\n\\n indices_set = set([ind+1 for ind, val in enumerate(board_state) if val == player_symbol])\\n\\n if {1, 2, 3}.issubset(indices_set) or {4, 5, 6}.issubset(indices_set) or {7, 8, 9}.issubset(indices_set):\\n\\n if display_message:\\n print(\\\"Row completed..!!!\\\")\\n print(\\\"Player \\\"+player_symbol+\\\" won the game.\\\")\\n\\n return True\\n\\n if {1, 4, 7}.issubset(indices_set) or {2, 5, 8}.issubset(indices_set) or {3, 6, 9}.issubset(indices_set):\\n\\n if display_message:\\n print(\\\"Column completed..!!!\\\")\\n print(\\\"Player \\\"+player_symbol+\\\" won the game.\\\")\\n\\n return True\\n if {1, 5, 9}.issubset(indices_set) or {3, 5, 7}.issubset(indices_set):\\n\\n if display_message:\\n print(\\\"Diagonal completed..!!!\\\")\\n print(\\\"Player \\\"+player_symbol+\\\" won the game.\\\")\\n\\n return True\\n\\n if is_board_completely_filled:\\n\\n if display_message:\\n print(\\\"Game is drawn...!\\\")\\n\\n return \\\"Draw\\\"\\n\\n return False\",\n \"def column_wise_checking(player_):\\n if board[0] == board[3] == player_:\\n return 6\\n elif board[3] == board[6] == player_:\\n return 0\\n elif board[1] == board[4] == player_:\\n return 7\\n elif board[4] == board[7] == player_:\\n return 1\\n elif board[2] == board[5] == player_:\\n return 8\\n elif board[5] == board[8] == player_:\\n return 2\\n else:\\n return -1\",\n \"def getGameState(self):\\n row1 = [0, 0, 0]\\n row2 = [0, 0, 0]\\n row3 = [0, 0, 0]\\n tilePosStatement = Statement()\\n posTerm1 = Term('?x')\\n posTerm2 = Term('?y')\\n posTerm3 = Term('?tile')\\n tilePosStatement.terms = (posTerm1, posTerm2, posTerm3)\\n tilePosStatement.predicate = 'tilePos'\\n for fact in self.kb.facts:\\n if match(fact.statement, tilePosStatement):\\n if fact.statement.terms[2] == Term(Constant('tile1')):\\n term = 1\\n if fact.statement.terms[2] == Term(Constant('tile2')):\\n term = 2\\n if fact.statement.terms[2] == Term(Constant('tile3')):\\n term = 3\\n if fact.statement.terms[2] == Term(Constant('tile4')):\\n term = 4\\n if fact.statement.terms[2] == Term(Constant('tile5')):\\n term = 5\\n if fact.statement.terms[2] == Term(Constant('tile6')):\\n term = 6\\n if fact.statement.terms[2] == Term(Constant('tile7')):\\n term = 7\\n if fact.statement.terms[2] == Term(Constant('tile8')):\\n term = 8\\n if fact.statement.terms[2] == Term(Constant('empty')):\\n term = -1\\n if fact.statement.terms[0] == Term(Constant('pos1')):\\n col = 0\\n elif fact.statement.terms[0] == Term(Constant('pos2')):\\n col = 1\\n elif fact.statement.terms[0] == Term(Constant('pos3')):\\n col = 2\\n if fact.statement.terms[1] == Term(Constant('pos1')):\\n row1[col] = term\\n\\n elif fact.statement.terms[1] == Term(Constant('pos2')):\\n row2[col] = term\\n\\n elif fact.statement.terms[1] == Term(Constant('pos3')):\\n row3[col] = term\\n\\n row1 = tuple(row1)\\n row2 = tuple(row2)\\n row3 = tuple(row3)\\n result = (row1, row2, row3)\\n return result\\n\\n ### Student code goes here\",\n \"def evaluate(self) :\\n for inp in self.inStates :\\n if inp.getState() == 0 : return 0\\n return 1\",\n \"def play(self, player: players.Player) -> int:\\n # A player first look at the board\\n player.peek(self)\\n position = player.play()\\n # print(position)\\n row, col = utils.index2coordinate(position, self.game_board.size)\\n self.put_piece(row, col)\\n\\n # Check status after move\\n status_after_play = self.check_status(row, col)\\n\\n return status_after_play\",\n \"def cell_entered(self, row: int, _):\\n self.selectRow(row)\",\n \"def player(board):\\n\\tif board == initial_state():\\n\\t\\treturn X\\n\\n\\tnumX=0\\n\\tnumO=0\\n\\n\\tfor i in range(len(board)):\\n\\t\\tfor j in range(len(board)):\\n\\t\\t\\tif(board[i][j]==X):\\n\\t\\t\\t\\tnumX+=1\\n\\t\\t\\telif(board[i][j]==O):\\n\\t\\t\\t\\tnumO+=1\\n\\n\\tif numX > numO:\\n\\t\\treturn O\\n\\telse:\\n\\t\\treturn X\",\n \"def evaluate_line(board, player, index1, index2, index3):\\n opponent = utils.get_opponent(player)\\n line_counts = Counter([board[index1], board[index2], board[index3]])\\n if line_counts[player] > 0 and line_counts[opponent] > 0:\\n return 0 # line has player and opponent values = dead line\\n if line_counts[opponent] == 0:\\n return int(pow(10, line_counts[player] - 1)) # line has only player values\\n return -int(pow(10, line_counts[opponent] - 1)) # line has only opponent values\",\n \"def stand_in_cell(self, player, board):\\n\\n if self.owner is None and player.money >= self.cost:\\n return 1\\n elif player.money < self.cost and self.owner is None:\\n return -1\\n elif self.owner == player:\\n return -2\\n elif self.owner is not None:\\n return 3\",\n \"def legitimateMoves(table,floor,X2,Y2,goes,csvX):\\n scores = []\\n legitimateColumns = []\\n try:\\n i = 0\\n while True:\\n if floor[i] != -1:\\n legitimateColumns.append(i)\\n i=i+1\\n \\n except IndexError:\\n pass\\n #print(legitimateColumns)\\n for x in legitimateColumns:\\n \\n table[floor[x]][x] = \\\"x\\\"\\n gameArray = []\\n for z in range(7):\\n for i in range(5,-1,-1):\\n gameArray.append(table[i][z])\\n \\n \\n gameArray = np.asarray(gameArray)\\n gameArray = np.reshape(gameArray, (1,42))\\n #print(gameArray)\\n np.append(X2, gameArray)\\n\\n \\n \\n if checkWin(table,x,True,floor,\\\"x\\\") == \\\"win\\\":\\n goes = goes+1\\n finished(table,csvX,goes,X2,floor)\\n\\n elif checkWin(table,x,True,floor,\\\"o\\\") == \\\"win\\\":\\n table[floor[x]][x] = \\\"b\\\"\\n return(x)\\n else:\\n #print(\\\"norm\\\")\\n #print(a[0][0])\\n table[floor[x]][x] = \\\"b\\\"\\n #scores.append(a[0][0])\\n #print(gameArray)\\n\\n a = trainer(True,X2,-1,Y2,goes,csvX)\\n\\n for x in a:\\n scores.append(x)\\n \\n #print(scores)\\n scores2 = []\\n for x in legitimateColumns:\\n scores2.append(scores[x])\\n scores = scores2\\n best = max(scores) \\n best_index = scores.index(best)\\n col = legitimateColumns[best_index]\\n #print(col)\\n return(col)\\n #floor[humanInput]=floor[humanInput]-1 \",\n \"def run_simulation(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n player = 0\\n visited_states = [(player, state)]\\n depth_limited = self.depth != -1\\n depth = self.depth\\n expand = True\\n while not visited_states[-1][1].isWin() and not visited_states[-1][1].isLose():\\n if depth_limited and depth == 0: break\\n state = self.UCB1(state, player) # Selection & Simulation\\n if expand and state not in self.plays: # Expansion\\n expand = False\\n self.plays[state] = 0\\n self.wins[state] = 0\\n visited_states.append((player, state))\\n player = (player + 1) % state.getNumAgents()\\n if not expand and depth_limited and player == 0: depth -= 1\\n \\n for player, state in visited_states:\\n if state in self.plays: # Not simulated nodes\\n self.plays[state] += 1\\n eval = self.evaluationFunction(visited_states[-1][1])\\n if depth_limited:\\n if player == 0: self.wins[state] += eval\\n if player != 0: self.wins[state] -= eval\\n else:\\n if player == 0: self.wins[state] += eval\\n if player != 0: self.wins[state] += (1 - eval)\",\n \"def scoreGame(self):\\n # create valueLs[card1,card2,...], pass it to sumHandReturnPoints(valueLs) or twoCardReturnPoints(valueLs)\\n scoreLs = []\\n ### Score of row\\n for rowKey in self.table:\\n valueLs = self.table[rowKey]\\n points = self.sumHandReturnPoints(valueLs)\\n scoreLs.append(points)\\n\\n ### Score of 4-card column\\n for offset in range(0,3): # 0,1,2\\n tmpLs = []\\n for rowKey in self.table:\\n valueLs = self.table[rowKey]\\n if len(valueLs) == 5:\\n iterStart = 1\\n else:\\n iterStart = 0\\n card = valueLs[iterStart+offset]\\n tmpLs.append(card)\\n points = self.sumHandReturnPoints(tmpLs)\\n scoreLs.append(points) \\n\\n ### Score of 2-card column\\n #(1) 1st column\\n valueLs1 = self.table['row1']\\n valueLs2 = self.table['row2']\\n tmpLs = []\\n tmpLs.append(valueLs1[0].get_rank())\\n tmpLs.append(valueLs2[0].get_rank())\\n points = self.twoCardReturnPoints(tmpLs)\\n scoreLs.append(points)\\n #(2) 5th column\\n valueLs3 = self.table['row1']\\n valueLs4 = self.table['row2']\\n tmpLs = []\\n tmpLs.append(valueLs3[-1].get_rank())\\n tmpLs.append(valueLs4[-1].get_rank())\\n points = self.twoCardReturnPoints(tmpLs)\\n scoreLs.append(points) \\n\\n ### Add up scoreLs\\n sumPoints = 0\\n for points in scoreLs:\\n sumPoints += points\\n return sumPoints\",\n \"def evaluate(self, state, player, random_state):\\n result = 0.0\\n for _ in range(self.n_rollouts):\\n working_state = state.clone()\\n while not working_state.is_terminal():\\n if working_state.is_chance_node():\\n outcomes = working_state.chance_outcomes()\\n action_list, prob_list = zip(*outcomes)\\n action = random_state.choice(action_list, p=prob_list)\\n else:\\n action = random_state.choice(working_state.legal_actions())\\n working_state.apply_action(action)\\n result += working_state.player_return(player)\\n\\n return result / self.n_rollouts\",\n \"def outcome(self):\\n if self.grid[0][0] == self.grid[1][0] == self.grid[2][0] and self.grid[0][0] != 0:\\n return self.grid[0][0]\\n if self.grid[0][1] == self.grid[1][1] == self.grid[2][1] and self.grid[0][1] != 0:\\n return self.grid[0][1]\\n if self.grid[0][2] == self.grid[1][2] == self.grid[2][2] and self.grid[0][2] != 0:\\n return self.grid[0][2]\\n if self.grid[0][0] == self.grid[0][1] == self.grid[0][2] and self.grid[0][0] != 0:\\n return self.grid[0][0]\\n if self.grid[1][0] == self.grid[1][1] == self.grid[1][2] and self.grid[1][0] != 0:\\n return self.grid[1][0]\\n if self.grid[2][0] == self.grid[2][1] == self.grid[2][2] and self.grid[2][0] != 0:\\n return self.grid[2][0]\\n if self.grid[0][0] == self.grid[1][1] == self.grid[2][2] and self.grid[0][0] != 0:\\n return self.grid[0][0]\\n if self.grid[0][2] == self.grid[1][1] == self.grid[2][0] and self.grid[0][2] != 0:\\n return self.grid[0][2]\\n return 0\",\n \"def isSolved(board):\\n for player in [1, 2]:\\n if [player]*3 in chain(\\n board, # Rows\\n zip(board), # Columns\\n [ # Diagonals\\n [board[i][i] for i in range(len(board))],\\n [board[len(board) - i - 1][i] for i in range(len(board))]\\n ]\\n ):\\n return player\\n return -1 if 0 in chain(*board) else 0\",\n \"def apply_move(self, move, state):\\n x, y , heading, grid_data = state\\n map_data = [row[:] for row in grid_data]\\n if move == self.MOVE_FORWARD:\\n # get coordinates for next cell\\n if heading == self.UP:\\n next_y = y - 1\\n next_x = x\\n elif heading == self.DOWN:\\n next_y = y + 1\\n next_x = x\\n elif heading == self.LEFT:\\n next_y = y\\n next_x = x - 1\\n else:\\n next_y = y\\n next_x = x + 1\\n\\n # handle special tile types\\n if map_data[next_y][next_x] == self.ICE_SYMBOL:\\n # handle ice tile - slide until first non-ice tile or blocked\\n if heading == self.UP:\\n for i in range(next_y, -1, -1):\\n if map_data[i][next_x] != self.ICE_SYMBOL:\\n if map_data[i][next_x] == self.WATER_SYMBOL:\\n # slide into water - game over\\n return self.GAME_OVER\\n elif self.cell_is_blocked(i, next_x, map_data):\\n # if blocked, stop on last ice cell\\n next_y = i + 1\\n break\\n else:\\n next_y = i\\n break\\n elif heading == self.DOWN:\\n for i in range(next_y, self.y_size):\\n if map_data[i][next_x] != self.ICE_SYMBOL:\\n if map_data[i][next_x] == self.WATER_SYMBOL:\\n # slide into water - game over\\n return self.GAME_OVER\\n elif self.cell_is_blocked(i, next_x, map_data):\\n # if blocked, stop on last ice cell\\n next_y = i - 1\\n break\\n else:\\n next_y = i\\n break\\n elif heading == self.LEFT:\\n for i in range(next_x, -1, -1):\\n if map_data[next_y][i] != self.ICE_SYMBOL:\\n if map_data[next_y][i] == self.WATER_SYMBOL:\\n # slide into water - game over\\n return self.GAME_OVER\\n elif self.cell_is_blocked(next_y, i, map_data):\\n # if blocked, stop on last ice cell\\n next_x = i + 1\\n break\\n else:\\n next_x = i\\n break\\n else:\\n for i in range(next_x, self.x_size):\\n if map_data[next_y][i] != self.ICE_SYMBOL:\\n if map_data[next_y][i] == self.WATER_SYMBOL:\\n # slide into water - game over\\n return self.GAME_OVER\\n elif self.cell_is_blocked(next_y, i, map_data):\\n # if blocked, stop on last ice cell\\n next_x = i - 1\\n break\\n else:\\n next_x = i\\n break\\n if map_data[next_y][next_x] == self.TELEPORT_SYMBOL:\\n # handle teleport - find the other teleporter\\n tpy, tpx = (None, None)\\n for i in range(self.y_size):\\n for j in range(self.x_size):\\n if map_data[i][j] == self.TELEPORT_SYMBOL and (i != next_y or j != next_x):\\n tpy, tpx = (i, j)\\n break\\n if tpy is not None:\\n break\\n if tpy is None:\\n raise Exception(\\\"LaserTank Map Error: Unmatched teleport symbol\\\")\\n next_y, next_x = (tpy, tpx)\\n else:\\n # if not ice or teleport, perform collision check\\n if self.cell_is_blocked(next_y, next_x, map_data):\\n return self.COLLISION\\n\\n # check for game over conditions\\n if self.cell_is_game_over(next_y, next_x, map_data):\\n return self.GAME_OVER\\n\\n # no collision and no game over - update player position\\n y = next_y\\n x = next_x\\n return (x, y, heading, map_data)\\n\\n elif move == self.TURN_LEFT:\\n # no collision or game over possible\\n if heading == self.UP:\\n heading = self.LEFT\\n elif heading == self.DOWN:\\n heading = self.RIGHT\\n elif heading == self.LEFT:\\n heading = self.DOWN\\n else:\\n heading = self.UP\\n return (x, y, heading, map_data)\\n\\n elif move == self.TURN_RIGHT:\\n # no collision or game over possible\\n if heading == self.UP:\\n heading = self.RIGHT\\n elif heading == self.DOWN:\\n heading = self.LEFT\\n elif heading == self.LEFT:\\n heading = self.UP\\n else:\\n heading = self.DOWN\\n return (x, y, heading, map_data)\\n\\n elif move == self.SHOOT_LASER:\\n # set laser direction\\n if heading == self.UP:\\n laserheading = self.UP\\n dy, dx = (-1, 0)\\n elif heading == self.DOWN:\\n laserheading = self.DOWN\\n dy, dx = (1, 0)\\n elif heading == self.LEFT:\\n laserheading = self.LEFT\\n dy, dx = (0, -1)\\n else:\\n laserheading = self.RIGHT\\n dy, dx = (0, 1)\\n\\n # loop until laser blocking object reached\\n ly, lx = (y, x)\\n while True:\\n ly += dy\\n lx += dx\\n\\n # handle boundary and immovable obstacles\\n if ly < 0 or ly >= self.y_size or \\\\\\n lx < 0 or lx >= self.x_size or \\\\\\n map_data[ly][lx] == self.OBSTACLE_SYMBOL:\\n # laser stopped without effect\\n return self.COLLISION\\n\\n # handle movable objects\\n elif self.cell_is_laser_movable(ly, lx, laserheading, map_data):\\n # check if tile can be moved without collision\\n if self.cell_is_blocked(ly + dy, lx + dx, map_data) or \\\\\\n map_data[ly + dy][lx + dx] == self.ICE_SYMBOL or \\\\\\n map_data[ly + dy][lx + dx] == self.TELEPORT_SYMBOL or \\\\\\n map_data[ly + dy][lx + dx] == self.FLAG_SYMBOL or \\\\\\n (ly + dy == y and lx + dx == x):\\n # tile cannot be moved\\n return self.COLLISION\\n else:\\n old_symbol = map_data[ly][lx]\\n map_data[ly][lx] = self.LAND_SYMBOL\\n if map_data[ly + dy][lx + dx] == self.WATER_SYMBOL:\\n # if new bridge position is water, convert to land tile\\n if old_symbol == self.BRIDGE_SYMBOL:\\n map_data[ly + dy][lx + dx] = self.LAND_SYMBOL\\n # otherwise, do not replace the old symbol\\n else:\\n # otherwise, move the tile forward\\n map_data[ly + dy][lx + dx] = old_symbol\\n break\\n\\n # handle bricks\\n elif map_data[ly][lx] == self.BRICK_SYMBOL:\\n # remove brick, replace with land\\n map_data[ly][lx] = self.LAND_SYMBOL\\n break\\n\\n # handle facing anti-tanks\\n elif (map_data[ly][lx] == self.ANTI_TANK_UP_SYMBOL and laserheading == self.DOWN) or \\\\\\n (map_data[ly][lx] == self.ANTI_TANK_DOWN_SYMBOL and laserheading == self.UP) or \\\\\\n (map_data[ly][lx] == self.ANTI_TANK_LEFT_SYMBOL and laserheading == self.RIGHT) or \\\\\\n (map_data[ly][lx] == self.ANTI_TANK_RIGHT_SYMBOL and laserheading == self.LEFT):\\n # mark anti-tank as destroyed\\n map_data[ly][lx] = self.ANTI_TANK_DESTROYED_SYMBOL\\n break\\n\\n # handle player laser collision\\n elif ly == y and lx == x:\\n return self.GAME_OVER\\n\\n # handle facing mirrors\\n elif (map_data[ly][lx] == self.MIRROR_UL_SYMBOL and laserheading == self.RIGHT) or \\\\\\n (map_data[ly][lx] == self.MIRROR_UR_SYMBOL and laserheading == self.LEFT):\\n # new direction is up\\n dy, dx = (-1, 0)\\n laserheading = self.UP\\n elif (map_data[ly][lx] == self.MIRROR_DL_SYMBOL and laserheading == self.RIGHT) or \\\\\\n (self.grid_data[ly][lx] == self.MIRROR_DR_SYMBOL and laserheading == self.LEFT):\\n # new direction is down\\n dy, dx = (1, 0)\\n laserheading = self.DOWN\\n elif (map_data[ly][lx] == self.MIRROR_UL_SYMBOL and laserheading == self.DOWN) or \\\\\\n (map_data[ly][lx] == self.MIRROR_DL_SYMBOL and laserheading == self.UP):\\n # new direction is left\\n dy, dx = (0, -1)\\n laserheading = self.LEFT\\n elif (map_data[ly][lx] == self.MIRROR_UR_SYMBOL and laserheading == self.DOWN) or \\\\\\n (map_data[ly][lx] == self.MIRROR_DR_SYMBOL and laserheading == self.UP):\\n # new direction is right\\n dy, dx = (0, 1)\\n laserheading = self.RIGHT\\n # do not terminate laser on facing mirror - keep looping\\n\\n # check for game over condition after effect of laser\\n if self.cell_is_game_over(y, x, map_data):\\n return self.GAME_OVER\\n return (x, y, heading, map_data)\\n return self.SUCCESS\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6999296","0.6501366","0.6476799","0.6461873","0.6389604","0.63032645","0.62785196","0.62500495","0.6232211","0.6228227","0.6160248","0.61407185","0.6129514","0.59984934","0.5966352","0.59632826","0.59607756","0.5958547","0.595793","0.5954501","0.5954304","0.59483385","0.5947483","0.59436905","0.5924104","0.59128046","0.58889556","0.5887487","0.588478","0.5874793","0.5855551","0.5817178","0.5799906","0.5799353","0.578176","0.5781559","0.57754415","0.5767741","0.5756056","0.57426435","0.57364905","0.57234627","0.57181937","0.5704819","0.5698537","0.56936705","0.5680267","0.5661539","0.56613374","0.56538916","0.56489223","0.5640781","0.56372094","0.5629981","0.56276685","0.5622133","0.5619491","0.55974793","0.55840737","0.5573895","0.5559479","0.5558021","0.55521756","0.5543646","0.554108","0.5524134","0.5514677","0.5513057","0.5501971","0.5476625","0.5474413","0.54705733","0.5469479","0.54671216","0.54648316","0.5460811","0.54479796","0.5446237","0.544205","0.54406124","0.543318","0.54283684","0.54199123","0.5419897","0.54104847","0.54076415","0.54074454","0.5402711","0.53911954","0.53891236","0.53740203","0.53682196","0.53589046","0.53519535","0.53503776","0.5344135","0.53405094","0.53390974","0.53277224","0.53276527"],"string":"[\n \"0.6999296\",\n \"0.6501366\",\n \"0.6476799\",\n \"0.6461873\",\n \"0.6389604\",\n \"0.63032645\",\n \"0.62785196\",\n \"0.62500495\",\n \"0.6232211\",\n \"0.6228227\",\n \"0.6160248\",\n \"0.61407185\",\n \"0.6129514\",\n \"0.59984934\",\n \"0.5966352\",\n \"0.59632826\",\n \"0.59607756\",\n \"0.5958547\",\n \"0.595793\",\n \"0.5954501\",\n \"0.5954304\",\n \"0.59483385\",\n \"0.5947483\",\n \"0.59436905\",\n \"0.5924104\",\n \"0.59128046\",\n \"0.58889556\",\n \"0.5887487\",\n \"0.588478\",\n \"0.5874793\",\n \"0.5855551\",\n \"0.5817178\",\n \"0.5799906\",\n \"0.5799353\",\n \"0.578176\",\n \"0.5781559\",\n \"0.57754415\",\n \"0.5767741\",\n \"0.5756056\",\n \"0.57426435\",\n \"0.57364905\",\n \"0.57234627\",\n \"0.57181937\",\n \"0.5704819\",\n \"0.5698537\",\n \"0.56936705\",\n \"0.5680267\",\n \"0.5661539\",\n \"0.56613374\",\n \"0.56538916\",\n \"0.56489223\",\n \"0.5640781\",\n \"0.56372094\",\n \"0.5629981\",\n \"0.56276685\",\n \"0.5622133\",\n \"0.5619491\",\n \"0.55974793\",\n \"0.55840737\",\n \"0.5573895\",\n \"0.5559479\",\n \"0.5558021\",\n \"0.55521756\",\n \"0.5543646\",\n \"0.554108\",\n \"0.5524134\",\n \"0.5514677\",\n \"0.5513057\",\n \"0.5501971\",\n \"0.5476625\",\n \"0.5474413\",\n \"0.54705733\",\n \"0.5469479\",\n \"0.54671216\",\n \"0.54648316\",\n \"0.5460811\",\n \"0.54479796\",\n \"0.5446237\",\n \"0.544205\",\n \"0.54406124\",\n \"0.543318\",\n \"0.54283684\",\n \"0.54199123\",\n \"0.5419897\",\n \"0.54104847\",\n \"0.54076415\",\n \"0.54074454\",\n \"0.5402711\",\n \"0.53911954\",\n \"0.53891236\",\n \"0.53740203\",\n \"0.53682196\",\n \"0.53589046\",\n \"0.53519535\",\n \"0.53503776\",\n \"0.5344135\",\n \"0.53405094\",\n \"0.53390974\",\n \"0.53277224\",\n \"0.53276527\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.654148"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":89599,"cells":{"query":{"kind":"string","value":"Checks newly inited props."},"document":{"kind":"string","value":"def _testConnectionProps(self, connection):\n self.assertEquals(36, len(connection.id))\n self.assertEquals(self.channel.name, connection.channel_name)\n self.assertTrue(connection.connected)\n self.assertFalse(connection.authenticated)\n self.assertEquals(None, connection.flex_user)\n self.assertTrue(connection.last_active > 0)\n self.assertTrue(time.time() * 1000 > connection.last_active)"},"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 check_properties(self):\r\n for prop in self.mandatory_properties:\r\n if not hasattr(self, prop):\r\n raise NameError(prop)","def set_check_props(self, props):\n _api.check_isinstance(dict, props=props)\n if 's' in props: # Keep API consistent with constructor.\n props['sizes'] = np.broadcast_to(props.pop('s'), len(self.labels))\n actives = self.get_status()\n self._checks.update(props)\n # If new colours are supplied, then we must re-apply the status.\n self._init_status(actives)","def _validate(self):\n for name, prop in self._properties.iteritems():\n value = getattr(self, name, None)\n prop._do_validate(value)","def ok(self):\r\n if hasattr(self, 'prm') and \\\r\n isinstance(self.prm, dict) and \\\r\n hasattr(self, 'type') and \\\r\n isinstance(self.type, dict) and \\\r\n hasattr(self, 'help') and \\\r\n isinstance(self.help, dict):\r\n return True\r\n else:\r\n raise ValueError(\r\n 'The constructor in class %s does not '\\\r\n 'initialize the\\ndictionaries '\\\r\n 'self.prm, self.type, self.help!' %\r\n self.__class__.__name__)","def _has_valid_mandatory_properties(self):\n for prop in self.mandatory_properties:\n if not hasattr(self, prop):\n logger.error(\n \"Skipping %s: could not find information about '%s'\",\n self, prop)\n return False\n return True","def test_read_props(self):\n basic_test_runner(self, 'read_props')","def _check_vals(self):\n\n try:\n self.is_set = True\n self.pack()\n except Exception as err:\n # Set default values again\n raise ValueError(\"Invalid arguments. Could not packed since: {}\".format(err))\n self.__init__()","def test_initial_device_properties(self):\n expected_count = 1 # model_key property already present in db\n self.assertEquals(expected_count, self._count_device_properties())","def _check_initialized(self):\n self.assertEquals(0, self._error_count)\n self.assertEquals(0, len(self._error_messages))","def props(self):\r\n return ()","def props(self):\r\n return ()","def props(self):\r\n return ()","def is_good_for_setup(self):\n attributes = [\n \"rotatePivot\",\n \"scalePivot\",\n \"rotatePivotTranslate\",\n \"scalePivotTranslate\",\n ]\n\n for attrStr in attributes:\n connections = self._object.attr(attrStr).connections()\n if len(connections) > 0:\n return False\n\n return True","def check_data(self):\n\n missing_params = {}\n flag = False\n\n missing_params['general'] = {}\n for name, param in self.params.items():\n if not param.check():\n missing_params['general'][name] = param.get_description()\n flag = True\n\n for component, comp_obj in self.components.items():\n missing_params[component], flag_comp = comp_obj.check_data()\n\n # Assign empty component parameters that have a general version:\n empty_general_params = set(missing_params[component]).intersection(\n set(self.params))\n for param in empty_general_params:\n comp_obj.change_param_object(param, self.params[param])\n del missing_params[component][param]\n\n if missing_params[component]:\n flag = True\n\n if flag:\n raise Exception('Following parameters are missing:\\n{}'\n .format(\n self._print_params(missing_params, disp=False)))\n\n return True","def check_mandatory_props(klass: pyorient.ogm.declarative.DeclarativeMeta, obj: Dict):\n missing = []\n props = klass.objects.g.props_from_db[klass](Graph.compute_all_properties(klass))\n for k, v in props.items():\n prop = getattr(klass, k)\n if hasattr(prop, 'mandatory'):\n if prop.mandatory and k not in obj:\n # Fix values if default set \n if k == \"revoked\":\n obj[k] = False\n continue\n if k == \"spec_version\":\n obj[k] = \"2.1\"\n continue\n missing.append(k)\n if isinstance(prop, odbproperty.String):\n obj[k] = 'added_default'\n elif isinstance(prop, (odbproperty.Date, odbproperty.DateTime)):\n obj[k] = get_datetime()\n elif isinstance(prop, odbproperty.EmbeddedList):\n obj[k] = ['added_default']\n elif isinstance(prop, odbproperty.Integer):\n obj[k] = 0\n elif isinstance(prop, odbproperty.Float):\n obj[k] = 0.0\n elif isinstance(prop, odbproperty.Binary):\n obj[k] = 0\n elif isinstance(prop, odbproperty.Byte):\n obj[k] = 0\n elif isinstance(prop, odbproperty.Decimal):\n obj[k] = 0.0\n elif isinstance(prop, odbproperty.Long):\n obj[k] = 0\n elif isinstance(prop, odbproperty.Short):\n obj[k] = 0\n elif isinstance(prop, odbproperty.Boolean):\n obj[k] = True\n else:\n logging.info(f'What to do with missing mandatory field {k} of type {v.__class__}?')\n if missing:\n logging.info(f'missing mandatory fields for {obj[\"id_\"]}: {missing}')\n return obj","def test_tap_config_valid_if_properties_is_none(self):\n self._assert_tap_config(config=self.valid_json_file, properties=None, state=self.valid_json_file)","def _check_params(self):\n pass","def is_initialized(self) -> bool:\n return (\n (self._exchange_params_by_currency_id is not None)\n and (self._utility_params_by_good_id is not None)\n and (self._transaction_fees is not None)\n )","def init(self):\n return True","def _init_checked(self):\n assert all(\n len(val) <= 2\n or (\n len(val) == 3\n and all(\n self.extra_parameters[parent_var] == self.fuse_parameter\n for parent_var in val\n )\n )\n for val in self.reversed_extra_parameters.values()\n )\n assert all(\n (\n any(\n parent_var in self.left_sided_parameters\n or parent_var in self.right_sided_parameters\n for parent_var in parent_vars\n )\n and any(\n parent_var in self.both_sided_parameters\n for parent_var in parent_vars\n )\n )\n or all(\n self.extra_parameters[parent_var] == self.fuse_parameter\n for parent_var in parent_vars\n )\n for parent_vars in self.reversed_extra_parameters.values()\n if len(parent_vars) == 2\n )","def sanity_check(self):\n pass","def _check_required_fields(self):\n assert self.volume_title\n super(MultiMonoComposer, self)._check_required_fields()","def _is_initialized(self) -> bool:\n return len(self) > 0","def populate_initial_valid_metadata(self):\n pass","def testAddingPropertyFields(self):\n map_sheet = self.properties[PROPERTY_SHEET]\n for key, value in PROPS.items():\n self.failUnless(map_sheet.hasProperty(key) and list(map_sheet.getProperty(key)) == value)","def _init_props(self):\n # N is the number of components in the distribution\n self.N = self.f.shape[-1]\n self._dist_samples = self.f.shape[0]\n self._true_batch_shape = self.f.shape[1:-1]\n\n self._calc_a_b(self.f, self.alpha, self.beta)\n self._calc_norm(self.f, self.a, self.b)","def sanity_check(self):\n return True","def _check_inputs(self):\n\n self._check_resident_prefs()\n self._check_hospital_prefs()","def init_check(self):\n for required_file in self._required_files:\n # Check if required files are there\n # FIXME Sometimes it doesn't work :?\n if required_file not in self.files:\n self.valid = False","def test_setup(self):\n self.assertIsNotNone(getattr(self, 'original_good_practice_attrs', None))\n self.assertIsNotNone(getattr(self, 'original_get_overrides', None))\n self.assertIsNotNone(getattr(self, 'original_get_alt_field_info', None))\n self.assertIsNone(getattr(self.form, 'is_prepared', None))\n self.assertNotIn('good_practice_attrs', self.form.has_call)\n self.assertNotIn('get_overrides', self.form.has_call)\n self.assertNotIn('get_alt_field_info', self.form.has_call)\n good_practice = self.form.good_practice_attrs()\n if self.good_practice == 'empty':\n self.assertEqual({}, good_practice)\n overrides = self.form.get_overrides()\n if self.overrides_empty_or_skip == 'empty':\n self.assertEqual({}, overrides)\n elif self.overrides_empty_or_skip == 'skip':\n self.assertEqual(self.no_resize_override(), overrides)\n if self.alt_info == 'empty':\n self.assertEqual({}, self.form.get_alt_field_info())\n self.assertIn('get_alt_field_info', self.form.has_call)\n self.assertEqual(self.form.get_alt_field_info.__name__, 'empty_get_alt_field_info')\n self.assertIn('good_practice_attrs', self.form.has_call)\n self.assertIn('get_overrides', self.form.has_call)\n self.form.has_call = []\n self.assertEqual(self.form.good_practice_attrs.__name__, 'empty_good_practice_attrs')\n if self.overrides_empty_or_skip == 'empty':\n self.assertEqual(self.form.get_overrides.__name__, 'empty_get_overrides')\n self.assertEqual(self.form.get_overrides.__name__, 'skip_get_overrides')\n request_type = 'POST' if self.get_initial_data() else 'GET'\n self.assertEqual(request_type, self.request.method)","def props(self, props):\n\n self._props = props","def _validate_params(self):\n assert set(self.required_params) - set(self._params) == set()\n for par, val in self.optional_params.items():\n if par not in self._params:\n self._params[par] = val","def check_init(self):\n if self.Nlayer > 1:\n raise Exception(\"Nlayer == 1 currently\")","def test_too_many_props(self):\n with pytest.raises(ValueError):\n State(\n substance=\"water\",\n T=Q_(300, \"K\"),\n p=Q_(101325, \"Pa\"),\n u=Q_(100, \"kJ/kg\"),\n )","def check_attributes(self):\n for key in self.json_parsed_file.keys():\n if key not in self.HARDCODED_REQUIRED_JSON_FIELDS:\n print(key)\n self.output_message += \"All JSON attribute key are not correct\\n\"\n self.is_parsed_pdf_valid = False\n\n for key in self.HARDCODED_REQUIRED_JSON_FIELDS:\n if key not in self.json_parsed_file.keys():\n self.output_message += \"All required attribute keys are not in the parsed information\\n\"\n self.is_parsed_pdf_valid = False","def test_init_valid_field(self):\n fields = {'Conn Note': {'offset': 0,\n 'length': 20}}\n parser = top.Parser(fields=fields)\n received = parser.get_fields()\n expected = fields\n msg = 'Fields initialisation property setter/getter error.'\n self.assertEqual(received, expected, msg)","def _check_assigned(self):\n\n if self.values is None and self.lazy:\n raise ValueError(\"This instance has not been assigned any data.\")","def check_state(self):\n pass","def _check_kwargs(cls, kwargs: Mapping[str, Any]):\n for name, prop in cls._props_by_name.items():\n if prop.required and name not in kwargs:\n raise ValueError(f'Required property {name} is missing.')\n for name, value in kwargs.items():\n if name not in cls._props_by_name:\n raise KeyError(f'Unknown property {name}.')\n prop = cls._props_by_name[name]\n prop.validate(value)","def check_vars(self):\n\n # The pipe name.\n if not has_pipe(self.pipe_name):\n raise RelaxNoPipeError(self.pipe_name)","def _should_initialize_check_run(self, payload):\n action = payload.get('action')\n return action in self.initialize_actions or self.initialize_actions is None","def initialize(\n self,\n state_args=None,\n state_vars_fixed=False,\n hold_state=False,\n outlvl=idaeslog.NOTSET,\n solver=None,\n optarg=None,\n ):\n # For now, there are no constraints in the property package, so only\n # fix state variables if required\n init_log = idaeslog.getInitLogger(self.name, outlvl, tag=\"properties\")\n\n init_log.info(\"Initialization Complete.\")\n\n if hold_state is True:\n flags = fix_state_vars(self, state_args)\n return flags\n else:\n return","def __post_init_check(self):\n try:\n t = self.time\n m = self.metadata\n except AttributeError as e:\n clsname = self.__class__.__name__\n raise TypeError(f\"Model not initialized. Please call 'SupernovaModel.__init__' within the '{clsname}.__init__'\") from e","def test_preferences_init(self):\n self.preferences.init(\n exchange_params_by_currency_id=self.exchange_params,\n utility_params_by_good_id=self.utility_params,\n tx_fee=self.tx_fee,\n )\n assert self.preferences.utility_params_by_good_id is not None\n assert self.preferences.exchange_params_by_currency_id is not None\n assert self.preferences.transaction_fees[\"seller_tx_fee\"] == 4\n assert self.preferences.transaction_fees[\"buyer_tx_fee\"] == 5\n assert self.preferences.is_initialized","def _is_ready(self):\n res = True\n for (key, val) in self._attrs.iteritems():\n if key not in self._optional_attrs:\n if val is None:\n res = False\n return res","def checkInit(this):\n\t\tif not this._CAP: raise Exception('Vous devez initialiser la caméra...')","def _further_validate_and_setup(self) -> None:\n\n # Make sure parameters make sense/are valid\n if len(self.validated['learners']) != len(self.validated['param_grids']):\n raise SchemaError(autos=None,\n errors='The lists of of learners and parameter '\n 'grids must be the same size.')\n if (self.validated['hashed_features'] is not None\n and self.validated['hashed_features'] == 0):\n self.validated['hashed_features'] = self._n_features_feature_hashing\n if self.validated['lognormal'] and self.validated['power_transform']:\n raise SchemaError(autos=None,\n errors='Both \"lognormal\" and \"power_transform\" '\n 'were set simultaneously.')\n if len(self.validated['learners']) != len(self.validated['param_grids']):\n raise SchemaError(autos=None,\n errors='The \"learners\" and \"param_grids\" '\n 'parameters were both set and the '\n 'lengths of the lists are unequal.')","def _initFields(self):\n pass","def check_for_new_data(self):\n return","def check(self):\n\n self.check_auto_update()\n assert not self.empty()","def _check_validity(self):\n pass","def assert_goodness(self):\n if self._setted:\n self.assert_stored_iss()\n self.assert_stored_ks()\n ## Check idxs\n self.assert_stored_idxs()\n ## Check sp_relative_pos\n self.assert_stored_sp_rel_pos()","def _set_init_param_dict(self):\n\n self.param_dict = {}\n\n try:\n suppress_warning = self._suppress_repeated_param_warning\n except AttributeError:\n suppress_warning = False\n msg = (\"\\n\\nThe param_dict key %s appears in more than one component model.\\n\"\n \"This is permissible, but if you are seeing this message you should be sure you \"\n \"understand it.\\nIn particular, double-check that this parameter does not have \"\n \"conflicting meanings across components.\\n\"\n \"\\nIf you do not wish to see this message every time you instantiate, \\n\"\n \"simply attach a _suppress_repeated_param_warning attribute \\n\"\n \"to any of your component models and set this variable to ``True``.\\n\")\n\n for component_model in self.model_dictionary.values():\n\n if not hasattr(component_model, 'param_dict'):\n component_model.param_dict = {}\n intersection = set(self.param_dict) & set(component_model.param_dict)\n if intersection != set():\n for key in intersection:\n if suppress_warning is False:\n warn(msg % key)\n\n for key, value in component_model.param_dict.iteritems():\n self.param_dict[key] = value\n\n self._init_param_dict = copy(self.param_dict)","def testRequiredAttributes(self):\n\n\t\trequiredAttributes = (\"name\",\n\t\t\t\t\t\t\t\"uiFile\",\n\t\t\t\t\t\t\t\"activated\",\n\t\t\t\t\t\t\t\"initializedUi\",\n\t\t\t\t\t\t\t\"deactivatable\")\n\n\t\tfor attribute in requiredAttributes:\n\t\t\tself.assertIn(attribute, dir(QWidgetComponentFactory()))","def _check_required_fields(self):\n assert self.title\n assert self.format","def check_primers(self):\n primer_keys=['sequence','description']\n if self.data.has_key('primer_dict'):\n for primer in self.data['primer_dict'].keys():\n for key in primer_keys:\n if not self.data['primer_dict'][primer].has_key(key):\n self.data['primer_dict'][primer][key]='None'","def parseProperties(self) -> bool:\n\n # vNetIds is not a mandatory property. This property can be used if the resources are distributed across multiple vNets.\n self.vNetIds = self.providerProperties.get(\"vNetIds\", None)\n\n # enabledProviders contains the provider types for which AIOps is enabled. Mandatory property.\n self.enabledProviders = self.providerProperties.get(\n \"enabledProviders\", None)\n if not self.enabledProviders:\n self.tracer.error(\n \"[%s] enabledProviders cannot be empty in the AIOps config.\" % self.fullName)\n return False\n return True","def test_validate_properties(self):\n\n ingest_mgmr = IngestManager()\n ingest_mgmr.validate_config_file(self.example_config_data)\n ingest_mgmr.validate_properties()\n assert (ingest_mgmr.collection.name == 'my_col_1')\n assert (ingest_mgmr.experiment.name == 'my_exp_1')\n assert (ingest_mgmr.channel.name == 'my_ch_1')","def checkParameters(self):\n self.DEBUG(\"EDPluginWaitMultiFile.checkParameters\")\n self.checkMandatoryParameters(self.dataInput, \"Data Input is None\")\n self.checkMandatoryParameters(self.dataInput.expectedFile, \"Data Input is None\")\n self.checkMandatoryParameters(self.dataInput.expectedSize, \"Data Input is None\")","def set_old_props(self):\n self.old_props = {k: v for k, v in self.node.props.items()}","def __init__(self, **properties):\n self._changed_fields = set()\n self._new = False\n self._deleted = False\n self._parent = None\n\n # Set all the fields silently to avoid marking them as changed.\n self.set_silent(**properties)\n\n # Verify every field has a value or is a LazyField. Do not check values as these\n # may trigger lazy loaders.\n for name in self.fields:\n if not (name in self.lazy_fields or hasattr(self, name)):\n raise ChipsError(\"Required field in model not defined %s [%s]\", self.__class__.__name__, name)\n # Verify this instance has an 'id' set.\n if self.get_id() == None:\n raise ChipsError(\"Model has no id field set %s [%s]\", self.__class__.__name__, self.id_field_name)","def test_too_few_props(self):\n with pytest.raises(ValueError):\n State(substance=\"water\", T=Q_(300, \"K\"))","def check_blank_prop(blank_mol, validate_dict):\n\n # Check if properties populated\n property_dict = blank_mol.GetPropsAsDict()\n\n # Properties to ignore\n prop_ignore_list = ['ref_mols', 'ref_pdb']\n\n for key, value in zip(property_dict.keys(), property_dict.values()):\n if value == '' and key not in prop_ignore_list:\n validate_dict = add_warning(molecule_name=blank_mol.GetProp('_Name'),\n field=key,\n warning_string='description for %s missing' % (key,),\n validate_dict=validate_dict)\n if key == 'ref_url' and check_url(value) == False:\n validate_dict = add_warning(molecule_name=blank_mol.GetProp('_Name'),\n field=key,\n warning_string='illegal URL %s provided' % (value,),\n validate_dict=validate_dict)\n\n return validate_dict","def check_required_props(self,\n df,\n node,\n dd,\n exclude_props = [ # submitters don't provide these properties, so remove them from QC check\n # case props not provided by submitters\n \"datasets.submitter_id\",\n \"token_record_id\",\n \"linked_external_data\",\n #series_file props not provided by submitters\n \"file_name\",\n \"md5sum\",\n \"file_size\",\n \"object_id\",\n \"storage_urls\",\n \"core_metadata_collections.submitter_id\",\n \"core_metadata_collections\",\n \"associated_ids\",\n #imaging_study props not provided by submitters\n \"loinc_code\",\n \"loinc_system\",\n \"loinc_contrast\",\n \"loinc_long_common_name\",\n \"loinc_method\",\n \"days_from_study_to_neg_covid_test\",\n \"days_from_study_to_pos_covid_test\"\n ]\n ):\n errors = []\n links = self.list_links(node, dd)\n any_na = df.columns[df.isna().any()].tolist()\n required_props = list(set(dd[node]['required']).difference(links).difference(exclude_props))\n for prop in required_props:\n if prop not in df:\n error = \"{} TSV does not have required property header '{}'!\".format(node,prop)\n print(error)\n errors.append(error)\n elif prop in any_na:\n error = \"{} TSV does not have complete data for required property '{}'!\".format(node,prop)\n print(error)\n errors.append(error)\n return errors","def verify_attrs(self):\n self.verify_namespace_attrs(self.newlibrary.wrap_namespace)","def _init_check_database(self):\n # FIXME add additional checks, for example that columns in BY,\n # ACROSS, ON are not the same ? (see task structure notes)\n # also that location columns are not used\n if self.verbose:\n print('checking input database {}'.format(self.database))\n\n # check that required columns are present\n cols = set(self.db.columns)\n message = (\n ' argument is invalid, check that all the provided attributes '\n 'are defined in the database {}'.format(self.database))\n # the argument of issuperset needs to be a list ...\n assert cols.issuperset(self.on), 'ON' + message\n assert cols.issuperset(self.across), 'ACROSS' + message\n assert cols.issuperset(self.by), 'BY' + message\n\n for col in cols:\n assert '_' not in col, \\\n col + ': you cannot use underscore in column names'\n assert '#' not in col, \\\n col + ': you cannot use \\'#\\' in column names'\n\n if self.verbose:\n print(\"input database verified\")","def check_blank_prop(blank_mol, validate_dict):\n\n # Check if properties populated\n property_dict = blank_mol.GetPropsAsDict()\n\n # Properties to ignore\n prop_ignore_list = ['ref_mols', 'ref_pdb']\n\n for key, value in zip(list(property_dict.keys()), list(property_dict.values())):\n if value == '' and key not in prop_ignore_list:\n validate_dict = add_warning(molecule_name=blank_mol.GetProp('_Name'),\n field=key,\n warning_string='description for %s missing' % (key,),\n validate_dict=validate_dict)\n if key == 'ref_url' and check_url(value) is False:\n validate_dict = add_warning(molecule_name=blank_mol.GetProp('_Name'),\n field=key,\n warning_string='illegal URL %s provided' % (value,),\n validate_dict=validate_dict)\n\n return validate_dict","def is_initialised(self) -> bool:\n return _schema.has_schema(self._engine)","def check(self):\n self.init()\n self.calculate_output()\n self.compare_outputs_with_expects()","def initialize(self) -> bool:\n raise NotImplementedError","def _check_parameters(self, X):\n _, n_features = X.shape\n\n if self.weights_init is not None:\n self.weights_init = _check_weights(self.weights_init,\n self.n_components)","def _check_attrs(cfg, attrs):\n for a in attrs:\n if (not hasattr(cfg, a)) or getattr(cfg, a) is None:\n print(\"{0} parameter is not set\".format(a))\n sys.exit(UNKNOWN)","def testAttributes(self):\n pl = Pipeline(loadInitFile=False)\n repl = REPL(pl)\n self.assertIs(pl, repl.pipeline)\n self.assertEqual(REPL.DEFAULT_PS1, repl.prompt)","def _check_config(self):","def initialized(self):\n # verbose = CMAKE_BUILD_VERBOSE\n # if verbose:\n # self.diagnose_initialized_problems()\n return self.project_build_dir.exists() and self.has_stored_config_file()","def _post_init(self):\n pass","def pre_save(self):\r\n self.validate()","def _check_params(self):\n\n # verify that estimator1 and estimator2 have predict_proba\n if (not hasattr(self.estimator1_, 'predict_proba') or\n not hasattr(self.estimator2_, 'predict_proba')):\n raise AttributeError(\"Co-training classifier must be initialized \"\n \"with classifiers supporting \"\n \"predict_proba().\")\n\n if (self.p_ is not None and self.p_ <= 0) or (self.n_ is not None and\n self.n_ <= 0):\n raise ValueError(\"Both p and n must be positive.\")\n\n if self.unlabeled_pool_size <= 0:\n raise ValueError(\"unlabeled_pool_size must be positive.\")\n\n if self.num_iter <= 0:\n raise ValueError(\"num_iter must be positive.\")","def valid(self):\n pass","def verify(self):\r\n self.title = self.title and self.title or '' \r\n self.descr = self.descr and self.descr or '' \r\n self.link = self.link and self.link or ''\r\n self.channelURL = self.channelURL and self.channelURL or ''","def test_init_attributes(self):\n t = self.Test({'id': 1, 'poop': 'abc'})\n\n self.assertEqual(t.id, 1)\n self.assertEqual(t.name, None)\n self.assertRaises(AttributeError, t.__getattribute__, 'poop')","def is_initialized(self) -> bool:\n return (\n self._amount_by_currency_id is not None\n and self._quantities_by_good_id is not None\n )","def init_attrs(self):\n raise NotImplementedError","def check_settings(self):\n pass","def check_initialized(self):\n for name, field in self.__by_name.items():\n value = getattr(self, name)\n if value is None:\n if field.required:\n raise ValidationError(\n \"Message %s is missing required field %s\" %\n (type(self).__name__, name))\n else:\n try:\n if (isinstance(field, MessageField) and\n issubclass(field.message_type, Message)):\n if field.repeated:\n for item in value:\n item_message_value = field.value_to_message(\n item)\n item_message_value.check_initialized()\n else:\n message_value = field.value_to_message(value)\n message_value.check_initialized()\n except ValidationError as err:\n if not hasattr(err, 'message_name'):\n err.message_name = type(self).__name__\n raise","def init_vars(self):\n # type: () -> None\n raise NotImplementedError","def matchesProperties(self, *args):\n return _libsbml.SBMLInitialAssignmentConverter_matchesProperties(self, *args)","def _validate(self):\n pass","def __check(self):\n if self.probid is None:\n raise ProblemConfigError('problem %s has no probid' % self.problem_name)\n if self.color is None:\n raise ProblemConfigError('problem %s has no color' % self.problem_name)\n if self.samples is None:\n raise ProblemConfigError('problem %s has no sample' % self.problem_name)","def __checkArgs(self, kwargs):\n requiredArgs = self.__class__.__requiredArgs + \\\n self.__class__.__singleCompArgs if self.singleComp else\\\n self.__class__.__requiredArgs + self.__class__.__doubleCompArgs\n for arg in requiredArgs:\n if arg not in kwargs:\n raise ValueError(\"Essential keyword argument %s missing\" % arg)\n for (k, v) in kwargs.items():\n assert k in self.__class__.__allowedArgs, \"Invalid Argument %s\" % k","def check_settings(self):\r\n pass","def test_base_props(self):\n\n self.assertTrue(hasattr(settings, \"PROJECT_PATH\"))\n self.assertTrue(hasattr(settings, \"DATABASE_PATH\"))\n self.assertTrue(hasattr(settings, \"EMAIL_HOST\"))\n self.assertTrue(hasattr(settings, \"EMAIL_FROM\"))\n self.assertTrue(hasattr(settings, \"DAYS_TO_ACTIVATE\"))\n self.assertTrue(hasattr(settings, \"MAX_PWD_TRIES\"))","def isInitialized(self):\n\t\tif self.isTypeSet and self.isCfgSet:\n\t\t\treturn True\n\t\telse:\n\t\t\treturn False","def check(self, context):\n self.set_prompts_from_properties()\n self.product.obj_x.location.x = self.width\n self.product.obj_y.location.y = -self.depth\n props_closet.update_render_materials(self, context)\n # self.update_product_size()\n return True","def check(self, context):\n self.set_prompts_from_properties()\n self.product.obj_x.location.x = self.width\n self.product.obj_y.location.y = -self.depth\n props_closet.update_render_materials(self, context)\n # self.update_product_size()\n return True","def post_init(self):\n\t\tpass","def __validate(self):\n pass","def _validate_instantiation_props(\n self,\n prop: Optional[numbers.Integral | int | float],\n prop_name: str,\n default_value: numbers.Integral | int | float\n ) -> bool:\n is_valid = True\n\n if prop is None or not validator.is_finite_number(prop) or prop <= 0:\n is_valid = False\n\n if prop_name == 'batch_size' and not isinstance(prop, numbers.Integral):\n is_valid = False\n\n if is_valid is False:\n self.logger.info(f'Using default value {default_value} for {prop_name}.')\n\n return is_valid","def _validate(self):\n for p in self.parameters:\n #Check for missing required parameters:\n if p.is_required and not(p.is_set):\n raise ValueError(\"Parameter %s is not set.\" \\\n % p.names[-1])\n #Also repeat the parameter validation here, just in case?","def __check_input__(self):\n # | - __check_input__\n tmp = set(self.tree_level_labels)\n input_diff = tmp.symmetric_difference(self.level_entries.keys())\n if not input_diff == set():\n undefined_labels = []\n for i in input_diff:\n undefined_labels.append(i)\n\n print(\"\\n\")\n message = \"Did not fill out level entries dict properly\" + \"\\n\"\n message += \"The following properties need to be defined\" + \"\\n\"\n message += str(undefined_labels)\n raise ValueError(message)\n # __|","def precheck(self):\n if self.__memory_size is None:\n self.logger.exception(\"[Memory] Please set memory size.\")\n raise ArgsNotCorrect(\"Please set memory size.\")"],"string":"[\n \"def check_properties(self):\\r\\n for prop in self.mandatory_properties:\\r\\n if not hasattr(self, prop):\\r\\n raise NameError(prop)\",\n \"def set_check_props(self, props):\\n _api.check_isinstance(dict, props=props)\\n if 's' in props: # Keep API consistent with constructor.\\n props['sizes'] = np.broadcast_to(props.pop('s'), len(self.labels))\\n actives = self.get_status()\\n self._checks.update(props)\\n # If new colours are supplied, then we must re-apply the status.\\n self._init_status(actives)\",\n \"def _validate(self):\\n for name, prop in self._properties.iteritems():\\n value = getattr(self, name, None)\\n prop._do_validate(value)\",\n \"def ok(self):\\r\\n if hasattr(self, 'prm') and \\\\\\r\\n isinstance(self.prm, dict) and \\\\\\r\\n hasattr(self, 'type') and \\\\\\r\\n isinstance(self.type, dict) and \\\\\\r\\n hasattr(self, 'help') and \\\\\\r\\n isinstance(self.help, dict):\\r\\n return True\\r\\n else:\\r\\n raise ValueError(\\r\\n 'The constructor in class %s does not '\\\\\\r\\n 'initialize the\\\\ndictionaries '\\\\\\r\\n 'self.prm, self.type, self.help!' %\\r\\n self.__class__.__name__)\",\n \"def _has_valid_mandatory_properties(self):\\n for prop in self.mandatory_properties:\\n if not hasattr(self, prop):\\n logger.error(\\n \\\"Skipping %s: could not find information about '%s'\\\",\\n self, prop)\\n return False\\n return True\",\n \"def test_read_props(self):\\n basic_test_runner(self, 'read_props')\",\n \"def _check_vals(self):\\n\\n try:\\n self.is_set = True\\n self.pack()\\n except Exception as err:\\n # Set default values again\\n raise ValueError(\\\"Invalid arguments. Could not packed since: {}\\\".format(err))\\n self.__init__()\",\n \"def test_initial_device_properties(self):\\n expected_count = 1 # model_key property already present in db\\n self.assertEquals(expected_count, self._count_device_properties())\",\n \"def _check_initialized(self):\\n self.assertEquals(0, self._error_count)\\n self.assertEquals(0, len(self._error_messages))\",\n \"def props(self):\\r\\n return ()\",\n \"def props(self):\\r\\n return ()\",\n \"def props(self):\\r\\n return ()\",\n \"def is_good_for_setup(self):\\n attributes = [\\n \\\"rotatePivot\\\",\\n \\\"scalePivot\\\",\\n \\\"rotatePivotTranslate\\\",\\n \\\"scalePivotTranslate\\\",\\n ]\\n\\n for attrStr in attributes:\\n connections = self._object.attr(attrStr).connections()\\n if len(connections) > 0:\\n return False\\n\\n return True\",\n \"def check_data(self):\\n\\n missing_params = {}\\n flag = False\\n\\n missing_params['general'] = {}\\n for name, param in self.params.items():\\n if not param.check():\\n missing_params['general'][name] = param.get_description()\\n flag = True\\n\\n for component, comp_obj in self.components.items():\\n missing_params[component], flag_comp = comp_obj.check_data()\\n\\n # Assign empty component parameters that have a general version:\\n empty_general_params = set(missing_params[component]).intersection(\\n set(self.params))\\n for param in empty_general_params:\\n comp_obj.change_param_object(param, self.params[param])\\n del missing_params[component][param]\\n\\n if missing_params[component]:\\n flag = True\\n\\n if flag:\\n raise Exception('Following parameters are missing:\\\\n{}'\\n .format(\\n self._print_params(missing_params, disp=False)))\\n\\n return True\",\n \"def check_mandatory_props(klass: pyorient.ogm.declarative.DeclarativeMeta, obj: Dict):\\n missing = []\\n props = klass.objects.g.props_from_db[klass](Graph.compute_all_properties(klass))\\n for k, v in props.items():\\n prop = getattr(klass, k)\\n if hasattr(prop, 'mandatory'):\\n if prop.mandatory and k not in obj:\\n # Fix values if default set \\n if k == \\\"revoked\\\":\\n obj[k] = False\\n continue\\n if k == \\\"spec_version\\\":\\n obj[k] = \\\"2.1\\\"\\n continue\\n missing.append(k)\\n if isinstance(prop, odbproperty.String):\\n obj[k] = 'added_default'\\n elif isinstance(prop, (odbproperty.Date, odbproperty.DateTime)):\\n obj[k] = get_datetime()\\n elif isinstance(prop, odbproperty.EmbeddedList):\\n obj[k] = ['added_default']\\n elif isinstance(prop, odbproperty.Integer):\\n obj[k] = 0\\n elif isinstance(prop, odbproperty.Float):\\n obj[k] = 0.0\\n elif isinstance(prop, odbproperty.Binary):\\n obj[k] = 0\\n elif isinstance(prop, odbproperty.Byte):\\n obj[k] = 0\\n elif isinstance(prop, odbproperty.Decimal):\\n obj[k] = 0.0\\n elif isinstance(prop, odbproperty.Long):\\n obj[k] = 0\\n elif isinstance(prop, odbproperty.Short):\\n obj[k] = 0\\n elif isinstance(prop, odbproperty.Boolean):\\n obj[k] = True\\n else:\\n logging.info(f'What to do with missing mandatory field {k} of type {v.__class__}?')\\n if missing:\\n logging.info(f'missing mandatory fields for {obj[\\\"id_\\\"]}: {missing}')\\n return obj\",\n \"def test_tap_config_valid_if_properties_is_none(self):\\n self._assert_tap_config(config=self.valid_json_file, properties=None, state=self.valid_json_file)\",\n \"def _check_params(self):\\n pass\",\n \"def is_initialized(self) -> bool:\\n return (\\n (self._exchange_params_by_currency_id is not None)\\n and (self._utility_params_by_good_id is not None)\\n and (self._transaction_fees is not None)\\n )\",\n \"def init(self):\\n return True\",\n \"def _init_checked(self):\\n assert all(\\n len(val) <= 2\\n or (\\n len(val) == 3\\n and all(\\n self.extra_parameters[parent_var] == self.fuse_parameter\\n for parent_var in val\\n )\\n )\\n for val in self.reversed_extra_parameters.values()\\n )\\n assert all(\\n (\\n any(\\n parent_var in self.left_sided_parameters\\n or parent_var in self.right_sided_parameters\\n for parent_var in parent_vars\\n )\\n and any(\\n parent_var in self.both_sided_parameters\\n for parent_var in parent_vars\\n )\\n )\\n or all(\\n self.extra_parameters[parent_var] == self.fuse_parameter\\n for parent_var in parent_vars\\n )\\n for parent_vars in self.reversed_extra_parameters.values()\\n if len(parent_vars) == 2\\n )\",\n \"def sanity_check(self):\\n pass\",\n \"def _check_required_fields(self):\\n assert self.volume_title\\n super(MultiMonoComposer, self)._check_required_fields()\",\n \"def _is_initialized(self) -> bool:\\n return len(self) > 0\",\n \"def populate_initial_valid_metadata(self):\\n pass\",\n \"def testAddingPropertyFields(self):\\n map_sheet = self.properties[PROPERTY_SHEET]\\n for key, value in PROPS.items():\\n self.failUnless(map_sheet.hasProperty(key) and list(map_sheet.getProperty(key)) == value)\",\n \"def _init_props(self):\\n # N is the number of components in the distribution\\n self.N = self.f.shape[-1]\\n self._dist_samples = self.f.shape[0]\\n self._true_batch_shape = self.f.shape[1:-1]\\n\\n self._calc_a_b(self.f, self.alpha, self.beta)\\n self._calc_norm(self.f, self.a, self.b)\",\n \"def sanity_check(self):\\n return True\",\n \"def _check_inputs(self):\\n\\n self._check_resident_prefs()\\n self._check_hospital_prefs()\",\n \"def init_check(self):\\n for required_file in self._required_files:\\n # Check if required files are there\\n # FIXME Sometimes it doesn't work :?\\n if required_file not in self.files:\\n self.valid = False\",\n \"def test_setup(self):\\n self.assertIsNotNone(getattr(self, 'original_good_practice_attrs', None))\\n self.assertIsNotNone(getattr(self, 'original_get_overrides', None))\\n self.assertIsNotNone(getattr(self, 'original_get_alt_field_info', None))\\n self.assertIsNone(getattr(self.form, 'is_prepared', None))\\n self.assertNotIn('good_practice_attrs', self.form.has_call)\\n self.assertNotIn('get_overrides', self.form.has_call)\\n self.assertNotIn('get_alt_field_info', self.form.has_call)\\n good_practice = self.form.good_practice_attrs()\\n if self.good_practice == 'empty':\\n self.assertEqual({}, good_practice)\\n overrides = self.form.get_overrides()\\n if self.overrides_empty_or_skip == 'empty':\\n self.assertEqual({}, overrides)\\n elif self.overrides_empty_or_skip == 'skip':\\n self.assertEqual(self.no_resize_override(), overrides)\\n if self.alt_info == 'empty':\\n self.assertEqual({}, self.form.get_alt_field_info())\\n self.assertIn('get_alt_field_info', self.form.has_call)\\n self.assertEqual(self.form.get_alt_field_info.__name__, 'empty_get_alt_field_info')\\n self.assertIn('good_practice_attrs', self.form.has_call)\\n self.assertIn('get_overrides', self.form.has_call)\\n self.form.has_call = []\\n self.assertEqual(self.form.good_practice_attrs.__name__, 'empty_good_practice_attrs')\\n if self.overrides_empty_or_skip == 'empty':\\n self.assertEqual(self.form.get_overrides.__name__, 'empty_get_overrides')\\n self.assertEqual(self.form.get_overrides.__name__, 'skip_get_overrides')\\n request_type = 'POST' if self.get_initial_data() else 'GET'\\n self.assertEqual(request_type, self.request.method)\",\n \"def props(self, props):\\n\\n self._props = props\",\n \"def _validate_params(self):\\n assert set(self.required_params) - set(self._params) == set()\\n for par, val in self.optional_params.items():\\n if par not in self._params:\\n self._params[par] = val\",\n \"def check_init(self):\\n if self.Nlayer > 1:\\n raise Exception(\\\"Nlayer == 1 currently\\\")\",\n \"def test_too_many_props(self):\\n with pytest.raises(ValueError):\\n State(\\n substance=\\\"water\\\",\\n T=Q_(300, \\\"K\\\"),\\n p=Q_(101325, \\\"Pa\\\"),\\n u=Q_(100, \\\"kJ/kg\\\"),\\n )\",\n \"def check_attributes(self):\\n for key in self.json_parsed_file.keys():\\n if key not in self.HARDCODED_REQUIRED_JSON_FIELDS:\\n print(key)\\n self.output_message += \\\"All JSON attribute key are not correct\\\\n\\\"\\n self.is_parsed_pdf_valid = False\\n\\n for key in self.HARDCODED_REQUIRED_JSON_FIELDS:\\n if key not in self.json_parsed_file.keys():\\n self.output_message += \\\"All required attribute keys are not in the parsed information\\\\n\\\"\\n self.is_parsed_pdf_valid = False\",\n \"def test_init_valid_field(self):\\n fields = {'Conn Note': {'offset': 0,\\n 'length': 20}}\\n parser = top.Parser(fields=fields)\\n received = parser.get_fields()\\n expected = fields\\n msg = 'Fields initialisation property setter/getter error.'\\n self.assertEqual(received, expected, msg)\",\n \"def _check_assigned(self):\\n\\n if self.values is None and self.lazy:\\n raise ValueError(\\\"This instance has not been assigned any data.\\\")\",\n \"def check_state(self):\\n pass\",\n \"def _check_kwargs(cls, kwargs: Mapping[str, Any]):\\n for name, prop in cls._props_by_name.items():\\n if prop.required and name not in kwargs:\\n raise ValueError(f'Required property {name} is missing.')\\n for name, value in kwargs.items():\\n if name not in cls._props_by_name:\\n raise KeyError(f'Unknown property {name}.')\\n prop = cls._props_by_name[name]\\n prop.validate(value)\",\n \"def check_vars(self):\\n\\n # The pipe name.\\n if not has_pipe(self.pipe_name):\\n raise RelaxNoPipeError(self.pipe_name)\",\n \"def _should_initialize_check_run(self, payload):\\n action = payload.get('action')\\n return action in self.initialize_actions or self.initialize_actions is None\",\n \"def initialize(\\n self,\\n state_args=None,\\n state_vars_fixed=False,\\n hold_state=False,\\n outlvl=idaeslog.NOTSET,\\n solver=None,\\n optarg=None,\\n ):\\n # For now, there are no constraints in the property package, so only\\n # fix state variables if required\\n init_log = idaeslog.getInitLogger(self.name, outlvl, tag=\\\"properties\\\")\\n\\n init_log.info(\\\"Initialization Complete.\\\")\\n\\n if hold_state is True:\\n flags = fix_state_vars(self, state_args)\\n return flags\\n else:\\n return\",\n \"def __post_init_check(self):\\n try:\\n t = self.time\\n m = self.metadata\\n except AttributeError as e:\\n clsname = self.__class__.__name__\\n raise TypeError(f\\\"Model not initialized. Please call 'SupernovaModel.__init__' within the '{clsname}.__init__'\\\") from e\",\n \"def test_preferences_init(self):\\n self.preferences.init(\\n exchange_params_by_currency_id=self.exchange_params,\\n utility_params_by_good_id=self.utility_params,\\n tx_fee=self.tx_fee,\\n )\\n assert self.preferences.utility_params_by_good_id is not None\\n assert self.preferences.exchange_params_by_currency_id is not None\\n assert self.preferences.transaction_fees[\\\"seller_tx_fee\\\"] == 4\\n assert self.preferences.transaction_fees[\\\"buyer_tx_fee\\\"] == 5\\n assert self.preferences.is_initialized\",\n \"def _is_ready(self):\\n res = True\\n for (key, val) in self._attrs.iteritems():\\n if key not in self._optional_attrs:\\n if val is None:\\n res = False\\n return res\",\n \"def checkInit(this):\\n\\t\\tif not this._CAP: raise Exception('Vous devez initialiser la caméra...')\",\n \"def _further_validate_and_setup(self) -> None:\\n\\n # Make sure parameters make sense/are valid\\n if len(self.validated['learners']) != len(self.validated['param_grids']):\\n raise SchemaError(autos=None,\\n errors='The lists of of learners and parameter '\\n 'grids must be the same size.')\\n if (self.validated['hashed_features'] is not None\\n and self.validated['hashed_features'] == 0):\\n self.validated['hashed_features'] = self._n_features_feature_hashing\\n if self.validated['lognormal'] and self.validated['power_transform']:\\n raise SchemaError(autos=None,\\n errors='Both \\\"lognormal\\\" and \\\"power_transform\\\" '\\n 'were set simultaneously.')\\n if len(self.validated['learners']) != len(self.validated['param_grids']):\\n raise SchemaError(autos=None,\\n errors='The \\\"learners\\\" and \\\"param_grids\\\" '\\n 'parameters were both set and the '\\n 'lengths of the lists are unequal.')\",\n \"def _initFields(self):\\n pass\",\n \"def check_for_new_data(self):\\n return\",\n \"def check(self):\\n\\n self.check_auto_update()\\n assert not self.empty()\",\n \"def _check_validity(self):\\n pass\",\n \"def assert_goodness(self):\\n if self._setted:\\n self.assert_stored_iss()\\n self.assert_stored_ks()\\n ## Check idxs\\n self.assert_stored_idxs()\\n ## Check sp_relative_pos\\n self.assert_stored_sp_rel_pos()\",\n \"def _set_init_param_dict(self):\\n\\n self.param_dict = {}\\n\\n try:\\n suppress_warning = self._suppress_repeated_param_warning\\n except AttributeError:\\n suppress_warning = False\\n msg = (\\\"\\\\n\\\\nThe param_dict key %s appears in more than one component model.\\\\n\\\"\\n \\\"This is permissible, but if you are seeing this message you should be sure you \\\"\\n \\\"understand it.\\\\nIn particular, double-check that this parameter does not have \\\"\\n \\\"conflicting meanings across components.\\\\n\\\"\\n \\\"\\\\nIf you do not wish to see this message every time you instantiate, \\\\n\\\"\\n \\\"simply attach a _suppress_repeated_param_warning attribute \\\\n\\\"\\n \\\"to any of your component models and set this variable to ``True``.\\\\n\\\")\\n\\n for component_model in self.model_dictionary.values():\\n\\n if not hasattr(component_model, 'param_dict'):\\n component_model.param_dict = {}\\n intersection = set(self.param_dict) & set(component_model.param_dict)\\n if intersection != set():\\n for key in intersection:\\n if suppress_warning is False:\\n warn(msg % key)\\n\\n for key, value in component_model.param_dict.iteritems():\\n self.param_dict[key] = value\\n\\n self._init_param_dict = copy(self.param_dict)\",\n \"def testRequiredAttributes(self):\\n\\n\\t\\trequiredAttributes = (\\\"name\\\",\\n\\t\\t\\t\\t\\t\\t\\t\\\"uiFile\\\",\\n\\t\\t\\t\\t\\t\\t\\t\\\"activated\\\",\\n\\t\\t\\t\\t\\t\\t\\t\\\"initializedUi\\\",\\n\\t\\t\\t\\t\\t\\t\\t\\\"deactivatable\\\")\\n\\n\\t\\tfor attribute in requiredAttributes:\\n\\t\\t\\tself.assertIn(attribute, dir(QWidgetComponentFactory()))\",\n \"def _check_required_fields(self):\\n assert self.title\\n assert self.format\",\n \"def check_primers(self):\\n primer_keys=['sequence','description']\\n if self.data.has_key('primer_dict'):\\n for primer in self.data['primer_dict'].keys():\\n for key in primer_keys:\\n if not self.data['primer_dict'][primer].has_key(key):\\n self.data['primer_dict'][primer][key]='None'\",\n \"def parseProperties(self) -> bool:\\n\\n # vNetIds is not a mandatory property. This property can be used if the resources are distributed across multiple vNets.\\n self.vNetIds = self.providerProperties.get(\\\"vNetIds\\\", None)\\n\\n # enabledProviders contains the provider types for which AIOps is enabled. Mandatory property.\\n self.enabledProviders = self.providerProperties.get(\\n \\\"enabledProviders\\\", None)\\n if not self.enabledProviders:\\n self.tracer.error(\\n \\\"[%s] enabledProviders cannot be empty in the AIOps config.\\\" % self.fullName)\\n return False\\n return True\",\n \"def test_validate_properties(self):\\n\\n ingest_mgmr = IngestManager()\\n ingest_mgmr.validate_config_file(self.example_config_data)\\n ingest_mgmr.validate_properties()\\n assert (ingest_mgmr.collection.name == 'my_col_1')\\n assert (ingest_mgmr.experiment.name == 'my_exp_1')\\n assert (ingest_mgmr.channel.name == 'my_ch_1')\",\n \"def checkParameters(self):\\n self.DEBUG(\\\"EDPluginWaitMultiFile.checkParameters\\\")\\n self.checkMandatoryParameters(self.dataInput, \\\"Data Input is None\\\")\\n self.checkMandatoryParameters(self.dataInput.expectedFile, \\\"Data Input is None\\\")\\n self.checkMandatoryParameters(self.dataInput.expectedSize, \\\"Data Input is None\\\")\",\n \"def set_old_props(self):\\n self.old_props = {k: v for k, v in self.node.props.items()}\",\n \"def __init__(self, **properties):\\n self._changed_fields = set()\\n self._new = False\\n self._deleted = False\\n self._parent = None\\n\\n # Set all the fields silently to avoid marking them as changed.\\n self.set_silent(**properties)\\n\\n # Verify every field has a value or is a LazyField. Do not check values as these\\n # may trigger lazy loaders.\\n for name in self.fields:\\n if not (name in self.lazy_fields or hasattr(self, name)):\\n raise ChipsError(\\\"Required field in model not defined %s [%s]\\\", self.__class__.__name__, name)\\n # Verify this instance has an 'id' set.\\n if self.get_id() == None:\\n raise ChipsError(\\\"Model has no id field set %s [%s]\\\", self.__class__.__name__, self.id_field_name)\",\n \"def test_too_few_props(self):\\n with pytest.raises(ValueError):\\n State(substance=\\\"water\\\", T=Q_(300, \\\"K\\\"))\",\n \"def check_blank_prop(blank_mol, validate_dict):\\n\\n # Check if properties populated\\n property_dict = blank_mol.GetPropsAsDict()\\n\\n # Properties to ignore\\n prop_ignore_list = ['ref_mols', 'ref_pdb']\\n\\n for key, value in zip(property_dict.keys(), property_dict.values()):\\n if value == '' and key not in prop_ignore_list:\\n validate_dict = add_warning(molecule_name=blank_mol.GetProp('_Name'),\\n field=key,\\n warning_string='description for %s missing' % (key,),\\n validate_dict=validate_dict)\\n if key == 'ref_url' and check_url(value) == False:\\n validate_dict = add_warning(molecule_name=blank_mol.GetProp('_Name'),\\n field=key,\\n warning_string='illegal URL %s provided' % (value,),\\n validate_dict=validate_dict)\\n\\n return validate_dict\",\n \"def check_required_props(self,\\n df,\\n node,\\n dd,\\n exclude_props = [ # submitters don't provide these properties, so remove them from QC check\\n # case props not provided by submitters\\n \\\"datasets.submitter_id\\\",\\n \\\"token_record_id\\\",\\n \\\"linked_external_data\\\",\\n #series_file props not provided by submitters\\n \\\"file_name\\\",\\n \\\"md5sum\\\",\\n \\\"file_size\\\",\\n \\\"object_id\\\",\\n \\\"storage_urls\\\",\\n \\\"core_metadata_collections.submitter_id\\\",\\n \\\"core_metadata_collections\\\",\\n \\\"associated_ids\\\",\\n #imaging_study props not provided by submitters\\n \\\"loinc_code\\\",\\n \\\"loinc_system\\\",\\n \\\"loinc_contrast\\\",\\n \\\"loinc_long_common_name\\\",\\n \\\"loinc_method\\\",\\n \\\"days_from_study_to_neg_covid_test\\\",\\n \\\"days_from_study_to_pos_covid_test\\\"\\n ]\\n ):\\n errors = []\\n links = self.list_links(node, dd)\\n any_na = df.columns[df.isna().any()].tolist()\\n required_props = list(set(dd[node]['required']).difference(links).difference(exclude_props))\\n for prop in required_props:\\n if prop not in df:\\n error = \\\"{} TSV does not have required property header '{}'!\\\".format(node,prop)\\n print(error)\\n errors.append(error)\\n elif prop in any_na:\\n error = \\\"{} TSV does not have complete data for required property '{}'!\\\".format(node,prop)\\n print(error)\\n errors.append(error)\\n return errors\",\n \"def verify_attrs(self):\\n self.verify_namespace_attrs(self.newlibrary.wrap_namespace)\",\n \"def _init_check_database(self):\\n # FIXME add additional checks, for example that columns in BY,\\n # ACROSS, ON are not the same ? (see task structure notes)\\n # also that location columns are not used\\n if self.verbose:\\n print('checking input database {}'.format(self.database))\\n\\n # check that required columns are present\\n cols = set(self.db.columns)\\n message = (\\n ' argument is invalid, check that all the provided attributes '\\n 'are defined in the database {}'.format(self.database))\\n # the argument of issuperset needs to be a list ...\\n assert cols.issuperset(self.on), 'ON' + message\\n assert cols.issuperset(self.across), 'ACROSS' + message\\n assert cols.issuperset(self.by), 'BY' + message\\n\\n for col in cols:\\n assert '_' not in col, \\\\\\n col + ': you cannot use underscore in column names'\\n assert '#' not in col, \\\\\\n col + ': you cannot use \\\\'#\\\\' in column names'\\n\\n if self.verbose:\\n print(\\\"input database verified\\\")\",\n \"def check_blank_prop(blank_mol, validate_dict):\\n\\n # Check if properties populated\\n property_dict = blank_mol.GetPropsAsDict()\\n\\n # Properties to ignore\\n prop_ignore_list = ['ref_mols', 'ref_pdb']\\n\\n for key, value in zip(list(property_dict.keys()), list(property_dict.values())):\\n if value == '' and key not in prop_ignore_list:\\n validate_dict = add_warning(molecule_name=blank_mol.GetProp('_Name'),\\n field=key,\\n warning_string='description for %s missing' % (key,),\\n validate_dict=validate_dict)\\n if key == 'ref_url' and check_url(value) is False:\\n validate_dict = add_warning(molecule_name=blank_mol.GetProp('_Name'),\\n field=key,\\n warning_string='illegal URL %s provided' % (value,),\\n validate_dict=validate_dict)\\n\\n return validate_dict\",\n \"def is_initialised(self) -> bool:\\n return _schema.has_schema(self._engine)\",\n \"def check(self):\\n self.init()\\n self.calculate_output()\\n self.compare_outputs_with_expects()\",\n \"def initialize(self) -> bool:\\n raise NotImplementedError\",\n \"def _check_parameters(self, X):\\n _, n_features = X.shape\\n\\n if self.weights_init is not None:\\n self.weights_init = _check_weights(self.weights_init,\\n self.n_components)\",\n \"def _check_attrs(cfg, attrs):\\n for a in attrs:\\n if (not hasattr(cfg, a)) or getattr(cfg, a) is None:\\n print(\\\"{0} parameter is not set\\\".format(a))\\n sys.exit(UNKNOWN)\",\n \"def testAttributes(self):\\n pl = Pipeline(loadInitFile=False)\\n repl = REPL(pl)\\n self.assertIs(pl, repl.pipeline)\\n self.assertEqual(REPL.DEFAULT_PS1, repl.prompt)\",\n \"def _check_config(self):\",\n \"def initialized(self):\\n # verbose = CMAKE_BUILD_VERBOSE\\n # if verbose:\\n # self.diagnose_initialized_problems()\\n return self.project_build_dir.exists() and self.has_stored_config_file()\",\n \"def _post_init(self):\\n pass\",\n \"def pre_save(self):\\r\\n self.validate()\",\n \"def _check_params(self):\\n\\n # verify that estimator1 and estimator2 have predict_proba\\n if (not hasattr(self.estimator1_, 'predict_proba') or\\n not hasattr(self.estimator2_, 'predict_proba')):\\n raise AttributeError(\\\"Co-training classifier must be initialized \\\"\\n \\\"with classifiers supporting \\\"\\n \\\"predict_proba().\\\")\\n\\n if (self.p_ is not None and self.p_ <= 0) or (self.n_ is not None and\\n self.n_ <= 0):\\n raise ValueError(\\\"Both p and n must be positive.\\\")\\n\\n if self.unlabeled_pool_size <= 0:\\n raise ValueError(\\\"unlabeled_pool_size must be positive.\\\")\\n\\n if self.num_iter <= 0:\\n raise ValueError(\\\"num_iter must be positive.\\\")\",\n \"def valid(self):\\n pass\",\n \"def verify(self):\\r\\n self.title = self.title and self.title or '' \\r\\n self.descr = self.descr and self.descr or '' \\r\\n self.link = self.link and self.link or ''\\r\\n self.channelURL = self.channelURL and self.channelURL or ''\",\n \"def test_init_attributes(self):\\n t = self.Test({'id': 1, 'poop': 'abc'})\\n\\n self.assertEqual(t.id, 1)\\n self.assertEqual(t.name, None)\\n self.assertRaises(AttributeError, t.__getattribute__, 'poop')\",\n \"def is_initialized(self) -> bool:\\n return (\\n self._amount_by_currency_id is not None\\n and self._quantities_by_good_id is not None\\n )\",\n \"def init_attrs(self):\\n raise NotImplementedError\",\n \"def check_settings(self):\\n pass\",\n \"def check_initialized(self):\\n for name, field in self.__by_name.items():\\n value = getattr(self, name)\\n if value is None:\\n if field.required:\\n raise ValidationError(\\n \\\"Message %s is missing required field %s\\\" %\\n (type(self).__name__, name))\\n else:\\n try:\\n if (isinstance(field, MessageField) and\\n issubclass(field.message_type, Message)):\\n if field.repeated:\\n for item in value:\\n item_message_value = field.value_to_message(\\n item)\\n item_message_value.check_initialized()\\n else:\\n message_value = field.value_to_message(value)\\n message_value.check_initialized()\\n except ValidationError as err:\\n if not hasattr(err, 'message_name'):\\n err.message_name = type(self).__name__\\n raise\",\n \"def init_vars(self):\\n # type: () -> None\\n raise NotImplementedError\",\n \"def matchesProperties(self, *args):\\n return _libsbml.SBMLInitialAssignmentConverter_matchesProperties(self, *args)\",\n \"def _validate(self):\\n pass\",\n \"def __check(self):\\n if self.probid is None:\\n raise ProblemConfigError('problem %s has no probid' % self.problem_name)\\n if self.color is None:\\n raise ProblemConfigError('problem %s has no color' % self.problem_name)\\n if self.samples is None:\\n raise ProblemConfigError('problem %s has no sample' % self.problem_name)\",\n \"def __checkArgs(self, kwargs):\\n requiredArgs = self.__class__.__requiredArgs + \\\\\\n self.__class__.__singleCompArgs if self.singleComp else\\\\\\n self.__class__.__requiredArgs + self.__class__.__doubleCompArgs\\n for arg in requiredArgs:\\n if arg not in kwargs:\\n raise ValueError(\\\"Essential keyword argument %s missing\\\" % arg)\\n for (k, v) in kwargs.items():\\n assert k in self.__class__.__allowedArgs, \\\"Invalid Argument %s\\\" % k\",\n \"def check_settings(self):\\r\\n pass\",\n \"def test_base_props(self):\\n\\n self.assertTrue(hasattr(settings, \\\"PROJECT_PATH\\\"))\\n self.assertTrue(hasattr(settings, \\\"DATABASE_PATH\\\"))\\n self.assertTrue(hasattr(settings, \\\"EMAIL_HOST\\\"))\\n self.assertTrue(hasattr(settings, \\\"EMAIL_FROM\\\"))\\n self.assertTrue(hasattr(settings, \\\"DAYS_TO_ACTIVATE\\\"))\\n self.assertTrue(hasattr(settings, \\\"MAX_PWD_TRIES\\\"))\",\n \"def isInitialized(self):\\n\\t\\tif self.isTypeSet and self.isCfgSet:\\n\\t\\t\\treturn True\\n\\t\\telse:\\n\\t\\t\\treturn False\",\n \"def check(self, context):\\n self.set_prompts_from_properties()\\n self.product.obj_x.location.x = self.width\\n self.product.obj_y.location.y = -self.depth\\n props_closet.update_render_materials(self, context)\\n # self.update_product_size()\\n return True\",\n \"def check(self, context):\\n self.set_prompts_from_properties()\\n self.product.obj_x.location.x = self.width\\n self.product.obj_y.location.y = -self.depth\\n props_closet.update_render_materials(self, context)\\n # self.update_product_size()\\n return True\",\n \"def post_init(self):\\n\\t\\tpass\",\n \"def __validate(self):\\n pass\",\n \"def _validate_instantiation_props(\\n self,\\n prop: Optional[numbers.Integral | int | float],\\n prop_name: str,\\n default_value: numbers.Integral | int | float\\n ) -> bool:\\n is_valid = True\\n\\n if prop is None or not validator.is_finite_number(prop) or prop <= 0:\\n is_valid = False\\n\\n if prop_name == 'batch_size' and not isinstance(prop, numbers.Integral):\\n is_valid = False\\n\\n if is_valid is False:\\n self.logger.info(f'Using default value {default_value} for {prop_name}.')\\n\\n return is_valid\",\n \"def _validate(self):\\n for p in self.parameters:\\n #Check for missing required parameters:\\n if p.is_required and not(p.is_set):\\n raise ValueError(\\\"Parameter %s is not set.\\\" \\\\\\n % p.names[-1])\\n #Also repeat the parameter validation here, just in case?\",\n \"def __check_input__(self):\\n # | - __check_input__\\n tmp = set(self.tree_level_labels)\\n input_diff = tmp.symmetric_difference(self.level_entries.keys())\\n if not input_diff == set():\\n undefined_labels = []\\n for i in input_diff:\\n undefined_labels.append(i)\\n\\n print(\\\"\\\\n\\\")\\n message = \\\"Did not fill out level entries dict properly\\\" + \\\"\\\\n\\\"\\n message += \\\"The following properties need to be defined\\\" + \\\"\\\\n\\\"\\n message += str(undefined_labels)\\n raise ValueError(message)\\n # __|\",\n \"def precheck(self):\\n if self.__memory_size is None:\\n self.logger.exception(\\\"[Memory] Please set memory size.\\\")\\n raise ArgsNotCorrect(\\\"Please set memory size.\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67081404","0.6280929","0.62653726","0.6081199","0.60551053","0.5979137","0.5961813","0.59598356","0.5843566","0.58019894","0.58019894","0.58019894","0.579083","0.5786345","0.57684004","0.5756698","0.5751388","0.57487404","0.5727648","0.57009995","0.56955844","0.5684905","0.56533104","0.56463754","0.56142175","0.5601803","0.5590509","0.5590473","0.55902386","0.5589433","0.5587133","0.5584987","0.55806726","0.5564563","0.5563685","0.5540872","0.55353534","0.55226374","0.5522542","0.55162466","0.5514949","0.54958755","0.5487754","0.54791796","0.5478613","0.5464902","0.5464228","0.54609907","0.5460665","0.54491353","0.54334456","0.54319566","0.54181796","0.54102796","0.5401622","0.5391874","0.5388405","0.53861666","0.5376904","0.5359691","0.53511655","0.53504074","0.53465796","0.53417337","0.53391933","0.533162","0.53288335","0.5325115","0.5323595","0.5320318","0.53191566","0.531095","0.5302782","0.53016716","0.5300603","0.5298981","0.52943873","0.5282752","0.5270689","0.52662313","0.5263171","0.5257818","0.52569515","0.5252885","0.5248855","0.52450365","0.52447015","0.5244179","0.5241269","0.52396524","0.52377534","0.5234492","0.5227409","0.5211325","0.5211325","0.5204588","0.5203465","0.51942706","0.5191164","0.5190606","0.51875615"],"string":"[\n \"0.67081404\",\n \"0.6280929\",\n \"0.62653726\",\n \"0.6081199\",\n \"0.60551053\",\n \"0.5979137\",\n \"0.5961813\",\n \"0.59598356\",\n \"0.5843566\",\n \"0.58019894\",\n \"0.58019894\",\n \"0.58019894\",\n \"0.579083\",\n \"0.5786345\",\n \"0.57684004\",\n \"0.5756698\",\n \"0.5751388\",\n \"0.57487404\",\n \"0.5727648\",\n \"0.57009995\",\n \"0.56955844\",\n \"0.5684905\",\n \"0.56533104\",\n \"0.56463754\",\n \"0.56142175\",\n \"0.5601803\",\n \"0.5590509\",\n \"0.5590473\",\n \"0.55902386\",\n \"0.5589433\",\n \"0.5587133\",\n \"0.5584987\",\n \"0.55806726\",\n \"0.5564563\",\n \"0.5563685\",\n \"0.5540872\",\n \"0.55353534\",\n \"0.55226374\",\n \"0.5522542\",\n \"0.55162466\",\n \"0.5514949\",\n \"0.54958755\",\n \"0.5487754\",\n \"0.54791796\",\n \"0.5478613\",\n \"0.5464902\",\n \"0.5464228\",\n \"0.54609907\",\n \"0.5460665\",\n \"0.54491353\",\n \"0.54334456\",\n \"0.54319566\",\n \"0.54181796\",\n \"0.54102796\",\n \"0.5401622\",\n \"0.5391874\",\n \"0.5388405\",\n \"0.53861666\",\n \"0.5376904\",\n \"0.5359691\",\n \"0.53511655\",\n \"0.53504074\",\n \"0.53465796\",\n \"0.53417337\",\n \"0.53391933\",\n \"0.533162\",\n \"0.53288335\",\n \"0.5325115\",\n \"0.5323595\",\n \"0.5320318\",\n \"0.53191566\",\n \"0.531095\",\n \"0.5302782\",\n \"0.53016716\",\n \"0.5300603\",\n \"0.5298981\",\n \"0.52943873\",\n \"0.5282752\",\n \"0.5270689\",\n \"0.52662313\",\n \"0.5263171\",\n \"0.5257818\",\n \"0.52569515\",\n \"0.5252885\",\n \"0.5248855\",\n \"0.52450365\",\n \"0.52447015\",\n \"0.5244179\",\n \"0.5241269\",\n \"0.52396524\",\n \"0.52377534\",\n \"0.5234492\",\n \"0.5227409\",\n \"0.5211325\",\n \"0.5211325\",\n \"0.5204588\",\n \"0.5203465\",\n \"0.51942706\",\n \"0.5191164\",\n \"0.5190606\",\n \"0.51875615\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":895,"numItemsPerPage":100,"numTotalItems":95772,"offset":89500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTg4MjU5NSwianRpIjoiZjU3Y2QwNzktN2E1YS00YjhjLTkxMmYtYTM2NWI3NWE3NzQzIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU4ODYxOTUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.WZPTYYgHNf6Mk5LJle2Wz_-FizJRQ-HA9jjAL9PxFiso_kDI2N5XwlFKntgUVd1w0BTkER8kpxaMtsnFcGyACA","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 |
|---|---|---|---|---|---|---|
Loop through available emails at the specified time and send emails containing link to the youtube video | def send_video_links():
email_list = Emails.query.filter_by(status="active").all()
print("Sending newsletters to ", len(email_list), " users")
random_video = get_random_video_link()
video_link = f"https://www.youtube.com/watch?v={random_video[1]}"
for email in email_list:
#send email to us... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_realtime_email(self,body_):\n import smtplib, ssl\n\n port = 465 # For SSL\n smtp_server = \"smtp.gmail.com\"\n sender_email = self.fromaddr # Enter your address\n receiver_email = self.toaddr # Enter receiver address\n password = self.pswd\n message = f... | [
"0.6318766",
"0.62500906",
"0.6119919",
"0.5765977",
"0.5693172",
"0.5690263",
"0.56841874",
"0.56350535",
"0.5619672",
"0.56012964",
"0.55933404",
"0.5580555",
"0.55799156",
"0.55671567",
"0.5559276",
"0.55554837",
"0.554504",
"0.5533154",
"0.5532039",
"0.5523625",
"0.550718... | 0.80123353 | 0 |
Perform "delta test" which, for each station checks each hour in a day, checks for jumps between consecutive observations that exceed a given threshold. | def step_check(obs, nstnnets, var, ivar, qc_flag):
iqcflag = istepflag
ndts = len(obs[:, 0, ivar]) # # of hours in d.
level1 = suspflag
level2 = warnflag
# if too_many_spikes (hours around which a spike is found) or more are found, flag all ndts worth.
too_many_spikes = 2
# set two max... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_stimOn_delays(data, **_):\n metric = np.nan_to_num(data[\"stimOn_times\"] - data[\"stimOnTrigger_times\"], nan=np.inf)\n passed = (metric <= 0.15) & (metric > 0)\n assert data[\"intervals\"].shape[0] == len(metric) == len(passed)\n return metric, passed",
"def check_stimOff_delays(data, **_... | [
"0.5618953",
"0.55575085",
"0.5495588",
"0.5383822",
"0.5307905",
"0.5293913",
"0.5288574",
"0.52735865",
"0.52714",
"0.52712524",
"0.52702117",
"0.52625877",
"0.5234081",
"0.5225572",
"0.52182305",
"0.5217845",
"0.52138704",
"0.52123916",
"0.51968604",
"0.5191688",
"0.518829... | 0.53497034 | 4 |
For each station, for a day of data, calculate mean and std deviation. Compare std deviation to set values and if it's too small, flag entire day as suspect (1) or warning (2). Also check the difference between subsequent obs and flag if this difference is too small. | def persistence_check(obs, nstnnets, var, ivar, qc_flag):
iqcflag = ipersistflag
ndts = len(obs[:, 0, ivar]) # number of dts in obs.
min_nobs = 8 # minimum number of good obs to do 24-hr std deviation test.
level = warnflag
pdeltas = {
'dew': 0.1,
'wind_gust': 0.0,
'rel_h... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_std(data, tables, detrend=False, detrend_kw={'how':'linear'}, chunk_size='2min', falseverbose=False):\n from . import signal as pmdata\n import numpy as np\n import pandas as pd\n from . import algs\n\n #-----------\n # Detrend the data or not\n if detrend:\n df = pmdata.detre... | [
"0.6323308",
"0.6181202",
"0.5973835",
"0.5918576",
"0.588349",
"0.5823822",
"0.5766629",
"0.5749268",
"0.57383245",
"0.57383245",
"0.5730596",
"0.5702945",
"0.569965",
"0.5698367",
"0.56733954",
"0.567308",
"0.56422246",
"0.56317925",
"0.56248516",
"0.552794",
"0.5518978",
... | 0.5318998 | 50 |
Spatial_check does does a spatial QC test using a simple neighbor check whereby it looks at stations within a radius and elevation band and checks if at least one value is near the value in question. If not, it tries a bigger radius and checks again, and if not again, the value is flagged. | def spatial_check(obs, nstnnets, lat, lon, elev, var, ivar, qc_flag):
ndts = len(obs[:, 0, 0]) # number of hours in obs.
roism = 100.0 # smaller radius of influence.
roibg = 150.0 # bigger radius of influence.
min_stations = 2 # min # of stns needed for testing.
level1 = suspflag
level2 = w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_nearest_filter(self):\n for airport, reports, count in (\n (True, True, 6),\n (True, False, 16),\n (False, True, 6),\n (False, False, 30),\n ):\n stations = station.nearest(30, -80, 30, airport, reports, 1.5)\n self.assertEqua... | [
"0.5917477",
"0.5785617",
"0.5634171",
"0.5627542",
"0.56037885",
"0.54991764",
"0.5456539",
"0.54477155",
"0.5431013",
"0.53721654",
"0.5309238",
"0.52754253",
"0.5254569",
"0.52498955",
"0.5234829",
"0.520549",
"0.520544",
"0.51749706",
"0.5160689",
"0.5160598",
"0.51577854... | 0.6094638 | 0 |
Execute an external process with the given command. | def execute(parent, cmd, *args, **kwargs):
with xtrace(parent, flatten(cmd)) as h:
try:
code = subprocess.call(cmd, *args, **kwargs)
except:
sys.exit(
DiagnosticReporter.fatal(EXCEPTION_EXECUTING_PROCESS, cmd[0]))
finally:
h.report(code)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def execute(command, **kwargs):\n proc = ProcessWrapper(command, **kwargs)\n proc.run()\n return proc.join()",
"def execute(command):\n process = subprocess.Popen(command, stdout=subprocess.PIPE)\n return process.communicate()",
"def executeCommand(command):\n time.sleep(1)\n #return os.sy... | [
"0.7686777",
"0.7311152",
"0.7208237",
"0.7196334",
"0.7129636",
"0.7074382",
"0.69738877",
"0.69667447",
"0.68976897",
"0.684397",
"0.68372613",
"0.67790544",
"0.67153364",
"0.6662913",
"0.6654921",
"0.664873",
"0.66351396",
"0.6610151",
"0.65903133",
"0.6584907",
"0.6583633... | 0.61334276 | 85 |
Verifica si el numero es par | def es_par(x):
if x == 0:
print('Es cero')
elif x % 2:
print('Es impar')
else:
print('Es par') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_if_it_includes_a_number_if_the_number_is(self):\n self.assertNotIn(16, prime_numbers(16))",
"def isintparname(self,parname_): # 3\n res,resargs = self.__obj.isintparname(parname_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n ... | [
"0.62935865",
"0.6170519",
"0.6041902",
"0.6038277",
"0.60228485",
"0.5984323",
"0.59038234",
"0.5883155",
"0.5881418",
"0.5859558",
"0.5853608",
"0.5849341",
"0.5844487",
"0.5840633",
"0.58350194",
"0.58315754",
"0.5823626",
"0.58214515",
"0.58213025",
"0.58170676",
"0.58013... | 0.5861336 | 9 |
Convert a coordinate to the point format used in R3 protocol | def to_cmd(c: Coordinate, pose_flag: Optional[int] = 7):
txt = ("{:.{d}f}".format(i, d=c.digits) if i is not None else "" for i in c.values)
return f'({",".join(txt)}) ({pose_flag},0)' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def coordinate_point_to_coordinate(self, point):\n return self.gen(self._point_to_ray[point])",
"def convert(coords):\n lat = coords[:4]\n lon = coords[4:]\n\n lat = lat[:2] + \".\" + lat[2:]\n\n if int(lon[0]) > 5:\n lon = \"-\" + lon[:2] + \".\" + lon[2:]\n else:\n lon = \"-... | [
"0.66741616",
"0.64301664",
"0.62839675",
"0.6281405",
"0.62608045",
"0.62392443",
"0.62174106",
"0.6155676",
"0.61556274",
"0.6136992",
"0.611316",
"0.61059934",
"0.6103914",
"0.60896146",
"0.608129",
"0.6037829",
"0.598683",
"0.5964238",
"0.5938356",
"0.5923728",
"0.5906637... | 0.0 | -1 |
Gets a dataset tuple with instructions for reading ImageNet. | def get_split(split_name, dataset_dir, file_pattern=None, reader=None):
if split_name not in _SPLITS_TO_SIZES:
raise ValueError('split name %s was not recognized.' % split_name)
if not file_pattern:
file_pattern = _FILE_PATTERN
file_pattern = os.path.join(dataset_dir, file_pattern % split_n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_dataset(self):\n\n trainset = datasets.ImageNet('datasets/ImageNet/train/', split='train', transform=self.train_transforms,\n target_transform=None, download=True)\n valset = datasets.ImageNet('datasets/ImageNet/val/', split='val', transform=self.val_transf... | [
"0.68794817",
"0.6613766",
"0.6534691",
"0.64912057",
"0.62819463",
"0.627172",
"0.6127508",
"0.60656",
"0.6060858",
"0.6053814",
"0.6050378",
"0.60380644",
"0.59980446",
"0.5997365",
"0.5990953",
"0.5964309",
"0.59536415",
"0.593581",
"0.5916653",
"0.5915211",
"0.5911865",
... | 0.0 | -1 |
Returns a function run by the chief worker to warmstart the training. | def get_variables_to_restore():
# checkpoint_exclude_scopes=["distance-module", "InceptionV4/Logits"]
checkpoint_exclude_scopes=["DeInceptionV4"]
exclusions = [scope.strip() for scope in checkpoint_exclude_scopes]
variables_to_restore = []
for var in slim.get_model_variables():
excluded = F... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _make_train_function(self):\n if self.train_function is None:\n print('compiling train function...')\n start = time.time()\n inputs = self._estimator.inputs + [self.T_Y]\n\n training_updates = self.optimizer.get_updates(\n self._estimator.traina... | [
"0.6448144",
"0.59868366",
"0.5864569",
"0.57344204",
"0.56454474",
"0.5639581",
"0.5620158",
"0.5602923",
"0.55440265",
"0.5528322",
"0.5525694",
"0.5521015",
"0.55153054",
"0.55153054",
"0.55153054",
"0.5466412",
"0.54663765",
"0.5445845",
"0.54326403",
"0.54326403",
"0.542... | 0.0 | -1 |
Searches the provided modules for the named class and returns it. | def find_class_by_name(name, modules):
modules = [getattr(module, name, None) for module in modules]
return next(a for a in modules if a) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_class(class_name, module_paths=None):\n class_ = locate(class_name)\n if (class_ is None) and (module_paths is not None):\n for module_path in module_paths:\n class_ = locate('.'.join([module_path, class_name]))\n if class_ is not None:\n break\n\n if cl... | [
"0.799943",
"0.78490835",
"0.768902",
"0.76566696",
"0.7428545",
"0.7255041",
"0.71981335",
"0.7016138",
"0.690594",
"0.6841157",
"0.68327856",
"0.6830363",
"0.67620075",
"0.67466897",
"0.67217135",
"0.6679323",
"0.6639524",
"0.6617279",
"0.66102403",
"0.64862704",
"0.6444248... | 0.8418128 | 0 |
Tests wholefunction forcedcompilation. This test checks that stateless_random_ can be used in forcedcompilation scenarios (e.g. TPU). The new version of stateless_random_ requires the intermediate tensor `alg` to be compiletime constant, so we need to check that this requirement won't prevent `seed` from depending on v... | def testForcedCompile(self):
if config.list_logical_devices('TPU'):
self.skipTest('To accommodate OSS, experimental_compile support for TPU '
'is not linked in.')
# GPU doesn't support int32 variables, so we use int64.
v = variables.Variable([1, 2], dtype=dtypes.int64)
@def_fu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testDistributionOfStatelessRandomUniform(self, alg, dtype, seed):\n philox = random_ops_util.Algorithm.PHILOX\n auto_select = random_ops_util.Algorithm.AUTO_SELECT\n device = xla_device()\n if 'CPU' in device.device_type:\n device_type = 'CPU'\n elif 'GPU' in device.device_type:\n devi... | [
"0.68754524",
"0.59406036",
"0.5894597",
"0.58839476",
"0.5882948",
"0.5839431",
"0.58107805",
"0.5770772",
"0.5769387",
"0.57007724",
"0.56494707",
"0.5602415",
"0.55889",
"0.55538785",
"0.5541321",
"0.5540075",
"0.55398744",
"0.55398744",
"0.55097663",
"0.5445315",
"0.54414... | 0.75544333 | 0 |
Tests all values of `alg`. | def testAlg(self, op, alg_group):
if config.list_logical_devices('TPU') or config.list_logical_devices('GPU'):
self.skipTest('Only _cpu tests linked in support for jit_compile on CPU.')
seed = [1, 2]
shape = [2, 3]
outputs = []
for alg in alg_group:
with ops.device('CPU'):
output... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testing():\n from random import randint\n algorithms = [dynamic_programming, patience_sort, lis]\n\n sequences = [[],\n [1, 2, 3, 4, 5],\n [5, 4, 3, 2, 1],\n [1, 1, 1, 1],\n [3, 2, 6, 4, 5, 1]]\n sequences.append([26, 65, 42, 18, 73, 7... | [
"0.5886989",
"0.5785402",
"0.56681657",
"0.55894595",
"0.5576564",
"0.55730575",
"0.55704665",
"0.5555382",
"0.55321616",
"0.55156225",
"0.54750127",
"0.5433971",
"0.54276794",
"0.53705645",
"0.5362628",
"0.5354084",
"0.53357923",
"0.53281313",
"0.5325226",
"0.5306349",
"0.52... | 0.6314615 | 0 |
Tests an OOM bug of StatelessRandomNormalV2 on TPU. | def testLargeNormal(self):
with self.session() as sess, self.test_scope():
seed_t = array_ops.placeholder(dtypes.int32, shape=[2])
key, counter, alg = (gen_stateless_random_ops_v2.
stateless_random_get_key_counter_alg(seed_t))
x = gen_stateless_random_ops_v2.stateless_ra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_random_small_sample_error(self):\n with self.assertRaises(ValueError):\n random_small_sample([], 1e7)",
"def safe_rand(self):\n rand_n = np.random.rand()\n if rand_n == float(1):\n rand_n -= 1e-10\n return rand_n",
"def test_rng_null(self):\n assert check_random_... | [
"0.6402965",
"0.6271759",
"0.6156134",
"0.60297525",
"0.60209405",
"0.5990309",
"0.5852385",
"0.58344805",
"0.58285826",
"0.5805117",
"0.5793341",
"0.57845455",
"0.5761305",
"0.5755326",
"0.56997",
"0.567426",
"0.56445813",
"0.5642521",
"0.56110024",
"0.5595961",
"0.55892664"... | 0.68676966 | 0 |
Use Pearson's Chisquared test to test for uniformity. | def testDistributionOfStatelessRandomUniform(self, alg, dtype, seed):
philox = random_ops_util.Algorithm.PHILOX
auto_select = random_ops_util.Algorithm.AUTO_SELECT
device = xla_device()
if 'CPU' in device.device_type:
device_type = 'CPU'
elif 'GPU' in device.device_type:
device_type = 'G... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_perfect_square():",
"def test_handcrafted_examples(self):\n for i in range(1000):\n self.assertEqual(perfectd(0), True)\n self.assertEqual(prime(0), False)\n self.assertEqual(prime(2), True)\n self.assertEqual(prime(7), True)\n self.assertEqual... | [
"0.63705397",
"0.6365156",
"0.6357226",
"0.63283384",
"0.62204665",
"0.6165126",
"0.6116574",
"0.61068803",
"0.60982686",
"0.6009989",
"0.5992657",
"0.59221864",
"0.59080833",
"0.590566",
"0.59009594",
"0.5900922",
"0.58917534",
"0.5864173",
"0.586082",
"0.58577067",
"0.58508... | 0.0 | -1 |
Use AndersonDarling test to test distribution appears normal. | def testDistributionOfStatelessRandomNormal(self, dtype, seed):
with self.session() as sess, self.test_scope():
seed_t = array_ops.placeholder(dtypes.int32, shape=[2])
n = 1000
x = stateless.stateless_random_normal(shape=[n], seed=seed_t, dtype=dtype)
y = sess.run(x, {seed_t: seed})
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_2_normal(self):\n print(\"test 2: normal distributions\")\n\n mean = self.means[0]\n dispersion = self.dispersions[0]\n\n for i, x in enumerate(self.X):\n print(i+1, normal(x, mean, dispersion), sep=' : ')",
"def calculate_anderson_darling(p, scipy_distribution='no... | [
"0.67574555",
"0.6637979",
"0.6378692",
"0.6172181",
"0.61652255",
"0.6160517",
"0.60518044",
"0.6038389",
"0.58880514",
"0.5874568",
"0.5843989",
"0.5839309",
"0.5826366",
"0.5820332",
"0.5807704",
"0.5770181",
"0.5748254",
"0.5744736",
"0.5732599",
"0.5699256",
"0.56802166"... | 0.63507676 | 3 |
Convert base 4 representation of nucleotide pattern back into the pattern | def number_to_pattern(cls, number: int, k: int, nucleotide_map: dict=None) -> str:
if nucleotide_map is None:
nucleotide_map = cls._nucleotide_int_map
base = 4
new_str = ''
while number > 0:
new_str += str(number % base)
number = number // base
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patten2number(sequence):\n try:\n if len(sequence) == 0:\n return 0\n last_base = sequence[-1]\n prefix = sequence[:-1]\n return 4 * patten2number(prefix) + BASE_TO_NUMBER[last_base]\n except KeyError:\n raise ValueError('Not able to convert nucleotide: %s' %... | [
"0.65671915",
"0.630287",
"0.5952596",
"0.5781955",
"0.5513129",
"0.54676986",
"0.54493964",
"0.5342942",
"0.5323698",
"0.52741677",
"0.5225667",
"0.52242655",
"0.5197174",
"0.5196729",
"0.5168805",
"0.51648843",
"0.516025",
"0.51343155",
"0.5102335",
"0.5079092",
"0.50685626... | 0.5834671 | 3 |
Get reverse complement of a nucleotide sequence e.g. ACTG > CAGT | def get_reverse_complement(cls, pattern: str) -> str:
return ''.join(reversed([cls.dna_complement[nuc] for nuc in pattern])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_reverse_complement(dna):\r\n\r\n seq = Seq(dna)\r\n rev_seq = seq.reverse_complement()\r\n return str(rev_seq)",
"def reverse_complement(seq):\n if sys.version_info.major == 2:\n conversion = string.maketrans('ACGTacgt','TGCAtgca')\n else:\n conversion = str.maketrans('ACGTac... | [
"0.80981606",
"0.808695",
"0.8052708",
"0.8022656",
"0.8015278",
"0.80125123",
"0.7950907",
"0.7912492",
"0.78892535",
"0.7876142",
"0.7800502",
"0.77927697",
"0.7769712",
"0.776244",
"0.7713318",
"0.77050287",
"0.7662372",
"0.7642589",
"0.7624215",
"0.7604546",
"0.75933224",... | 0.7605945 | 19 |
Get all nearby patterns within hamming distance max_distance | def _get_neighbors(cls, pattern: str, max_distance: int) -> List[str]:
return get_neighborhood(pattern, ''.join(cls.nucleobases.keys()), max_distance) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def neighbors(pattern, d):\n tides = set([\"A\", \"C\", \"G\", \"T\"])\n if d == 0:\n return set([pattern])\n if len(pattern) == 1:\n return tides\n neighborhood = set([])\n suffix_neighbors = neighbors(pattern[1:], d)\n for text in suffix_neighbors:\n if ham_dist(pattern[1:]... | [
"0.60756433",
"0.586826",
"0.5829426",
"0.57467127",
"0.5627865",
"0.5625409",
"0.5618249",
"0.55964565",
"0.5565963",
"0.55327606",
"0.54889137",
"0.54708976",
"0.5464563",
"0.5462131",
"0.53667754",
"0.5361143",
"0.5356188",
"0.5352204",
"0.53446394",
"0.52754647",
"0.52659... | 0.6922144 | 0 |
Return whether a user has already voted | def has_voted(self, user):
return user.choice_set.filter(vote=self).exists() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_voted(self, user, ip_address):\r\n if user.is_anonymous():\r\n return len(self.usedip_set.filter(address=ip_address))>0\r\n else:\r\n return self.is_expert(user) and self.expert_set.filter(user=user)[0].voted",
"def vote_exists(self):\n con = psycopg2.connect(**... | [
"0.77529603",
"0.7535864",
"0.65836215",
"0.6361191",
"0.6361191",
"0.62889564",
"0.626759",
"0.625303",
"0.6251645",
"0.62177384",
"0.6179546",
"0.61739177",
"0.6148994",
"0.6078883",
"0.5977957",
"0.5973656",
"0.5966548",
"0.58713126",
"0.5856128",
"0.584966",
"0.58388305",... | 0.84560186 | 0 |
Generates a sequential id unique for this exe session. | def newId():
global lastId
lastId += 1
return 'id%d' % lastId | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_session_id():\n return utils.get_32bit_random_num()",
"def gen_id(self) -> str:\n self._id += 1\n return str(self._id)",
"def get_generator_id() -> str:\n res = os.name + str(os.getpid()) + str(random.randint(-1000, 1000))\n res = hashlib.sha224(res.encode('utf-8')).dige... | [
"0.79363555",
"0.7690968",
"0.7679877",
"0.7678485",
"0.7678172",
"0.76593244",
"0.76256436",
"0.7593852",
"0.7585659",
"0.7561776",
"0.7545377",
"0.7545377",
"0.74505085",
"0.7432396",
"0.7419196",
"0.73942035",
"0.7390403",
"0.73147666",
"0.7304635",
"0.72568166",
"0.725517... | 0.6847583 | 57 |
Generates the documentation type string | def docType():
return (u'<?xml version="1.0" encoding="UTF-8"?>\n'
u'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 '
u'Transitional//EN" '
u'"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">\n') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_type_doc_name(type):\n name = type.name\n if type.is_simple:\n return _get_simple_type_mapping(name)\n elif type.is_enum:\n return '{0}.{1}'.format(get_package_name(name), get_enum_name(name))\n elif type.is_complex:\n return '{0}.{1}'.format(get_package_name(name), get_cla... | [
"0.709732",
"0.70114326",
"0.6969742",
"0.6881393",
"0.6750534",
"0.6399172",
"0.6352584",
"0.63299954",
"0.62866646",
"0.6270518",
"0.62495774",
"0.6239356",
"0.6220442",
"0.62143224",
"0.61934704",
"0.61934704",
"0.6177531",
"0.61766106",
"0.6158902",
"0.61579823",
"0.61572... | 0.658089 | 5 |
Generates the common header XHTML | def header(style=u'default'):
return (docType() +
u'<html xmlns="http://www.w3.org/1999/xhtml">\n'
u'<head>\n'
u'<style type="text/css">\n'
u' @import url(/css/exe.css);\n'
u' @import url(/style/base.css);\n'
u' @import url(/style/%s/conten... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def renderHeader(self, name):\n html = u\"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\n\"\n html += u'<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 '\n html += u'Transitional//EN\" '\n html += u'\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\\n'\n html += u... | [
"0.74553525",
"0.7425798",
"0.7310361",
"0.72088915",
"0.7052019",
"0.70107",
"0.6935558",
"0.6934121",
"0.6880456",
"0.67663515",
"0.6619934",
"0.6499455",
"0.6466389",
"0.6450139",
"0.6448158",
"0.644058",
"0.63944995",
"0.63919437",
"0.63732743",
"0.6343069",
"0.633073",
... | 0.7433771 | 1 |
Generates the common page footer XHTML | def footer():
return u'</form></body></html>\n' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_footer():\n return '</body></html>'",
"def WriteFooter(self):\n return",
"def common_html_footer(outfile: TextIO, indexpath: str = \"\") -> None:\n outfile.write(\"\\n\")\n outfile.write(\" <footer>\\n\")\n outfile.write(\" <figure id=\\\"footmap\\\"><script type=\\\"text/javasc... | [
"0.8209114",
"0.7574358",
"0.7457577",
"0.73935664",
"0.7313318",
"0.7277284",
"0.7117509",
"0.6951311",
"0.6943452",
"0.6894811",
"0.68390125",
"0.6802921",
"0.6785685",
"0.6785685",
"0.66476876",
"0.6617712",
"0.66044176",
"0.65872484",
"0.65571517",
"0.6428135",
"0.6368189... | 0.69917154 | 7 |
Adds a hidden field to a form | def hiddenField(name, value=u""):
html = u"<input type=\"hidden\" "
html += u"name=\"%s\" " % name
html += u"id=\"%s\" " % name
html += u"value=\"%s\"/>\n" % value
return html | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def form_Hidden(request):\n schema = schemaish.Structure()\n schema.add('Visible', schemaish.String())\n schema.add('Hidden', schemaish.String())\n\n form = formish.Form(schema, 'form')\n form['Hidden'].widget = formish.Hidden()\n return form",
"def add_hidden_input(\n self,\n nam... | [
"0.7501152",
"0.70271856",
"0.65093476",
"0.65093476",
"0.65093476",
"0.6465911",
"0.63139683",
"0.6194723",
"0.6082944",
"0.6055618",
"0.59255236",
"0.5911473",
"0.56137574",
"0.5548985",
"0.55037236",
"0.54748195",
"0.53836066",
"0.53755033",
"0.53438234",
"0.5320544",
"0.5... | 0.73137796 | 1 |
Adds a text input to a form | def textInput(name, value=u"", size=40, disabled=u"", **kwargs):
html = u"<input type=\"text\" "
html += u"name=\"%s\" " % name
html += u"id=\"%s\" " % name
html += u"value=\"%s\" " % value
html += u"size=\"%s\" " % size
for key, val in kwargs.items():
html += u' %s="%s"' % (key.replace... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def TextFieldOptionsAddText(builder, text):\n return AddText(builder, text)",
"def add_text_edit(self, name, value=None, label=None, add_indicator=None, location=(None,0)):\n widget=edit.LVTextEdit(self,value=value)\n widget.setObjectName(_fromUtf8(self.name+\"_\"+name))\n return self.add... | [
"0.66011745",
"0.64968944",
"0.6393522",
"0.63851357",
"0.6345662",
"0.6336389",
"0.63294166",
"0.6301488",
"0.62964344",
"0.62394214",
"0.62078243",
"0.61974514",
"0.6119116",
"0.60870457",
"0.60489494",
"0.60489494",
"0.60489494",
"0.6038742",
"0.6032041",
"0.59584516",
"0.... | 0.6069953 | 14 |
Adds a text area to a form | def textArea(name, value="", disabled="", cols="80", rows="8"):
log.debug(u"textArea %s" % value)
html = u'<textarea name="%s" ' % name
html += 'id = "%s"' % name
if disabled:
html += u'disabled="disabled" '
html += u'style=\"width:100%"'
html += u'cols="%s" rows="%s">' %(cols, rows)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def form_TextAreaColsAndRows(request):\n schema = schemaish.Structure()\n schema.add('textAreaCustom', schemaish.String())\n\n form = formish.Form(schema, 'form')\n form['textAreaCustom'].widget = formish.TextArea(cols=20,rows=4)\n return form",
"def form_TextAreaStrip(request):\n schema = sche... | [
"0.70033205",
"0.65260094",
"0.64773655",
"0.63208395",
"0.614079",
"0.6058951",
"0.60212314",
"0.59914464",
"0.5919031",
"0.584087",
"0.5834448",
"0.57610804",
"0.57148194",
"0.5706627",
"0.5695541",
"0.5676627",
"0.5663998",
"0.5651863",
"0.5630527",
"0.5580933",
"0.5561570... | 0.6582529 | 1 |
Adds a editor to a form | def richTextArea(name, value="", width="100%", height=100):
log.debug(u"richTextArea %s, height=%s" % (value, height))
html = u'<textarea name="%s" ' % name
html += u'style=\"width:' + width + '; height:' + str(height) + 'px;" '
html += u'class="mceEditor" '
html += u'cols="52" rows="8">'
html ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addEditor(self, editor: QWidget, type: str):\n if type == NodeType.Node:\n self.ui.layoutNode.addWidget(editor)\n else:\n self.ui.layoutSpec.addWidget(editor)\n editor.setVisible(False)\n self._editor_dict[type] = editor",
"def editor():\n pass",
"de... | [
"0.71680623",
"0.6764222",
"0.6761778",
"0.6656136",
"0.66182566",
"0.6595414",
"0.63707495",
"0.6299939",
"0.596213",
"0.5892001",
"0.58302903",
"0.57997614",
"0.57550246",
"0.57416964",
"0.5740289",
"0.57223016",
"0.56482834",
"0.56267375",
"0.5620819",
"0.55850405",
"0.556... | 0.0 | -1 |
Returns the XHTML for an image | def image(name, value, width="", height="", alt=None):
if alt is None:
alt = name
log.debug(u"image %s" % value)
html = u"<img id=\"%s\" " % name
html += u'alt="%s" ' % alt
if width:
html += u"width=\"%s\" " % width
if height:
html += u"height=\"%s\" " % height
html ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def image(self, src, title, text):\n src = escape_link(src)\n text = escape(text, quote=True)\n if title:\n title = escape(title, quote=True)\n html = '<img src=\"%s\" alt=\"%s\" title=\"%s\"' % (src, text, title)\n else:\n html = '<img src=\"%s\" alt=\"... | [
"0.69611996",
"0.67423284",
"0.67166317",
"0.669368",
"0.6571337",
"0.6528769",
"0.64684045",
"0.6419062",
"0.6330245",
"0.6321424",
"0.62781984",
"0.62261355",
"0.6211105",
"0.61640394",
"0.61532664",
"0.61467296",
"0.6129031",
"0.6124882",
"0.6118638",
"0.61112887",
"0.6087... | 0.65244746 | 6 |
Returns the XHTML for flash. 'params' is a dictionary of name, value pairs that will be turned into a bunch of tags | def flash(src, width, height, id_=None, params=None, **kwparams):
log.debug(u"flash %s" % src)
stan = \
T._object(type='application/x-shockwave-flash',
width=width,
height=height,
**kwparams)
if id_:
stan.attributes['id'] = id_
stan.attr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flash_message(self, request):\n return FlashMessagesElement()",
"def flash_message(self, request):\n return FlashMessagesElement()",
"def mediaplayer(src,width=400,height=250):\n return XML('<embed allowfullscreen=\"true\" allowscriptaccess=\"always\" flashvars=\"height=%(height)s&widt... | [
"0.57332635",
"0.57332635",
"0.54264164",
"0.5292242",
"0.52749646",
"0.52352464",
"0.52238834",
"0.5138303",
"0.5057226",
"0.49932578",
"0.48965406",
"0.48927727",
"0.48299986",
"0.4776292",
"0.4755645",
"0.4748481",
"0.47427863",
"0.47350845",
"0.46903166",
"0.46795943",
"0... | 0.6152918 | 0 |
Returns the XHTML for a flash movie | def flashMovie(movie, width, height, resourcesDir=''):
log.debug(u"flash %s" % movie)
src = resourcesDir
src += 'videoContainer.swf?videoSource=%s&autoPlay=false' % movie
return flash(src, width, height,
params={'movie': src,
'menu' : 'false'}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mediaplayer(src,width=400,height=250):\n return XML('<embed allowfullscreen=\"true\" allowscriptaccess=\"always\" flashvars=\"height=%(height)s&width=%(width)s&file=%(src)s\" height=\"%(height)spx\" src=\"%(url)s\" width=\"%(width)spx\"></embed>'%dict(url=URL('static','plugin_wiki/mediaplayer.swf'),src=... | [
"0.67839944",
"0.66639304",
"0.57066834",
"0.55713564",
"0.5500554",
"0.5500554",
"0.5404905",
"0.5377051",
"0.53009015",
"0.5279575",
"0.5074877",
"0.5065303",
"0.506393",
"0.5044238",
"0.49113828",
"0.48947486",
"0.48934996",
"0.48878092",
"0.48661235",
"0.48661235",
"0.481... | 0.66404533 | 2 |
Adds a submit button to a form | def submitButton(name, value, enabled=True, **kwargs):
html = u'<input class="button" type="submit" name="%s" ' % name
html += u'value="%s" ' % value
if not enabled:
html += u' disabled'
for key, val in kwargs.items():
html += u' %s="%s"' % (key.replace('_', ''), val.replace('"', '\\"')... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def submit(self):\n self.driver.find_element(*BaseLocators.SUBMIT_BUTTON).click()",
"def htmlSubmit(text, parName, attr='', onlyOnce=False):\n if onlyOnce:\n # FIXME: this doesn't work yet - it disables submission\n s = '<input type=\"button\" name=\"%s\" value=\"%s\"' % (parName,text)\n ... | [
"0.68879074",
"0.6494475",
"0.64015305",
"0.62032175",
"0.603863",
"0.5858578",
"0.5552755",
"0.553243",
"0.55282384",
"0.551249",
"0.5505816",
"0.5478316",
"0.5471883",
"0.5449857",
"0.5446425",
"0.5442419",
"0.54329383",
"0.5431257",
"0.54045117",
"0.5382428",
"0.53795224",... | 0.6159708 | 4 |
Adds a NONsubmit button to a form | def button(name, value, enabled=True, **kwargs):
html = u'<input type="button" name="%s"' % name
html += u' value="%s"' % value
if not enabled:
html += u' disabled'
for key, val in kwargs.items():
html += u' %s="%s"' % (key.replace('_', ''), val.replace('"', '\\"'))
html += u'/>\n'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def htmlSubmit(text, parName, attr='', onlyOnce=False):\n if onlyOnce:\n # FIXME: this doesn't work yet - it disables submission\n s = '<input type=\"button\" name=\"%s\" value=\"%s\"' % (parName,text)\n s += ' onclick=\"this.form.submit()\"'\n s += '%s />\\n' % sep(attr)\n re... | [
"0.6327102",
"0.5945655",
"0.5778734",
"0.56412446",
"0.55579346",
"0.5518062",
"0.5501025",
"0.5490777",
"0.5484271",
"0.5459105",
"0.54470176",
"0.54278964",
"0.5370909",
"0.5295769",
"0.5279715",
"0.5274572",
"0.5236318",
"0.52006644",
"0.5200261",
"0.5189816",
"0.5171976"... | 0.0 | -1 |
Adds a feedback button | def feedbackButton(name, value=None, enabled=True, **kwparams):
if value is None:
value = _(u'Feedback')
kwparams.setdefault('class', 'feedbackbutton')
return button(name, value, enabled, **kwparams) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def feedback():\n return render_template(\"feedback.html\")",
"async def feedback(self, ctx, *, feedback):\n url = os.environ.get(\"FEEDBACK_WEBHOOK\", None)\n if url:\n webhook = Webhook.from_url(url, adapter=RequestsWebhookAdapter())\n embed = discord.Embed(description=fe... | [
"0.6485179",
"0.6422864",
"0.63804656",
"0.61001223",
"0.60035086",
"0.5993185",
"0.5932232",
"0.59071183",
"0.58853",
"0.58728164",
"0.5863927",
"0.57498777",
"0.5733604",
"0.5621053",
"0.5585151",
"0.5584186",
"0.5577006",
"0.55740017",
"0.5564906",
"0.555417",
"0.5552995",... | 0.7189924 | 0 |
Adds an image link which will trigger the javascript needed to post a form with the action and object passed in the args | def submitImage(action, object_, imageFile, title=u"", isChanged=1):
onclick = "submitLink('%s', '%s', %d);" % (action, object_, isChanged)
titleText = u''
if title:
titleText = u'title="%s" ' % title
html = u'<a %s' % titleText
html += u' href="#" onclick="%s">' % onclick
html += u'<im... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def confirmThenSubmitImage(message, action, object_, imageFile, \n title=u\"\", isChanged=1):\n html = u\"<a \"\n if title:\n html += u\"title=\\\"\"+title+\"\\\" \"\n html += \" href=\\\"#\\\" \"\n html += \"onclick=\\\"confirmThenSubmitLink('\"+message+\"', '\"+actio... | [
"0.6467419",
"0.6291856",
"0.5695191",
"0.55512077",
"0.54058975",
"0.54002887",
"0.5396562",
"0.5381138",
"0.5377608",
"0.5334084",
"0.52907336",
"0.52907336",
"0.52527887",
"0.524726",
"0.5207052",
"0.51895213",
"0.51895213",
"0.51895213",
"0.51895213",
"0.5137885",
"0.5096... | 0.75600076 | 0 |
Adds an image link which will trigger the javascript needed to post a form with the action and object passed in the args | def insertSymbol(name, image, title, string, text ='', num=0):
onclick = "insertSymbol('%s', '%s', %d);" % (name, string, num)
html = u'<a onclick="%s" ' % onclick
html += u'title="%s">' % title
html += text
if image <> "":
html += u'<img alt="%s" src="%s"/>' % ('symbol', image)
html += ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def submitImage(action, object_, imageFile, title=u\"\", isChanged=1):\n onclick = \"submitLink('%s', '%s', %d);\" % (action, object_, isChanged)\n titleText = u''\n if title:\n titleText = u'title=\"%s\" ' % title\n html = u'<a %s' % titleText\n html += u' href=\"#\" onclick=\"%s\">' % oncl... | [
"0.755693",
"0.6464906",
"0.62912494",
"0.56953716",
"0.55490845",
"0.5405367",
"0.5399931",
"0.5397571",
"0.53791434",
"0.5375661",
"0.5333625",
"0.528877",
"0.528877",
"0.5250972",
"0.52447456",
"0.52054894",
"0.51920485",
"0.51920485",
"0.51920485",
"0.51920485",
"0.513760... | 0.0 | -1 |
Adds an image link which will trigger the javascript needed to post a form with the action and object passed in the args | def confirmThenSubmitImage(message, action, object_, imageFile,
title=u"", isChanged=1):
html = u"<a "
if title:
html += u"title=\""+title+"\" "
html += " href=\"#\" "
html += "onclick=\"confirmThenSubmitLink('"+message+"', '"+action+"', "
html += "'"+object_+"',... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def submitImage(action, object_, imageFile, title=u\"\", isChanged=1):\n onclick = \"submitLink('%s', '%s', %d);\" % (action, object_, isChanged)\n titleText = u''\n if title:\n titleText = u'title=\"%s\" ' % title\n html = u'<a %s' % titleText\n html += u' href=\"#\" onclick=\"%s\">' % oncl... | [
"0.75593275",
"0.62918144",
"0.56968886",
"0.5551059",
"0.5405228",
"0.5401838",
"0.5398058",
"0.5381089",
"0.53773266",
"0.5335524",
"0.5290609",
"0.5290609",
"0.52529365",
"0.52459806",
"0.52074254",
"0.51923656",
"0.51923656",
"0.51923656",
"0.51923656",
"0.51381063",
"0.5... | 0.6467512 | 1 |
Add a option input | def option(name, checked, value):
chkStr = u''
if checked:
chkStr = u'checked="checked"'
html = (u'<input type="radio" name="%s"'
u' value="%s" %s/>\n' %
(name, value, chkStr))
return html | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_option(self, label, action, type_func, shortcut):\n pass",
"def addOption(self, parser):\n pass",
"def add_option(self, *args, **kwargs):\n self.parser.add_option(*args, **kwargs)",
"def add_input(self, var):\n raise NotImplementedError",
"def add_option(self, label, act... | [
"0.70007855",
"0.651464",
"0.64733064",
"0.64430857",
"0.63783973",
"0.6359492",
"0.6343427",
"0.6325761",
"0.6278913",
"0.62763506",
"0.62433684",
"0.618273",
"0.6166285",
"0.6092797",
"0.6078784",
"0.6073309",
"0.6062212",
"0.60102624",
"0.5983635",
"0.59361875",
"0.5933234... | 0.0 | -1 |
Add a help instruction for a element | def elementInstruc(instruc, imageFile="help.gif", label=None):
if label is None:
label = _(u"Instructions")
if not instruc.strip():
html = u''
else:
id_ = newId()
html = u'<a onmousedown="Javascript:updateCoords(event);" '
html += u' title="%s" ' % _(u'Click for comp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_help(text):\n global default_text\n default_text += text",
"def help(self):",
"def help(self):",
"def help_description():\n pass",
"def help(self, value: str):\n self._help = value",
"def help(self):\r\n self._short_help(None, None, None, None)",
"def help():\n \n ... | [
"0.71474516",
"0.7015725",
"0.7015725",
"0.6980685",
"0.6937339",
"0.6921581",
"0.6878647",
"0.6869714",
"0.6837826",
"0.6819098",
"0.67912656",
"0.67912656",
"0.6771253",
"0.6769475",
"0.6750411",
"0.6733238",
"0.6719639",
"0.67021394",
"0.66982436",
"0.6681121",
"0.666716",... | 0.0 | -1 |
A standard way for showing any form field nicely | def formField(type_, caption, action, object_='', instruction='', *args, **kwargs):
html = '<div class="block">'
html += '<strong>%s</strong>' % caption
if instruction:
html += elementInstruc(instruction)
html += '</div>'
html += '<div class="block">'
if type_ == 'select':
html ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def html(self):\n lbl = escape(self._label)\n dis = ('disabled' if not self._enabled else '')\n typ = ('password' if self._password else 'text')\n nam = escape(self._name)\n val = escape(self._value)\n return '%s <input name=\"%s\" %s type=\"%s\" value=\"%s\" size=\"%i\">' % (lbl, nam, dis, typ, ... | [
"0.6636922",
"0.6503447",
"0.6492283",
"0.64133143",
"0.64047253",
"0.64039874",
"0.6366983",
"0.62991357",
"0.62760854",
"0.6225514",
"0.61878324",
"0.6112394",
"0.6105818",
"0.6105642",
"0.6099386",
"0.6054292",
"0.6020611",
"0.5959966",
"0.59108335",
"0.58825946",
"0.58703... | 0.68652034 | 0 |
Adds a dropdown selection to a form | def select(action, object_='', options=[], selection=None):
html = u'<select '
html += u'name="'+action+object_+'" '
if action and object_:
html += u'onchange="submitLink(\''+action+'\', \''+object_+'\');"'
html += u'>\n'
for option, value in options:
html += u' <option value="'+uni... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def form_SelectChoice(request):\n schema = schemaish.Structure()\n schema.add('mySelect', schemaish.Integer())\n options = [(1,'a'),(2,'b'),(3,'c')]\n\n form = formish.Form(schema, 'form')\n form['mySelect'].widget = formish.SelectChoice(options)\n return form",
"def form_SelectWithOtherChoice(... | [
"0.70253795",
"0.68037504",
"0.619008",
"0.61317617",
"0.6127463",
"0.60849595",
"0.6075871",
"0.6057535",
"0.60314304",
"0.59447914",
"0.58972394",
"0.58765864",
"0.5842999",
"0.5775621",
"0.56882447",
"0.56757563",
"0.5617067",
"0.55429757",
"0.5520181",
"0.5507859",
"0.550... | 0.52415097 | 32 |
Provides a styled editSectionHeading | def editModeHeading(text):
return u'<p style="editModeHeading">%s</p>' % text | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def heading(self):\n return self.wrap(\"-------\")",
"def format_heading(self, level, text):\n underlining = ['=', '-', '~', ][level-1] * len(text)\n return '%s\\n%s\\n\\n' % (text, underlining)",
"def print_section_header(title, color):\n block = \"#\" * (len(title) + 2)\n print(\"\... | [
"0.66849434",
"0.6272026",
"0.6106788",
"0.61038226",
"0.60833454",
"0.6072701",
"0.5986174",
"0.59668994",
"0.5961167",
"0.594331",
"0.5935845",
"0.5911637",
"0.58749354",
"0.58624434",
"0.5846889",
"0.5835326",
"0.5825542",
"0.58238256",
"0.5794538",
"0.57842624",
"0.578426... | 0.67918336 | 0 |
Construct a molecule from a InChI string | def MolFromInchi(inchi, sanitize=True, removeHs=True, logLevel=None, treatWarningAsError=False):
try:
mol, retcode, message, log = rdinchi.InchiToMol(inchi, sanitize, removeHs)
except ValueError as e:
logger.error(str(e))
return None
if logLevel is not None:
if logLevel not in logLevelToLogFuncti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_molecule_subclass_from_inchi(self):\n mol = MyMol.from_inchi(\"InChI=1S/C2H6O/c1-2-3/h3H,2H2,1H3\")\n assert isinstance(mol, MyMol)",
"def ReadMolFromInchi(inchi=\"\"):\n import pybel\n temp=pybel.readstring(\"inchi\",inchi)\n smi=temp.write(\"smi\")\n mol = Chem.MolFromSmiles(... | [
"0.72785413",
"0.69075364",
"0.6564429",
"0.6517638",
"0.642409",
"0.6403566",
"0.62167716",
"0.6087867",
"0.60767406",
"0.6017357",
"0.5984189",
"0.59590703",
"0.5955019",
"0.5944773",
"0.5714933",
"0.5712715",
"0.5630374",
"0.5622037",
"0.56003404",
"0.5586199",
"0.5564522"... | 0.0 | -1 |
Returns the standard InChI string and InChI auxInfo for a molecule | def MolToInchiAndAuxInfo(mol, options="", logLevel=None, treatWarningAsError=False):
inchi, retcode, message, logs, aux = rdinchi.MolToInchi(mol, options)
if logLevel is not None:
if logLevel not in logLevelToLogFunctionLookup:
raise ValueError("Unsupported log level: %d" % logLevel)
log = logLevelToL... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inchi(self) -> str:\n if not self._inchi:\n self.sanitize(raise_exception=False)\n self._inchi = Chem.MolToInchi(self.rd_mol)\n if self._inchi is None:\n raise MoleculeException(\"Could not make InChI\")\n return self._inchi",
"def MolToInchi(mol,... | [
"0.6346383",
"0.5750787",
"0.57444793",
"0.5686185",
"0.56063706",
"0.56049293",
"0.55815786",
"0.55815786",
"0.5549947",
"0.5546916",
"0.5512506",
"0.54929435",
"0.5482103",
"0.5443629",
"0.54201764",
"0.5419237",
"0.5418019",
"0.533771",
"0.52724075",
"0.5272198",
"0.523930... | 0.58500123 | 1 |
Returns the standard InChI string and InChI auxInfo for a mol block | def MolBlockToInchiAndAuxInfo(molblock, options="", logLevel=None, treatWarningAsError=False):
inchi, retcode, message, logs, aux = rdinchi.MolBlockToInchi(molblock, options)
if logLevel is not None:
if logLevel not in logLevelToLogFunctionLookup:
raise ValueError("Unsupported log level: %d" % logLevel)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def MolBlockToInchi(molblock, options=\"\", logLevel=None, treatWarningAsError=False):\n if options.find('AuxNone') == -1:\n if options:\n options += \" /AuxNone\"\n else:\n options += \"/AuxNone\"\n\n try:\n inchi, aux = MolBlockToInchiAndAuxInfo(molblock, options, logLevel=logLevel,\n ... | [
"0.64976436",
"0.60744226",
"0.6004788",
"0.57994264",
"0.5761588",
"0.5618919",
"0.554857",
"0.5285582",
"0.52573204",
"0.52302134",
"0.51718366",
"0.5170532",
"0.515442",
"0.51395327",
"0.5137501",
"0.5132895",
"0.5129088",
"0.51100504",
"0.5109222",
"0.5099051",
"0.5088721... | 0.64511925 | 1 |
Returns the standard InChI string for a molecule | def MolToInchi(mol, options="", logLevel=None, treatWarningAsError=False):
if options.find('AuxNone') == -1:
if options:
options += " /AuxNone"
else:
options += "/AuxNone"
try:
inchi, aux = MolToInchiAndAuxInfo(mol, options, logLevel=logLevel,
treatWarn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inchi(self) -> str:\n if not self._inchi:\n self.sanitize(raise_exception=False)\n self._inchi = Chem.MolToInchi(self.rd_mol)\n if self._inchi is None:\n raise MoleculeException(\"Could not make InChI\")\n return self._inchi",
"def inchi_key(self)... | [
"0.7660741",
"0.63990366",
"0.60433763",
"0.595492",
"0.5946647",
"0.59346324",
"0.592875",
"0.5795559",
"0.5732636",
"0.57045305",
"0.566792",
"0.5595976",
"0.5595365",
"0.5565196",
"0.55554646",
"0.55542576",
"0.5534849",
"0.54897135",
"0.54738885",
"0.5453322",
"0.5441915"... | 0.5070574 | 79 |
Returns the standard InChI string for a mol block | def MolBlockToInchi(molblock, options="", logLevel=None, treatWarningAsError=False):
if options.find('AuxNone') == -1:
if options:
options += " /AuxNone"
else:
options += "/AuxNone"
try:
inchi, aux = MolBlockToInchiAndAuxInfo(molblock, options, logLevel=logLevel,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inchi(self) -> str:\n if not self._inchi:\n self.sanitize(raise_exception=False)\n self._inchi = Chem.MolToInchi(self.rd_mol)\n if self._inchi is None:\n raise MoleculeException(\"Could not make InChI\")\n return self._inchi",
"def ReadMolFromInch... | [
"0.6524756",
"0.63204664",
"0.5977838",
"0.57800525",
"0.5521084",
"0.54988",
"0.54791445",
"0.5471375",
"0.54505354",
"0.54045933",
"0.53946084",
"0.53804225",
"0.5335063",
"0.52932346",
"0.52757055",
"0.524747",
"0.5240518",
"0.5237671",
"0.5237412",
"0.5205528",
"0.5186665... | 0.58252805 | 3 |
Return the InChI key for the given InChI string. Return None on error | def InchiToInchiKey(inchi):
ret = rdinchi.InchiToInchiKey(inchi)
if ret:
return ret
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inchi_to_inchi_key(ich):\n return _rd_chem.inchi.InchiToInchiKey(ich)",
"def inchi_key(self) -> str:\n if not self._inchi_key:\n self.sanitize(raise_exception=False)\n self._inchi_key = Chem.MolToInchiKey(self.rd_mol)\n if self._inchi_key is None:\n r... | [
"0.71598774",
"0.7087606",
"0.70870805",
"0.67726326",
"0.66098547",
"0.6378951",
"0.62275",
"0.61656976",
"0.59837407",
"0.587364",
"0.5690562",
"0.5690562",
"0.5690562",
"0.5690562",
"0.5690562",
"0.5690562",
"0.5690562",
"0.5690562",
"0.5690562",
"0.5690562",
"0.5690562",
... | 0.7775047 | 0 |
Returns the standard InChI key for a molecule | def MolToInchiKey(mol, options=""):
return rdinchi.MolToInchiKey(mol,options) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inchi_key(self) -> str:\n if not self._inchi_key:\n self.sanitize(raise_exception=False)\n self._inchi_key = Chem.MolToInchiKey(self.rd_mol)\n if self._inchi_key is None:\n raise MoleculeException(\"Could not make InChI key\")\n return self._inchi_k... | [
"0.81321317",
"0.7113956",
"0.6988666",
"0.68637294",
"0.6657926",
"0.6496378",
"0.6411273",
"0.6411273",
"0.6411273",
"0.6411273",
"0.6411273",
"0.6411273",
"0.6411273",
"0.6411273",
"0.6411273",
"0.6411273",
"0.6411273",
"0.6411273",
"0.6411273",
"0.6411273",
"0.6411273",
... | 0.7232959 | 1 |
Compute the accuracies for a batch of predictions and answers | def batch_accuracy(predicted, true):
_, predicted_index = predicted.max(dim=1, keepdim=True)
agreeing = true.gather(dim=1, index=predicted_index)
'''
Acc needs to be averaged over all 10 choose 9 subsets of human answers.
While we could just use a loop, surely this can be done more efficiently (and ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eval_metrics_for_multiclass(self, predicted_answers):\n total_correct_in_all = 0\n total_pred_in_all = len(predicted_answers)\n # initial a dict for total correct in topK counting.\n total_correct_in_topK = dict([(i, 0) for i in self.topK_list])\n total_pred_in_topK = dict([... | [
"0.72240007",
"0.7196117",
"0.7156245",
"0.71237266",
"0.7044354",
"0.7011002",
"0.69618726",
"0.69563323",
"0.69142157",
"0.6911175",
"0.69000417",
"0.6897008",
"0.6889631",
"0.68849134",
"0.6882984",
"0.68819773",
"0.68688965",
"0.6854075",
"0.6837835",
"0.68339974",
"0.681... | 0.7324437 | 0 |
Parse command line arguments. | def parse_args():
parser = argparse.ArgumentParser("BaselineMembershipInferenceAttack")
parser.add_argument("--batch_size",
type=int, default=128,
help="The batch size of normal training.")
parser.add_argument("--train_epoch",
type=int,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_command_line(self, argv):\n from optparse import OptionParser\n usage = \"usage: %prog [options]\"\n parser = OptionParser(usage)\n\n (options, args) = parser.parse_args(argv)",
"def parseArguments(self):\n iterator = iter(sys.argv[1:])... | [
"0.807208",
"0.74767",
"0.73985106",
"0.73932225",
"0.73173845",
"0.72599804",
"0.7232453",
"0.7222555",
"0.713585",
"0.7102058",
"0.71020466",
"0.7096281",
"0.7093058",
"0.70890576",
"0.7080071",
"0.70745754",
"0.70641047",
"0.70633066",
"0.70568484",
"0.7051162",
"0.7048470... | 0.0 | -1 |
get train dataset and test dataset for cifar10 | def get_data():
transform = Compose([paddle.vision.Resize(32),
Normalize(mean=[127.5], std=[127.5], data_format='CHW'),
paddle.vision.transforms.Transpose()])
train_data = paddle.vision.datasets.Cifar10(mode='train', transform=transform)
l = len(train_data)
return... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_dataset(self):\n\n trainset = datasets.CIFAR10('datasets/CIFAR10/train/', train=True, transform=self.train_transforms,\n target_transform=None, download=True)\n valset = datasets.CIFAR10('datasets/CIFAR10/test/', train=False, transform=self.val_transforms,\n... | [
"0.80263996",
"0.7815118",
"0.73785543",
"0.7335551",
"0.7159393",
"0.7085548",
"0.7073933",
"0.7025835",
"0.702049",
"0.69826376",
"0.6974629",
"0.6938204",
"0.693361",
"0.69160396",
"0.6911001",
"0.690179",
"0.68777454",
"0.6869696",
"0.6860709",
"0.6856323",
"0.68560594",
... | 0.69423556 | 11 |
get labels from multiple dataset | def get_all_labels(data_list):
labels = []
for dataset in data_list:
for data in dataset:
labels.append(data[1])
return paddle.to_tensor(labels) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data_labels(datasets):\n # Split by words\n x_text = datasets['data']\n x_text = [clean_str(sent) for sent in x_text]\n # Generate labels\n labels = [0, 1, 2, 3, 4]\n print(len(x_text))\n for i in range(len(x_text)):\n label = [0 for j in datasets['target_names']] \n ... | [
"0.77368695",
"0.7720466",
"0.7348672",
"0.7334549",
"0.7235436",
"0.71652806",
"0.7130086",
"0.7105828",
"0.70865",
"0.70461166",
"0.6970475",
"0.6970475",
"0.6970475",
"0.6970475",
"0.6970475",
"0.6970475",
"0.6970475",
"0.6970475",
"0.6970475",
"0.6970475",
"0.6970475",
... | 0.7676018 | 2 |
The training procedure that starts from training target model, then launchs baseline membership inference attack | def train_and_attack(args):
mem_data, non_mem_data = get_data()
num_classes = 10
model = paddle.Model(ResNet(num_classes))
# train model
model.prepare(paddle.optimizer.Adam(parameters=model.parameters(), learning_rate=args.train_lr),
paddle.nn.CrossEntropyLoss(),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self) -> None:\n self.model = self.trainer.train_model(self.model, self.data)",
"def train():\n # YOUR TRAINING CODE GOES HERE",
"def train():\n pass",
"def training(self) -> None:\n self.compile_model()\n self.train_epoch()\n self.agent.save()",
"def train_nai... | [
"0.6831418",
"0.67969114",
"0.6743277",
"0.6665565",
"0.65510994",
"0.6513925",
"0.6478302",
"0.6475857",
"0.6475857",
"0.6475857",
"0.6475857",
"0.6475857",
"0.6414337",
"0.6410145",
"0.6364995",
"0.6352841",
"0.6326412",
"0.63112336",
"0.6307469",
"0.6284598",
"0.6273873",
... | 0.73666734 | 0 |
Save checkpoint if a new best is achieved | def save_checkpoint(model, is_best, filename='./model/checkpoint.pth.tar'):
if is_best:
torch.save(model.state_dict(), filename) # save checkpoint
else:
print ("=> Validation Accuracy did not improve") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_checkpoint(state, is_best, filename='checkpoint/chpt.tar'):\n if is_best:\n print (\"=> Saving a new best\")\n torch.save(state, filename) # save checkpoint\n else:\n print (\"=> Validation Accuracy did not improve\")",
"def save_checkpoint(self):\n ... | [
"0.8414909",
"0.8096639",
"0.79832625",
"0.79078",
"0.7821017",
"0.78085893",
"0.7779003",
"0.77387804",
"0.761438",
"0.74721783",
"0.735547",
"0.735091",
"0.73230714",
"0.72978014",
"0.7288464",
"0.7276494",
"0.7276335",
"0.7263861",
"0.7252227",
"0.7241171",
"0.7217522",
... | 0.7952169 | 3 |
Querys the db and returns a list of the TrafficControl objects that are stored there. returns as a list of dicts that have a key for 'tc' and 'timeout' | def get_saved_shapings(self):
query = 'SELECT * FROM CurrentShapings'
with self._get_conn() as conn:
results = conn.execute(query).fetchall()
conn.close()
# shapings = [{'tc': tc_obj, 'timeout': 123456}, ... ]
shapings = []
for result in results:
s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getConnectionTime(probe,since=None):\n\ttry:\n\t\tresult = {}\n\t\t\t\t\n\t\tconnectionResults = ProbeConnectionResult.objects.filter(test__log__probe = probe).prefetch_related('timecheck_set')\n\t\tif since != None:\n\t\t\tconnectionResults = connectionResults.filter(date__gte=since)\n\n\t\tssids = set(connec... | [
"0.5754736",
"0.55170316",
"0.54215854",
"0.52672046",
"0.5189539",
"0.5179965",
"0.5162168",
"0.5150871",
"0.5091114",
"0.5085517",
"0.5053782",
"0.50338143",
"0.50289965",
"0.5020709",
"0.5008953",
"0.5006596",
"0.49898326",
"0.49799904",
"0.49670634",
"0.49581826",
"0.4955... | 0.490537 | 26 |
Test that pulling of debian native packages works | def test_pull_explicit_remote(self, repo):
dest = os.path.join(self._tmpdir, 'cloned_repo')
clone(['arg0', repo.path, dest])
cloned = ComponentTestGitRepository(dest)
self._check_repo_state(cloned, 'master', ['master'])
eq_(pull(['argv0', 'origin']), 0)
assert len(repo.ge... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_download_linux(salt_test_command, pkg_container, root_url, salt_release):\n res = pkg_container.container.run(salt_test_command)\n assert res.returncode == 0",
"def test_get_rpms_in_external_repo(mock_makedirs, mock_dnf_base):\n RPM = namedtuple(\"RPM\", [\"arch\", \"epoch\", \"name\", \"releas... | [
"0.654571",
"0.64206904",
"0.631205",
"0.6275644",
"0.6266007",
"0.61789083",
"0.6118366",
"0.6115174",
"0.60432506",
"0.60055846",
"0.59587467",
"0.5954195",
"0.5938046",
"0.59331083",
"0.5919058",
"0.59029514",
"0.58995456",
"0.5886596",
"0.5878436",
"0.584673",
"0.58319265... | 0.0 | -1 |
Test that pulling of debian native packages works | def test_pull_default_remote(self, repo):
dest = os.path.join(self._tmpdir, 'cloned_repo')
clone(['arg0', repo.path, dest])
cloned = ComponentTestGitRepository(dest)
self._check_repo_state(cloned, 'master', ['master'])
eq_(pull(['argv0']), 0)
assert len(repo.get_commits()... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_download_linux(salt_test_command, pkg_container, root_url, salt_release):\n res = pkg_container.container.run(salt_test_command)\n assert res.returncode == 0",
"def test_get_rpms_in_external_repo(mock_makedirs, mock_dnf_base):\n RPM = namedtuple(\"RPM\", [\"arch\", \"epoch\", \"name\", \"releas... | [
"0.6546456",
"0.6420844",
"0.6313209",
"0.6276825",
"0.62671494",
"0.61788535",
"0.6118443",
"0.6115961",
"0.6044262",
"0.60066915",
"0.5959526",
"0.59548897",
"0.5938736",
"0.5934302",
"0.59197736",
"0.5903306",
"0.58999807",
"0.58880717",
"0.5879673",
"0.5848288",
"0.583314... | 0.0 | -1 |
Implement signal generation method | def generateSignal(self, input):
raise NotImplementedError("generateSignals() not implemented!") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_signals(self):\n\n raise NotImplementedError('''\n Must implement generate_signals. Call help() for details.\n ''')",
"def _generate_signal(self):\n x = np.arange(self.n, dtype='float')\n resample = np.random.rand(self.n) >= self.proba\n resample[0] = Tr... | [
"0.70712364",
"0.685625",
"0.6824514",
"0.67229414",
"0.66387045",
"0.64469135",
"0.6422895",
"0.63325095",
"0.630998",
"0.62810314",
"0.61788267",
"0.6141524",
"0.60813624",
"0.6066498",
"0.6045314",
"0.6020478",
"0.60055816",
"0.59975064",
"0.599733",
"0.59551203",
"0.59359... | 0.77800155 | 0 |
Examples to run this script | def main():
input_video = sys.argv[1]
input_audio = sys.argv[2]
output_video = sys.argv[3]
set_audio(input_video, input_audio, output_video) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def examples():\n script = \"DFT: Performs a Density Functional Theory .\"\n explain = (\"This code produces a numerical solution for the energy of a system of \"\n \"atoms.\")\n contents = [((\"Find the charge density for a sc cell with lattice parameter of 6 \"\n \"with 4 ... | [
"0.7200266",
"0.7133502",
"0.6964735",
"0.6952409",
"0.6941993",
"0.6908678",
"0.6896632",
"0.6867165",
"0.6867165",
"0.6867165",
"0.6867165",
"0.6814864",
"0.6543554",
"0.6504114",
"0.6484388",
"0.6484388",
"0.646267",
"0.64583576",
"0.64355856",
"0.64224166",
"0.6421345",
... | 0.0 | -1 |
Return all valid assignment statuses | def valid() -> List[str]:
return [
AssignmentState.CREATED,
AssignmentState.LAUNCHED,
AssignmentState.ASSIGNED,
AssignmentState.COMPLETED,
AssignmentState.ACCEPTED,
AssignmentState.MIXED,
AssignmentState.REJECTED,
As... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_assignment_completion_status(self, assignments):\n\n status_summary = {}\n\n for a in assignments:\n project_id = a.project_id\n user_id = a.user_id\n lof_labels_for_assignment = self._get_users_labels_for_assignment(project_id,\n ... | [
"0.70143026",
"0.6910826",
"0.6844077",
"0.68170166",
"0.68170166",
"0.6687421",
"0.6442801",
"0.6300295",
"0.62620544",
"0.62461126",
"0.6133815",
"0.6131959",
"0.609542",
"0.6061567",
"0.60590816",
"0.60590816",
"0.5903232",
"0.5902111",
"0.5862888",
"0.5786772",
"0.5783396... | 0.7898887 | 0 |
Return all statuses that are considered incomplete | def incomplete() -> List[str]:
return [
AssignmentState.CREATED,
AssignmentState.LAUNCHED,
AssignmentState.ASSIGNED,
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stalled(self):\n oneHourAgo = datetime.today() - timedelta(hours = 1)\n return self.filter(status=m.Update.IN_PROGRESS, requestedAt__lte=oneHourAgo)",
"def valid_statuses(self):\n return [\n \"dish_maintenance\",\n \"dish_ok\",\n \"RF_maintenance\",\n ... | [
"0.64917",
"0.6279671",
"0.62576777",
"0.6151896",
"0.61158884",
"0.61158884",
"0.6105256",
"0.58749634",
"0.5759064",
"0.5759049",
"0.57464796",
"0.5656729",
"0.5593512",
"0.5588268",
"0.55776554",
"0.55524373",
"0.5532122",
"0.55231184",
"0.54844177",
"0.5471768",
"0.546771... | 0.6704028 | 0 |
Return all statuses that should be considered spent budget | def payable() -> List[str]:
return [
AssignmentState.LAUNCHED,
AssignmentState.ASSIGNED,
AssignmentState.COMPLETED,
AssignmentState.ACCEPTED,
AssignmentState.SOFT_REJECTED,
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_budgets(self) -> list:\n return list(self.budgets.values())",
"def get_budgets(self) -> list:\n return self.budget_manager.get_budgets()",
"def get_expenses(budget):\n return sum(expense['bgt'] for expense in budget['spend'])",
"def goalStatus(self, fromdt, todt):\r\n ret = {}\r\n... | [
"0.6197711",
"0.5866314",
"0.58636606",
"0.5837114",
"0.5803818",
"0.57145053",
"0.5618266",
"0.5618266",
"0.557279",
"0.55300575",
"0.5525475",
"0.5521347",
"0.549343",
"0.544975",
"0.54426533",
"0.5441119",
"0.54360914",
"0.5415565",
"0.54076195",
"0.5386957",
"0.5374891",
... | 0.0 | -1 |
Return all statuses that are valids for a Unit | def valid_unit() -> List[str]:
return [
AssignmentState.CREATED,
AssignmentState.LAUNCHED,
AssignmentState.ASSIGNED,
AssignmentState.COMPLETED,
AssignmentState.ACCEPTED,
AssignmentState.REJECTED,
AssignmentState.SOFT_REJECTED,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def valid_statuses(self):\n return [\n \"dish_maintenance\",\n \"dish_ok\",\n \"RF_maintenance\",\n \"RF_ok\",\n \"digital_maintenance\",\n \"digital_ok\",\n \"calibration_maintenance\",\n \"calibration_ok\",\n ... | [
"0.656063",
"0.5927815",
"0.5911592",
"0.5833105",
"0.58151245",
"0.57673633",
"0.5725099",
"0.5665793",
"0.5665793",
"0.5660064",
"0.55945444",
"0.553925",
"0.55057263",
"0.5491091",
"0.54821205",
"0.54818356",
"0.5468045",
"0.5451015",
"0.5422831",
"0.54221743",
"0.536189",... | 0.7242456 | 0 |
Return all statuses that are terminal for a Unit | def final_unit() -> List[str]:
return [
AssignmentState.ACCEPTED,
AssignmentState.EXPIRED,
AssignmentState.SOFT_REJECTED,
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_status():\n return \"\"",
"def all_status_strings(cls):\n return [info[1] for info in cls._STATUS_INFO]",
"def get_statuses(self):\n return self.statuses",
"def available_statuses(self):\n return self.pipeline.get(self.status, ())",
"def available_statuses(self):\n ... | [
"0.64170635",
"0.636362",
"0.6179687",
"0.6164907",
"0.6164907",
"0.615675",
"0.6095279",
"0.60594827",
"0.60594827",
"0.5980172",
"0.5957454",
"0.5952193",
"0.594075",
"0.5914528",
"0.59069455",
"0.59009343",
"0.5834746",
"0.5790579",
"0.5789686",
"0.5777166",
"0.57682526",
... | 0.5450325 | 49 |
Return all statuses that denote a unit having been completed | def completed() -> List[str]:
return [
AssignmentState.COMPLETED,
AssignmentState.ACCEPTED,
AssignmentState.REJECTED,
AssignmentState.SOFT_REJECTED,
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def final_unit() -> List[str]:\n return [\n AssignmentState.ACCEPTED,\n AssignmentState.EXPIRED,\n AssignmentState.SOFT_REJECTED,\n ]",
"def get_completed_outputs(self):\n return [o for o in self.get_outputs() if o.get_status() == Constants.DONE]",
"def get... | [
"0.67235607",
"0.6332416",
"0.62031937",
"0.61352724",
"0.6079362",
"0.6010533",
"0.5997141",
"0.59853554",
"0.5900161",
"0.5900161",
"0.5868536",
"0.5863787",
"0.5846556",
"0.5814982",
"0.5788143",
"0.5734089",
"0.57160795",
"0.5701123",
"0.5682662",
"0.5680916",
"0.56778914... | 0.619753 | 3 |
Return all statuses that are terminal changes to a Unit's agent | def final_agent() -> List[str]:
return [
AssignmentState.COMPLETED,
AssignmentState.ACCEPTED,
AssignmentState.REJECTED,
AssignmentState.SOFT_REJECTED,
AssignmentState.EXPIRED,
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_statuses(self):\n return self.statuses",
"def all_statuses(cls):\n return list(cls.pipeline.keys())",
"def all_statuses(cls):\n return list(cls.pipeline.keys())",
"def all_status_strings(cls):\n return [info[1] for info in cls._STATUS_INFO]",
"def available_statuses(self... | [
"0.6090644",
"0.606578",
"0.606578",
"0.602715",
"0.6008285",
"0.6008285",
"0.5971154",
"0.59391505",
"0.5897747",
"0.5881984",
"0.5844441",
"0.5834486",
"0.5834267",
"0.58058405",
"0.5776367",
"0.5741957",
"0.5713715",
"0.57072484",
"0.56672096",
"0.5628539",
"0.5623949",
... | 0.54473484 | 33 |
Returns the rendered template in HTML format of the main page of the website for the GET request along the path "/" or "index.html". Returns Any | def index() -> Any:
return render_template("index.html") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main_page():\n return render_template(\"index.html\")",
"def get(self):\n return render_template(\"index.html\")",
"def get(self):\n template = Constants.JINJA_ENVIRONMENT.get_template('homepage.html')\n self.response.headers['Content-Type'] = 'text/html'\n self.response.writ... | [
"0.7773576",
"0.7701407",
"0.76876473",
"0.75099677",
"0.7498149",
"0.7437251",
"0.7437251",
"0.7436899",
"0.7420055",
"0.7402748",
"0.7386607",
"0.7386607",
"0.7386607",
"0.73803544",
"0.73803544",
"0.73736036",
"0.734291",
"0.7334071",
"0.73024625",
"0.72956324",
"0.7279382... | 0.7218152 | 25 |
Returns the site icon for the GET request along the path "/favicon.ico". Returns Any | def favicon() -> Any:
return send_from_directory(os.path.join(app.root_path, "static"),
"favicon.ico", mimetype="image/png") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_favicon(self): \n favurl = \"%s://%s/favicon.ico\" % (self.urlparts.scheme, self.domain)\n r = requests.get(favurl)\n if r:\n return favurl\n else:\n return \"\"",
"async def api_favicon(self):\n # SECURITY: We control the path of the file so ... | [
"0.79970914",
"0.75161207",
"0.7465618",
"0.74292725",
"0.74158657",
"0.73389995",
"0.73227185",
"0.72797966",
"0.72470355",
"0.72041726",
"0.7127063",
"0.7098606",
"0.6974032",
"0.6884807",
"0.6819414",
"0.66975546",
"0.6694368",
"0.64336145",
"0.64245147",
"0.6389769",
"0.6... | 0.7102287 | 11 |
Prepares the file (image) to be sent for segmentation. | def prepare_input(image) -> Optional[np.ndarray]:
try:
array = np.array(Image.open(image))
if len(array.shape) != 3 or (array.shape[2] != 3):
return None
return array
except Exception as e:
print(e, file=sys.stderr)
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(self):\n meta_file_path = os.path.join(database_directory, 'data.txt')\n meta = pd.read_csv(meta_file_path, delimiter=' ', header=None)\n meta = meta[meta[0] != '45567.jpg'] # Corrupt image.\n meta.to_pickle(os.path.join(database_directory, 'meta.pkl'))\n for file... | [
"0.6084572",
"0.59575695",
"0.5840077",
"0.583626",
"0.5746459",
"0.57462585",
"0.5689625",
"0.5584192",
"0.55820864",
"0.5489294",
"0.54305816",
"0.5362292",
"0.53555655",
"0.5353772",
"0.5340276",
"0.5322325",
"0.5318856",
"0.53078175",
"0.5304188",
"0.5268499",
"0.5263105"... | 0.0 | -1 |
Prepares the image for sending to the client by converting it to text format. | def prepare_output(image: np.ndarray) -> str:
response_image = Image.fromarray(np.uint8(image * 255))
buffer = BytesIO()
response_image.save(buffer, "PNG")
encoded = base64.b64encode(buffer.getvalue())
return "data:image/png;base64," + str(encoded)[2:-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _prep_msg(self, msg):\r\n self.msg_image = self.font.render(\r\n msg, True, self.text_color, self.button_color)\r\n self.msg_image_rect = self.msg_image.get_rect()\r\n self.msg_image_rect.center = self.rect.center",
"def prep_msg(self, msg):\r\n\t\tself.msg_image = self.font.r... | [
"0.65707946",
"0.6427434",
"0.6427434",
"0.6412722",
"0.63966095",
"0.62622935",
"0.61812085",
"0.60693014",
"0.5919003",
"0.58565766",
"0.5826771",
"0.581563",
"0.58148193",
"0.5772711",
"0.5729759",
"0.5698953",
"0.56830406",
"0.5657847",
"0.56474227",
"0.5642789",
"0.56408... | 0.60236084 | 8 |
Processes a POST request for image segmentation and processes it based on the received request parameters. Returns Any | def predict() -> Any:
threshold = request.form.get("threshold", type=float)
source_size = request.form.get("source_size", type=bool)
images = request.files.getlist("images")
result = {}
for image in images:
input_image = prepare_input(image)
if input_image is not None:
ou... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def input_handler(data, context):\n if context.request_content_type == 'application/x-image':\n payload = data.read()\n\n img = Image.open(io.BytesIO(payload))\n img = img.convert('RGB')\n img = img.resize((IMG_SIZE, IMG_SIZE), Image.NEAREST)\n img_array = image.img_to_array(i... | [
"0.6971213",
"0.655263",
"0.63524324",
"0.61500496",
"0.61297464",
"0.60867846",
"0.6001201",
"0.59744674",
"0.5959857",
"0.5941481",
"0.58751166",
"0.58427125",
"0.5840908",
"0.57562405",
"0.5677892",
"0.56442463",
"0.5642099",
"0.56363547",
"0.5599171",
"0.55561036",
"0.555... | 0.5706896 | 14 |
The function is executed after each request and allows the client access to resources. | def after_request(response: Response) -> Response:
response.headers.add("Access-Control-Allow-Origin", "*")
response.headers.add("Access-Control-Allow-Headers", "Content-Type,Authorization")
response.headers.add("Access-Control-Allow-Methods", "GET,PUT,POST,DELETE")
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _after_serve_actions(self):\n pass",
"def _handle_first_request(self):\n pass",
"def request_access(self):\n pass",
"def preRun_(self):\n super().preRun_()\n self.client = None",
"def resources(self):",
"async def _response_handler(self):",
"def authorizeClients(s... | [
"0.6888452",
"0.6410466",
"0.60665774",
"0.6043423",
"0.59470767",
"0.5932155",
"0.5909394",
"0.5878597",
"0.5843578",
"0.5820882",
"0.58163774",
"0.5806532",
"0.57784736",
"0.57709193",
"0.5765497",
"0.5747301",
"0.573821",
"0.5729589",
"0.57053524",
"0.56958234",
"0.5678566... | 0.0 | -1 |
Returns if the next K elements exists in a list given a NODE | def is_group_valid(node, k):
counter = 0
while node.next is not None and counter < k:
node = node.next
counter += 1
return counter == k | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_element_of(node, lst):\n for k in lst:\n if node is k:\n return True\n return False",
"def my_func(k: int, lst: List) -> bool:\n\n if not len(lst) > 0:\n raise ValueError(\"Parameter 'lst' must have at least 2 elements\")\n\n try:\n for x in lst:\n fo... | [
"0.69980997",
"0.64902776",
"0.64226055",
"0.61012685",
"0.60695064",
"0.6065002",
"0.60114795",
"0.5890691",
"0.588333",
"0.5854959",
"0.58148426",
"0.57728654",
"0.577021",
"0.57222736",
"0.57114935",
"0.57027185",
"0.57027185",
"0.5697907",
"0.5697862",
"0.56517047",
"0.56... | 0.65423954 | 1 |
Reverses a group of length K given a GROUP_HEAD, returning the new HEAD, new TAIL, and the next element that was detached. | def reverse_group(group_head, k):
counter = 0
group_head.next = None
previous_node = group_head
next_node = previous_node.next_node
while counter < k:
new_next_node = new_node.next
next_node.next = previous_node
previous_node = next_node
next_node = new_next_node
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reverseList(head, k) :\n\n ptr = head\n new_head = None\n new_tail = None\n \n num_reverse = (n % k) if (n%k) != 0 else k\n while ptr :\n \n left_portion_start = ptr\n \n i = 1\n while ptr.next and i < num_reverse :\n ptr = ptr.next\n i... | [
"0.5858687",
"0.56919616",
"0.56714123",
"0.54803526",
"0.546783",
"0.52534944",
"0.519177",
"0.51836807",
"0.5168894",
"0.5149832",
"0.51307",
"0.51258576",
"0.5063978",
"0.5059032",
"0.505075",
"0.50137126",
"0.50092584",
"0.50075793",
"0.498712",
"0.496472",
"0.4932703",
... | 0.8169252 | 0 |
Sorts records for fetch_state method fetch_state is expecting these records to be ordered from newest to oldest | def sort_records(records):
return sorted(records, key=lambda r: r.value.event.datetime, reverse=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sort_records(self):\n self.records.sort(reverse=True, key=lambda record: record.timestamp)",
"def sort_results(self):\n pass",
"def sortby(self):\n ...",
"def orderby():\n pass",
"def _sort(self, row):\n if not self._head:\n self._head = self._create_head(row)... | [
"0.68760866",
"0.65122795",
"0.621062",
"0.6098413",
"0.5909024",
"0.5905206",
"0.5877997",
"0.57966155",
"0.5737469",
"0.5735158",
"0.57189",
"0.5637238",
"0.5595025",
"0.55897605",
"0.558635",
"0.5570938",
"0.5564488",
"0.5541713",
"0.55372554",
"0.5536486",
"0.5525967",
... | 0.64857996 | 2 |
ensure we handle different styles of host_port specifications correctly | def test_host_port_parsing() -> None:
examples = [
"http://localhost:9200",
"https://localhost:9200",
"localhost:9300",
"localhost",
"http://localhost:3400",
"192.168.0.1",
"192.168.0.1:9200",
"http://192.168.2.1",
"https://192.168.0.1:9300",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_parse_host_port(self):\n # test default port for http\n endpoint = \"1.2.3.4\"\n default_protocol = baidubce.protocol.HTTP\n ret_protocol, host, port = utils.parse_host_port(endpoint, default_protocol)\n self.assertEqual(ret_protocol, baidubce.protocol.HTTP)\n sel... | [
"0.73706514",
"0.69666415",
"0.6963635",
"0.6923132",
"0.68688023",
"0.677662",
"0.67610186",
"0.672299",
"0.6717529",
"0.66561246",
"0.6630539",
"0.6600969",
"0.65933025",
"0.65751106",
"0.65122914",
"0.64998335",
"0.6483765",
"0.63974476",
"0.6387543",
"0.63678545",
"0.6342... | 0.64203054 | 17 |
Compute the cross entropy loss given outputs and labels. | def loss_fn(outputs, labels):
return nn.CrossEntropyLoss()(outputs, labels) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cross_entropy_loss(outputs, labels): \n# works properly\n \n m = labels.shape[0]\n p = outputs\n log_likelihood = -1*torch.log(p[range(m),labels])\n loss = torch.sum(log_likelihood) / m\n return loss.item()",
"def loss_fn(outputs, labels, wts):\n\n # reshape labels to give a flat vecto... | [
"0.8123369",
"0.78822637",
"0.78552246",
"0.76500595",
"0.76134384",
"0.7363692",
"0.73583025",
"0.73449636",
"0.7331515",
"0.7310738",
"0.72997314",
"0.7284572",
"0.7263381",
"0.7261452",
"0.7139764",
"0.71252644",
"0.71147245",
"0.7082844",
"0.707002",
"0.7058059",
"0.70415... | 0.8459237 | 0 |
Compute the accuracy, given the outputs and labels for all images. | def accuracy(outputs, labels):
outputs = np.argmax(outputs, axis=1)
return np.sum(outputs==labels)/float(labels.size) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def accuracy(outputs, labels):\n predicted = outputs.argmax(dim=1)\n correct = (predicted == labels).sum().item()\n return correct / labels.size(0)",
"def accuracy(outputs, labels):\n outputs = np.argmax(outputs, axis=1)\n return np.sum(outputs == labels) / float(labels.size)",
"def accuracy(out... | [
"0.8425722",
"0.83553445",
"0.8349379",
"0.8345116",
"0.81717366",
"0.80323327",
"0.8018599",
"0.7950924",
"0.7903909",
"0.7850474",
"0.7824042",
"0.7801253",
"0.77871346",
"0.7722627",
"0.7703765",
"0.7697583",
"0.76889527",
"0.7661256",
"0.76277435",
"0.7615854",
"0.7610093... | 0.83619267 | 2 |
Demonstrate configuring an AWS KMS discoverylike keyring a particular AWS region and failover to others. | def run(aws_kms_cmk, source_plaintext):
# type: (str, bytes) -> None
# Prepare your encryption context.
# Remember that your encryption context is NOT SECRET.
# https://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/concepts.html#encryption-context
encryption_context = {
"encrypti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect_from_conf(aws_conf):\n aws_access_key = config.get(aws_conf,'access_key','')\n aws_secret_key = config.get(aws_conf,'secret_key','')\n aws_region = config.get(aws_conf, 'region','')\n\n return {\n 'ec2':\n boto.ec2.connect_to_region(\n region_name = aws_region,\n aws_access_key_id... | [
"0.60066545",
"0.5716527",
"0.5659477",
"0.558825",
"0.5491737",
"0.54010624",
"0.5273491",
"0.52714884",
"0.51753235",
"0.5171362",
"0.503142",
"0.50292635",
"0.501804",
"0.5014415",
"0.49773937",
"0.4953896",
"0.4916813",
"0.48963338",
"0.48947433",
"0.4876656",
"0.48352057... | 0.46199822 | 46 |
Get user to authenticate. | def get_user(self):
if "user" not in self._data:
self._data["user"] = User.objects.get(pk=self.kwargs["user_id"])
return self._data["user"] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getUser(self):\n user = users.get_current_user()\n if not user:\n self.redirect(users.create_login_url(self.request.uri))\n else:\n return user",
"def get_user(self):\n\n user_session = self.get()\n if not user_session:\n return None\n\n us = ServiceLocator.... | [
"0.8123508",
"0.8005101",
"0.79044837",
"0.79044837",
"0.7888709",
"0.7852747",
"0.7719708",
"0.7672492",
"0.7597761",
"0.75580394",
"0.7552152",
"0.7516508",
"0.74907863",
"0.7489541",
"0.7483551",
"0.74748856",
"0.747313",
"0.74607813",
"0.7458102",
"0.74417126",
"0.7425163... | 0.71351135 | 44 |
Return all approved jobs. | def get_queryset(self):
jobs = Job.objects.all()
if not self.kwargs.get("pk"):
jobs = jobs.filter(
status=choices.APPROVED, submission_deadline__gte=datetime.today()
).order_by("-created_at")
if not self.request.user.is_anonymous():
# i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def approved_jobs(self):\n\n return Job.objects.filter(\n house=self.house,\n approved=True,\n )",
"def get(self):\n # TODO: auth\n return list(self.app.db.jobs.find())",
"def get_jobs(self):\n return list(self._jobs.values())",
"def jobs(self):\n ... | [
"0.8423612",
"0.6918933",
"0.68650305",
"0.6849823",
"0.6733432",
"0.6682889",
"0.66028017",
"0.6548614",
"0.6484468",
"0.64795184",
"0.64795184",
"0.64699847",
"0.6453018",
"0.64463496",
"0.64217526",
"0.63939035",
"0.63658416",
"0.63469434",
"0.63382804",
"0.62918526",
"0.6... | 0.6868619 | 2 |
Create and store image if present. | def create(self, request, *args, **kwargs):
if request.data.get("audition_range"):
if not (
request.data["audition_range"].get("lower")
and request.data["audition_range"].get("upper")
):
raise ValidationError(
"Audition ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_image(self, path):\n\t\treturn None",
"def init_image_info():\n if not os.path.exists(UPLOAD_FOLDER):\n os.makedirs(UPLOAD_FOLDER)",
"def add_image(self, image):\r\n metadata = self.collection.find_one( { \"_id\": image.identifier } )\r\n if metadata:\r\n raise Image... | [
"0.7149512",
"0.6749277",
"0.6722661",
"0.6690721",
"0.6631919",
"0.6602101",
"0.6598603",
"0.6576423",
"0.65016603",
"0.6495591",
"0.6426691",
"0.63978994",
"0.6382946",
"0.63492",
"0.6312564",
"0.6279855",
"0.62750727",
"0.6258959",
"0.6241422",
"0.6241246",
"0.6229668",
... | 0.0 | -1 |
Sort by natural keys like humans do. | def _natural_key_sort(string_to_sort):
return [int(s) if s.isdigit() else s for s in re.split(r'(\d+)', string_to_sort)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def natural_sorted(iterable, key=None, reverse=False):\n prog = re.compile(r\"(\\d+)\")\n\n def alphanum_key(element):\n \"\"\"Split given key in list of strings and digits\"\"\"\n return [int(c) if c.isdigit() else c for c in prog.split(element[0])]\n\n return sorted(iterable, key=alphanum_... | [
"0.7241791",
"0.72414905",
"0.7165252",
"0.714794",
"0.7144302",
"0.7127257",
"0.69953287",
"0.6937837",
"0.6937837",
"0.6929218",
"0.68815076",
"0.68514144",
"0.6846641",
"0.68061537",
"0.6733701",
"0.6701501",
"0.66959745",
"0.66778487",
"0.6677466",
"0.6673203",
"0.6665935... | 0.6931419 | 9 |
Return true if in service mode. | def is_in_service(self) -> bool:
return self._enabled | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __some_alive(self):\n for service in self.__services.values():\n if service.is_alive():\n return True\n return False",
"def _interesting_service(self, service: UpnpService) -> bool:\n service_type = service.service_type\n for service_types in self._SERVIC... | [
"0.6862805",
"0.6793361",
"0.67728746",
"0.6701036",
"0.66946507",
"0.66204697",
"0.65540534",
"0.6552107",
"0.6548141",
"0.65428823",
"0.6535179",
"0.6533675",
"0.6501911",
"0.6458908",
"0.6420852",
"0.6314876",
"0.63050145",
"0.6295161",
"0.62929493",
"0.62170863",
"0.62095... | 0.812418 | 0 |
Add an alert about a technical problem. | def add_technical_alert(self, device, issue):
del device
del issue
# this is prepared but not yet implemented in service mode | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def requestAlert(self, text=\"Error\", buttons=None):\n\t\tself.alerts.append((text, buttons))",
"def add_alerts(self):",
"def add_alert(self, content):\n self._add_content(html_alert(content))",
"def send_alert(self, level, title, additional_data):\n\n full_title = \"{}: {}\".format(self.build... | [
"0.61283493",
"0.5944216",
"0.56979954",
"0.56085527",
"0.55186415",
"0.5486692",
"0.539759",
"0.5389057",
"0.5285975",
"0.5193649",
"0.5193604",
"0.5187262",
"0.5168358",
"0.5166665",
"0.5079088",
"0.50631",
"0.50447834",
"0.5036596",
"0.50321543",
"0.5027627",
"0.50111544",... | 0.726797 | 0 |
Return a map of all switches in the machine. | def get_switch_map(self, do_sort=True):
switch_map = []
for switch in self.machine.switches.values():
switch_map.append(SwitchMap(switch.hw_switch.get_board_name(), switch))
# sort by board + driver number
if do_sort:
switch_map.sort(key=lambda x: (self._natural_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def switches(self) -> List[dict]:\n return self.items_by_domain(\"switch\")",
"def switches(self):\n return {k:v for k, v in self._data.items() \n if v[\"type\"] == \"SWITCH\"}",
"async def get_hw_switch_states(self) -> Dict[str, bool]:\n raise NotImplementedError",
"d... | [
"0.7777836",
"0.7621708",
"0.7443831",
"0.73941827",
"0.72622395",
"0.7212569",
"0.6953223",
"0.68368125",
"0.6708856",
"0.6657472",
"0.6531701",
"0.65303135",
"0.64049363",
"0.6335255",
"0.61550575",
"0.6124635",
"0.59139466",
"0.57728636",
"0.5758768",
"0.5725718",
"0.56988... | 0.7177897 | 6 |
Return a map of all coils in the machine. | def get_coil_map(self, do_sort=True) -> List[CoilMap]:
coil_map = []
for coil in self.machine.coils.values():
assert coil.hw_driver is not None
coil_map.append(CoilMap(coil.hw_driver.get_board_name(), coil))
# sort by board + driver number
if do_sort:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_cliffs(self):\n cliff_list = Cliff.list()\n rtn = {}\n\n for clf in cliff_list:\n rtn[clf] = self.read_cliff(clf)\n\n return rtn",
"def councils(self):\n catalog = getToolByName(self.context, 'portal_catalog')\n\n return [dict(url=council.getURL(), ti... | [
"0.61735106",
"0.6158383",
"0.6126377",
"0.6033344",
"0.5983551",
"0.59124845",
"0.58763355",
"0.57980853",
"0.57952774",
"0.57756484",
"0.56649864",
"0.5617694",
"0.55903614",
"0.5582277",
"0.5558947",
"0.5551839",
"0.5548989",
"0.55406815",
"0.55191165",
"0.5518905",
"0.549... | 0.6748809 | 0 |
Return a map of all lights in the machine. | def get_light_map(self, do_sort=True) -> List[LightMap]:
light_map = []
for light in self.machine.lights.values():
light_map.append(LightMap(next(iter(light.hw_drivers.values()))[0].get_board_name(), light))
# sort by board + driver number
if do_sort:
light_map.s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lights(self) -> List[dict]:\n return self.items_by_domain(\"light\")",
"def lights(self):\n return list(self.GetLights())",
"def get_light_list(self):\n return self.light_array",
"async def Lights_Description() -> List[Dict[str, Any]]:\n result = []\n for index, light in enumer... | [
"0.77625406",
"0.7692243",
"0.666766",
"0.6640105",
"0.6638155",
"0.66082543",
"0.6484388",
"0.6472033",
"0.64579195",
"0.63853127",
"0.6246505",
"0.6225373",
"0.5922354",
"0.5830553",
"0.5820328",
"0.5761303",
"0.5710284",
"0.57049817",
"0.568536",
"0.5679185",
"0.5666204",
... | 0.7016345 | 2 |
This function responds to a request for /api/movie with the complete lists of movies | def read_all():
# Get the list of movies from our DB
movies = Movie.query.order_by(Movie.movie_id).all()
# Serialize for the response
movie_schema = MovieSchema(many=True)
return movie_schema.dump(movies) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_movies(jwt):\n\n movies = Movie.query.all()\n\n return jsonify({\n 'success': True,\n 'movies': [movie.format() for movie in movies],\n }), 200",
"def get_movies(self, **kwargs):\n self.url = f\"{self.base_url}{self.FILMS_URL}\"\n self.method = \"g... | [
"0.80497384",
"0.7806071",
"0.76628554",
"0.76375085",
"0.7446299",
"0.7426503",
"0.73704696",
"0.7356363",
"0.7258904",
"0.72565234",
"0.72373384",
"0.7051818",
"0.6993698",
"0.69705373",
"0.6852738",
"0.6796348",
"0.67957854",
"0.6794787",
"0.67766225",
"0.67315435",
"0.672... | 0.6311159 | 41 |
This function responds to a request for /api/movie/{movie_id} with one matching movie. | def read_one(**kwargs):
# Get the movie by id
movie_id = kwargs['movie_id']
fields = kwargs.get('fields')
movie = Movie.query.filter(Movie.movie_id == movie_id).one_or_none()
# Did we find a movie?
if movie is not None:
#Intersect supplied fields with Schema defined ones => Receive only... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_movie(movie_id=None):\n movie = [movie for movie in store.data if movie['id'] == int(movie_id)]\n msg = helper.create_message(MSG['movie_not_found'])\n\n return (jsonify(movie=movie[0]), 200) if movie else (jsonify(msg), 404)",
"def get_movie(payload: PayloadJSON, movie_id: int) -> ResourceJSON:... | [
"0.77707213",
"0.7636874",
"0.7499034",
"0.7423642",
"0.7315157",
"0.72396636",
"0.71681803",
"0.7103371",
"0.7078891",
"0.7065013",
"0.6978475",
"0.69712627",
"0.695383",
"0.6861186",
"0.6836065",
"0.6782413",
"0.6756869",
"0.67431486",
"0.67383784",
"0.6677799",
"0.64845866... | 0.70478445 | 10 |
This function creates a new movie record in the DB | def create(movie):
schema = MovieSchema()
new_movie = schema.load(movie, session=db.session)
# Add the new movie record to the database
db.session.add(new_movie)
db.session.commit()
# Return the newly created record in the response
data = schema.dump(new_movie)
return data, 201 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_movie(input_title, input_overview, input_release_date, input_poster_path):\n \n movie = Movie(title=input_title, overview=input_overview, release_date=input_release_date, poster_path=input_poster_path)\n\n db.session.add(movie)\n db.session.commit()\n\n return movie",
"def create_movie(... | [
"0.7874085",
"0.78123325",
"0.76599956",
"0.73156875",
"0.7210305",
"0.720738",
"0.7147179",
"0.7054669",
"0.69906896",
"0.6978543",
"0.69119096",
"0.6850396",
"0.67323774",
"0.6692045",
"0.6638124",
"0.66215795",
"0.65686864",
"0.6558507",
"0.6555675",
"0.6542822",
"0.650204... | 0.8181835 | 0 |
This function updates an existing movie in the database | def update(movie_id, movie):
# Get the movie requested from the db into session
update_movie = Movie.query.filter(
Movie.movie_id == movie_id
).one_or_none()
# Are we trying to find a movie that does not exist?
if update_movie is None:
abort(
404,
"Movie not ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(director_id, movie_id, movie):\n\n uid = movie.get(\"uid\")\n title = movie.get(\"title\")\n\n # validators\n if not((uid or uid==0) and title):\n return \"\",400\n\n update_movie = (\n Movies.query.filter(Directors.id == director_id)\n .filter(Movies.id == movie_id)\... | [
"0.7535328",
"0.7432664",
"0.7139674",
"0.6838955",
"0.6776376",
"0.6612775",
"0.6560875",
"0.6487124",
"0.64318943",
"0.6392981",
"0.63567483",
"0.6219889",
"0.6115629",
"0.6100723",
"0.6053239",
"0.6041352",
"0.6033099",
"0.5974189",
"0.5945165",
"0.5855674",
"0.58400196",
... | 0.74178797 | 2 |
This function deletes a movie from the Database The method will always succeed, because we want idempotent delete | def delete(movie_id):
# Get the movie requested
movie = Movie.query.filter(Movie.movie_id == movie_id).one_or_none()
if movie is not None:
db.session.delete(movie)
db.session.commit()
return "", 200 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_movie():\n id = request.params.get('id')\n mongo_mgr.remove_film_from_user(id, aaa.current_user.id)",
"def test_delete_movie(self):\n # add movie to update -- this functionality requires the executive\n # producer token\n res = self.client().post('/movies', headers={\n ... | [
"0.7769285",
"0.7741501",
"0.77175105",
"0.76620966",
"0.7380153",
"0.7365287",
"0.7278483",
"0.7272325",
"0.71963173",
"0.70115995",
"0.69912124",
"0.69016904",
"0.6759788",
"0.6758979",
"0.6728785",
"0.671315",
"0.6663361",
"0.6526206",
"0.6491936",
"0.6491221",
"0.6486579"... | 0.80962527 | 0 |
Use Bayes' rule for random variables to compute the posterior distribution of a hidden variable X, given N observations Y_0, Y_1, ..., Y_{N1}. Conditioned on X, these observations Y_0, Y_1, ..., Y_{N1} are i.i.d. Hidden random variable X is assumed to take on a value in {0, 1, ..., M1}. Each random variable Y_i takes o... | def compute_posterior(prior, likelihood, y):
# -------------------------------------------------------------------------
# ERROR CHECKS -- DO NOT MODIFY
#
# check that prior probabilities sum to 1
if np.abs(1 - np.sum(prior)) > 1e-06:
exit('In compute_posterior: The prior probabilities nee... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def posterior(self, rnn_hidden, obs):\n hidden_obs = self.hidden_obs(torch.cat([rnn_hidden, obs], dim=-1)) # [batch, hidden]\n poster = self.poster(hidden_obs) # [batch, hidden]\n poster_mean = self.post_mean(poster) # [batch, state]\n # poster_sigma = F.softplus(self.post_sigma(post... | [
"0.5937747",
"0.59187853",
"0.59155023",
"0.591405",
"0.59086555",
"0.5886364",
"0.576593",
"0.5758174",
"0.57571816",
"0.5747239",
"0.56912947",
"0.56840754",
"0.5660271",
"0.5657272",
"0.56493473",
"0.56485134",
"0.5631239",
"0.5609588",
"0.56038404",
"0.56019413",
"0.55819... | 0.5578112 | 21 |
Compute the rating likelihood probability distribution of Y given X where Y is an individual rating (takes on a value in {0, 1, ..., M1}), and X is the hidden true/inherent rating of a movie (also takes on a value in {0, 1, ..., M1}). Please refer to the instructions of the project to see what the likelihood for rating... | def compute_movie_rating_likelihood(M):
# define the size to begin with
likelihood = np.zeros((M, M))
# -------------------------------------------------------------------------
# YOUR CODE GOES HERE FOR PART (c)
#
# Remember to normalize the likelihood, so that each column is a
# probabil... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def infer_true_movie_ratings(num_observations=-1):\n\n M = 11 # all of our ratings are between 0 and 10\n prior = np.array([1.0 / M] * M) # uniform distribution\n likelihood = compute_movie_rating_likelihood(M)\n\n # get the list of all movie IDs to process\n movie_id_list = movie_data_helper.get_... | [
"0.6651372",
"0.64923996",
"0.6368747",
"0.6227888",
"0.60699147",
"0.606234",
"0.6056535",
"0.6044773",
"0.6008728",
"0.5998901",
"0.598668",
"0.5961036",
"0.59381664",
"0.5892908",
"0.58896697",
"0.58854824",
"0.58576494",
"0.5855964",
"0.58468914",
"0.58361566",
"0.5829488... | 0.75495005 | 0 |
For every movie, computes the posterior distribution and MAP estimate of the movie's true/inherent rating given the movie's observed ratings. Input | def infer_true_movie_ratings(num_observations=-1):
M = 11 # all of our ratings are between 0 and 10
prior = np.array([1.0 / M] * M) # uniform distribution
likelihood = compute_movie_rating_likelihood(M)
# get the list of all movie IDs to process
movie_id_list = movie_data_helper.get_movie_id_lis... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_rating(self, movie):\n\n #\n # option 1: SQLAlchemy ORM\n #\n UserMovies = db.aliased(Rating)\n MovieUsers = db.aliased(Rating)\n\n query = (db.session.query(Rating.user_id, Rating.score, UserMovies.score, MovieUsers.score)\n .join(UserMovies, U... | [
"0.6833105",
"0.67717224",
"0.65626323",
"0.62562567",
"0.6245194",
"0.6105975",
"0.60951227",
"0.60900235",
"0.6040918",
"0.5983867",
"0.59045374",
"0.58595026",
"0.5855716",
"0.5835745",
"0.5835745",
"0.58348227",
"0.5734984",
"0.5729565",
"0.57091314",
"0.5681885",
"0.5681... | 0.7685785 | 0 |
Called when the Player object is initialized. You can use this to store any persistent data you want to store for the game. | def __init__(self):
self.transposition = {}
self.currentDepthLimit = 0
self.counter = 0
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\r\n self.players = {}",
"def __init__(self):\n self.games = {} # Dict from gameIDs to game objects. Initially empty.\n self.players = {} # Dict from playerID to player name\n self._version = __version__ # Used in version check during un-pickling\n\n # Log... | [
"0.687386",
"0.6623529",
"0.64238656",
"0.6392974",
"0.63051546",
"0.62751853",
"0.6266884",
"0.62623644",
"0.62329775",
"0.6226287",
"0.62254786",
"0.6207377",
"0.6186291",
"0.6179973",
"0.61705506",
"0.6159125",
"0.6156226",
"0.6151657",
"0.6132384",
"0.61177516",
"0.609563... | 0.0 | -1 |
You're free to implement the move(self, state) however you want. Be run time efficient and innovative. | def move(self, state):
result = None
self.currentDepthLimit = 0
self.transposition = {}
self.counter = 0
while True:
u = float("inf")
v = float("-inf")
self.counter = 0
result = None
self.transposition = {}
for a in state.actions():
new = self.min_value(state.re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self, state):\n raise NotImplementedError(\"Need to implement this method\")",
"def move(self):\n pass",
"def move(self):\n raise NotImplementedError",
"def move(self, move):\n raise NotImplementedError()",
"def play_move(self,state):\n raise AIError(\"Must be im... | [
"0.8853466",
"0.7574632",
"0.7553293",
"0.7552819",
"0.7345882",
"0.7279182",
"0.72217304",
"0.7157332",
"0.7038979",
"0.70239437",
"0.70111984",
"0.70072323",
"0.70054066",
"0.696469",
"0.69503534",
"0.69253767",
"0.690871",
"0.6824246",
"0.6807558",
"0.6804139",
"0.6804139"... | 0.69629246 | 14 |
Evaluates the state for the player with the given row | def evaluate(self, state, my_row):
stoneonmyside = 0.00
stoneonopside = 0.00
result = 0.00
for a in range(0,state.M+1):
stoneonmyside += state.board[a]
for a in range(state.M+1, 2*(state.M)+1):
stoneonopside += state.board[a]
if my_row == 0:
result = (stoneonmyside - stoneonopside) / (2*(state.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(self, state, my_row):\n myStones = 0.0\n opponentStones = 0.0\n for i in range(len(state.board)):\n if my_row == 0:\n if i <= State.M:\n myStones += state.board[i]\n else:\n opponentStones += state.boar... | [
"0.6999296",
"0.6501366",
"0.6476799",
"0.6461873",
"0.6389604",
"0.63032645",
"0.62785196",
"0.62500495",
"0.6232211",
"0.6228227",
"0.6160248",
"0.61407185",
"0.6129514",
"0.59984934",
"0.5966352",
"0.59632826",
"0.59607756",
"0.5958547",
"0.595793",
"0.5954501",
"0.5954304... | 0.654148 | 1 |
Checks newly inited props. | def _testConnectionProps(self, connection):
self.assertEquals(36, len(connection.id))
self.assertEquals(self.channel.name, connection.channel_name)
self.assertTrue(connection.connected)
self.assertFalse(connection.authenticated)
self.assertEquals(None, connection.flex_user)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_properties(self):\r\n for prop in self.mandatory_properties:\r\n if not hasattr(self, prop):\r\n raise NameError(prop)",
"def set_check_props(self, props):\n _api.check_isinstance(dict, props=props)\n if 's' in props: # Keep API consistent with constructo... | [
"0.67081404",
"0.6280929",
"0.62653726",
"0.6081199",
"0.60551053",
"0.5979137",
"0.5961813",
"0.59598356",
"0.5843566",
"0.58019894",
"0.58019894",
"0.58019894",
"0.579083",
"0.5786345",
"0.57684004",
"0.5756698",
"0.5751388",
"0.57487404",
"0.5727648",
"0.57009995",
"0.5695... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.