prompt
large_stringlengths 72
9.34k
| completion
large_stringlengths 0
7.61k
|
|---|---|
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
<|fim_middle|>
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | """
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
<|fim_middle|>
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1 |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
<|fim_middle|>
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | return every(job, timedelta=timedelta(days=1), loop=loop) |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
<|fim_middle|>
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | return every(job, timedelta=timedelta(days=7), loop=loop) |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
<|fim_middle|>
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7) |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
<|fim_middle|>
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop) |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
<|fim_middle|>
<｜fim▁end｜> | return once_at(job, _nearest_weekday(weekday), loop=loop) |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
<|fim_middle|>
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | loop = asyncio.get_event_loop() |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def <|fim_middle|>(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | every_random_interval |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def <|fim_middle|>():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | wait_time_gen |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def <|fim_middle|>(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | every_day |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def <|fim_middle|>(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | every_week |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def <|fim_middle|>(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | _nearest_weekday |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def <|fim_middle|>(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def _once_at_weekday(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | _every_weekday |
<|file_name|>ext.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
from datetime import timedelta, datetime
import asyncio
import random
from .api import every, once_at, JobSchedule, default_schedule_manager
__all__ = ['every_day', 'every_week', 'every_monday', 'every_tuesday', 'every_wednesday',
'every_thursday', 'every_friday', 'every_saturday', 'every_sunday',
'once_at_next_monday', 'once_at_next_tuesday', 'once_at_next_wednesday',
'once_at_next_thursday', 'once_at_next_friday', 'once_at_next_saturday',
'once_at_next_sunday', 'every_random_interval']
def every_random_interval(job, interval: timedelta, loop=None):
"""
executes the job randomly once in the specified interval.
example:
run a job every day at random time
run a job every hour at random time
:param job: a callable(co-routine function) which returns
a co-routine or a future or an awaitable
:param interval: the interval can also be given in the format of datetime.timedelta,
then seconds, minutes, hours, days, weeks parameters are ignored.
:param loop: io loop if the provided job is a custom future linked up
with a different event loop.
:return: schedule object, so it could be cancelled at will of the user by
aschedule.cancel(schedule)
"""
if loop is None:
loop = asyncio.get_event_loop()
start = loop.time()
def wait_time_gen():
count = 0
while True:
rand = random.randrange(round(interval.total_seconds()))
tmp = round(start + interval.total_seconds() * count + rand - loop.time())
yield tmp
count += 1
schedule = JobSchedule(job, wait_time_gen(), loop=loop)
# add it to default_schedule_manager, so that user can aschedule.cancel it
default_schedule_manager.add_schedule(schedule)
return schedule
def every_day(job, loop=None):
return every(job, timedelta=timedelta(days=1), loop=loop)
def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop)
every_monday = lambda job, loop=None: _every_weekday(job, 0, loop=loop)
every_tuesday = lambda job, loop=None: _every_weekday(job, 1, loop=loop)
every_wednesday = lambda job, loop=None: _every_weekday(job, 2, loop=loop)
every_thursday = lambda job, loop=None: _every_weekday(job, 3, loop=loop)
every_friday = lambda job, loop=None: _every_weekday(job, 4, loop=loop)
every_saturday = lambda job, loop=None: _every_weekday(job, 5, loop=loop)
every_sunday = lambda job, loop=None: _every_weekday(job, 6, loop=loop)
once_at_next_monday = lambda job, loop=None: _once_at_weekday(job, 0, loop=loop)
once_at_next_tuesday = lambda job, loop=None: _once_at_weekday(job, 1, loop=loop)
once_at_next_wednesday = lambda job, loop=None: _once_at_weekday(job, 2, loop=loop)
once_at_next_thursday = lambda job, loop=None: _once_at_weekday(job, 3, loop=loop)
once_at_next_friday = lambda job, loop=None: _once_at_weekday(job, 4, loop=loop)
once_at_next_saturday = lambda job, loop=None: _once_at_weekday(job, 5, loop=loop)
once_at_next_sunday = lambda job, loop=None: _once_at_weekday(job, 6, loop=loop)
def _nearest_weekday(weekday):
return datetime.now() + timedelta(days=(weekday - datetime.now().weekday()) % 7)
def _every_weekday(job, weekday, loop=None):
return every(job, timedelta=timedelta(days=7), start_at=_nearest_weekday(weekday), loop=loop)
def <|fim_middle|>(job, weekday, loop=None):
return once_at(job, _nearest_weekday(weekday), loop=loop)
<｜fim▁end｜> | _once_at_weekday |
<|file_name|>package.py<|end_file_name|><｜fim▁begin｜># Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack import *
class Serf(SConsPackage):
"""Apache Serf - a high performance C-based HTTP client library
built upon the Apache Portable Runtime (APR) library"""
homepage = 'https://serf.apache.org/'
url = 'https://archive.apache.org/dist/serf/serf-1.3.9.tar.bz2'
maintainers = ['cosmicexplorer']
version('1.3.9', sha256='549c2d21c577a8a9c0450facb5cca809f26591f048e466552240947bdf7a87cc')
version('1.3.8', sha256='e0500be065dbbce490449837bb2ab624e46d64fc0b090474d9acaa87c82b2590')
variant('debug', default=False,
description='Enable debugging info and strict compile warnings')
depends_on('apr')
depends_on('apr-util')
depends_on('openssl')
depends_on('python+pythoncmd', type='build')
depends_on('[email protected]:', type='build')
depends_on('uuid')
depends_on('zlib')
patch('py3syntax.patch')
patch('py3-hashbang.patch')
def build_args(self, spec, prefix):
args = {
'PREFIX': prefix,
'APR': spec['apr'].prefix,
'APU': spec['apr-util'].prefix,
'OPENSSL': spec['openssl'].prefix,
'ZLIB': spec['zlib'].prefix,
'DEBUG': 'yes' if '+debug' in spec else 'no',
}
# SCons doesn't pass Spack environment variables to the
# execution environment. Therefore, we can't use Spack's compiler
# wrappers. Use the actual compilers. SCons seems to RPATH things
# on its own anyway.
args['CC'] = self.compiler.cc<｜fim▁hole｜> # Pass explicit link flags for both.
library_dirs = []
include_dirs = []
for dep in spec.dependencies(deptype='link'):
query = self.spec[dep.name]
library_dirs.extend(query.libs.directories)
include_dirs.extend(query.headers.directories)
rpath = self.compiler.cc_rpath_arg
args['LINKFLAGS'] = '-L' + ' -L'.join(library_dirs)
args['LINKFLAGS'] += ' ' + rpath + (' ' + rpath).join(library_dirs)
args['CPPFLAGS'] = '-I' + ' -I'.join(include_dirs)
return [key + '=' + value for key, value in args.items()]
def build_test(self):
# FIXME: Several test failures:
#
# There were 14 failures:
# 1) test_ssl_trust_rootca
# 2) test_ssl_certificate_chain_with_anchor
# 3) test_ssl_certificate_chain_all_from_server
# 4) test_ssl_no_servercert_callback_allok
# 5) test_ssl_large_response
# 6) test_ssl_large_request
# 7) test_ssl_client_certificate
# 8) test_ssl_future_server_cert
# 9) test_setup_ssltunnel
# 10) test_ssltunnel_basic_auth
# 11) test_ssltunnel_basic_auth_server_has_keepalive_off
# 12) test_ssltunnel_basic_auth_proxy_has_keepalive_off
# 13) test_ssltunnel_basic_auth_proxy_close_conn_on_200resp
# 14) test_ssltunnel_digest_auth
#
# These seem to be related to:
# https://groups.google.com/forum/#!topic/serf-dev/YEFTTdF1Qwc
scons('check')<｜fim▁end｜> |
# Old versions of serf ignore the ZLIB variable on non-Windows platforms.
# Also, there is no UUID variable to specify its installation location. |
<|file_name|>package.py<|end_file_name|><｜fim▁begin｜># Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack import *
class Serf(SConsPackage):
<|fim_middle|>
<｜fim▁end｜> | """Apache Serf - a high performance C-based HTTP client library
built upon the Apache Portable Runtime (APR) library"""
homepage = 'https://serf.apache.org/'
url = 'https://archive.apache.org/dist/serf/serf-1.3.9.tar.bz2'
maintainers = ['cosmicexplorer']
version('1.3.9', sha256='549c2d21c577a8a9c0450facb5cca809f26591f048e466552240947bdf7a87cc')
version('1.3.8', sha256='e0500be065dbbce490449837bb2ab624e46d64fc0b090474d9acaa87c82b2590')
variant('debug', default=False,
description='Enable debugging info and strict compile warnings')
depends_on('apr')
depends_on('apr-util')
depends_on('openssl')
depends_on('python+pythoncmd', type='build')
depends_on('[email protected]:', type='build')
depends_on('uuid')
depends_on('zlib')
patch('py3syntax.patch')
patch('py3-hashbang.patch')
def build_args(self, spec, prefix):
args = {
'PREFIX': prefix,
'APR': spec['apr'].prefix,
'APU': spec['apr-util'].prefix,
'OPENSSL': spec['openssl'].prefix,
'ZLIB': spec['zlib'].prefix,
'DEBUG': 'yes' if '+debug' in spec else 'no',
}
# SCons doesn't pass Spack environment variables to the
# execution environment. Therefore, we can't use Spack's compiler
# wrappers. Use the actual compilers. SCons seems to RPATH things
# on its own anyway.
args['CC'] = self.compiler.cc
# Old versions of serf ignore the ZLIB variable on non-Windows platforms.
# Also, there is no UUID variable to specify its installation location.
# Pass explicit link flags for both.
library_dirs = []
include_dirs = []
for dep in spec.dependencies(deptype='link'):
query = self.spec[dep.name]
library_dirs.extend(query.libs.directories)
include_dirs.extend(query.headers.directories)
rpath = self.compiler.cc_rpath_arg
args['LINKFLAGS'] = '-L' + ' -L'.join(library_dirs)
args['LINKFLAGS'] += ' ' + rpath + (' ' + rpath).join(library_dirs)
args['CPPFLAGS'] = '-I' + ' -I'.join(include_dirs)
return [key + '=' + value for key, value in args.items()]
def build_test(self):
# FIXME: Several test failures:
#
# There were 14 failures:
# 1) test_ssl_trust_rootca
# 2) test_ssl_certificate_chain_with_anchor
# 3) test_ssl_certificate_chain_all_from_server
# 4) test_ssl_no_servercert_callback_allok
# 5) test_ssl_large_response
# 6) test_ssl_large_request
# 7) test_ssl_client_certificate
# 8) test_ssl_future_server_cert
# 9) test_setup_ssltunnel
# 10) test_ssltunnel_basic_auth
# 11) test_ssltunnel_basic_auth_server_has_keepalive_off
# 12) test_ssltunnel_basic_auth_proxy_has_keepalive_off
# 13) test_ssltunnel_basic_auth_proxy_close_conn_on_200resp
# 14) test_ssltunnel_digest_auth
#
# These seem to be related to:
# https://groups.google.com/forum/#!topic/serf-dev/YEFTTdF1Qwc
scons('check') |
<|file_name|>package.py<|end_file_name|><｜fim▁begin｜># Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack import *
class Serf(SConsPackage):
"""Apache Serf - a high performance C-based HTTP client library
built upon the Apache Portable Runtime (APR) library"""
homepage = 'https://serf.apache.org/'
url = 'https://archive.apache.org/dist/serf/serf-1.3.9.tar.bz2'
maintainers = ['cosmicexplorer']
version('1.3.9', sha256='549c2d21c577a8a9c0450facb5cca809f26591f048e466552240947bdf7a87cc')
version('1.3.8', sha256='e0500be065dbbce490449837bb2ab624e46d64fc0b090474d9acaa87c82b2590')
variant('debug', default=False,
description='Enable debugging info and strict compile warnings')
depends_on('apr')
depends_on('apr-util')
depends_on('openssl')
depends_on('python+pythoncmd', type='build')
depends_on('[email protected]:', type='build')
depends_on('uuid')
depends_on('zlib')
patch('py3syntax.patch')
patch('py3-hashbang.patch')
def build_args(self, spec, prefix):
<|fim_middle|>
def build_test(self):
# FIXME: Several test failures:
#
# There were 14 failures:
# 1) test_ssl_trust_rootca
# 2) test_ssl_certificate_chain_with_anchor
# 3) test_ssl_certificate_chain_all_from_server
# 4) test_ssl_no_servercert_callback_allok
# 5) test_ssl_large_response
# 6) test_ssl_large_request
# 7) test_ssl_client_certificate
# 8) test_ssl_future_server_cert
# 9) test_setup_ssltunnel
# 10) test_ssltunnel_basic_auth
# 11) test_ssltunnel_basic_auth_server_has_keepalive_off
# 12) test_ssltunnel_basic_auth_proxy_has_keepalive_off
# 13) test_ssltunnel_basic_auth_proxy_close_conn_on_200resp
# 14) test_ssltunnel_digest_auth
#
# These seem to be related to:
# https://groups.google.com/forum/#!topic/serf-dev/YEFTTdF1Qwc
scons('check')
<｜fim▁end｜> | args = {
'PREFIX': prefix,
'APR': spec['apr'].prefix,
'APU': spec['apr-util'].prefix,
'OPENSSL': spec['openssl'].prefix,
'ZLIB': spec['zlib'].prefix,
'DEBUG': 'yes' if '+debug' in spec else 'no',
}
# SCons doesn't pass Spack environment variables to the
# execution environment. Therefore, we can't use Spack's compiler
# wrappers. Use the actual compilers. SCons seems to RPATH things
# on its own anyway.
args['CC'] = self.compiler.cc
# Old versions of serf ignore the ZLIB variable on non-Windows platforms.
# Also, there is no UUID variable to specify its installation location.
# Pass explicit link flags for both.
library_dirs = []
include_dirs = []
for dep in spec.dependencies(deptype='link'):
query = self.spec[dep.name]
library_dirs.extend(query.libs.directories)
include_dirs.extend(query.headers.directories)
rpath = self.compiler.cc_rpath_arg
args['LINKFLAGS'] = '-L' + ' -L'.join(library_dirs)
args['LINKFLAGS'] += ' ' + rpath + (' ' + rpath).join(library_dirs)
args['CPPFLAGS'] = '-I' + ' -I'.join(include_dirs)
return [key + '=' + value for key, value in args.items()] |
<|file_name|>package.py<|end_file_name|><｜fim▁begin｜># Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack import *
class Serf(SConsPackage):
"""Apache Serf - a high performance C-based HTTP client library
built upon the Apache Portable Runtime (APR) library"""
homepage = 'https://serf.apache.org/'
url = 'https://archive.apache.org/dist/serf/serf-1.3.9.tar.bz2'
maintainers = ['cosmicexplorer']
version('1.3.9', sha256='549c2d21c577a8a9c0450facb5cca809f26591f048e466552240947bdf7a87cc')
version('1.3.8', sha256='e0500be065dbbce490449837bb2ab624e46d64fc0b090474d9acaa87c82b2590')
variant('debug', default=False,
description='Enable debugging info and strict compile warnings')
depends_on('apr')
depends_on('apr-util')
depends_on('openssl')
depends_on('python+pythoncmd', type='build')
depends_on('[email protected]:', type='build')
depends_on('uuid')
depends_on('zlib')
patch('py3syntax.patch')
patch('py3-hashbang.patch')
def build_args(self, spec, prefix):
args = {
'PREFIX': prefix,
'APR': spec['apr'].prefix,
'APU': spec['apr-util'].prefix,
'OPENSSL': spec['openssl'].prefix,
'ZLIB': spec['zlib'].prefix,
'DEBUG': 'yes' if '+debug' in spec else 'no',
}
# SCons doesn't pass Spack environment variables to the
# execution environment. Therefore, we can't use Spack's compiler
# wrappers. Use the actual compilers. SCons seems to RPATH things
# on its own anyway.
args['CC'] = self.compiler.cc
# Old versions of serf ignore the ZLIB variable on non-Windows platforms.
# Also, there is no UUID variable to specify its installation location.
# Pass explicit link flags for both.
library_dirs = []
include_dirs = []
for dep in spec.dependencies(deptype='link'):
query = self.spec[dep.name]
library_dirs.extend(query.libs.directories)
include_dirs.extend(query.headers.directories)
rpath = self.compiler.cc_rpath_arg
args['LINKFLAGS'] = '-L' + ' -L'.join(library_dirs)
args['LINKFLAGS'] += ' ' + rpath + (' ' + rpath).join(library_dirs)
args['CPPFLAGS'] = '-I' + ' -I'.join(include_dirs)
return [key + '=' + value for key, value in args.items()]
def build_test(self):
# FIXME: Several test failures:
#
# There were 14 failures:
# 1) test_ssl_trust_rootca
# 2) test_ssl_certificate_chain_with_anchor
# 3) test_ssl_certificate_chain_all_from_server
# 4) test_ssl_no_servercert_callback_allok
# 5) test_ssl_large_response
# 6) test_ssl_large_request
# 7) test_ssl_client_certificate
# 8) test_ssl_future_server_cert
# 9) test_setup_ssltunnel
# 10) test_ssltunnel_basic_auth
# 11) test_ssltunnel_basic_auth_server_has_keepalive_off
# 12) test_ssltunnel_basic_auth_proxy_has_keepalive_off
# 13) test_ssltunnel_basic_auth_proxy_close_conn_on_200resp
# 14) test_ssltunnel_digest_auth
#
# These seem to be related to:
# https://groups.google.com/forum/#!topic/serf-dev/YEFTTdF1Qwc
<|fim_middle|>
<｜fim▁end｜> | scons('check') |
<|file_name|>package.py<|end_file_name|><｜fim▁begin｜># Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack import *
class Serf(SConsPackage):
"""Apache Serf - a high performance C-based HTTP client library
built upon the Apache Portable Runtime (APR) library"""
homepage = 'https://serf.apache.org/'
url = 'https://archive.apache.org/dist/serf/serf-1.3.9.tar.bz2'
maintainers = ['cosmicexplorer']
version('1.3.9', sha256='549c2d21c577a8a9c0450facb5cca809f26591f048e466552240947bdf7a87cc')
version('1.3.8', sha256='e0500be065dbbce490449837bb2ab624e46d64fc0b090474d9acaa87c82b2590')
variant('debug', default=False,
description='Enable debugging info and strict compile warnings')
depends_on('apr')
depends_on('apr-util')
depends_on('openssl')
depends_on('python+pythoncmd', type='build')
depends_on('[email protected]:', type='build')
depends_on('uuid')
depends_on('zlib')
patch('py3syntax.patch')
patch('py3-hashbang.patch')
def <|fim_middle|>(self, spec, prefix):
args = {
'PREFIX': prefix,
'APR': spec['apr'].prefix,
'APU': spec['apr-util'].prefix,
'OPENSSL': spec['openssl'].prefix,
'ZLIB': spec['zlib'].prefix,
'DEBUG': 'yes' if '+debug' in spec else 'no',
}
# SCons doesn't pass Spack environment variables to the
# execution environment. Therefore, we can't use Spack's compiler
# wrappers. Use the actual compilers. SCons seems to RPATH things
# on its own anyway.
args['CC'] = self.compiler.cc
# Old versions of serf ignore the ZLIB variable on non-Windows platforms.
# Also, there is no UUID variable to specify its installation location.
# Pass explicit link flags for both.
library_dirs = []
include_dirs = []
for dep in spec.dependencies(deptype='link'):
query = self.spec[dep.name]
library_dirs.extend(query.libs.directories)
include_dirs.extend(query.headers.directories)
rpath = self.compiler.cc_rpath_arg
args['LINKFLAGS'] = '-L' + ' -L'.join(library_dirs)
args['LINKFLAGS'] += ' ' + rpath + (' ' + rpath).join(library_dirs)
args['CPPFLAGS'] = '-I' + ' -I'.join(include_dirs)
return [key + '=' + value for key, value in args.items()]
def build_test(self):
# FIXME: Several test failures:
#
# There were 14 failures:
# 1) test_ssl_trust_rootca
# 2) test_ssl_certificate_chain_with_anchor
# 3) test_ssl_certificate_chain_all_from_server
# 4) test_ssl_no_servercert_callback_allok
# 5) test_ssl_large_response
# 6) test_ssl_large_request
# 7) test_ssl_client_certificate
# 8) test_ssl_future_server_cert
# 9) test_setup_ssltunnel
# 10) test_ssltunnel_basic_auth
# 11) test_ssltunnel_basic_auth_server_has_keepalive_off
# 12) test_ssltunnel_basic_auth_proxy_has_keepalive_off
# 13) test_ssltunnel_basic_auth_proxy_close_conn_on_200resp
# 14) test_ssltunnel_digest_auth
#
# These seem to be related to:
# https://groups.google.com/forum/#!topic/serf-dev/YEFTTdF1Qwc
scons('check')
<｜fim▁end｜> | build_args |
<|file_name|>package.py<|end_file_name|><｜fim▁begin｜># Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack import *
class Serf(SConsPackage):
"""Apache Serf - a high performance C-based HTTP client library
built upon the Apache Portable Runtime (APR) library"""
homepage = 'https://serf.apache.org/'
url = 'https://archive.apache.org/dist/serf/serf-1.3.9.tar.bz2'
maintainers = ['cosmicexplorer']
version('1.3.9', sha256='549c2d21c577a8a9c0450facb5cca809f26591f048e466552240947bdf7a87cc')
version('1.3.8', sha256='e0500be065dbbce490449837bb2ab624e46d64fc0b090474d9acaa87c82b2590')
variant('debug', default=False,
description='Enable debugging info and strict compile warnings')
depends_on('apr')
depends_on('apr-util')
depends_on('openssl')
depends_on('python+pythoncmd', type='build')
depends_on('[email protected]:', type='build')
depends_on('uuid')
depends_on('zlib')
patch('py3syntax.patch')
patch('py3-hashbang.patch')
def build_args(self, spec, prefix):
args = {
'PREFIX': prefix,
'APR': spec['apr'].prefix,
'APU': spec['apr-util'].prefix,
'OPENSSL': spec['openssl'].prefix,
'ZLIB': spec['zlib'].prefix,
'DEBUG': 'yes' if '+debug' in spec else 'no',
}
# SCons doesn't pass Spack environment variables to the
# execution environment. Therefore, we can't use Spack's compiler
# wrappers. Use the actual compilers. SCons seems to RPATH things
# on its own anyway.
args['CC'] = self.compiler.cc
# Old versions of serf ignore the ZLIB variable on non-Windows platforms.
# Also, there is no UUID variable to specify its installation location.
# Pass explicit link flags for both.
library_dirs = []
include_dirs = []
for dep in spec.dependencies(deptype='link'):
query = self.spec[dep.name]
library_dirs.extend(query.libs.directories)
include_dirs.extend(query.headers.directories)
rpath = self.compiler.cc_rpath_arg
args['LINKFLAGS'] = '-L' + ' -L'.join(library_dirs)
args['LINKFLAGS'] += ' ' + rpath + (' ' + rpath).join(library_dirs)
args['CPPFLAGS'] = '-I' + ' -I'.join(include_dirs)
return [key + '=' + value for key, value in args.items()]
def <|fim_middle|>(self):
# FIXME: Several test failures:
#
# There were 14 failures:
# 1) test_ssl_trust_rootca
# 2) test_ssl_certificate_chain_with_anchor
# 3) test_ssl_certificate_chain_all_from_server
# 4) test_ssl_no_servercert_callback_allok
# 5) test_ssl_large_response
# 6) test_ssl_large_request
# 7) test_ssl_client_certificate
# 8) test_ssl_future_server_cert
# 9) test_setup_ssltunnel
# 10) test_ssltunnel_basic_auth
# 11) test_ssltunnel_basic_auth_server_has_keepalive_off
# 12) test_ssltunnel_basic_auth_proxy_has_keepalive_off
# 13) test_ssltunnel_basic_auth_proxy_close_conn_on_200resp
# 14) test_ssltunnel_digest_auth
#
# These seem to be related to:
# https://groups.google.com/forum/#!topic/serf-dev/YEFTTdF1Qwc
scons('check')
<｜fim▁end｜> | build_test |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"<｜fim▁hole｜> }
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)<｜fim▁end｜> | user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False, |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
<|fim_middle|>
<｜fim▁end｜> | def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
|
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
<|fim_middle|>
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
<|fim_middle|>
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd) |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
<|fim_middle|>
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | pass |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
<|fim_middle|>
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code) |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
<|fim_middle|>
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code) |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
<|fim_middle|>
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code) |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
<|fim_middle|>
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code) |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
<|fim_middle|>
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code) |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
<|fim_middle|>
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code) |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
<|fim_middle|>
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code) |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
<|fim_middle|>
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
<|fim_middle|>
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
|
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
<|fim_middle|>
<｜fim▁end｜> | response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
|
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
<|fim_middle|>
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | return |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def <|fim_middle|>(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | _init_test_lecturer |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def <|fim_middle|>(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | setUp |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def <|fim_middle|>(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | tearDown |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def <|fim_middle|>(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | test_home |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def <|fim_middle|>(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | test_index |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def <|fim_middle|>(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | test_login |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def <|fim_middle|>(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | test_login_auth |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def <|fim_middle|>(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | test_logout |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def <|fim_middle|>(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | test_timeslots |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def <|fim_middle|>(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | test_living |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def <|fim_middle|>(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | test_timeslot_questions |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def <|fim_middle|>(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = reverse('lecturer:api-exercise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | test_exercise_store |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
from app import models
from django.test import Client, TestCase
from django.contrib.auth.hashers import make_password
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
# Create your tests here.
class TestLecturerWeb(TestCase):
def _init_test_lecturer(self):
if hasattr(self, '_lecturer'):
return
self.lecturer = "lecturer_oUP1zwTO9"
self.lecturer_pswd = "123"
user_data = {
'password': make_password(self.lecturer_pswd),
'is_staff': False,
'is_superuser': False,
}
user, _ = User.objects.get_or_create(username=self.lecturer,
defaults=user_data)
_lecturer, _ = models.Lecturer.objects.get_or_create(
user=user,
defaults={
"subject": models.Subject.get_english(),
"name": "kaoru"
})
self._lecturer = _lecturer
def setUp(self):
self.client = Client()
self._init_test_lecturer()
self.client.login(username=self.lecturer, password=self.lecturer_pswd)
def tearDown(self):
pass
def test_home(self):
response = self.client.get(reverse('lecturer:home'))
self.assertEqual(302, response.status_code)
def test_index(self):
response = self.client.get(reverse('lecturer:index'))
self.assertEqual(200, response.status_code)
def test_login(self):
client = Client()
response = client.get(reverse('lecturer:login'))
self.assertEqual(200, response.status_code)
def test_login_auth(self):
client = Client()
data = {'username': self.lecturer, 'password': self.lecturer_pswd}
response = client.post(reverse('lecturer:login'), data=data)
self.assertEqual(302, response.status_code)
def test_logout(self):
client = Client()
client.login(username=self.lecturer, password=self.lecturer_pswd)
response = client.get(reverse('lecturer:logout'))
self.assertEqual(302, response.status_code)
def test_timeslots(self):
response = self.client.get(reverse('lecturer:timeslots'))
self.assertEqual(200, response.status_code)
def test_living(self):
response = self.client.get(reverse('lecturer:living'))
self.assertEqual(200, response.status_code)
def test_timeslot_questions(self):
response = self.client.get(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 1}))
self.assertEqual(200, response.status_code)
# update test
response = self.client.post(
reverse('lecturer:timeslot-questions', kwargs={'tsid': 0}),
data={'gids': ''}
)
self.assertEqual(404, response.status_code)
# TODO: create test LiveCourse
def test_exercise_store(self):
response = self.client.get(reverse('lecturer:exercise-store'))
self.assertEqual(200, response.status_code)
data = {
"group": '{"exercises":[{"analyse":"题目解析","solution":"选项1","id":"","title":"题目","options":[{"text":"选项1","id":""},{"text":"选项2","id":""},{"text":"选项3","id":""},{"text":"选项4","id":""}]}],"desc":"题组描述","id":"","title":"题组名称"}'}
response = self.client.post(reverse('lecturer:exercise-store'), data)
self.assertEqual(200, response.status_code)
def test_api_exercise_store(self):
url = rev<|fim_middle|>cise-store')
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group_list'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
url = reverse('lecturer:api-exercise-store') + '?action=group&gid=1'
response = self.client.get(url)
self.assertEqual(200, response.status_code)
<｜fim▁end｜> | erse('lecturer:api-exer |
<|file_name|>setup.py<|end_file_name|><｜fim▁begin｜>from setuptools import setup
def readme():
with open('README.rst') as f:
return f.read()<｜fim▁hole｜>setup(name='MapperTools',
packages=['MapperTools'],
version='0.1',
description='A python 2.7 implementation of Mapper algorithm for Topological Data Analysis',
keywords='mapper TDA python',
long_description=readme(),
url='http://github.com/alpatania',
author='Alice Patania',
author_email='[email protected]',
license='MIT',
classifiers=['Development Status :: 3 - Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 2.7'],
install_requires=['hdbscan', 'sklearn', 'pandas', 'collections'],
include_package_data=True,
zip_safe=False)<｜fim▁end｜> | |
<|file_name|>setup.py<|end_file_name|><｜fim▁begin｜>from setuptools import setup
def readme():
<|fim_middle|>
setup(name='MapperTools',
packages=['MapperTools'],
version='0.1',
description='A python 2.7 implementation of Mapper algorithm for Topological Data Analysis',
keywords='mapper TDA python',
long_description=readme(),
url='http://github.com/alpatania',
author='Alice Patania',
author_email='[email protected]',
license='MIT',
classifiers=['Development Status :: 3 - Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 2.7'],
install_requires=['hdbscan', 'sklearn', 'pandas', 'collections'],
include_package_data=True,
zip_safe=False)<｜fim▁end｜> | with open('README.rst') as f:
return f.read() |
<|file_name|>setup.py<|end_file_name|><｜fim▁begin｜>from setuptools import setup
def <|fim_middle|>():
with open('README.rst') as f:
return f.read()
setup(name='MapperTools',
packages=['MapperTools'],
version='0.1',
description='A python 2.7 implementation of Mapper algorithm for Topological Data Analysis',
keywords='mapper TDA python',
long_description=readme(),
url='http://github.com/alpatania',
author='Alice Patania',
author_email='[email protected]',
license='MIT',
classifiers=['Development Status :: 3 - Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 2.7'],
install_requires=['hdbscan', 'sklearn', 'pandas', 'collections'],
include_package_data=True,
zip_safe=False)<｜fim▁end｜> | readme |
<|file_name|>data_export_script_new.py<|end_file_name|><｜fim▁begin｜>None
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
import os
# simple json is a python 2.5 library you need to install
import json
# json comes bundled with python 2.6. use one or the other
#import json
def run():
print "starting"
from receiver.models import Submission
from xformmanager.models import FormDefModel
# this part of the script walks through all the registered
# form definitions and bundles them with the original xsd
# schema for resubmission
domain = None
# you can manually set a single domain here. if you don't then
# all the data will be exported.
domain = "Grameen"
if domain:
all_schemas = FormDefModel.objects.filter(domain__name__iexact=domain)
else:
all_schemas = FormDefModel.objects.all()
for schema in all_schemas:
print "processsing %s" % schema
file_loc = schema.xsd_file_location
print "xsd file: %s" % file_loc
if file_loc:
headers = {
"original-submit-time" : str(schema.submit_time),
"original-submit-ip" : str(schema.submit_ip),
"bytes-received" : schema.bytes_received,
"form-name" : schema.form_name,
"form-display-name" : schema.form_display_name,
"target-namespace" : schema.target_namespace,
"date-created" : str(schema.date_created),
"domain" : str(schema.get_domain)
}
dir, filename = os.path.split(file_loc)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
write_file = os.path.join(new_dir, filename.replace(".xml", ".xsdexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
print jsoned
fout.write(jsoned)<｜fim▁hole｜> xsd_file.close()
fout.write(payload)
fout.close()
# this part of the script walks through all the submissions
# and bundles them in an exportable format with the original
# submitting IP and time, as well as a reference to the
# original post
#all_submissions = Submission.objects.all()
if domain:
all_submissions = Submission.objects.filter(domain__name__iexact=domain)
else:
all_submissions = Submission.objects.all()
for submission in all_submissions:
#print "processing %s (%s)" % (submission,submission.raw_post)
post_file = open(submission.raw_post, "r")
submit_time = str(submission.submit_time)
# first line is content type
content_type = post_file.readline().split(":")[1].strip()
# second line is content length
content_length = post_file.readline().split(":")[1].strip()
# third line is empty
post_file.readline()
# the rest is the actual body of the post
headers = { "content-type" : content_type,
"content-length" : content_length,
"time-received" : str(submission.submit_time),
"original-ip" : str(submission.submit_ip),
"domain" : submission.domain.name
}
# check the directory and create it if it doesn't exist
dir, filename = os.path.split(submission.raw_post)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
# the format will be:
# {headers} (dict)
# (empty line)
# <body>
write_file = os.path.join(new_dir, filename.replace("postdata", "postexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
fout.write(jsoned)
fout.write("\n\n")
try:
payload = post_file.read()
fout.write(payload)
except Exception:
print "error processing %s" % write_file
fout.close()
print "done"<｜fim▁end｜> | fout.write("\n\n")
xsd_file = open(file_loc, "r")
payload = xsd_file.read() |
<|file_name|>data_export_script_new.py<|end_file_name|><｜fim▁begin｜>None
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
import os
# simple json is a python 2.5 library you need to install
import json
# json comes bundled with python 2.6. use one or the other
#import json
def run():
<|fim_middle|>
<｜fim▁end｜> | print "starting"
from receiver.models import Submission
from xformmanager.models import FormDefModel
# this part of the script walks through all the registered
# form definitions and bundles them with the original xsd
# schema for resubmission
domain = None
# you can manually set a single domain here. if you don't then
# all the data will be exported.
domain = "Grameen"
if domain:
all_schemas = FormDefModel.objects.filter(domain__name__iexact=domain)
else:
all_schemas = FormDefModel.objects.all()
for schema in all_schemas:
print "processsing %s" % schema
file_loc = schema.xsd_file_location
print "xsd file: %s" % file_loc
if file_loc:
headers = {
"original-submit-time" : str(schema.submit_time),
"original-submit-ip" : str(schema.submit_ip),
"bytes-received" : schema.bytes_received,
"form-name" : schema.form_name,
"form-display-name" : schema.form_display_name,
"target-namespace" : schema.target_namespace,
"date-created" : str(schema.date_created),
"domain" : str(schema.get_domain)
}
dir, filename = os.path.split(file_loc)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
write_file = os.path.join(new_dir, filename.replace(".xml", ".xsdexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
print jsoned
fout.write(jsoned)
fout.write("\n\n")
xsd_file = open(file_loc, "r")
payload = xsd_file.read()
xsd_file.close()
fout.write(payload)
fout.close()
# this part of the script walks through all the submissions
# and bundles them in an exportable format with the original
# submitting IP and time, as well as a reference to the
# original post
#all_submissions = Submission.objects.all()
if domain:
all_submissions = Submission.objects.filter(domain__name__iexact=domain)
else:
all_submissions = Submission.objects.all()
for submission in all_submissions:
#print "processing %s (%s)" % (submission,submission.raw_post)
post_file = open(submission.raw_post, "r")
submit_time = str(submission.submit_time)
# first line is content type
content_type = post_file.readline().split(":")[1].strip()
# second line is content length
content_length = post_file.readline().split(":")[1].strip()
# third line is empty
post_file.readline()
# the rest is the actual body of the post
headers = { "content-type" : content_type,
"content-length" : content_length,
"time-received" : str(submission.submit_time),
"original-ip" : str(submission.submit_ip),
"domain" : submission.domain.name
}
# check the directory and create it if it doesn't exist
dir, filename = os.path.split(submission.raw_post)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
# the format will be:
# {headers} (dict)
# (empty line)
# <body>
write_file = os.path.join(new_dir, filename.replace("postdata", "postexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
fout.write(jsoned)
fout.write("\n\n")
try:
payload = post_file.read()
fout.write(payload)
except Exception:
print "error processing %s" % write_file
fout.close()
print "done" |
<|file_name|>data_export_script_new.py<|end_file_name|><｜fim▁begin｜>None
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
import os
# simple json is a python 2.5 library you need to install
import json
# json comes bundled with python 2.6. use one or the other
#import json
def run():
print "starting"
from receiver.models import Submission
from xformmanager.models import FormDefModel
# this part of the script walks through all the registered
# form definitions and bundles them with the original xsd
# schema for resubmission
domain = None
# you can manually set a single domain here. if you don't then
# all the data will be exported.
domain = "Grameen"
if domain:
<|fim_middle|>
else:
all_schemas = FormDefModel.objects.all()
for schema in all_schemas:
print "processsing %s" % schema
file_loc = schema.xsd_file_location
print "xsd file: %s" % file_loc
if file_loc:
headers = {
"original-submit-time" : str(schema.submit_time),
"original-submit-ip" : str(schema.submit_ip),
"bytes-received" : schema.bytes_received,
"form-name" : schema.form_name,
"form-display-name" : schema.form_display_name,
"target-namespace" : schema.target_namespace,
"date-created" : str(schema.date_created),
"domain" : str(schema.get_domain)
}
dir, filename = os.path.split(file_loc)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
write_file = os.path.join(new_dir, filename.replace(".xml", ".xsdexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
print jsoned
fout.write(jsoned)
fout.write("\n\n")
xsd_file = open(file_loc, "r")
payload = xsd_file.read()
xsd_file.close()
fout.write(payload)
fout.close()
# this part of the script walks through all the submissions
# and bundles them in an exportable format with the original
# submitting IP and time, as well as a reference to the
# original post
#all_submissions = Submission.objects.all()
if domain:
all_submissions = Submission.objects.filter(domain__name__iexact=domain)
else:
all_submissions = Submission.objects.all()
for submission in all_submissions:
#print "processing %s (%s)" % (submission,submission.raw_post)
post_file = open(submission.raw_post, "r")
submit_time = str(submission.submit_time)
# first line is content type
content_type = post_file.readline().split(":")[1].strip()
# second line is content length
content_length = post_file.readline().split(":")[1].strip()
# third line is empty
post_file.readline()
# the rest is the actual body of the post
headers = { "content-type" : content_type,
"content-length" : content_length,
"time-received" : str(submission.submit_time),
"original-ip" : str(submission.submit_ip),
"domain" : submission.domain.name
}
# check the directory and create it if it doesn't exist
dir, filename = os.path.split(submission.raw_post)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
# the format will be:
# {headers} (dict)
# (empty line)
# <body>
write_file = os.path.join(new_dir, filename.replace("postdata", "postexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
fout.write(jsoned)
fout.write("\n\n")
try:
payload = post_file.read()
fout.write(payload)
except Exception:
print "error processing %s" % write_file
fout.close()
print "done"
<｜fim▁end｜> | all_schemas = FormDefModel.objects.filter(domain__name__iexact=domain) |
<|file_name|>data_export_script_new.py<|end_file_name|><｜fim▁begin｜>None
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
import os
# simple json is a python 2.5 library you need to install
import json
# json comes bundled with python 2.6. use one or the other
#import json
def run():
print "starting"
from receiver.models import Submission
from xformmanager.models import FormDefModel
# this part of the script walks through all the registered
# form definitions and bundles them with the original xsd
# schema for resubmission
domain = None
# you can manually set a single domain here. if you don't then
# all the data will be exported.
domain = "Grameen"
if domain:
all_schemas = FormDefModel.objects.filter(domain__name__iexact=domain)
else:
<|fim_middle|>
for schema in all_schemas:
print "processsing %s" % schema
file_loc = schema.xsd_file_location
print "xsd file: %s" % file_loc
if file_loc:
headers = {
"original-submit-time" : str(schema.submit_time),
"original-submit-ip" : str(schema.submit_ip),
"bytes-received" : schema.bytes_received,
"form-name" : schema.form_name,
"form-display-name" : schema.form_display_name,
"target-namespace" : schema.target_namespace,
"date-created" : str(schema.date_created),
"domain" : str(schema.get_domain)
}
dir, filename = os.path.split(file_loc)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
write_file = os.path.join(new_dir, filename.replace(".xml", ".xsdexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
print jsoned
fout.write(jsoned)
fout.write("\n\n")
xsd_file = open(file_loc, "r")
payload = xsd_file.read()
xsd_file.close()
fout.write(payload)
fout.close()
# this part of the script walks through all the submissions
# and bundles them in an exportable format with the original
# submitting IP and time, as well as a reference to the
# original post
#all_submissions = Submission.objects.all()
if domain:
all_submissions = Submission.objects.filter(domain__name__iexact=domain)
else:
all_submissions = Submission.objects.all()
for submission in all_submissions:
#print "processing %s (%s)" % (submission,submission.raw_post)
post_file = open(submission.raw_post, "r")
submit_time = str(submission.submit_time)
# first line is content type
content_type = post_file.readline().split(":")[1].strip()
# second line is content length
content_length = post_file.readline().split(":")[1].strip()
# third line is empty
post_file.readline()
# the rest is the actual body of the post
headers = { "content-type" : content_type,
"content-length" : content_length,
"time-received" : str(submission.submit_time),
"original-ip" : str(submission.submit_ip),
"domain" : submission.domain.name
}
# check the directory and create it if it doesn't exist
dir, filename = os.path.split(submission.raw_post)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
# the format will be:
# {headers} (dict)
# (empty line)
# <body>
write_file = os.path.join(new_dir, filename.replace("postdata", "postexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
fout.write(jsoned)
fout.write("\n\n")
try:
payload = post_file.read()
fout.write(payload)
except Exception:
print "error processing %s" % write_file
fout.close()
print "done"
<｜fim▁end｜> | all_schemas = FormDefModel.objects.all() |
<|file_name|>data_export_script_new.py<|end_file_name|><｜fim▁begin｜>None
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
import os
# simple json is a python 2.5 library you need to install
import json
# json comes bundled with python 2.6. use one or the other
#import json
def run():
print "starting"
from receiver.models import Submission
from xformmanager.models import FormDefModel
# this part of the script walks through all the registered
# form definitions and bundles them with the original xsd
# schema for resubmission
domain = None
# you can manually set a single domain here. if you don't then
# all the data will be exported.
domain = "Grameen"
if domain:
all_schemas = FormDefModel.objects.filter(domain__name__iexact=domain)
else:
all_schemas = FormDefModel.objects.all()
for schema in all_schemas:
print "processsing %s" % schema
file_loc = schema.xsd_file_location
print "xsd file: %s" % file_loc
if file_loc:
<|fim_middle|>
# this part of the script walks through all the submissions
# and bundles them in an exportable format with the original
# submitting IP and time, as well as a reference to the
# original post
#all_submissions = Submission.objects.all()
if domain:
all_submissions = Submission.objects.filter(domain__name__iexact=domain)
else:
all_submissions = Submission.objects.all()
for submission in all_submissions:
#print "processing %s (%s)" % (submission,submission.raw_post)
post_file = open(submission.raw_post, "r")
submit_time = str(submission.submit_time)
# first line is content type
content_type = post_file.readline().split(":")[1].strip()
# second line is content length
content_length = post_file.readline().split(":")[1].strip()
# third line is empty
post_file.readline()
# the rest is the actual body of the post
headers = { "content-type" : content_type,
"content-length" : content_length,
"time-received" : str(submission.submit_time),
"original-ip" : str(submission.submit_ip),
"domain" : submission.domain.name
}
# check the directory and create it if it doesn't exist
dir, filename = os.path.split(submission.raw_post)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
# the format will be:
# {headers} (dict)
# (empty line)
# <body>
write_file = os.path.join(new_dir, filename.replace("postdata", "postexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
fout.write(jsoned)
fout.write("\n\n")
try:
payload = post_file.read()
fout.write(payload)
except Exception:
print "error processing %s" % write_file
fout.close()
print "done"
<｜fim▁end｜> | headers = {
"original-submit-time" : str(schema.submit_time),
"original-submit-ip" : str(schema.submit_ip),
"bytes-received" : schema.bytes_received,
"form-name" : schema.form_name,
"form-display-name" : schema.form_display_name,
"target-namespace" : schema.target_namespace,
"date-created" : str(schema.date_created),
"domain" : str(schema.get_domain)
}
dir, filename = os.path.split(file_loc)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
write_file = os.path.join(new_dir, filename.replace(".xml", ".xsdexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
print jsoned
fout.write(jsoned)
fout.write("\n\n")
xsd_file = open(file_loc, "r")
payload = xsd_file.read()
xsd_file.close()
fout.write(payload)
fout.close() |
<|file_name|>data_export_script_new.py<|end_file_name|><｜fim▁begin｜>None
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
import os
# simple json is a python 2.5 library you need to install
import json
# json comes bundled with python 2.6. use one or the other
#import json
def run():
print "starting"
from receiver.models import Submission
from xformmanager.models import FormDefModel
# this part of the script walks through all the registered
# form definitions and bundles them with the original xsd
# schema for resubmission
domain = None
# you can manually set a single domain here. if you don't then
# all the data will be exported.
domain = "Grameen"
if domain:
all_schemas = FormDefModel.objects.filter(domain__name__iexact=domain)
else:
all_schemas = FormDefModel.objects.all()
for schema in all_schemas:
print "processsing %s" % schema
file_loc = schema.xsd_file_location
print "xsd file: %s" % file_loc
if file_loc:
headers = {
"original-submit-time" : str(schema.submit_time),
"original-submit-ip" : str(schema.submit_ip),
"bytes-received" : schema.bytes_received,
"form-name" : schema.form_name,
"form-display-name" : schema.form_display_name,
"target-namespace" : schema.target_namespace,
"date-created" : str(schema.date_created),
"domain" : str(schema.get_domain)
}
dir, filename = os.path.split(file_loc)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
<|fim_middle|>
write_file = os.path.join(new_dir, filename.replace(".xml", ".xsdexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
print jsoned
fout.write(jsoned)
fout.write("\n\n")
xsd_file = open(file_loc, "r")
payload = xsd_file.read()
xsd_file.close()
fout.write(payload)
fout.close()
# this part of the script walks through all the submissions
# and bundles them in an exportable format with the original
# submitting IP and time, as well as a reference to the
# original post
#all_submissions = Submission.objects.all()
if domain:
all_submissions = Submission.objects.filter(domain__name__iexact=domain)
else:
all_submissions = Submission.objects.all()
for submission in all_submissions:
#print "processing %s (%s)" % (submission,submission.raw_post)
post_file = open(submission.raw_post, "r")
submit_time = str(submission.submit_time)
# first line is content type
content_type = post_file.readline().split(":")[1].strip()
# second line is content length
content_length = post_file.readline().split(":")[1].strip()
# third line is empty
post_file.readline()
# the rest is the actual body of the post
headers = { "content-type" : content_type,
"content-length" : content_length,
"time-received" : str(submission.submit_time),
"original-ip" : str(submission.submit_ip),
"domain" : submission.domain.name
}
# check the directory and create it if it doesn't exist
dir, filename = os.path.split(submission.raw_post)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
# the format will be:
# {headers} (dict)
# (empty line)
# <body>
write_file = os.path.join(new_dir, filename.replace("postdata", "postexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
fout.write(jsoned)
fout.write("\n\n")
try:
payload = post_file.read()
fout.write(payload)
except Exception:
print "error processing %s" % write_file
fout.close()
print "done"
<｜fim▁end｜> | os.makedirs(new_dir) |
<|file_name|>data_export_script_new.py<|end_file_name|><｜fim▁begin｜>None
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
import os
# simple json is a python 2.5 library you need to install
import json
# json comes bundled with python 2.6. use one or the other
#import json
def run():
print "starting"
from receiver.models import Submission
from xformmanager.models import FormDefModel
# this part of the script walks through all the registered
# form definitions and bundles them with the original xsd
# schema for resubmission
domain = None
# you can manually set a single domain here. if you don't then
# all the data will be exported.
domain = "Grameen"
if domain:
all_schemas = FormDefModel.objects.filter(domain__name__iexact=domain)
else:
all_schemas = FormDefModel.objects.all()
for schema in all_schemas:
print "processsing %s" % schema
file_loc = schema.xsd_file_location
print "xsd file: %s" % file_loc
if file_loc:
headers = {
"original-submit-time" : str(schema.submit_time),
"original-submit-ip" : str(schema.submit_ip),
"bytes-received" : schema.bytes_received,
"form-name" : schema.form_name,
"form-display-name" : schema.form_display_name,
"target-namespace" : schema.target_namespace,
"date-created" : str(schema.date_created),
"domain" : str(schema.get_domain)
}
dir, filename = os.path.split(file_loc)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
write_file = os.path.join(new_dir, filename.replace(".xml", ".xsdexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
print jsoned
fout.write(jsoned)
fout.write("\n\n")
xsd_file = open(file_loc, "r")
payload = xsd_file.read()
xsd_file.close()
fout.write(payload)
fout.close()
# this part of the script walks through all the submissions
# and bundles them in an exportable format with the original
# submitting IP and time, as well as a reference to the
# original post
#all_submissions = Submission.objects.all()
if domain:
<|fim_middle|>
else:
all_submissions = Submission.objects.all()
for submission in all_submissions:
#print "processing %s (%s)" % (submission,submission.raw_post)
post_file = open(submission.raw_post, "r")
submit_time = str(submission.submit_time)
# first line is content type
content_type = post_file.readline().split(":")[1].strip()
# second line is content length
content_length = post_file.readline().split(":")[1].strip()
# third line is empty
post_file.readline()
# the rest is the actual body of the post
headers = { "content-type" : content_type,
"content-length" : content_length,
"time-received" : str(submission.submit_time),
"original-ip" : str(submission.submit_ip),
"domain" : submission.domain.name
}
# check the directory and create it if it doesn't exist
dir, filename = os.path.split(submission.raw_post)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
# the format will be:
# {headers} (dict)
# (empty line)
# <body>
write_file = os.path.join(new_dir, filename.replace("postdata", "postexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
fout.write(jsoned)
fout.write("\n\n")
try:
payload = post_file.read()
fout.write(payload)
except Exception:
print "error processing %s" % write_file
fout.close()
print "done"
<｜fim▁end｜> | all_submissions = Submission.objects.filter(domain__name__iexact=domain) |
<|file_name|>data_export_script_new.py<|end_file_name|><｜fim▁begin｜>None
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
import os
# simple json is a python 2.5 library you need to install
import json
# json comes bundled with python 2.6. use one or the other
#import json
def run():
print "starting"
from receiver.models import Submission
from xformmanager.models import FormDefModel
# this part of the script walks through all the registered
# form definitions and bundles them with the original xsd
# schema for resubmission
domain = None
# you can manually set a single domain here. if you don't then
# all the data will be exported.
domain = "Grameen"
if domain:
all_schemas = FormDefModel.objects.filter(domain__name__iexact=domain)
else:
all_schemas = FormDefModel.objects.all()
for schema in all_schemas:
print "processsing %s" % schema
file_loc = schema.xsd_file_location
print "xsd file: %s" % file_loc
if file_loc:
headers = {
"original-submit-time" : str(schema.submit_time),
"original-submit-ip" : str(schema.submit_ip),
"bytes-received" : schema.bytes_received,
"form-name" : schema.form_name,
"form-display-name" : schema.form_display_name,
"target-namespace" : schema.target_namespace,
"date-created" : str(schema.date_created),
"domain" : str(schema.get_domain)
}
dir, filename = os.path.split(file_loc)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
write_file = os.path.join(new_dir, filename.replace(".xml", ".xsdexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
print jsoned
fout.write(jsoned)
fout.write("\n\n")
xsd_file = open(file_loc, "r")
payload = xsd_file.read()
xsd_file.close()
fout.write(payload)
fout.close()
# this part of the script walks through all the submissions
# and bundles them in an exportable format with the original
# submitting IP and time, as well as a reference to the
# original post
#all_submissions = Submission.objects.all()
if domain:
all_submissions = Submission.objects.filter(domain__name__iexact=domain)
else:
<|fim_middle|>
for submission in all_submissions:
#print "processing %s (%s)" % (submission,submission.raw_post)
post_file = open(submission.raw_post, "r")
submit_time = str(submission.submit_time)
# first line is content type
content_type = post_file.readline().split(":")[1].strip()
# second line is content length
content_length = post_file.readline().split(":")[1].strip()
# third line is empty
post_file.readline()
# the rest is the actual body of the post
headers = { "content-type" : content_type,
"content-length" : content_length,
"time-received" : str(submission.submit_time),
"original-ip" : str(submission.submit_ip),
"domain" : submission.domain.name
}
# check the directory and create it if it doesn't exist
dir, filename = os.path.split(submission.raw_post)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
# the format will be:
# {headers} (dict)
# (empty line)
# <body>
write_file = os.path.join(new_dir, filename.replace("postdata", "postexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
fout.write(jsoned)
fout.write("\n\n")
try:
payload = post_file.read()
fout.write(payload)
except Exception:
print "error processing %s" % write_file
fout.close()
print "done"
<｜fim▁end｜> | all_submissions = Submission.objects.all() |
<|file_name|>data_export_script_new.py<|end_file_name|><｜fim▁begin｜>None
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
import os
# simple json is a python 2.5 library you need to install
import json
# json comes bundled with python 2.6. use one or the other
#import json
def run():
print "starting"
from receiver.models import Submission
from xformmanager.models import FormDefModel
# this part of the script walks through all the registered
# form definitions and bundles them with the original xsd
# schema for resubmission
domain = None
# you can manually set a single domain here. if you don't then
# all the data will be exported.
domain = "Grameen"
if domain:
all_schemas = FormDefModel.objects.filter(domain__name__iexact=domain)
else:
all_schemas = FormDefModel.objects.all()
for schema in all_schemas:
print "processsing %s" % schema
file_loc = schema.xsd_file_location
print "xsd file: %s" % file_loc
if file_loc:
headers = {
"original-submit-time" : str(schema.submit_time),
"original-submit-ip" : str(schema.submit_ip),
"bytes-received" : schema.bytes_received,
"form-name" : schema.form_name,
"form-display-name" : schema.form_display_name,
"target-namespace" : schema.target_namespace,
"date-created" : str(schema.date_created),
"domain" : str(schema.get_domain)
}
dir, filename = os.path.split(file_loc)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
write_file = os.path.join(new_dir, filename.replace(".xml", ".xsdexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
print jsoned
fout.write(jsoned)
fout.write("\n\n")
xsd_file = open(file_loc, "r")
payload = xsd_file.read()
xsd_file.close()
fout.write(payload)
fout.close()
# this part of the script walks through all the submissions
# and bundles them in an exportable format with the original
# submitting IP and time, as well as a reference to the
# original post
#all_submissions = Submission.objects.all()
if domain:
all_submissions = Submission.objects.filter(domain__name__iexact=domain)
else:
all_submissions = Submission.objects.all()
for submission in all_submissions:
#print "processing %s (%s)" % (submission,submission.raw_post)
post_file = open(submission.raw_post, "r")
submit_time = str(submission.submit_time)
# first line is content type
content_type = post_file.readline().split(":")[1].strip()
# second line is content length
content_length = post_file.readline().split(":")[1].strip()
# third line is empty
post_file.readline()
# the rest is the actual body of the post
headers = { "content-type" : content_type,
"content-length" : content_length,
"time-received" : str(submission.submit_time),
"original-ip" : str(submission.submit_ip),
"domain" : submission.domain.name
}
# check the directory and create it if it doesn't exist
dir, filename = os.path.split(submission.raw_post)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
<|fim_middle|>
# the format will be:
# {headers} (dict)
# (empty line)
# <body>
write_file = os.path.join(new_dir, filename.replace("postdata", "postexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
fout.write(jsoned)
fout.write("\n\n")
try:
payload = post_file.read()
fout.write(payload)
except Exception:
print "error processing %s" % write_file
fout.close()
print "done"
<｜fim▁end｜> | os.makedirs(new_dir) |
<|file_name|>data_export_script_new.py<|end_file_name|><｜fim▁begin｜>None
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
import os
# simple json is a python 2.5 library you need to install
import json
# json comes bundled with python 2.6. use one or the other
#import json
def <|fim_middle|>():
print "starting"
from receiver.models import Submission
from xformmanager.models import FormDefModel
# this part of the script walks through all the registered
# form definitions and bundles them with the original xsd
# schema for resubmission
domain = None
# you can manually set a single domain here. if you don't then
# all the data will be exported.
domain = "Grameen"
if domain:
all_schemas = FormDefModel.objects.filter(domain__name__iexact=domain)
else:
all_schemas = FormDefModel.objects.all()
for schema in all_schemas:
print "processsing %s" % schema
file_loc = schema.xsd_file_location
print "xsd file: %s" % file_loc
if file_loc:
headers = {
"original-submit-time" : str(schema.submit_time),
"original-submit-ip" : str(schema.submit_ip),
"bytes-received" : schema.bytes_received,
"form-name" : schema.form_name,
"form-display-name" : schema.form_display_name,
"target-namespace" : schema.target_namespace,
"date-created" : str(schema.date_created),
"domain" : str(schema.get_domain)
}
dir, filename = os.path.split(file_loc)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
write_file = os.path.join(new_dir, filename.replace(".xml", ".xsdexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
print jsoned
fout.write(jsoned)
fout.write("\n\n")
xsd_file = open(file_loc, "r")
payload = xsd_file.read()
xsd_file.close()
fout.write(payload)
fout.close()
# this part of the script walks through all the submissions
# and bundles them in an exportable format with the original
# submitting IP and time, as well as a reference to the
# original post
#all_submissions = Submission.objects.all()
if domain:
all_submissions = Submission.objects.filter(domain__name__iexact=domain)
else:
all_submissions = Submission.objects.all()
for submission in all_submissions:
#print "processing %s (%s)" % (submission,submission.raw_post)
post_file = open(submission.raw_post, "r")
submit_time = str(submission.submit_time)
# first line is content type
content_type = post_file.readline().split(":")[1].strip()
# second line is content length
content_length = post_file.readline().split(":")[1].strip()
# third line is empty
post_file.readline()
# the rest is the actual body of the post
headers = { "content-type" : content_type,
"content-length" : content_length,
"time-received" : str(submission.submit_time),
"original-ip" : str(submission.submit_ip),
"domain" : submission.domain.name
}
# check the directory and create it if it doesn't exist
dir, filename = os.path.split(submission.raw_post)
new_dir = os.path.join(dir, "export")
if not os.path.exists(new_dir):
os.makedirs(new_dir)
# the format will be:
# {headers} (dict)
# (empty line)
# <body>
write_file = os.path.join(new_dir, filename.replace("postdata", "postexport"))
fout = open(write_file, 'w')
jsoned = json.dumps(headers)
fout.write(jsoned)
fout.write("\n\n")
try:
payload = post_file.read()
fout.write(payload)
except Exception:
print "error processing %s" % write_file
fout.close()
print "done"
<｜fim▁end｜> | run |
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def selector(values, setBits):
maxBits = len(values)
def select(v):
out = []
for i in range(maxBits):
if (v & (1 << i)):
out.append(values[i])
return out
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v)
def normalize(perm):
ref = sorted(perm)<｜fim▁hole｜>def contains_pattern(perm, patt):
if len(patt) > len(perm):
return False
for p in selector(perm, len(patt)):
if normalize(p) == patt:
return True
return False
if __name__ == '__main__':
print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True)<｜fim▁end｜> | return [ref.index(x) for x in perm]
|
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def selector(values, setBits):
<|fim_middle|>
def normalize(perm):
ref = sorted(perm)
return [ref.index(x) for x in perm]
def contains_pattern(perm, patt):
if len(patt) > len(perm):
return False
for p in selector(perm, len(patt)):
if normalize(p) == patt:
return True
return False
if __name__ == '__main__':
print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True)
<｜fim▁end｜> | maxBits = len(values)
def select(v):
out = []
for i in range(maxBits):
if (v & (1 << i)):
out.append(values[i])
return out
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v) |
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def selector(values, setBits):
maxBits = len(values)
def select(v):
<|fim_middle|>
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v)
def normalize(perm):
ref = sorted(perm)
return [ref.index(x) for x in perm]
def contains_pattern(perm, patt):
if len(patt) > len(perm):
return False
for p in selector(perm, len(patt)):
if normalize(p) == patt:
return True
return False
if __name__ == '__main__':
print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True)
<｜fim▁end｜> | out = []
for i in range(maxBits):
if (v & (1 << i)):
out.append(values[i])
return out |
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def selector(values, setBits):
maxBits = len(values)
def select(v):
out = []
for i in range(maxBits):
if (v & (1 << i)):
out.append(values[i])
return out
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v)
def normalize(perm):
<|fim_middle|>
def contains_pattern(perm, patt):
if len(patt) > len(perm):
return False
for p in selector(perm, len(patt)):
if normalize(p) == patt:
return True
return False
if __name__ == '__main__':
print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True)
<｜fim▁end｜> | ref = sorted(perm)
return [ref.index(x) for x in perm] |
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def selector(values, setBits):
maxBits = len(values)
def select(v):
out = []
for i in range(maxBits):
if (v & (1 << i)):
out.append(values[i])
return out
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v)
def normalize(perm):
ref = sorted(perm)
return [ref.index(x) for x in perm]
def contains_pattern(perm, patt):
<|fim_middle|>
if __name__ == '__main__':
print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True)
<｜fim▁end｜> | if len(patt) > len(perm):
return False
for p in selector(perm, len(patt)):
if normalize(p) == patt:
return True
return False |
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def selector(values, setBits):
maxBits = len(values)
def select(v):
out = []
for i in range(maxBits):
if (v & (1 << i)):
<|fim_middle|>
return out
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v)
def normalize(perm):
ref = sorted(perm)
return [ref.index(x) for x in perm]
def contains_pattern(perm, patt):
if len(patt) > len(perm):
return False
for p in selector(perm, len(patt)):
if normalize(p) == patt:
return True
return False
if __name__ == '__main__':
print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True)
<｜fim▁end｜> | out.append(values[i]) |
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def selector(values, setBits):
maxBits = len(values)
def select(v):
out = []
for i in range(maxBits):
if (v & (1 << i)):
out.append(values[i])
return out
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v)
def normalize(perm):
ref = sorted(perm)
return [ref.index(x) for x in perm]
def contains_pattern(perm, patt):
if len(patt) > len(perm):
<|fim_middle|>
for p in selector(perm, len(patt)):
if normalize(p) == patt:
return True
return False
if __name__ == '__main__':
print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True)
<｜fim▁end｜> | return False |
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def selector(values, setBits):
maxBits = len(values)
def select(v):
out = []
for i in range(maxBits):
if (v & (1 << i)):
out.append(values[i])
return out
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v)
def normalize(perm):
ref = sorted(perm)
return [ref.index(x) for x in perm]
def contains_pattern(perm, patt):
if len(patt) > len(perm):
return False
for p in selector(perm, len(patt)):
if normalize(p) == patt:
<|fim_middle|>
return False
if __name__ == '__main__':
print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True)
<｜fim▁end｜> | return True |
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def selector(values, setBits):
maxBits = len(values)
def select(v):
out = []
for i in range(maxBits):
if (v & (1 << i)):
out.append(values[i])
return out
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v)
def normalize(perm):
ref = sorted(perm)
return [ref.index(x) for x in perm]
def contains_pattern(perm, patt):
if len(patt) > len(perm):
return False
for p in selector(perm, len(patt)):
if normalize(p) == patt:
return True
return False
if __name__ == '__main__':
<|fim_middle|>
<｜fim▁end｜> | print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True) |
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def <|fim_middle|>(values, setBits):
maxBits = len(values)
def select(v):
out = []
for i in range(maxBits):
if (v & (1 << i)):
out.append(values[i])
return out
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v)
def normalize(perm):
ref = sorted(perm)
return [ref.index(x) for x in perm]
def contains_pattern(perm, patt):
if len(patt) > len(perm):
return False
for p in selector(perm, len(patt)):
if normalize(p) == patt:
return True
return False
if __name__ == '__main__':
print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True)
<｜fim▁end｜> | selector |
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def selector(values, setBits):
maxBits = len(values)
def <|fim_middle|>(v):
out = []
for i in range(maxBits):
if (v & (1 << i)):
out.append(values[i])
return out
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v)
def normalize(perm):
ref = sorted(perm)
return [ref.index(x) for x in perm]
def contains_pattern(perm, patt):
if len(patt) > len(perm):
return False
for p in selector(perm, len(patt)):
if normalize(p) == patt:
return True
return False
if __name__ == '__main__':
print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True)
<｜fim▁end｜> | select |
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def selector(values, setBits):
maxBits = len(values)
def select(v):
out = []
for i in range(maxBits):
if (v & (1 << i)):
out.append(values[i])
return out
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v)
def <|fim_middle|>(perm):
ref = sorted(perm)
return [ref.index(x) for x in perm]
def contains_pattern(perm, patt):
if len(patt) > len(perm):
return False
for p in selector(perm, len(patt)):
if normalize(p) == patt:
return True
return False
if __name__ == '__main__':
print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True)
<｜fim▁end｜> | normalize |
<|file_name|>cpattern.py<|end_file_name|><｜fim▁begin｜># https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
def selector(values, setBits):
maxBits = len(values)
def select(v):
out = []
for i in range(maxBits):
if (v & (1 << i)):
out.append(values[i])
return out
v = (2 ** setBits) - 1
endState = v << (maxBits - setBits)
yield select(v)
while v != endState:
t = (v | (v - 1)) + 1
v = t | ((((t & (-t % (1 << maxBits))) // (v & (-v % (1 << maxBits)))) >> 1) - 1)
yield select(v)
def normalize(perm):
ref = sorted(perm)
return [ref.index(x) for x in perm]
def <|fim_middle|>(perm, patt):
if len(patt) > len(perm):
return False
for p in selector(perm, len(patt)):
if normalize(p) == patt:
return True
return False
if __name__ == '__main__':
print(contains_pattern(
[14, 12, 6, 10, 0, 9, 1, 11, 13, 16, 17, 3, 7, 5, 15, 2, 4, 8],
[3, 0, 1, 2]))
print(True)
<｜fim▁end｜> | contains_pattern |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;<｜fim▁hole｜>BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def getButton(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def setButton(self, button):
self.__button = button<｜fim▁end｜> | |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
<|fim_middle|>
<｜fim▁end｜> | def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def getButton(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def setButton(self, button):
self.__button = button |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
<|fim_middle|>
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def getButton(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def setButton(self, button):
self.__button = button
<｜fim▁end｜> | self.__button = button
self.__action = action |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
<|fim_middle|>
def getAction(self):
return self.__action
def getButton(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def setButton(self, button):
self.__button = button
<｜fim▁end｜> | return "ButtonEvent [__button %i]" % self.__button |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
<|fim_middle|>
def getButton(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def setButton(self, button):
self.__button = button
<｜fim▁end｜> | return self.__action |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def getButton(self):
<|fim_middle|>
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def setButton(self, button):
self.__button = button
<｜fim▁end｜> | return self.__button |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def getButton(self):
return self.__button
def getButtonName(self):
<|fim_middle|>
def setAction(self, action):
self.__action = action
def setButton(self, button):
self.__button = button
<｜fim▁end｜> | return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button] |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def getButton(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
<|fim_middle|>
def setButton(self, button):
self.__button = button
<｜fim▁end｜> | self.__action = action |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def getButton(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def setButton(self, button):
<|fim_middle|>
<｜fim▁end｜> | self.__button = button |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def <|fim_middle|>(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def getButton(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def setButton(self, button):
self.__button = button
<｜fim▁end｜> | __init__ |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def <|fim_middle|> (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def getButton(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def setButton(self, button):
self.__button = button
<｜fim▁end｜> | __str__ |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def <|fim_middle|>(self):
return self.__action
def getButton(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def setButton(self, button):
self.__button = button
<｜fim▁end｜> | getAction |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def <|fim_middle|>(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def setButton(self, button):
self.__button = button
<｜fim▁end｜> | getButton |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def getButton(self):
return self.__button
def <|fim_middle|>(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def setButton(self, button):
self.__button = button
<｜fim▁end｜> | getButtonName |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def getButton(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def <|fim_middle|>(self, action):
self.__action = action
def setButton(self, button):
self.__button = button
<｜fim▁end｜> | setAction |
<|file_name|>ButtonEvent.py<|end_file_name|><｜fim▁begin｜>'''
*******************************************************************************
* ButtonEvent.py is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ButtonEvent.py is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ButtonEvent.py. If not, see <http://www.gnu.org/licenses/>.
********************************************************************************
Created on Jan 5, 2010
@author: iocanto
'''
BUTTON_SELECT = 257
BUTTON_HOTKEY_1 = 258;
BUTTON_HOTKEY_2 = 259;
BUTTON_HOTKEY_3 = 260;
BUTTON_HOTKEY_4 = 261;
BUTTON_RIGHT = 262;
BUTTON_LEFT = 263;
BUTTON_UP = 264;
BUTTON_DOWN = 265;
KEY_UP = 0
KEY_DOWN = 1
class ButtonEvent():
# Constructor
def __init__(self, button = BUTTON_HOTKEY_1, action = KEY_UP ):
self.__button = button
self.__action = action
def __str__ (self):
return "ButtonEvent [__button %i]" % self.__button
def getAction(self):
return self.__action
def getButton(self):
return self.__button
def getButtonName(self):
return { 257 : "BUTTON_SELECT" ,
258 : "BUTTON_HOTKEY_1",
259 : "BUTTON_HOTKEY_2",
260 : "BUTTON_HOTKEY_3",
261 : "BUTTON_HOTKEY_4",
262 : "BUTTON_RIGHT" ,
263 : "BUTTON_LEFT" ,
264 : "BUTTON_UP" ,
265 : "BUTTON_DOWN" ,
}[self.__button]
def setAction(self, action):
self.__action = action
def <|fim_middle|>(self, button):
self.__button = button
<｜fim▁end｜> | setButton |
<|file_name|>__init__.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python
"""
LeBLEU - Letter-edit / Levenshtein BLEU
"""
import logging
#__all__ = []
__version__ = '0.0.1'
__author__ = 'Stig-Arne Gronroos'
__author_email__ = "[email protected]"
_logger = logging.getLogger(__name__)<｜fim▁hole｜>
def get_version():
return __version__
# The public api imports need to be at the end of the file,
# so that the package global names are available to the modules
# when they are imported.
from .lebleu import LeBLEU
# Convenience functions
def eval_single(*args, **kwargs):
lb = LeBLEU(**kwargs)
return lb.eval_single(*args)
def eval(*args, **kwargs):
lb = LeBLEU(**kwargs)
return lb.eval(*args)<｜fim▁end｜> | |
<|file_name|>__init__.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python
"""
LeBLEU - Letter-edit / Levenshtein BLEU
"""
import logging
#__all__ = []
__version__ = '0.0.1'
__author__ = 'Stig-Arne Gronroos'
__author_email__ = "[email protected]"
_logger = logging.getLogger(__name__)
def get_version():
<|fim_middle|>
# The public api imports need to be at the end of the file,
# so that the package global names are available to the modules
# when they are imported.
from .lebleu import LeBLEU
# Convenience functions
def eval_single(*args, **kwargs):
lb = LeBLEU(**kwargs)
return lb.eval_single(*args)
def eval(*args, **kwargs):
lb = LeBLEU(**kwargs)
return lb.eval(*args)
<｜fim▁end｜> | return __version__ |
<|file_name|>__init__.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python
"""
LeBLEU - Letter-edit / Levenshtein BLEU
"""
import logging
#__all__ = []
__version__ = '0.0.1'
__author__ = 'Stig-Arne Gronroos'
__author_email__ = "[email protected]"
_logger = logging.getLogger(__name__)
def get_version():
return __version__
# The public api imports need to be at the end of the file,
# so that the package global names are available to the modules
# when they are imported.
from .lebleu import LeBLEU
# Convenience functions
def eval_single(*args, **kwargs):
<|fim_middle|>
def eval(*args, **kwargs):
lb = LeBLEU(**kwargs)
return lb.eval(*args)
<｜fim▁end｜> | lb = LeBLEU(**kwargs)
return lb.eval_single(*args) |
<|file_name|>__init__.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python
"""
LeBLEU - Letter-edit / Levenshtein BLEU
"""
import logging
#__all__ = []
__version__ = '0.0.1'
__author__ = 'Stig-Arne Gronroos'
__author_email__ = "[email protected]"
_logger = logging.getLogger(__name__)
def get_version():
return __version__
# The public api imports need to be at the end of the file,
# so that the package global names are available to the modules
# when they are imported.
from .lebleu import LeBLEU
# Convenience functions
def eval_single(*args, **kwargs):
lb = LeBLEU(**kwargs)
return lb.eval_single(*args)
def eval(*args, **kwargs):
<|fim_middle|>
<｜fim▁end｜> | lb = LeBLEU(**kwargs)
return lb.eval(*args) |
<|file_name|>__init__.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python
"""
LeBLEU - Letter-edit / Levenshtein BLEU
"""
import logging
#__all__ = []
__version__ = '0.0.1'
__author__ = 'Stig-Arne Gronroos'
__author_email__ = "[email protected]"
_logger = logging.getLogger(__name__)
def <|fim_middle|>():
return __version__
# The public api imports need to be at the end of the file,
# so that the package global names are available to the modules
# when they are imported.
from .lebleu import LeBLEU
# Convenience functions
def eval_single(*args, **kwargs):
lb = LeBLEU(**kwargs)
return lb.eval_single(*args)
def eval(*args, **kwargs):
lb = LeBLEU(**kwargs)
return lb.eval(*args)
<｜fim▁end｜> | get_version |
<|file_name|>__init__.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python
"""
LeBLEU - Letter-edit / Levenshtein BLEU
"""
import logging
#__all__ = []
__version__ = '0.0.1'
__author__ = 'Stig-Arne Gronroos'
__author_email__ = "[email protected]"
_logger = logging.getLogger(__name__)
def get_version():
return __version__
# The public api imports need to be at the end of the file,
# so that the package global names are available to the modules
# when they are imported.
from .lebleu import LeBLEU
# Convenience functions
def <|fim_middle|>(*args, **kwargs):
lb = LeBLEU(**kwargs)
return lb.eval_single(*args)
def eval(*args, **kwargs):
lb = LeBLEU(**kwargs)
return lb.eval(*args)
<｜fim▁end｜> | eval_single |
<|file_name|>__init__.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python
"""
LeBLEU - Letter-edit / Levenshtein BLEU
"""
import logging
#__all__ = []
__version__ = '0.0.1'
__author__ = 'Stig-Arne Gronroos'
__author_email__ = "[email protected]"
_logger = logging.getLogger(__name__)
def get_version():
return __version__
# The public api imports need to be at the end of the file,
# so that the package global names are available to the modules
# when they are imported.
from .lebleu import LeBLEU
# Convenience functions
def eval_single(*args, **kwargs):
lb = LeBLEU(**kwargs)
return lb.eval_single(*args)
def <|fim_middle|>(*args, **kwargs):
lb = LeBLEU(**kwargs)
return lb.eval(*args)
<｜fim▁end｜> | eval |
<|file_name|>keyword.py<|end_file_name|><｜fim▁begin｜>#! /usr/bin/env python
"""Keywords (from "graminit.c")
This file is automatically generated; please don't muck it up!
To update the symbols in this file, 'cd' to the top directory of
the python source tree after building the interpreter and run:
python Lib/keyword.py
"""
__all__ = ["iskeyword", "kwlist"]
kwlist = [
#--start keywords--
'and',
'assert',
'break',
'class',
'continue',
'def',
'del',
'elif',
'else',
'except',
'exec',
<｜fim▁hole｜> 'finally',
'for',
'from',
'global',
'if',
'import',
'in',
'is',
'lambda',
'not',
'or',
'pass',
'print',
'raise',
'return',
'try',
'while',
'yield',
#--end keywords--
]
kwdict = {}
for keyword in kwlist:
kwdict[keyword] = 1
iskeyword = kwdict.has_key
def main():
import sys, re
args = sys.argv[1:]
iptfile = args and args[0] or "Python/graminit.c"
if len(args) > 1: optfile = args[1]
else: optfile = "Lib/keyword.py"
# scan the source file for keywords
fp = open(iptfile)
strprog = re.compile('"([^"]+)"')
lines = []
while 1:
line = fp.readline()
if not line: break
if line.find('{1, "') > -1:
match = strprog.search(line)
if match:
lines.append(" '" + match.group(1) + "',\n")
fp.close()
lines.sort()
# load the output skeleton from the target
fp = open(optfile)
format = fp.readlines()
fp.close()
# insert the lines of keywords
try:
start = format.index("#--start keywords--\n") + 1
end = format.index("#--end keywords--\n")
format[start:end] = lines
except ValueError:
sys.stderr.write("target does not contain format markers\n")
sys.exit(1)
# write the output file
fp = open(optfile, 'w')
fp.write(''.join(format))
fp.close()
if __name__ == "__main__":
main()<｜fim▁end｜> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.