def post(self):
key = self['email']
redirect_url = str(
self['redirect_url']) if self['redirect_url'] else '/community'
if self['fb-pic-checkbox']:
image_url = 'https://graph.facebook.com/' + self[
"facebook_id"] + '/picture?type=normal&height=300&width=300'
else:
image_url = '/assets/img/landing/default_member.png'
role = int(self['role']) if self['role'] else MEMBER_ROLE[ENGINEER]
member = Member.create_or_update(key,
name=self['name'],
organization=self["organization"],
designation=self["designation"],
website=self["website"],
twitter_handle=self["twitter_handle"],
facebook_id=self["facebook_id"],
bio=self["bio"],
password=self['password'],
image_url=image_url,
role=role)
self.session['member'] = key
redirect_url = '/tracks'
if role == MEMBER_ROLE[MANAGER]:
Manager.create(member)
else:
managed_by = self['manager']
ManagedUser.create(member, Manager._for(managed_by))
self.redirect(redirect_url)
def test_manager_no_puede_unirse_con_usuario_repetido(self) -> None:
manager = Manager()
manager.agregar_jugador("Román", "Amongas Volley Club")
self.assertRaises(JugadorExistenteException, manager.agregar_jugador,
"Román", "Amongas Volley Club 2")
self.assertFalse("Amongas Volley Club 2" in manager.listar_lobbies())
def test_manager_no_se_puede_sacar_al_jugador_si_no_existe(self) -> None:
manager = Manager()
manager.agregar_jugador("Román", "Amongas Volley Club")
manager.agregar_jugador("Ramón", "Amongas Volley Club")
self.assertRaises(JugadorInExistenteException, manager.sacar_jugador,
"Ron", "Amongas Volley Club")
def test_manager_no_puede_cortar_partidas_no_iniciadas(self) -> None:
manager = Manager()
manager.agregar_jugador("Román", "Amongas Volley Club")
manager.agregar_jugador("Ramón", "Amongas Volley Club")
self.assertRaises(PartidaNoIniciadaException, manager.cortar_juego_en,
"Amongas Volley Club")
def test_manager_no_se_puede_pedir_estado_en_partida_no_iniciada(
self) -> None:
manager = Manager()
manager.agregar_jugador("Román", "Amongas Volley Club")
manager.agregar_jugador("Ramón", "Amongas Volley Club")
self.assertRaises(PartidaNoIniciadaException, manager.estado_en,
"Amongas Volley Club")
def test_manager_no_se_puede_tomar_accion_en_partida_no_iniciada(
self) -> None:
manager = Manager()
manager.agregar_jugador("Román", "Amongas Volley Club")
manager.agregar_jugador("Ramón", "Amongas Volley Club")
accion = {'jugador': "Román", 'accion': 'DESCARTAR', 'carta': 0}
self.assertRaises(PartidaNoIniciadaException, manager.tomar_accion_en,
"Amongas Volley Club", accion)
def test_manager_se_saca_la_partida_al_cortar(self) -> None:
manager = Manager()
manager.agregar_jugador("Román", "Amongas Volley Club")
manager.agregar_jugador("Ramón", "Amongas Volley Club")
manager.iniciar_juego_en("Amongas Volley Club")
manager.cortar_juego_en("Amongas Volley Club")
self.assertTrue("Amongas Volley Club" in manager.listar_lobbies())
def get_system(name, args, schema=None, timed=False, model_path=None):
if name in ('rulebased', 'neural'):
lexicon = Lexicon(schema,
args.learned_lex,
stop_words=args.stop_words,
lexicon_path=args.lexicon)
if args.inverse_lexicon:
realizer = InverseLexicon.from_file(args.inverse_lexicon)
else:
realizer = DefaultInverseLexicon()
if name == 'rulebased':
templates = Templates.from_pickle(args.templates)
generator = Generator(templates)
manager = Manager.from_pickle(args.policy)
return RulebasedSystem(lexicon, generator, manager, timed)
elif name == 'neural':
assert args.model_path
return NeuralSystem(schema,
lexicon,
args.model_path,
args.fact_check,
args.decoding,
realizer=realizer)
elif name == 'cmd':
return CmdSystem()
else:
raise ValueError('Unknown system %s' % name)
def get_system(name, args, schema=None, timed=False, model_path=None):
lexicon = PriceTracker(args.price_tracker_model)
if name == 'rulebased':
templates = Templates.from_pickle(args.templates)
generator = Generator(templates)
manager = Manager.from_pickle(args.policy)
return RulebasedSystem(lexicon, generator, manager, timed)
#elif name == 'config-rulebased':
# configs = read_json(args.rulebased_configs)
# return ConfigurableRulebasedSystem(configs, lexicon, timed_session=timed, policy=args.config_search_policy, max_chats_per_config=args.chats_per_config, db=args.trials_db, templates=templates)
elif name == 'cmd':
return CmdSystem()
elif name.startswith('ranker'):
# TODO: hack
#retriever1 = Retriever(args.index+'-1', context_size=args.retriever_context_len, num_candidates=args.num_candidates)
#retriever2 = Retriever(args.index+'-2', context_size=args.retriever_context_len, num_candidates=args.num_candidates)
retriever = Retriever(args.index, context_size=args.retriever_context_len, num_candidates=args.num_candidates)
if name == 'ranker-ir':
return IRRankerSystem(schema, lexicon, retriever)
elif name == 'ranker-ir1':
return IRRankerSystem(schema, lexicon, retriever1)
elif name == 'ranker-ir2':
return IRRankerSystem(schema, lexicon, retriever2)
elif name == 'ranker-neural':
return NeuralRankerSystem(schema, lexicon, retriever, model_path, args.mappings)
else:
raise ValueError
elif name in ('neural-gen', 'neural-sel'):
assert model_path
return NeuralSystem(schema, lexicon, model_path, args.mappings, args.decoding, index=args.index, num_candidates=args.num_candidates, retriever_context_len=args.retriever_context_len, timed_session=timed)
else:
raise ValueError('Unknown system %s' % name)
def get_system(name, args, schema=None, timed=False, model_path=None):
from core.price_tracker import PriceTracker
lexicon = PriceTracker(args.price_tracker_model)
if name == 'rulebased':
from rulebased_system import RulebasedSystem
from model.generator import Templates, Generator
from model.manager import Manager
templates = Templates.from_pickle(args.templates)
generator = Generator(templates)
manager = Manager.from_pickle(args.policy)
return RulebasedSystem(lexicon, generator, manager, timed)
elif name == 'hybrid':
from hybrid_system import HybridSystem
templates = Templates.from_pickle(args.templates)
manager = PytorchNeuralSystem(args, schema, lexicon, model_path, timed)
generator = Generator(templates)
return HybridSystem(lexicon, generator, manager, timed)
elif name == 'cmd':
from cmd_system import CmdSystem
return CmdSystem()
elif name == 'pt-neural':
from neural_system import PytorchNeuralSystem
assert model_path
return PytorchNeuralSystem(args, schema, lexicon, model_path, timed)
else:
raise ValueError('Unknown system %s' % name)
def test_manager_no_se_puede_tomar_accion_en_lobby_inexistente(
self) -> None:
manager = Manager()
accion = {'jugador': "Román", 'accion': 'DESCARTAR', 'carta': 0}
self.assertRaises(LobbyInexistenteException, manager.tomar_accion_en,
"Amongas Volley Club", accion)
def test_manager_unirse_con_usuario_a_lobby(self) -> None:
manager = Manager()
manager.crear_lobby("Amongas Volley Club")
manager.agregar_jugador("Román", "Amongas Volley Club")
self.assertEqual("Amongas Volley Club", manager.sala_de("Román"))
def test_manager_iniciar_partida_la_deja_de_mostrar_al_listar(
self) -> None:
manager = Manager()
manager.agregar_jugador("Román", "Amongas Volley Club")
manager.agregar_jugador("Ramón", "Amongas Volley Club")
manager.iniciar_juego_en("Amongas Volley Club")
self.assertFalse("Amongas Volley Club" in manager.listar_lobbies())
def test_manager_pueden_haber_varios_lobbies(self) -> None:
manager = Manager()
manager.agregar_jugador("Román", "Amongas Volley Club")
manager.agregar_jugador("Ramón", "Amongas Volley Club 2")
self.assertEquals(["Amongas Volley Club", "Amongas Volley Club 2"],
manager.listar_lobbies())
def test_manager_tomar_accion_en_partida(self) -> None:
self.maxDiff = None
manager = Manager(mezclar_rojo_verde)
manager.agregar_jugador("Román", "Amongas Volley Club")
manager.agregar_jugador("Ramón", "Amongas Volley Club")
manager.iniciar_juego_en("Amongas Volley Club")
accion = {'jugador': "Román", 'accion': 'DESCARTAR', 'carta': 0}
manager.tomar_accion_en("Amongas Volley Club", accion)
self.assertEqual(
{
'global': {
'terminado': False,
'jugadores': ["Román", "Ramón"],
'turno_de': "Ramón",
'vidas': 3,
'pistas_restantes': 7,
'cartas_restantes': 9,
'tablero': {
'Rojo': 0,
'Azul': 0,
'Amarillo': 0,
'Verde': 0,
'Blanco': 0
},
'puntaje': 0,
'descarte': {
'Rojo': [],
'Azul': [],
'Amarillo': [],
'Verde': [],
'Blanco': []
}
},
'estado_jugadores': {
'Román': {
'cartas': [(i, "Verde")
for i in range(2, 6)] + [(5, "Azul")],
'pistas': [[], [], [], [], []]
},
'Ramón': {
'cartas': [(i, "Rojo") for i in range(1, 6)],
'pistas': [[], [], [], [], []]
}
}
}, manager.estado_en("Amongas Volley Club"))
def get(self):
redirect_url = self['redirect_url'] if self['redirect_url'] else '/community'
path = 'member_registration.html'
template_values = {}
template_values['redirect_url'] = redirect_url
template_values['is_member'] = True if 'member' in self.session else False
if 'member' in self.session:
template_values['member'] = Member.get_member_json(self.session['member'])
template_values['managers'] = Manager.get_managers()
self.write(self.get_rendered_html(path, template_values), 200)
def test_manager_se_borra_el_lobby_si_la_sala_queda_vacia(self) -> None:
manager = Manager()
manager.agregar_jugador("Román", "Amongas Volley Club")
manager.agregar_jugador("Ramón", "Amongas Volley Club")
manager.sacar_jugador("Román", "Amongas Volley Club")
manager.sacar_jugador("Ramón", "Amongas Volley Club")
self.assertEqual([], manager.listar_lobbies())
def post(self):
key = self['email']
redirect_url = str(self['redirect_url']) if self['redirect_url'] else '/community'
if self['fb-pic-checkbox']:
image_url = 'https://graph.facebook.com/'+self["facebook_id"]+'/picture?type=normal&height=300&width=300'
else:
image_url = '/assets/img/landing/default_member.png'
role = int(self['role']) if self['role'] else MEMBER_ROLE[ENGINEER]
member = Member.create_or_update(key, name=self['name'], organization=self["organization"],
designation=self["designation"], website=self["website"],
twitter_handle=self["twitter_handle"], facebook_id=self["facebook_id"], bio=self["bio"],
password=self['password'], image_url=image_url, role=role)
self.session['member'] = key
redirect_url = '/tracks'
if role == MEMBER_ROLE[MANAGER]:
Manager.create(member)
else:
managed_by = self['manager']
ManagedUser.create(member, Manager._for(managed_by))
self.redirect(redirect_url)
def __to_object(self, data, role):
name = data[0]
email = data[1]
login = data[2]
pwd = data[3]
if role == 'Manager':
return Manager(name=name, email=email, login=login, password=pwd)
if role == 'Client':
return Client(name=name, email=email, login=login, password=pwd)
raise Exception('Invalid person role "{0}".'.format(role))
def get_system(name, args, schema, model_path=None, timed=False):
lexicon = Lexicon.from_pickle(args.lexicon)
templates = Templates.from_pickle(args.templates)
if name == 'rulebased':
templates = Templates.from_pickle(args.templates)
generator = Generator(templates)
manager = Manager.from_pickle(args.policy)
return RulebasedSystem(lexicon, generator, manager, timed)
elif name == 'cmd':
return CmdSystem()
else:
raise ValueError('Unknown system %s' % name)
def get(self):
redirect_url = self['redirect_url'] if self[
'redirect_url'] else '/community'
path = 'member_registration.html'
template_values = {}
template_values['redirect_url'] = redirect_url
template_values[
'is_member'] = True if 'member' in self.session else False
if 'member' in self.session:
template_values['member'] = Member.get_member_json(
self.session['member'])
template_values['managers'] = Manager.get_managers()
self.write(self.get_rendered_html(path, template_values), 200)
def get_system(name, args, schema=None, timed=False):
lexicon = Lexicon(schema.values['owner'])
if name == 'rulebased':
templates = Templates.from_pickle(args.templates)
generator = Generator(templates)
manager = Manager.from_pickle(args.policy)
return RulebasedSystem(lexicon, generator, manager, timed)
elif name == 'cmd':
return CmdSystem()
# elif name == 'neural':
# return NeuralSystem(args.model_file, args.temperature, timed_session=timed, gpu=args.gpu)
else:
raise ValueError('Unknown system %s' % name)
def test_manager_unirse_a_lobby_inexistente_lo_tiene_que_crear(
self) -> None:
manager = Manager()
manager.agregar_jugador("Román", "Amongas Volley Club")
self.assertTrue("Amongas Volley Club" in manager.listar_lobbies())
self.assertEqual("Amongas Volley Club", manager.sala_de("Román"))
def test_manager_no_se_puede_iniciar_una_partida_ya_iniciada(self) -> None:
manager = Manager()
manager.agregar_jugador("Román", "Amongas Volley Club")
manager.agregar_jugador("Ramón", "Amongas Volley Club")
manager.iniciar_juego_en("Amongas Volley Club")
self.assertRaises(PartidaYaIniciadaException, manager.iniciar_juego_en,
"Amongas Volley Club")
def test_manager_sacar_al_jugador_lo_remueve_completamente(self) -> None:
manager = Manager()
manager.agregar_jugador("Román", "Amongas Volley Club")
manager.agregar_jugador("Ramón", "Amongas Volley Club")
manager.sacar_jugador("Román", "Amongas Volley Club")
self.assertRaises(JugadorInExistenteException, manager.sala_de,
"Román")
def user_session(id, class_name):
"""Return object with given class name in class_name and id"""
if class_name == "Student":
return Student.get_by_id(id)
elif class_name == "Mentor":
return Mentor.get_by_id(id)
elif class_name == "Employee":
return Employee.get_by_id(id, 'assistant')
elif class_name == "Manager":
return Manager.get_by_id(id)
return None
def get_system(name, args, schema=None, timed=False, model_path=None):
lexicon = Lexicon(schema.values['item'])
if name == 'rulebased':
templates = Templates.from_pickle(args.templates)
generator = Generator(templates)
manager = Manager.from_pickle(args.policy)
return RulebasedSystem(lexicon, generator, manager, timed)
elif name == 'hybrid':
assert model_path
templates = Templates.from_pickle(args.templates)
manager = PytorchNeuralSystem(args, schema, lexicon, model_path, timed)
generator = Generator(templates)
return HybridSystem(lexicon, generator, manager, timed)
elif name == 'cmd':
return CmdSystem()
elif name == 'fb-neural':
assert model_path
return FBNeuralSystem(model_path, args.temperature, timed_session=timed, gpu=False)
elif name == 'pt-neural':
assert model_path
return PytorchNeuralSystem(args, schema, lexicon, model_path, timed)
else:
raise ValueError('Unknown system %s' % name)
parser.add_argument('--transcripts',
nargs='*',
help='JSON transcripts to extract templates')
parser.add_argument('--max-examples', default=-1, type=int)
parser.add_argument('--templates', help='Path to load templates')
parser.add_argument('--policy', help='Path to load model')
parser.add_argument('--schema-path', help='Path to schema')
parser.add_argument(
'--agent', help='Only consider examples with the given type of agent')
add_price_tracker_arguments(parser)
args = parser.parse_args()
lexicon = PriceTracker(args.price_tracker_model)
#templates = Templates.from_pickle(args.templates)
templates = Templates()
manager = Manager.from_pickle(args.policy)
analyzer = Analyzer(lexicon)
# TODO: skip examples
examples = read_examples(args.transcripts, args.max_examples, Scenario)
agent = args.agent
if agent is not None:
examples = [e for e in examples if agent in e.agents.values()]
analyzer.example_stats(examples, agent=agent)
#import sys; sys.exit()
parsed_dialogues = []
for example in examples:
utterances = parse_example(example, lexicon, templates)
parsed_dialogues.append(utterances)
def test_manager_no_puede_crear_lobby_ya_existente(self) -> None:
manager = Manager()
manager.crear_lobby("Amongas Volley Club")
self.assertRaises(LobbyExistenteException, manager.crear_lobby,
"Amongas Volley Club")
def test_manager_no_se_puede_iniciar_una_partida_de_un_lobby_inexistente(
self) -> None:
manager = Manager()
self.assertRaises(LobbyInexistenteException, manager.iniciar_juego_en,
"Amongas Volley Club")
import time
from flask import Flask, render_template, request
from flask_socketio import SocketIO, join_room, leave_room, emit, send
from model.manager import Manager
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app,
engineio_logger=True,
cors_allowed_origins=[
'http://*****:*****@app.route('/')
def index():
return "Holo"
@app.route('/time')
def time_api():
return {'time': time.time()}
"""
@socketio.on('message')
def handle_message(data):
print('received message:', data)
@socketio.on('json')
def handle_message(json):
print('received json:', json)
def get_managed_users(cls, manager_email):
return ManagedUser.all().ancestor(Manager._for(manager_email)).fetch(limit=50)
def get_managed_users(cls, manager_email):
return ManagedUser.all().ancestor(
Manager._for(manager_email)).fetch(limit=50)
