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)
class CompetitionTest(unittest.TestCase):
def setUp(self):
self.competition = Competition('fixture1.csv')
def test_init(self):
self.assertEqual(len(self.competition.games), 3)
self.assertEqual(len(self.competition.teams.keys()), 3)
def test_processing(self):
self.competition.process()
self.assertEqual(len(self.competition.teams), 3)
gro = self.competition.teams['GRO']
self.assertEqual(gro.points, 4)
self.assertEqual(gro.goals, 3)
self.assertEqual(gro.goals_against, 3)
self.assertEqual(gro.saldo(), 0)
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 __init__(self, host, port, competition=None):
self._host = host
self._port = port
self._app = Bottle()
self._route()
self.competition = competition
if not self.competition:
self.competition = Competition(games_to_run=100)
# Have a default AI for people to play against
self.competition.add("Internal Demo", BattleshipsAI)
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 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 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 __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()
def setUp(self):
self.competition = Competition('fixture1.csv')
#
# 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")
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()
class BattleshipsServer(object):
""" A server for providing a dashboard to Battleships game. """
def __init__(self, host, port, competition=None):
self._host = host
self._port = port
self._app = Bottle()
self._route()
self.competition = competition
if not self.competition:
self.competition = Competition(games_to_run=100)
# Have a default AI for people to play against
self.competition.add("Internal Demo", BattleshipsAI)
def _route(self):
""" Set up bottle routes for the app. """
self._app.route('/', method="GET", callback=self.index)
self._app.route('/entries', method="GET", callback=self.entries)
self._app.route('/enter', method="POST", callback=self.add_entry)
self._app.route('/static/bower_components/<filepath:path>',
callback=self.serve_bower)
self._app.route('/static/<filepath:path>', callback=self.serve_static)
def start(self):
""" Start the bottle server. """
self._app.run(host=self._host, port=self._port)
def serve_bower(self, filepath):
""" Serve bower components. """
return static_file(filepath, root='server/bower_components')
def serve_static(self, filepath):
""" Server /static files. """
return static_file(filepath, root='server/static')
def index(self):
""" The game dashboard. """
return template('index')
def entries(self):
""" Dump all entries as json. """
return json.dumps(self.competition.entries.values(), cls=EntryEncoder)
def add_entry(self, code=None, forms=None):
""" Add an entry to the competition. """
if code is None:
code = request.files.get("filedata").file.read()
if forms is None:
forms = request.forms
exec(code, globals())
team_name = BattleshipsAI.TEAM_NAME
if team_name in self.competition.entries and\
not forms.get('replace') == "1":
increment = 1
while team_name + " " + n2w(increment) in self.competition.entries:
increment += 1
team_name = team_name + " " + n2w(increment)
self.competition.add(team_name, BattleshipsAI)
# -*- 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]
# 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")
# 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)
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))
