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"
