def __init__(self, server): self.server = server self.deck = createCards() self.table = [] self.clients = [] self.comparator = Comparator() self.rise_client = None
class StrategyCalculator(): def __init__(self, tickerName): self.tickerName = tickerName self.comparator = Comparator(self.tickerName) self.analyser = Analyser(self.tickerName, self.comparator) def inform(self, df): # print("Calculating Strategy for " + str(self.tickerName) + " at " + str(timeStamp) + "...") ### TO-DO: Develop strategies to calculate ## ## Inform Analyser to do the interval Analysis first ## This is before the pseudotrades to ensure no clashes self.analyser.intervalAnalysis(df.head(1)) self.comparator.intervalAnalysis(df.head(1)) indi = ind.Indicator() Results = indi.beginCalc(df, self.tickerName) for i in Results: # print('Indicator: ' + i) # print('Position: ' + str((Results[i])['position'])) if (Results[i])["position"] != 0: self.analyser.PseudoTrade(df, i, Results[i]) ### for testing # self.analyser.PseudoTrade(df,i, Results[i], atr) ### ### END TO-DO # print("Calculated Strategy for " + str(self.tickerName) + " at " + str(timeStamp)) self.comparator.compare(Results, df["date"].values[0])
def __init__(self, number_of_gaussian): self.ng = number_of_gaussian self.gmm = GMM(number_of_gaussian) self.comparator_with_impostor = ComparatorWithImpostor( number_of_gaussian) self.comparator = Comparator(number_of_gaussian) self.cross_validator = CrossValidation(0.3)
def detect_single(self, img, mask): thresholds = [0.4] * 7 thresholds[1] = 0.7 thresholds[2] = 0.3 labels, self.nodes = img_to_nodes(img, mask) self.comparator = Comparator(self.nodes, labels) res = [] for dots in range(6, 0, -1): matches = [] for node in tqdm(self.nodes.values()): matches.append(self.detect_with_node(node, dots)) matches.sort(key=itemgetter(0)) for m in matches: if m[0] > thresholds[dots]: break vis = False for n in m[1]: if n.visited: vis = True if vis: continue pattern = self.comparator.get_pattern(m[1], dots) res.append((find_contours(pattern, 0.5)[0], dots)) print(m[0]) for n in m[2]: print(n.a, end=' ') n.visited = True print(' ') return res
class StrategyCalculator(): def __init__(self, tickerName): self.tickerName = tickerName self.comparator = Comparator(self.tickerName) self.analyser = Analyser(self.tickerName, self.comparator) def inform(self, df): # print("Calculating Strategy for " + str(self.tickerName) + " at " + str(timeStamp) + "...") ### TO-DO: Develop strategies to calculate ## ## Inform Analyser to do the interval Analysis first ## This is before the pseudotrades to ensure no clashes self.analyser.intervalAnalysis(df.head(1)) #1. Calculate ATR for potential trade atr = atrcalc.ATRcalc(df) indi = ind.Indicator() Results = indi.beginCalc(df, self.tickerName, atr) for i in Results: if Results[i] != 0: self.analyser.PseudoTrade(df, i, Results[i], atr) ### for testing # self.analyser.PseudoTrade(df,i, Results[i], atr) ### ### END TO-DO # print("Calculated Strategy for " + str(self.tickerName) + " at " + str(timeStamp)) self.comparator.compare(Results, atr)
def test_string_representation(self): self.assertEqual( repr(Comparator(5, delta=0.1)), "Comparator(5, delta=0.1)", ) self.assertEqual(repr(Comparator(5)), "Comparator(5, delta=1e-07)") self.assertEqual(str(Comparator(5)), "Comparator(5, delta=1e-07)")
def onClicked_CreateNewComparator(self): toAddUids = self.qMainTreev.getSelectedItemUids() if toAddUids: comp = Comparator() for uid in toAddUids: entry = self.compTableModel.ADB.getEntryByUid(uid) comp.addEntry(entry) self.addTab1_new(comp)
def __init__(self, server): self.server = server self.deck = createCards() self.table = [] self.clients = [] self.comparator = Comparator() self.rise_client = None self.bet = 0 self.bank = 0 self.big_blind = 100
def test_arithmetic_and_comparisons_with_comparators(self): five = Comparator(5, delta=0.1) six = Comparator(6, delta=0.1) seven = Comparator(7, delta=0.5) self.assertEqual(five + six, 11.1) self.assertNotEqual(five + six, 11.2) self.assertEqual(five + seven, 12.1) self.assertEqual(five + seven, 12.5) self.assertEqual(seven + five, 12.5) self.assertNotEqual(five + seven, 12.6)
class ComparatorPnml(object): def __init__(self, filename, nfilename=None, max_coef=10, smt_timeout_iter=0, smt_timeout_matrix=0, positive_log=None): self.filename = filename parser = PnmlParser(filename) parser.parse() self.net = parser.petrinet self.dim = parser.dim self.event_dictionary = parser.event_dictionary self.positive_log = positive_log # Helper pach. Doesn't actually compute hull self.pach = PacH(filename, nfilename=nfilename) self.pach.event_dictionary = parser.event_dictionary self.pach.dim = self.dim self.pach.reversed_dictionary = rotate_dict(parser.event_dictionary) if nfilename: self.pach.parse_negatives() #qhull = self.net.get_qhull() # TODO WTF!? qhull = self.net.get_qhull(neg_points=self.pach.npv_set) qhull.prepare_negatives() # Hull for NO SMT qhull_no_smt = copy.deepcopy(qhull) # Hull for SMT iterative simp qhull_smt_iter = copy.deepcopy(qhull) # Hull for SMT matrix simp qhull_smt_matrix = qhull self.comparator = Comparator(qhull_no_smt, qhull_smt_iter, qhull_smt_matrix, max_coef, smt_timeout_iter, smt_timeout_matrix) def generate_pnml(self): output_pnml = self.filename output_pnml = (output_pnml.endswith('.pnml') and output_pnml[:-5])\ or output_pnml or '' return self.comparator.generate_pnml(filename=output_pnml, reversed_dictionary=self.pach.reversed_dictionary) def compare(self): return self.comparator.compare() def generate_outputs(self): # For every benchmark, generate the output return self.comparator.generate_outputs(pach=self.pach) def check_hull(self): if self.positive_log: return self.comparator.check_hull(log_file=self.positive_log, event_dictionary=self.event_dictionary)
def setComparatorToShow(self, cp): if cp: self.comp = Comparator() # The one to be modified self.originalComp = cp # The pointer to the original Comparator self.comp.updateFromGiven(cp) srcModel = SourceArticleDBModel(self.comp) self.qCompViewer.setSourceModel(srcModel) self.qCompViewer.loadHeaderState() self.compNameLineEdit.setText(self.comp.name) self.compCommentText.setPlainText(self.comp.comment)
def test_addition_and_subtraction(self): self.assertEqual(Comparator(5, delta=0.1) + 6, 11.1) self.assertEqual(6 + Comparator(5, delta=0.1), 10.9) self.assertNotEqual(Comparator(5, delta=0.1) + 6, 11.2) self.assertNotEqual(6 + Comparator(5, delta=0.1) + 6, 10.8) self.assertEqual(Comparator(7, delta=0.1) - 6, 1.05) self.assertNotEqual(Comparator(7, delta=0.1) - 6, 1.2) self.assertEqual(7 - Comparator(7, delta=0.1), 0.05) self.assertNotEqual(7 - Comparator(7, delta=0.1), 0.11) self.assertEqual(6 - Comparator(7, delta=0.1), -1.05)
def __init__(self, filename, nfilename=None, max_coef=10, smt_timeout_iter=0, smt_timeout_matrix=0, positive_log=None): self.filename = filename parser = PnmlParser(filename) parser.parse() self.net = parser.petrinet self.dim = parser.dim self.event_dictionary = parser.event_dictionary self.positive_log = positive_log # Helper pach. Doesn't actually compute hull self.pach = PacH(filename,nfilename=nfilename) self.pach.event_dictionary = parser.event_dictionary self.pach.reversed_dictionary = rotate_dict(parser.event_dictionary) self.pach.parse_negatives() qhull = self.net.get_qhull() # Hull for NO SMT qhull_no_smt = copy.deepcopy(qhull) # Hull for SMT iterative simp qhull_smt_iter = copy.deepcopy(qhull) # Hull for SMT matrix simp qhull_smt_matrix = copy.deepcopy(qhull) self.comparator = Comparator(qhull_no_smt, qhull_smt_iter, qhull_smt_matrix, max_coef, smt_timeout_iter, smt_timeout_matrix)
def detect_objects(): global previous_objects, appLogger detector = Detector() comp = Comparator(detector) while True: detected_objects = detector.process_next_frame() print("[Detection Stage] Done") if not previous_objects: previous_objects = detected_objects else: print("[Looking for changes - Tracking Stage]") print( comp.compare_objects_lists(previous_objects, detected_objects)) previous_objects = detected_objects detector.show_frame() time.sleep(DELAY)
def bmh_matcher(t,p): table = make_table(p) c = Comparator() results = [] i = 0 while i < len(t): try: first = t[i+len(p)] except IndexError: return results, c for j in range(len(p)-1,-1,-1): if not c.compare(p,j,t,i+j): i += table[first] break elif j == 0: results.append(i) i+=table[first] return results, c
def test_1(): ref_file = open('./tests/data/input/optimization1.out.json', 'r', encoding="utf-8") comp_file = open('./tests/data/input/optimization2.out.json', 'r', encoding="utf-8") ref_content = json.loads(ref_file.read()) comp_content = json.loads(comp_file.read()) ref_file.close() comp_file.close() comp = Comparator(ref_content, comp_content) comp_results = comp.compare() assert isinstance(comp_results, List) assert len(comp_results) == 3 # First result res = comp_results[0] assert isinstance(res, TestResult) assert res.file_path == '/home/evaluation/evaluation/pub/bench/lorem/ipsum/1' exit_diff = res.exit_diff assert isinstance(exit_diff, Diff) assert exit_diff.label == 'Exit value' assert exit_diff.reference == 4 assert exit_diff.value == 2 assert exit_diff.diff == -2 assert exit_diff.variation == -50 diffs = res.diffs assert isinstance(diffs, List) assert len(diffs) == 2 diff_bound = diffs[0] assert diff_bound.label == 'bound' assert diff_bound.reference == 12 assert diff_bound.value == 12 assert diff_bound.diff == 0 assert diff_bound.variation == 0 diff_time = diffs[1] assert diff_time.label == 'time' assert diff_time.reference == 2 assert diff_time.value == 1 assert diff_time.diff == -1 assert diff_time.variation == -50
def kmp_match(t, p): ''' Find all instances of p in t, runs a comparator class that keeps track of the number of comparisons made ''' pi = compute_prefix(p) q = 0 #number of thus far matched characters in the pattern c = Comparator() results = [] for i in range(0, len(t)): # we've matched some characters, but not enough, so we shift forward by the prefix amount while q > 0 and not c.compare(p, q, t, i): q = pi[q] # we've matched another character if c.compare(p, q, t, i): q += 1 # we've matched as many chars are there in the pattern, we've found a match if q == len(p): results.append(i - len(p) + 1) q = pi[q - 1] return results, c
def create(scripts_processor: "ScriptSetProcessor", directive_provider: DirectiveProvider, python_version: str, source_script: SourceScript): comparator = Comparator({'python_version': python_version}) def local_is_true(args: List[str]): return comparator.check(args[0], args[1], args[2]) branch_processor = BranchProcessor(local_is_true) return DirectiveProcessor(scripts_processor, branch_processor, directive_provider)
def test_equality_with_default_delta(self): self.assertEqual(Comparator(5), 4.99999999) self.assertEqual(Comparator(5), 5.00000001) self.assertEqual(5, Comparator(4.99999999)) self.assertEqual(5, Comparator(5.00000001)) self.assertNotEqual(Comparator(5), 4.99999) self.assertNotEqual(Comparator(5), 5.00001)
def test_default_delta_context_manager(self): with Comparator.default_delta(0.5): self.assertEqual(Comparator(5), 5.5) self.assertNotEqual(Comparator(5), 5.6) self.assertNotEqual(Comparator(5, delta=0.1), 5.5) self.assertNotEqual(Comparator(5), 5.5) try: with Comparator.default_delta(0.5): raise ValueError except ValueError: pass self.assertNotEqual(Comparator(5), 5.5)
def rerun(self): self.tries = self.tries + 1 if self.appState == State.ALL_EQUALS: print("Good Job monkeys! finded!") print(" tries " + str(self.tries)) exit() if self.appState == State.NONE_EQUAL: res = Comparator.compareRandomWithSearched( self.searched, Generator.generateRandomWord(len(self.searched))) self.appState = res[0] App.searchedTemp = res[1] self.rerun() if self.appState == State.PARTIALY_EQUAL: res = Comparator.compareRandomWithSearched( "".join(App.searchedTemp), Generator.generateRandomWord(len(self.searched)), ) self.appState = res[0] App.searchedTemp = res[1] self.rerun()
def onClicked_SaveComparator_New(self): currentCTab = self.tabWidget.currentWidget() name = currentCTab.compNameLineEdit.text() if not self.validateComparatorName(): return currentCTab.comp.setName(currentCTab.compNameLineEdit.text()) currentCTab.comp.setComment(currentCTab.compCommentText.toPlainText()) if currentCTab.originalComp is None: print("Create comparator ", name) currentCTab.originalComp = Comparator() currentCTab.originalComp.updateFromGiven(currentCTab.comp) self.compTableModel.addComparator(currentCTab.originalComp) else: print("Update comparator ", name) currentCTab.originalComp.updateFromGiven(currentCTab.comp) self.compTableModel.emitAllDataChanged()
def __init__(self, filename, samp_num=1, samp_size=None, proj_size=None, proj_connected=True, nfilename=None, max_coef=10, smt_timeout_iter=0, smt_timeout_matrix=0, sanity_check=False): self.pach = PacH(filename, samp_num=samp_num, samp_size=samp_size, proj_size=proj_size, proj_connected=proj_connected, nfilename=nfilename, max_coef=max_coef, sanity_check=sanity_check) self.pach.parse() qhull = self.pach.qhull # Hull for NO SMT qhull_no_smt = copy.deepcopy(qhull) # Hull for SMT iterative simp qhull_smt_iter = copy.deepcopy(qhull) # Hull for SMT matrix simp qhull_smt_matrix = copy.deepcopy(qhull) self.comparator = Comparator(qhull_no_smt, qhull_smt_iter, qhull_smt_matrix, max_coef, smt_timeout_iter, smt_timeout_matrix)
def main(): if len(sys.argv) < 2: print("Usage: " + sys.argv[0] + " <board>") return board = sys.argv[1] posts = {} try: posts = json.loads(open("data/posts_%s.json" % board).read()) except Exception as e: pass regexps_like = [ regex.split("\n")[0] for regex in open("data/regexps_like").readlines() ] regexps_dislike = [ regex.split("\n")[0] for regex in open("data/regexps_dislike").readlines() ] comparator_dislike = Comparator( open("data/comparator.wasm", "rb").read(), [ base64.b64decode(image.split("\n")[0]) for image in open("data/images").readlines() ]) checker = Checker(regexps_like, regexps_dislike, comparator_dislike) proxies = Proxies( [proxy.split("\n")[0] for proxy in open("data/proxies").readlines()]) network = Network(proxies, 10) liker = Liker(board, checker, posts, network) network.start() network.join()
def addTab1_Append(self): if len(self.compTableView.view.selectedIndexes()) < 1: return original = self.compTableView.view.selectedIndexes( )[0].internalPointer() uids = self.qMainTreev.getSelectedItemUids() if not uids: return tabIndex = self.checkIfCompOpened(original.name) if tabIndex > 0: tgtTab = self.tabWidget.widget(tabIndex) for uid in uids: entry = self.compTableModel.ADB.getEntryByUid(uid) tgtTab.qCompViewer.proxyModel.sourceModel().appendItem(entry) self.tabWidget.setCurrentIndex(tabIndex) return theComp = Comparator() theComp.updateFromGiven(original) for uid in uids: entry = self.compTableModel.ADB.getEntryByUid(uid) theComp.addEntry(entry) tab = ComparatorTabPageWidget() tab.setComparatorToShow(theComp) tab.originalComp = original newidx = self.tabWidget.addTab( tab, theComp.name[:16] if len(theComp.name) < 16 else theComp.name[:13] + "..") self.tabWidget.setCurrentIndex(newidx) tab.btnCancel.clicked.connect(self.closeCurrentTab) tab.btnSave.clicked.connect(self.onClicked_SaveComparator_OpenAppend) tab.qCompViewer.proxyView.doubleClicked.connect( self.onDoubleClicked_EditCompEntry) tab.compNameLineEdit.textChanged.connect( self.setCurrentComparatorTabLabel) self.setCurrentComparatorTabLabel()
class DiceDetector(): def __init__(self): self.rotations_matrices = {} for angle in range(0, 90, 15): theta = np.radians(angle) self.rotations_matrices[angle] = np.array( [[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]) def generate_fake_node(self, a, b, ratio, pattern_id): a = np.array(a.center) b = np.array(b.center) v = b - a u = np.array([v[1], -v[0]]) u *= ratio / 2 n = Node(-1, None, None, True) if pattern_id == 2: n.center = (a + b) / 2 + u else: n.center = b + 2 * u return n def detect_with_node(self, node, dots): best = 1e9 best_nodes = [] best_regions = [] if dots > 3: for i in node.neighbours: for j in node.neighbours: if i == j: continue nodes = [node, self.nodes[i], self.nodes[j]] penalty, regions = self.comparator.compare(nodes, dots) if penalty < best: best = penalty best_nodes = nodes best_regions = regions elif dots in {2, 3}: for i in node.neighbours: for ratio in [0.5, 0.75, 1, 1.33, 2]: nodes = [ node, self.nodes[i], self.generate_fake_node(node, self.nodes[i], ratio, dots) ] penalty, regions = self.comparator.compare(nodes, dots) if penalty < best: best = penalty best_nodes = nodes best_regions = regions else: val, nodes = self.size_detector.detect(node) if val > 0.5: penalty, regions = self.comparator.compare(nodes, dots) if penalty < best: best = penalty best_nodes = nodes best_regions = regions return best, best_nodes, best_regions def detect_single(self, img, mask): thresholds = [0.4] * 7 thresholds[1] = 0.7 thresholds[2] = 0.3 labels, self.nodes = img_to_nodes(img, mask) self.comparator = Comparator(self.nodes, labels) res = [] for dots in range(6, 0, -1): matches = [] for node in tqdm(self.nodes.values()): matches.append(self.detect_with_node(node, dots)) matches.sort(key=itemgetter(0)) for m in matches: if m[0] > thresholds[dots]: break vis = False for n in m[1]: if n.visited: vis = True if vis: continue pattern = self.comparator.get_pattern(m[1], dots) res.append((find_contours(pattern, 0.5)[0], dots)) print(m[0]) for n in m[2]: print(n.a, end=' ') n.visited = True print(' ') return res def detect(self, img): img = median(img) self.size_detector = SideDetector(img) gray = rgb2gray(img) minv = np.percentile(gray, 3) maxv = np.percentile(gray, 97) gray = (gray - minv) / (maxv - minv) self.res = self.detect_single(img, gray < 0.3) self.res += self.detect_single(img, gray > 0.4) return self.res def mark_sides(self, img): colors = np.array([(0, 0, 0), (1, 0, 0), (1, 1, 0), (0, 1, 0), (0, 1, 1), (0, 0, 1), (1, 0, 1)]) for c in self.res: border = polygon_perimeter(c[0][:, 0], c[0][:, 1]) border_mask = np.zeros((img.shape[0], img.shape[1])) border_mask[border] = 1 border_mask = mp.dilation(border_mask) img[border_mask == 1] = colors[c[1]] * 255 return img
class ComparatorXes(object): def __init__(self, filename, samp_num=1, samp_size=None, proj_size=None, proj_connected=True, nfilename=None, max_coef=10, smt_timeout_iter=0, smt_timeout_matrix=0, sanity_check=False): self.pach = PacH(filename, samp_num=samp_num, samp_size=samp_size, proj_size=proj_size, proj_connected=proj_connected, nfilename=nfilename, max_coef=max_coef, sanity_check=sanity_check) self.pach.parse() qhull = self.pach.qhull # Hull for NO SMT qhull_no_smt = copy.deepcopy(qhull) # Hull for SMT iterative simp qhull_smt_iter = copy.deepcopy(qhull) # Hull for SMT matrix simp qhull_smt_matrix = copy.deepcopy(qhull) self.comparator = Comparator(qhull_no_smt, qhull_smt_iter, qhull_smt_matrix, max_coef, smt_timeout_iter, smt_timeout_matrix) def generate_pnml(self): return self.comparator.generate_pnml(filename=self.pach.filename, reversed_dictionary=self.pach.reversed_dictionary) def compare(self,log_file='', event_dictionary={}): return self.comparator.compare(log_file=log_file, event_dictionary=event_dictionary) def generate_outputs(self): # For every benchmark, generate the output qhull = self.comparator.qhull_no_smt self.pach.output.get('times',{}).update(qhull.output.get('times',{})) self.pach.qhull = qhull self.pach.smt_matrix = False self.pach.smt_iter = False # Force initial complexity for effectiveness calculation self.pach.initial_complexity = self.comparator.no_smt_initial_complexity self.pach.generate_output_file() logger.info('Generated output for NO SMT simplification') qhull = self.comparator.qhull_smt_iter self.pach.output.get('times',{}).update(qhull.output.get('times',{})) self.pach.qhull = qhull self.pach.smt_matrix = False self.pach.smt_iter = True # Force initial complexity for effectiveness calculation self.pach.initial_complexity = self.comparator.iter_initial_complexity self.pach.generate_output_file() logger.info('Generated output for Iterative SMT simplification') qhull = self.comparator.qhull_smt_matrix self.pach.output.get('times',{}).update(qhull.output.get('times',{})) self.pach.qhull = qhull self.pach.smt_matrix = True self.pach.smt_iter = False # Force initial complexity for effectiveness calculation self.pach.initial_complexity = self.comparator.matrix_initial_complexity self.pach.generate_output_file() logger.info('Generated output for Matrix SMT simplification') return True
import sys from comparator import Comparator if __name__ == "__main__": args = sys.argv if len(args) != 3: print('incorrect args') sys.exit(0) comparator = Comparator() degree = comparator.compare(sys.argv[1], sys.argv[2]) sys.stdout.write(str(degree)) sys.exit(0)
phones = self.get_models(brand) self.phones.extend(phones) print "-------------" print "Finished crawling all phones. Total number = " + str( len(self.phones)) return self.phones if __name__ == "__main__": script_loc = os.path.dirname(os.path.realpath(__file__)) os.chdir(script_loc) scrapper = Scrapper() phones = scrapper.build_knowledge_base() if os.path.isfile("save.p"): old_phones = pickle.load(open("save.p", "rb")) comparator = Comparator(old_phones, phones) new_phones = comparator.get_new_phones() removed_phones = comparator.get_removed_phones() updated_phones = comparator.get_updated_phones() # Dumping the new data to the disk print "Storing today's data to disk .." pickle.dump(phones, open("save.p", "wb")) # Sending mail results print "Sending mail results .." reporter = Report(phones, new_phones, removed_phones, updated_phones) reporter.send_updates()
def test_very_small_delta(self): self.assertEqual(-6.000000000000001, Comparator(-6, delta=1e-15)) self.assertNotEqual(-6.000000000000002, Comparator(-6, delta=1e-15))
class Diler: class Client: class Status: pass class NotReady(Status): def ready(self): return False class Ready(Status): def ready(self): return True class Check(Ready): pass class AllIn(Ready): pass class Called(Ready): pass class Rised(Ready): pass class Pass(Ready): pass def __init__(self, id, conn): self.rise_client = None self.conn = conn self.id = id self.cards = [] self.status = Diler.Client.NotReady() def __eq__(self, other): return self.id == other.id def addCard(self, card): self.cards.append(card) def ready(self): return self.status.ready() def __init__(self, server): self.server = server self.deck = createCards() self.table = [] self.clients = [] self.comparator = Comparator() self.rise_client = None def getClient(self, client): missing = Diler.Client(client[1][1], client[0]) if missing in self.clients: return self.clients[self.clients.index(missing)] self.clients.append(missing) return self.clients[-1] def request(self, client): card = self.getCard() self.getClient(client).addCard(card) return card def getCard(self): return self.deck.pop(randint(0, len(self.deck) - 1)) def getState(self): return self.clients def roundRun(self): if len(list(filter(lambda x: type(x.status) != Diler.Client.Pass, self.clients))) < 2: return for client in filter(lambda x: type(x.status) != Diler.Client.Pass, self.clients): client.status = Diler.Client.NotReady() k = 0 if self.rise_client is None else self.rise_client while not all([client.ready() for client in self.clients]): if not self.clients[k].ready(): sleep(0.01) self.server.send(self.clients[k].conn, 'ask') ans = self.server.recv(self.clients[k].conn) self.server.broadcast('info: игрок ' + str(self.clients[k].id) + ' ответил ' + ans) if ans == 'pass': self.clients[k].status = Diler.Client.Pass() elif ans == 'call': self.clients[k].status = Diler.Client.Called() elif ans == 'rise': for c in filter(lambda x: type(x.status) != Diler.Client.Pass, self.clients): c.status = Diler.Client.NotReady() self.clients[k].status = Diler.Client.Rised() self.rise_client = k else: self.clients[k].status = Diler.Client.Pass() print('error: непонятный ответ от клиента') k = (k + 1) % len(self.clients) def flop(self): self.roundRun() for i in range(3): self.table.append(self.getCard()) print('flop', ' '.join(map(str, self.table[0: 3]))) return ' '.join(map(str, self.table)) def turn(self): self.roundRun() self.table.append(self.getCard()) print('turn', str(self.table[-1])) return str(self.table[-1]) def river(self): self.roundRun() self.table.append(self.getCard()) print('river', str(self.table[-1])) return str(self.table[-1]) def opening(self): self.roundRun() clients = {} for client in filter(lambda x: type(x.status) != Diler.Client.Pass, self.clients): clients[client.id] = client.cards win = self.comparator.compare(clients, self.table) if len(win) == 1: res = 'победитель: ' + str(win[0]) else: res = 'победители: ' + ', '.join(map(str, win)) return res def next_turn(self): self.clients.append(self.clients.pop(0))
def __init__(self, task): Comparator.__init__(self, task) self.name = "highwaysgeometrypostgis" self.geometry_type = "lines" self.database_type = "postgis"
def test_negative_numbers(self): self.assertNotEqual(-5.5, Comparator(-6, delta=0.25)) self.assertEqual(-5.75, Comparator(-6, delta=0.25)) self.assertEqual(-6.25, Comparator(-6, delta=0.25)) self.assertNotEqual(-6.3, Comparator(-6, delta=0.25))
class Diler: class Client: class Status: pass class NotReady(Status): def ready(self): return False class Ready(Status): def ready(self): return True class Check(Ready): pass class Bet(Ready): pass class AllIn(Bet): pass class Called(Bet): pass class Rised(Bet): pass class Pass(Ready): pass def __init__(self, id, conn): self.rise_client = None self.conn = conn self.id = id self.cards = [] self.status = Diler.Client.NotReady() self.bet = 0 self.money = 1000 self.pass = False def __eq__(self, other): return self.id == other.id def addCard(self, card): self.cards.append(card) def ready(self, max_bet): return self.money == 0 or self.bet >= max_bet or self.pass def __init__(self, server): self.server = server self.deck = createCards() self.table = [] self.clients = [] self.comparator = Comparator() self.rise_client = None self.bet = 0 self.bank = 0 self.big_blind = 100 def getClient(self, client): missing = Diler.Client(client[1][1], client[0]) if missing in self.clients: return self.clients[self.clients.index(missing)] self.clients.append(missing) return self.clients[-1] def request(self, client): card = self.getCard() self.getClient(client).addCard(card) return card def getCard(self): return self.deck.pop(randint(0, len(self.deck) - 1)) def getState(self): return self.clients def roundRun(self): for client in filter(lambda x: type(x.status) != Diler.Client.Pass, self.clients): client.status = Diler.Client.NotReady() k = 0 if self.rise_client is None else self.rise_client while not all([client.ready() for client in self.clients]) or len(list(filter(lambda x: type(x.status) != Diler.Client.Pass, self.clients))) < 2: if not self.clients[k].ready(): sleep(0.01) if self.bet > 0: self.server.send(self.clients[k].conn, 'ask1 ' + str(bet - self.clients[k].bet)) else: self.server.send(self.clients[k].conn, 'ask0') ans = self.server.recv(self.clients[k].conn) self.broadcast('info: игрок ' + str(self.clients[k].id) + ' ответил ' + ans) if ans == 'check': self.clients[k].status = Diler.Client.Check() elif ans == 'pass': self.clients[k].status = Diler.Client.Pass() elif ans == 'call': self.clients[k].status = Diler.Client.Called() elif ans[:4] == 'rise' or ans[:3] == 'bet': for c in filter(lambda x: type(x.status) != Diler.Client.Pass, self.clients): c.status = Diler.Client.NotReady() self.clients[k].status = Diler.Client.Rised() self.rise_client = k bet = int(ans[4:]) self.bank += bet self.clients[k].bet = bet else: self.clients[k].status = Diler.Client.Pass() print('error: непонятный ответ от клиента') k = (k + 1) % len(self.clients) def blind(self): self.bank += self.big_blind // 2 self.bank += self.big_blind self.clients[0].bed(self.big_blind // 2) self.clients[1].bed(self.big_blind) self.bet = True return "Игрок " + str(self.clients[0].id) + " поставил " + str(self.big_blind // 2) + ", игрок " + str(self.clients[1].id) + " поставил " + str(self.big_blind) def flop(self): self.roundRun() for i in range(3): self.table.append(self.getCard()) print('flop', ' '.join(map(str, self.table[0: 3]))) return ' '.join(map(str, self.table)) def turn(self): self.roundRun() self.table.append(self.getCard()) print('turn', str(self.table[-1])) return str(self.table[-1]) def river(self): self.roundRun() self.table.append(self.getCard()) print('river', str(self.table[-1])) return str(self.table[-1]) def opening(self): self.roundRun() clients = {} for client in filter(lambda x: type(x.status) != Diler.Client.Pass, self.clients): clients[client.id] = client.cards win = self.comparator.compare(clients, self.table) if len(win) == 1: res = 'победитель: ' + str(win[0]) else: res = 'победители: ' + ', '.join(map(str, win)) return res def game(self): self.broadcast(self.blind()) self.broadcast(self.flop()) self.broadcast(self.turn()) self.broadcast(self.river()) self.broadcast(self.opening()) self.next_turn() self.broadcast("Спасибо за игру!") def broadcast(self, msg): for client in self.clients: self.server.send(client.conn, msg) def next_turn(self): self.clients.append(self.clients.pop(0))
def test_equality_with_delta(self): self.assertEqual(5.5, Comparator(6, delta=0.5)) self.assertEqual(6.5, Comparator(6, delta=0.5)) self.assertNotEqual(6.51, Comparator(6, delta=0.5)) self.assertNotEqual(5.49, Comparator(6, delta=0.5))
def __init__(self, task): Comparator.__init__(self, task) self.name = "highwaysgeometryspatialite" self.geometry_type = "lines" self.database_type = "spatialite"