def onCommandAlias(e):
if e.args and 'r' in e.switches:
name = e.args[0].lower()
command = aliases[name]
del aliases[name]
conf['aliases'] = aliases
e.window.write("* Deleted alias %s%s (was %s)" % (conf.get('command-prefix','/'),name,command))
events.load(__name__,reloading=True)
elif 'l' in e.switches:
e.window.write("* Current aliases:")
for i in aliases:
e.window.write("* %s%s: %s" % (conf.get('command-prefix','/'),i,aliases[i]))
elif len(e.args) >= 2:
name = e.args[0].lower()
command = ' '.join(e.args[1:])
aliases[name] = command
conf['aliases'] = aliases
e.window.write("* Created an alias %s%s to %s" % (conf.get('command-prefix','/'),name,command))
events.reload(__name__)
elif len(e.args) == 1:
name = e.args[0].lower()
if name in aliases:
e.window.write("* %s%s is an alias to %s" % (conf.get('command-prefix','/'),name,aliases[name]))
else:
e.window.write("* There is no alias %s%s" % (conf.get('command-prefix','/'),name))
else:
e.window.write(
"""Usage:
/alias \x02name\x02 \x02expression\x02 to create or replace an alias
/alias \x02name\x02 to look at an alias
/alias -r \x02name\x02 to remove an alias
/alias -l to see a list of aliases""")
def on_query(self,origin,message,**kw):
"""Reaguje na !reload do query tak, že znovu načte eventy a příkazy. Nefunguje?"""
if message==COMMANDPREFIX+"reload":
try:
reload_module(command)
except SyntaxError:
traceback.print_exc()
self.msg(origin,"Syntax error v seznamu příkazů. Detaily v konzoli.")
for module_name in filter(lambda x: not x.startswith('_'), dir(command)):
try:
reload_module(getattr(command,module_name))
except SyntaxError:
traceback.print_exc()
self.msg(origin,"Syntax error v příkazu "+module_name+". Detaily v konzoli.")
events.unload(self)
try:
reload_module(events)
except SyntaxError:
traceback.print_exc()
self.msg(origin,"Syntax error v seznamu eventů. Detaily v konzoli.")
for module_name in filter(lambda x: not x.startswith('_'), dir(events)):
try:
reload_module(getattr(events,module_name))
except SyntaxError:
traceback.print_exc()
self.msg(origin,"Syntax error v eventu "+module_name+". Detaily v konzoli.")
except BaseException:
pass
events.load(self)
def main():
for script_path in set(sys.path[1:8:2]):
try:
suffix = os.extsep+"py"
for script in os.listdir(script_path):
if script.endswith(suffix):
try:
events.load(script)
except:
traceback.print_exc()
print "Failed loading script %s." % script
except OSError:
pass
ui.start(' '.join(sys.argv[1:]))
def verify_submission(s, submission_id):
"""Validate event database storage of classic db import data."""
submission, stack = events.load(submission_id)
assert submission.metadata.title == s['title']
assert submission.metadata.abstract == s['abstract']
assert submission.metadata.comments == s['comments']
assert submission.metadata.report_num == s['report_num']
assert submission.metadata.doi == s['doi']
assert submission.metadata.journal_ref == s['journal_ref']
if s.get('userinfo') == '1':
assert submission.submitter_contact_verified, "VerifyContactInformationError"
else:
assert not submission.submitter_contact_verified
if s.get('agree_policy') == '1':
assert submission.submitter_accepts_policy, "AcceptPolicy Error"
else:
assert not submission.submitter_accepts_policy
if s.get('license'):
assert submission.license.uri == s['license']
if s.get('is_author') == '1':
assert submission.submitter_is_author, "AssertAuthorship not aligned: returns False, should be True"
else:
assert not submission.submitter_is_author, "AssertAuthorship does not match: returns True, should be False"
if s.get('status') not in INVALID_STATUSES:
assert submission.status == Submission.SUBMITTED
else:
assert submission.status == Submission.WORKING
def test_publication_status_is_reflected_after_files_expire(self):
"""The submission has been published/announced, and files expired."""
with self.app.app_context():
session = classic.current_session()
# Publication agent publishes the paper.
db_submission = session.query(classic.models.Submission)\
.get(self.submission.submission_id)
db_submission.status = db_submission.DELETED_PUBLISHED
dated = (datetime.now() - datetime.utcfromtimestamp(0))
primary = self.submission.primary_classification.category
db_submission.document = classic.models.Document(
document_id=1,
paper_id='1901.00123',
title=self.submission.metadata.title,
authors=self.submission.metadata.authors_display,
dated=dated.total_seconds(),
primary_subject_class=primary,
created=datetime.now(),
submitter_email=self.submission.creator.email,
submitter_id=self.submission.creator.native_id
)
session.add(db_submission)
session.commit()
# Submission state should reflect publication status.
submission, _ = events.load(self.submission.submission_id)
self.assertEqual(submission.status, submission.PUBLISHED,
"Submission should have published status.")
self.assertEqual(submission.arxiv_id, "1901.00123",
"arXiv paper ID should be set")
self.assertFalse(submission.active,
"Published submission should no longer be active")
def __init__(self):
IRC.__init__(self,SERVER)
self.version = VERSION
self.nickname = NICKNAME
self.realname = REALNAME
self.names = set()
self.add_handler("connected",lambda **kw: self.on_connect())
self.add_handler("channel message",self.on_channel_message)
self.add_handler("query",self.on_query)
self.add_handler("nick in use", lambda **kw: self.nick(self.nickname+"_"))
self.add_handler("names",self.on_names)
self.add_handler("joined",lambda nick,**kw: self.names.add(nick))
self.add_handler("left",lambda nick,**kw: self.names.discard(nick))
self.add_handler("nick",lambda nick, new_nick,**kw: self.names.symmetric_difference_update(set((nick,new_nick))) if nick!=new_nick else None)
events.load(self)
def get_submission(submission_id: str, user: Optional[str] = None,
client: Optional[str] = None,
token: Optional[str] = None) -> Response:
"""Retrieve the current state of a submission."""
try:
submission, events = ev.load(submission_id)
except ev.NoSuchSubmission as e:
raise NotFound('Submission not found') from e
except Exception as e:
logger.error('Unhandled exception: (%s) %s', str(type(e)), str(e))
raise InternalServerError('Encountered unhandled exception') from e
return submission.to_dict(), status.HTTP_200_OK, {}
def __init__(self):
IRC.__init__(self, "irc.rizon.net")
self.version = "Lal, robot pro #vch 0.0.1"
self.nickname = NICKNAME
self.realname = "Lal, VCh robot"
self.names = set()
self.add_handler("connected", lambda **kw: self.on_connect())
self.add_handler("channel message", self.on_channel_message)
self.add_handler("query", self.on_query)
self.add_handler("nick in use", lambda **kw: self.nick(self.nickname + "_"))
self.add_handler("names", self.on_names)
self.add_handler("joined", lambda nick, **kw: self.names.add(nick))
self.add_handler("left", lambda nick, **kw: self.names.discard(nick))
self.add_handler(
"nick",
lambda nick, new_nick, **kw: self.names.symmetric_difference_update(set((nick, new_nick)))
if nick != new_nick
else None,
)
events.load(self)
def test_publication_failed(self):
"""The submission was not published successfully."""
with self.app.app_context():
session = classic.current_session()
# Publication agent publishes the paper.
db_submission = session.query(classic.models.Submission)\
.get(self.submission.submission_id)
db_submission.status = db_submission.ERROR_STATE
session.add(db_submission)
session.commit()
# Submission state should reflect scheduled status.
submission, _ = events.load(self.submission.submission_id)
self.assertEqual(submission.status, submission.ERROR,
"Submission should have error status.")
def test_scheduled_tomorrow_status_is_reflected(self):
"""The submission has been scheduled for publication tomorrow."""
with self.app.app_context():
session = classic.current_session()
# Publication agent publishes the paper.
db_submission = session.query(classic.models.Submission)\
.get(self.submission.submission_id)
db_submission.status = db_submission.NEXT_PUBLISH_DAY
session.add(db_submission)
session.commit()
# Submission state should reflect scheduled status.
submission, _ = events.load(self.submission.submission_id)
self.assertEqual(submission.status, submission.SCHEDULED,
"Submission should be scheduled for tomorrow.")
def test_scheduled_status_is_reflected_prior_to_announcement(self):
"""The submission is being published; not yet announced."""
with self.app.app_context():
session = classic.current_session()
# Publication agent publishes the paper.
db_submission = session.query(classic.models.Submission)\
.get(self.submission.submission_id)
db_submission.status = db_submission.NEEDS_EMAIL
session.add(db_submission)
session.commit()
# Submission state should reflect scheduled status.
submission, _ = events.load(self.submission.submission_id)
self.assertEqual(submission.status, submission.SCHEDULED,
"Submission should have scheduled status.")
def test_scheduled_status_is_reflected_processing_submission(self):
"""The submission has been scheduled for publication today."""
with self.app.app_context():
session = classic.current_session()
# Publication agent publishes the paper.
db_submission = session.query(classic.models.Submission)\
.get(self.submission.submission_id)
db_submission.status = db_submission.PROCESSING_SUBMISSION
session.add(db_submission)
session.commit()
# Submission state should reflect scheduled status.
submission, _ = events.load(self.submission.submission_id)
self.assertEqual(submission.status, submission.SCHEDULED,
"Submission should have scheduled status.")
def test_load_existant_submission(self, mock_classic):
"""When the submission exists, submission and events are returned."""
u = User(12345, '*****@*****.**')
mock_classic.get_submission.return_value = (
Submission(creator=u, submission_id=1, owner=u,
created=datetime.now()),
[CreateSubmission(creator=u, submission_id=1, committed=True)]
)
submission, events = load(1)
self.assertEqual(mock_classic.get_submission.call_count, 1)
self.assertIsInstance(submission, Submission,
"A submission should be returned")
self.assertIsInstance(events, list,
"A list of events should be returned")
self.assertIsInstance(events[0], Event,
"A list of events should be returned")
def test_deleted(self):
"""The submission was deleted."""
with self.app.app_context():
session = classic.current_session()
for classic_status in classic.models.Submission.DELETED:
# Publication agent publishes the paper.
db_submission = session.query(classic.models.Submission)\
.get(self.submission.submission_id)
db_submission.status = classic_status
session.add(db_submission)
session.commit()
# Submission state should reflect scheduled status.
submission, _ = events.load(self.submission.submission_id)
self.assertEqual(submission.status, submission.DELETED,
"Submission should have deleted status.")
e.done = True
def setupCtcpReply(e):
if e.name == 'PING':
try:
elapsed_time = "%0.2f seconds" % (time.time() - float(e.args[0]))
e.old_args = e.args
e.args = [elapsed_time]
except:
pass
def setupCtcp(e):
if not e.done:
if e.name == 'ACTION':
e_data = events.data(**e.__dict__)
e_data.text = ' '.join(e.args)
events.trigger('Action', e_data)
e.done = True
e.quiet = True
elif e.name == 'PING':
ctcp_reply(e.network, e.source, e.text)
e.done = True
elif e.name == 'VERSION':
ctcp_reply(e.network, e.source, 'VERSION %s - %s' % (urk.long_version, urk.website))
e.done = True
elif e.name == 'TIME':
ctcp_reply(e.network, e.source, 'TIME %s' % time.asctime())
e.done = True
events.load(__name__)
def test_load_nonexistant_submission(self, mock_classic):
"""When the submission does not exist, an exception is raised."""
mock_classic.get_submission.side_effect = classic.NoSuchSubmission
mock_classic.NoSuchSubmission = classic.NoSuchSubmission
with self.assertRaises(NoSuchSubmission):
load(1)
