def get_move(self, board):
start = time.time()
from competition import Competition
self.board = board
random_player = Player('random')
best_move = {
engine.UP: 0,
engine.DOWN: 0,
engine.LEFT: 0,
engine.RIGHT: 0
}
for initial_move in best_move:
new_board = copy.deepcopy(self.board)
new_board.move_board(initial_move)
comp = Competition(games_number=self.games_number,
game_size=self.board.size,
max_turns=self.max_turns,
players=[random_player],
initial_board=new_board,
store_in_db=False)
comp.play()
comp.show_results()
average = comp.results['score'].mean()
best_move[initial_move] = average
maxi = max(best_move, key=lambda k: best_move[k])
end = time.time()
#print('move is ',maxi,'time is ', end-start)
return maxi
def create_comp(comp):
with open(f'./competitions/{comp}.json') as comp_json:
comp_dict = json.load(comp_json)
teams = []
for team in comp_dict["teams"]:
matches_needed = team["min_matches"]
temp_team = Team(team["names"], matches_needed)
teams.append(temp_team)
return Competition(teams)
def create(**kwargs):
# subject = Field.query.filter_by(id=field_id).first()
comp = Competition(name=kwargs['name'],
date=kwargs['date'],
field_id=kwargs['field'].id)
comp.field = kwargs['field']
return CompetitionService.add(comp, kwargs.get('commit', False))
def pop_competition(self):
comp = None
if self.validate():
comp = Competition(name=self.name.data,
date=self.date.data,
field_id=self.subject.data.id)
comp.field = self.subject.data
return comp
def test_your_competition_class(self):
# TODO: Run tests against your competition class.
self.run_test(Competition)
for testcase in testcases.testcases:
competition = Competition(competitors=testcase['competitors'],
duration=testcase['duration'])
events = list(competition.run())
expected_winner = events[len(events) - 1].name
real_winner = competition.winner()
self.assertEqual(real_winner, expected_winner)
def setup():
a_competition = Competition('Mitre 10 Cup', 2018)
competition_data = json.loads(open('json.txt').read())
all_teams = competition_data['teams']
for team in all_teams:
a_competition.add_team(team['rank'], team['name'], team['venue'],
team['city'])
all_games = competition_data['games']
for game in all_games:
a_competition.add_game(game['week'], game['homeTeamRank'],
game['awayTeamRank'], game['dateTime'])
getResults(the_2018_competition)
return a_competition
def setup():
the_2018_competition = Competition('Mitre 10 Cup', 2018)
competition_data = json.loads(open('json.txt').read())
# print (competition_data)
all_teams = competition_data['teams']
# print (all_teams)
for team in all_teams:
the_2018_competition.addTeam(team['rank'], team['name'], team['venue'],
team['city'])
all_games = competition_data['games']
for game in all_games:
the_2018_competition.addGame(game['week'], game['homeTeamRank'],
game['awayTeamRank'], game['dateTime'])
return the_2018_competition
def setup():
a_competition = Competition('Mitre 10 Cup', 2018)
competition_data = json.loads(open('json.txt').read())
results_data = json.loads(open('BETTERresultsJSON.txt').read())
all_teams = competition_data['teams']
for team in all_teams:
a_competition.add_team(team['rank'], team['name'], team['venue'], team['city'])
all_games = competition_data['games']
for game in all_games:
a_competition.add_game(game['week'], game['homeTeamRank'], game['awayTeamRank'], game['dateTime'])
all_results = results_data['results']
for result in all_results:
a_competition.find_game_add_result(result['homeTeamRank'], result['awayTeamRank'], result['homeTeamScore'], result['awayTeamScore'], result['homeTeamTries'], result['awayTeamTries'])
return a_competition
def __init__(self,
club,
teams,
league,
fixtures=[],
played=[],
competition=Competition(),
new=True):
super(Manager, self).__init__()
self.club = Club(club)
self.teams = teams
self.league = league
self.fixtures = fixtures
self.played = played
self.stats = {"Points: ": 0, "Wins: ": 0, "Draws: ": 0, "Losses: ": 0}
self.competition = competition
self.new = new
print(self.new)
if self.new:
self._generate_fixtures()
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from competition import Competition
from competition import WIKI_MEDIUM_10M
# simple example that runs benchmark with WIKI_MEDIUM source and taks files
# Baseline here is ../trunk versus ../patch
if __name__ == '__main__':
# debug=True uses a smaller number of documents and less iterations when searching
comp = Competition(debug=True)
index = comp.newIndex('trunk', WIKI_MEDIUM_10M)
# create a competitor named baseline with sources in the ../trunk folder
comp.competitor('baseline', 'trunk', index=index)
# use the same index here
# create a competitor named my_modified_version with sources in the ../patch folder
# note that we haven't specified an index here, luceneutil will automatically use the index from the base competitor for searching
# while the codec that is used for running this competitor is taken from this competitor.
comp.competitor('my_modified_version', 'patch', index=index)
# start the benchmark - this can take long depending on your index and machines
comp.benchmark("trunk_vs_patch")
# -*- coding: utf-8 -*- """ Created on Mon May 14 17:12:19 2018 @author: greg """ import requests from bs4 import BeautifulSoup import codecs import time import pandas as pd import numpy as np from competition import Competition from competitor import Competitor from dataManager import DataManager competition_manager = Competition() competitor_manager = Competitor() data_manager = DataManager()
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from competition import Competition
from sklearn.metrics import roc_auc_score
from taigapy import TaigaClient
import seaborn as sns
import random
from pygcnn.utils import *
from pygcnn.indexing import *
from pygcnn.layers import *
from pygcnn.backbone import *
# Load training + test data
client = Competition()
taiga_client = TaigaClient()
features = taiga_client.get(name='rnaseq-gene-expression-5362', file='RNAseq_CCLE_RSEM_TPM', version='6').transpose().rename(lambda x: x.split(" (", 1)[0]).transpose()
targets = taiga_client.get(name='ccle-copy-number-variants-hgnc-mapped', version='4').rename(lambda x: x.split(" (", 1)[0]).transpose()
cls = list(set(list(features.transpose())) & set(list(targets.transpose())))
random.shuffle(cls)
train_cls = cls[50:]
test_cls = cls[:50]
feature_genes = list(set(list(features)) & set(list(targets)))
target_genes = list(set(list(features)) & set(list(targets)))
features = features[feature_genes]
targets = targets[target_genes]
def setUp(self):
self.competition = Competition('fixture1.csv')
# PlayFighting Cats App
#
# Create a program where two cats compete in a playfight for food.
#
# We need to create a couple of cats, some food, and a way to have a
# playfight and determine who wins the food.
from food import Food
from cat import Cat
from competition import Competition
# Create some food
prize_food = Food()
# Create two cats that will playfight
sunny = Cat('Sunny the Cat', 16, 27, 'medium')
bob = Cat('Robert the Cat', 9, 30, 'large')
# we have two cats, sunny and bob, who are competing in a
# playfight for TheFood.
#
# What are rules do we need for a playfight?
# We have energy, size, and pride as attributes for cats.
# Let's make some rules that determine who wins a playfight
# based on those attributes.
# What should those rules be?
competition1 = Competition(sunny, bob)
competition1.playfight(prize_food)
driver = webdriver.Chrome('/usr/bin/chromedriver', options=chrome_options)
url = "https://www.fis-ski.com/DB/alpine-skiing/calendar-results.html?eventselection=&place=§orcode=AL&seasoncode=2021&categorycode=WC&disciplinecode=&gendercode=&racedate=&racecodex=&nationcode=&seasonmonth=X-2021&saveselection=-1&seasonselection="
driver.get(url)
print("Main page loaded")
elems = driver.find_elements_by_class_name("table-row")
# elems = elems[10:13]
competitionList = []
for e in elems:
competition = Competition(e)
competitionList.append(competition)
liveEvent = []
# For each competition, go to the corresponding page
for competition in competitionList:
competition.addEvents()
if competition.live:
liveEvent.append(competition)
# liveEvent=competitionList
# Send email about live competitions
# sendHTMLEmail()
def seed(database):
"""
Function that makes an initial database data seed
so we could have something to work on after DB init.
"""
# User roles are inserted first
Role.insert_roles()
# List of object to be added to DB
users = []
# Users
s1 = Student(name='John',
surname='Doe',
email='*****@*****.**',
index_number='10000',
study_year=3)
s1.password = "******"
s1.confirmed = True
users.append(s1)
s2 = Student(name='Demo',
surname='User',
email='*****@*****.**',
index_number='10001',
study_year=2)
s2.password = "******"
s2.confirmed = True
users.append(s2)
s3 = Student(name='Mary',
surname='Lilly',
email='*****@*****.**',
index_number='10002',
study_year=1)
s3.password = '******'
s3.confirmed = True
users.append(s3)
s4 = Student(name='Jolly',
surname='Foster',
email='*****@*****.**',
index_number='10003',
study_year=1)
s4.password = '******'
s4.confirmed = True
users.append(s4)
s5 = Student(name='Mike',
surname='Young',
email='*****@*****.**',
index_number='10004',
study_year=1)
s5.password = '******'
s5.confirmed = True
users.append(s5)
a1 = Administrator(name='Some',
surname='Body',
email='*****@*****.**',
position='Assistent')
a1.password = '******'
users.append(a1)
a2 = Administrator(name='Eddy',
surname='Maiden',
email='*****@*****.**',
position='Professor')
a2.password = '******'
users.append(a2)
a3 = Administrator(name='Master',
surname='Yoda',
email='*****@*****.**',
position='Professor')
a3.password = '******'
users.append(a3)
a4 = Administrator(name='Qui Gon',
surname='Gin',
email='*****@*****.**',
position='Professor')
a4.password = '******'
users.append(a4)
# Fields
fields = [
Field(name='Baze podataka'),
Field(name='Operativna istraživanja'),
Field(name='Optimizacija resursa'),
Field(name='Paralelni računarski sistemi'),
Field(name='Multimedijalni sistemi'),
]
# Competitions
competitions = [
Competition("Prvo takmičenje", "11.12.2018", 1),
Competition("Drugo takmičenje", "11.01.2018", 2),
Competition("Treće takmičenje", "01.12.2018", 3)
]
users[6].competitions.append(competitions[1])
# Seeding the data to db session
data = fields + competitions + users
for o in data:
database.session.add(o)
database.session.flush()
users[1].participations.append(
Participation(user_id=users[1].id,
competition_name=competitions[0].name,
competition_date=competitions[0].date))
users[1].participations.append(
Participation(user_id=users[1].id,
competition_name=competitions[1].name,
competition_date=competitions[1].date))
users[1].participations.append(
Participation(user_id=users[1].id,
competition_name=competitions[2].name,
competition_date=competitions[2].date))
users[7].competitions.append(competitions[1])
database.session.flush()
data.append(Result(participation_id=0, points_scored=10))
data.append(Result(participation_id=1, points_scored=15))
data.append(Result(participation_id=2, points_scored=20))
