commit stringlengths 40 40 | old_file stringlengths 4 106 | new_file stringlengths 4 106 | old_contents stringlengths 10 2.94k | new_contents stringlengths 21 2.95k | subject stringlengths 16 444 | message stringlengths 17 2.63k | lang stringclasses 1 value | license stringclasses 13 values | repos stringlengths 7 43k | ndiff stringlengths 52 3.31k | instruction stringlengths 16 444 | content stringlengths 133 4.32k | diff stringlengths 49 3.61k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f80bd7dbb1b66f3fec52200ecfbc50d779caca05 | src/tmlib/workflow/jterator/args.py | src/tmlib/workflow/jterator/args.py | from tmlib.workflow.args import Argument
from tmlib.workflow.args import BatchArguments
from tmlib.workflow.args import SubmissionArguments
from tmlib.workflow.args import ExtraArguments
from tmlib.workflow.registry import batch_args
from tmlib.workflow.registry import submission_args
from tmlib.workflow.registry import extra_args
@batch_args('jterator')
class JteratorBatchArguments(BatchArguments):
plot = Argument(
type=bool, default=False, flag='p', disabled=True,
help='whether plotting should be activated'
)
@submission_args('jterator')
class JteratorSubmissionArguments(SubmissionArguments):
pass
def get_names_of_existing_pipelines(experiment):
'''Gets names of all existing jterator pipelines for a given experiment.
Parameters
----------
experiment: tmlib.models.Experiment
processed experiment
Returns
-------
List[str]
names of jterator pipelines
'''
import os
from tmlib.workflow.jterator.project import list_projects
return [
os.path.basename(project)
for project
in list_projects(os.path.join(experiment.workflow_location, 'jterator'))
]
@extra_args('jterator')
class JteratorExtraArguments(ExtraArguments):
pipeline = Argument(
type=str, help='name of the pipeline that should be processed',
required=True, flag='p', get_choices=get_names_of_existing_pipelines
)
| from tmlib.workflow.args import Argument
from tmlib.workflow.args import BatchArguments
from tmlib.workflow.args import SubmissionArguments
from tmlib.workflow.args import ExtraArguments
from tmlib.workflow.registry import batch_args
from tmlib.workflow.registry import submission_args
from tmlib.workflow.registry import extra_args
@batch_args('jterator')
class JteratorBatchArguments(BatchArguments):
plot = Argument(
type=bool, default=False, flag='p', disabled=True,
help='whether plotting should be activated'
)
@submission_args('jterator')
class JteratorSubmissionArguments(SubmissionArguments):
pass
def get_names_of_existing_pipelines(experiment):
'''Gets names of all existing jterator pipelines for a given experiment.
Parameters
----------
experiment: tmlib.models.Experiment
processed experiment
Returns
-------
List[str]
names of jterator pipelines
'''
import os
from tmlib.workflow.jterator.project import list_projects
directory = os.path.join(experiment.workflow_location, 'jterator')
if not os.path.exists(directory):
return []
else:
return [
os.path.basename(project)
for project in list_projects(directory)
]
@extra_args('jterator')
class JteratorExtraArguments(ExtraArguments):
pipeline = Argument(
type=str, help='name of the pipeline that should be processed',
required=True, flag='p', get_choices=get_names_of_existing_pipelines
)
| Fix bug in function that lists existing jterator projects | Fix bug in function that lists existing jterator projects
| Python | agpl-3.0 | TissueMAPS/TmLibrary,TissueMAPS/TmLibrary,TissueMAPS/TmLibrary,TissueMAPS/TmLibrary,TissueMAPS/TmLibrary | from tmlib.workflow.args import Argument
from tmlib.workflow.args import BatchArguments
from tmlib.workflow.args import SubmissionArguments
from tmlib.workflow.args import ExtraArguments
from tmlib.workflow.registry import batch_args
from tmlib.workflow.registry import submission_args
from tmlib.workflow.registry import extra_args
@batch_args('jterator')
class JteratorBatchArguments(BatchArguments):
plot = Argument(
type=bool, default=False, flag='p', disabled=True,
help='whether plotting should be activated'
)
@submission_args('jterator')
class JteratorSubmissionArguments(SubmissionArguments):
pass
def get_names_of_existing_pipelines(experiment):
'''Gets names of all existing jterator pipelines for a given experiment.
Parameters
----------
experiment: tmlib.models.Experiment
processed experiment
Returns
-------
List[str]
names of jterator pipelines
'''
import os
from tmlib.workflow.jterator.project import list_projects
+ directory = os.path.join(experiment.workflow_location, 'jterator')
+ if not os.path.exists(directory):
+ return []
+ else:
- return [
+ return [
- os.path.basename(project)
+ os.path.basename(project)
+ for project in list_projects(directory)
+ ]
- for project
- in list_projects(os.path.join(experiment.workflow_location, 'jterator'))
- ]
@extra_args('jterator')
class JteratorExtraArguments(ExtraArguments):
pipeline = Argument(
type=str, help='name of the pipeline that should be processed',
required=True, flag='p', get_choices=get_names_of_existing_pipelines
)
| Fix bug in function that lists existing jterator projects | ## Code Before:
from tmlib.workflow.args import Argument
from tmlib.workflow.args import BatchArguments
from tmlib.workflow.args import SubmissionArguments
from tmlib.workflow.args import ExtraArguments
from tmlib.workflow.registry import batch_args
from tmlib.workflow.registry import submission_args
from tmlib.workflow.registry import extra_args
@batch_args('jterator')
class JteratorBatchArguments(BatchArguments):
plot = Argument(
type=bool, default=False, flag='p', disabled=True,
help='whether plotting should be activated'
)
@submission_args('jterator')
class JteratorSubmissionArguments(SubmissionArguments):
pass
def get_names_of_existing_pipelines(experiment):
'''Gets names of all existing jterator pipelines for a given experiment.
Parameters
----------
experiment: tmlib.models.Experiment
processed experiment
Returns
-------
List[str]
names of jterator pipelines
'''
import os
from tmlib.workflow.jterator.project import list_projects
return [
os.path.basename(project)
for project
in list_projects(os.path.join(experiment.workflow_location, 'jterator'))
]
@extra_args('jterator')
class JteratorExtraArguments(ExtraArguments):
pipeline = Argument(
type=str, help='name of the pipeline that should be processed',
required=True, flag='p', get_choices=get_names_of_existing_pipelines
)
## Instruction:
Fix bug in function that lists existing jterator projects
## Code After:
from tmlib.workflow.args import Argument
from tmlib.workflow.args import BatchArguments
from tmlib.workflow.args import SubmissionArguments
from tmlib.workflow.args import ExtraArguments
from tmlib.workflow.registry import batch_args
from tmlib.workflow.registry import submission_args
from tmlib.workflow.registry import extra_args
@batch_args('jterator')
class JteratorBatchArguments(BatchArguments):
plot = Argument(
type=bool, default=False, flag='p', disabled=True,
help='whether plotting should be activated'
)
@submission_args('jterator')
class JteratorSubmissionArguments(SubmissionArguments):
pass
def get_names_of_existing_pipelines(experiment):
'''Gets names of all existing jterator pipelines for a given experiment.
Parameters
----------
experiment: tmlib.models.Experiment
processed experiment
Returns
-------
List[str]
names of jterator pipelines
'''
import os
from tmlib.workflow.jterator.project import list_projects
directory = os.path.join(experiment.workflow_location, 'jterator')
if not os.path.exists(directory):
return []
else:
return [
os.path.basename(project)
for project in list_projects(directory)
]
@extra_args('jterator')
class JteratorExtraArguments(ExtraArguments):
pipeline = Argument(
type=str, help='name of the pipeline that should be processed',
required=True, flag='p', get_choices=get_names_of_existing_pipelines
)
| from tmlib.workflow.args import Argument
from tmlib.workflow.args import BatchArguments
from tmlib.workflow.args import SubmissionArguments
from tmlib.workflow.args import ExtraArguments
from tmlib.workflow.registry import batch_args
from tmlib.workflow.registry import submission_args
from tmlib.workflow.registry import extra_args
@batch_args('jterator')
class JteratorBatchArguments(BatchArguments):
plot = Argument(
type=bool, default=False, flag='p', disabled=True,
help='whether plotting should be activated'
)
@submission_args('jterator')
class JteratorSubmissionArguments(SubmissionArguments):
pass
def get_names_of_existing_pipelines(experiment):
'''Gets names of all existing jterator pipelines for a given experiment.
Parameters
----------
experiment: tmlib.models.Experiment
processed experiment
Returns
-------
List[str]
names of jterator pipelines
'''
import os
from tmlib.workflow.jterator.project import list_projects
+ directory = os.path.join(experiment.workflow_location, 'jterator')
+ if not os.path.exists(directory):
+ return []
+ else:
- return [
+ return [
? ++++
- os.path.basename(project)
+ os.path.basename(project)
? ++++
+ for project in list_projects(directory)
+ ]
- for project
- in list_projects(os.path.join(experiment.workflow_location, 'jterator'))
- ]
@extra_args('jterator')
class JteratorExtraArguments(ExtraArguments):
pipeline = Argument(
type=str, help='name of the pipeline that should be processed',
required=True, flag='p', get_choices=get_names_of_existing_pipelines
) |
d0aba6489a96003c9a746bd38818cffa717d1469 | akatsuki/bib2html.py | akatsuki/bib2html.py |
from __future__ import unicode_literals
from akatsuki.exporter import export_html
from akatsuki.parser import load_bibtex_file
from akatsuki.utils import sort_by_date
def main(bibtex_file, html_file):
"""Load BibTeX file and export to HTML file"""
entries = load_bibtex_file(bibtex_file)
entries = sort_by_date(entries, reverse=True)
export_html(html_file, entries)
|
from __future__ import unicode_literals
from akatsuki.exporter import export_html
from akatsuki.parser import load_bibtex_file
from akatsuki.utils import pmid_to_url, sort_by_date
def main(bibtex_file, html_file):
"""Load BibTeX file and export to HTML file"""
entries = load_bibtex_file(bibtex_file)
entries = pmid_to_url(entries)
entries = sort_by_date(entries, reverse=True)
export_html(html_file, entries)
| Add pmid to url convertion | Add pmid to url convertion
| Python | mit | 403JFW/akatsuki |
from __future__ import unicode_literals
from akatsuki.exporter import export_html
from akatsuki.parser import load_bibtex_file
- from akatsuki.utils import sort_by_date
+ from akatsuki.utils import pmid_to_url, sort_by_date
def main(bibtex_file, html_file):
"""Load BibTeX file and export to HTML file"""
entries = load_bibtex_file(bibtex_file)
+ entries = pmid_to_url(entries)
entries = sort_by_date(entries, reverse=True)
export_html(html_file, entries)
| Add pmid to url convertion | ## Code Before:
from __future__ import unicode_literals
from akatsuki.exporter import export_html
from akatsuki.parser import load_bibtex_file
from akatsuki.utils import sort_by_date
def main(bibtex_file, html_file):
"""Load BibTeX file and export to HTML file"""
entries = load_bibtex_file(bibtex_file)
entries = sort_by_date(entries, reverse=True)
export_html(html_file, entries)
## Instruction:
Add pmid to url convertion
## Code After:
from __future__ import unicode_literals
from akatsuki.exporter import export_html
from akatsuki.parser import load_bibtex_file
from akatsuki.utils import pmid_to_url, sort_by_date
def main(bibtex_file, html_file):
"""Load BibTeX file and export to HTML file"""
entries = load_bibtex_file(bibtex_file)
entries = pmid_to_url(entries)
entries = sort_by_date(entries, reverse=True)
export_html(html_file, entries)
|
from __future__ import unicode_literals
from akatsuki.exporter import export_html
from akatsuki.parser import load_bibtex_file
- from akatsuki.utils import sort_by_date
+ from akatsuki.utils import pmid_to_url, sort_by_date
? +++++++++++++
def main(bibtex_file, html_file):
"""Load BibTeX file and export to HTML file"""
entries = load_bibtex_file(bibtex_file)
+ entries = pmid_to_url(entries)
entries = sort_by_date(entries, reverse=True)
export_html(html_file, entries) |
da2dc4e6f905356a705e2f75701f9d23c4b008ba | signac/contrib/errors.py | signac/contrib/errors.py | from ..core.errors import Error
class WorkspaceError(Error, OSError):
"Raised when there is an issue to create or access the workspace."
def __init__(self, error):
self.error = error
"The underlying error causing this issue."
class DestinationExistsError(Error, RuntimeError):
"The destination for a move or copy operation already exists."
def __init__(self, destination):
self.destination = destination
"The destination object causing the error."
class JobsCorruptedError(Error, RuntimeError):
"The state point manifest file of one or more jobs cannot be openend or is corrupted."
def __init__(self, job_ids):
self.job_ids = job_ids
"The job id(s) of the corrupted job(s)."
| from ..core.errors import Error
class WorkspaceError(Error, OSError):
"Raised when there is an issue to create or access the workspace."
def __init__(self, error):
self.error = error
"The underlying error causing this issue."
def __str__(self):
return self.error
class DestinationExistsError(Error, RuntimeError):
"The destination for a move or copy operation already exists."
def __init__(self, destination):
self.destination = destination
"The destination object causing the error."
class JobsCorruptedError(Error, RuntimeError):
"The state point manifest file of one or more jobs cannot be openend or is corrupted."
def __init__(self, job_ids):
self.job_ids = job_ids
"The job id(s) of the corrupted job(s)."
| Fix OSError not printing bug | Fix OSError not printing bug
| Python | bsd-3-clause | csadorf/signac,csadorf/signac | from ..core.errors import Error
class WorkspaceError(Error, OSError):
"Raised when there is an issue to create or access the workspace."
def __init__(self, error):
self.error = error
"The underlying error causing this issue."
+
+ def __str__(self):
+ return self.error
class DestinationExistsError(Error, RuntimeError):
"The destination for a move or copy operation already exists."
def __init__(self, destination):
self.destination = destination
"The destination object causing the error."
class JobsCorruptedError(Error, RuntimeError):
"The state point manifest file of one or more jobs cannot be openend or is corrupted."
def __init__(self, job_ids):
self.job_ids = job_ids
"The job id(s) of the corrupted job(s)."
| Fix OSError not printing bug | ## Code Before:
from ..core.errors import Error
class WorkspaceError(Error, OSError):
"Raised when there is an issue to create or access the workspace."
def __init__(self, error):
self.error = error
"The underlying error causing this issue."
class DestinationExistsError(Error, RuntimeError):
"The destination for a move or copy operation already exists."
def __init__(self, destination):
self.destination = destination
"The destination object causing the error."
class JobsCorruptedError(Error, RuntimeError):
"The state point manifest file of one or more jobs cannot be openend or is corrupted."
def __init__(self, job_ids):
self.job_ids = job_ids
"The job id(s) of the corrupted job(s)."
## Instruction:
Fix OSError not printing bug
## Code After:
from ..core.errors import Error
class WorkspaceError(Error, OSError):
"Raised when there is an issue to create or access the workspace."
def __init__(self, error):
self.error = error
"The underlying error causing this issue."
def __str__(self):
return self.error
class DestinationExistsError(Error, RuntimeError):
"The destination for a move or copy operation already exists."
def __init__(self, destination):
self.destination = destination
"The destination object causing the error."
class JobsCorruptedError(Error, RuntimeError):
"The state point manifest file of one or more jobs cannot be openend or is corrupted."
def __init__(self, job_ids):
self.job_ids = job_ids
"The job id(s) of the corrupted job(s)."
| from ..core.errors import Error
class WorkspaceError(Error, OSError):
"Raised when there is an issue to create or access the workspace."
def __init__(self, error):
self.error = error
"The underlying error causing this issue."
+
+ def __str__(self):
+ return self.error
class DestinationExistsError(Error, RuntimeError):
"The destination for a move or copy operation already exists."
def __init__(self, destination):
self.destination = destination
"The destination object causing the error."
class JobsCorruptedError(Error, RuntimeError):
"The state point manifest file of one or more jobs cannot be openend or is corrupted."
def __init__(self, job_ids):
self.job_ids = job_ids
"The job id(s) of the corrupted job(s)." |
20d02eef92d458dac890f1ab814ca146f2bd1853 | s3direct/urls.py | s3direct/urls.py | from django.conf.urls import patterns, url
from s3direct.views import get_upload_params
urlpatterns = patterns('',
url('^get_upload_params/',
get_upload_params, name='s3direct'),
)
| from django.conf.urls import url
from s3direct.views import get_upload_params
urlpatterns = [
url('^get_upload_params/', get_upload_params, name='s3direct')
]
| Update urlpatterns to use list of url() | Update urlpatterns to use list of url()
| Python | mit | AlexRiina/django-s3direct,yunojuno/django-s3-upload,yunojuno/django-s3-upload,bradleyg/django-s3direct,yunojuno/django-s3-upload,Artory/django-s3direct,Artory/django-s3direct,bradleyg/django-s3direct,Artory/django-s3direct,AlexRiina/django-s3direct,AlexRiina/django-s3direct,bradleyg/django-s3direct | - from django.conf.urls import patterns, url
+ from django.conf.urls import url
from s3direct.views import get_upload_params
+ urlpatterns = [
+ url('^get_upload_params/', get_upload_params, name='s3direct')
+ ]
- urlpatterns = patterns('',
- url('^get_upload_params/',
- get_upload_params, name='s3direct'),
- )
| Update urlpatterns to use list of url() | ## Code Before:
from django.conf.urls import patterns, url
from s3direct.views import get_upload_params
urlpatterns = patterns('',
url('^get_upload_params/',
get_upload_params, name='s3direct'),
)
## Instruction:
Update urlpatterns to use list of url()
## Code After:
from django.conf.urls import url
from s3direct.views import get_upload_params
urlpatterns = [
url('^get_upload_params/', get_upload_params, name='s3direct')
]
| - from django.conf.urls import patterns, url
? ----------
+ from django.conf.urls import url
from s3direct.views import get_upload_params
+ urlpatterns = [
+ url('^get_upload_params/', get_upload_params, name='s3direct')
+ ]
- urlpatterns = patterns('',
- url('^get_upload_params/',
- get_upload_params, name='s3direct'),
- ) |
210b24b1e04106745b5680d099f31f3a354446e8 | test/599-whitewater.py | test/599-whitewater.py | assert_has_feature(
16, 34003, 23060, 'pois',
{ 'kind': 'put_in' })
# way 308154534
assert_has_feature(
13, 2448, 2992, 'roads',
{ 'kind': 'portage_way' })
| assert_has_feature(
16, 19591, 23939, 'pois',
{ 'kind': 'put_in_egress' })
# way 308154534
assert_has_feature(
13, 2448, 2992, 'roads',
{ 'kind': 'portage_way' })
| Use test feature from North America | Use test feature from North America
| Python | mit | mapzen/vector-datasource,mapzen/vector-datasource,mapzen/vector-datasource | assert_has_feature(
- 16, 34003, 23060, 'pois',
+ 16, 19591, 23939, 'pois',
- { 'kind': 'put_in' })
+ { 'kind': 'put_in_egress' })
# way 308154534
assert_has_feature(
13, 2448, 2992, 'roads',
{ 'kind': 'portage_way' })
| Use test feature from North America | ## Code Before:
assert_has_feature(
16, 34003, 23060, 'pois',
{ 'kind': 'put_in' })
# way 308154534
assert_has_feature(
13, 2448, 2992, 'roads',
{ 'kind': 'portage_way' })
## Instruction:
Use test feature from North America
## Code After:
assert_has_feature(
16, 19591, 23939, 'pois',
{ 'kind': 'put_in_egress' })
# way 308154534
assert_has_feature(
13, 2448, 2992, 'roads',
{ 'kind': 'portage_way' })
| assert_has_feature(
- 16, 34003, 23060, 'pois',
+ 16, 19591, 23939, 'pois',
- { 'kind': 'put_in' })
+ { 'kind': 'put_in_egress' })
? +++++++
# way 308154534
assert_has_feature(
13, 2448, 2992, 'roads',
{ 'kind': 'portage_way' }) |
23f23884cb55899a77b08dfa8c1649a195815f8c | examples/semaphore_wait.py | examples/semaphore_wait.py | from locust import HttpLocust, TaskSet, task, events, between
from gevent.lock import Semaphore
all_locusts_spawned = Semaphore()
all_locusts_spawned.acquire()
def on_hatch_complete(**kw):
all_locusts_spawned.release()
events.hatch_complete += on_hatch_complete
class UserTasks(TaskSet):
def on_start(self):
all_locusts_spawned.wait()
self.wait()
@task
def index(self):
self.client.get("/")
class WebsiteUser(HttpLocust):
host = "http://127.0.0.1:8089"
wait_time = between(2, 5)
task_set = UserTasks
| from locust import HttpLocust, TaskSet, task, events, between
from gevent.lock import Semaphore
all_locusts_spawned = Semaphore()
all_locusts_spawned.acquire()
@events.init.add_listener
def _(environment, **kw):
@environment.events.hatch_complete.add_listener
def on_hatch_complete(**kw):
all_locusts_spawned.release()
class UserTasks(TaskSet):
def on_start(self):
all_locusts_spawned.wait()
self.wait()
@task
def index(self):
self.client.get("/")
class WebsiteUser(HttpLocust):
host = "http://127.0.0.1:8089"
wait_time = between(2, 5)
task_set = UserTasks
| Update example to use new event API | Update example to use new event API | Python | mit | locustio/locust,locustio/locust,locustio/locust,mbeacom/locust,mbeacom/locust,mbeacom/locust,locustio/locust,mbeacom/locust | from locust import HttpLocust, TaskSet, task, events, between
from gevent.lock import Semaphore
all_locusts_spawned = Semaphore()
all_locusts_spawned.acquire()
+ @events.init.add_listener
+ def _(environment, **kw):
+ @environment.events.hatch_complete.add_listener
- def on_hatch_complete(**kw):
+ def on_hatch_complete(**kw):
- all_locusts_spawned.release()
+ all_locusts_spawned.release()
-
- events.hatch_complete += on_hatch_complete
class UserTasks(TaskSet):
def on_start(self):
all_locusts_spawned.wait()
self.wait()
@task
def index(self):
self.client.get("/")
class WebsiteUser(HttpLocust):
host = "http://127.0.0.1:8089"
wait_time = between(2, 5)
task_set = UserTasks
| Update example to use new event API | ## Code Before:
from locust import HttpLocust, TaskSet, task, events, between
from gevent.lock import Semaphore
all_locusts_spawned = Semaphore()
all_locusts_spawned.acquire()
def on_hatch_complete(**kw):
all_locusts_spawned.release()
events.hatch_complete += on_hatch_complete
class UserTasks(TaskSet):
def on_start(self):
all_locusts_spawned.wait()
self.wait()
@task
def index(self):
self.client.get("/")
class WebsiteUser(HttpLocust):
host = "http://127.0.0.1:8089"
wait_time = between(2, 5)
task_set = UserTasks
## Instruction:
Update example to use new event API
## Code After:
from locust import HttpLocust, TaskSet, task, events, between
from gevent.lock import Semaphore
all_locusts_spawned = Semaphore()
all_locusts_spawned.acquire()
@events.init.add_listener
def _(environment, **kw):
@environment.events.hatch_complete.add_listener
def on_hatch_complete(**kw):
all_locusts_spawned.release()
class UserTasks(TaskSet):
def on_start(self):
all_locusts_spawned.wait()
self.wait()
@task
def index(self):
self.client.get("/")
class WebsiteUser(HttpLocust):
host = "http://127.0.0.1:8089"
wait_time = between(2, 5)
task_set = UserTasks
| from locust import HttpLocust, TaskSet, task, events, between
from gevent.lock import Semaphore
all_locusts_spawned = Semaphore()
all_locusts_spawned.acquire()
+ @events.init.add_listener
+ def _(environment, **kw):
+ @environment.events.hatch_complete.add_listener
- def on_hatch_complete(**kw):
+ def on_hatch_complete(**kw):
? ++++
- all_locusts_spawned.release()
+ all_locusts_spawned.release()
? ++++
-
- events.hatch_complete += on_hatch_complete
class UserTasks(TaskSet):
def on_start(self):
all_locusts_spawned.wait()
self.wait()
@task
def index(self):
self.client.get("/")
class WebsiteUser(HttpLocust):
host = "http://127.0.0.1:8089"
wait_time = between(2, 5)
task_set = UserTasks |
79e5cab2908c26ff80ae5c5e4b37ced9765a952c | dbaas/physical/forms/database_infra.py | dbaas/physical/forms/database_infra.py | from __future__ import absolute_import, unicode_literals
import logging
from django import forms
from .. import models
log = logging.getLogger(__name__)
class DatabaseInfraForm(forms.ModelForm):
class Meta:
model = models.DatabaseInfra
def __init__(self, *args, **kwargs):
if args:
disk_offering = args[0]['disk_offering']
plan_id = args[0]['plan']
if not disk_offering and plan_id:
plan = models.Plan.objects.get(id=plan_id)
if plan.disk_offering:
args[0]['disk_offering'] = plan.disk_offering.id
super(DatabaseInfraForm, self).__init__(*args, **kwargs)
| from __future__ import absolute_import, unicode_literals
import logging
from django import forms
from .. import models
log = logging.getLogger(__name__)
class DatabaseInfraForm(forms.ModelForm):
class Meta:
model = models.DatabaseInfra
def __init__(self, *args, **kwargs):
if args and 'disk_offering' in args[0]:
disk_offering = args[0]['disk_offering']
plan_id = args[0]['plan']
if not disk_offering and plan_id:
plan = models.Plan.objects.get(id=plan_id)
if plan.disk_offering:
args[0]['disk_offering'] = plan.disk_offering.id
super(DatabaseInfraForm, self).__init__(*args, **kwargs)
| Fix database infra save method | Fix database infra save method
| Python | bsd-3-clause | globocom/database-as-a-service,globocom/database-as-a-service,globocom/database-as-a-service,globocom/database-as-a-service | from __future__ import absolute_import, unicode_literals
import logging
from django import forms
from .. import models
log = logging.getLogger(__name__)
class DatabaseInfraForm(forms.ModelForm):
class Meta:
model = models.DatabaseInfra
def __init__(self, *args, **kwargs):
- if args:
+ if args and 'disk_offering' in args[0]:
disk_offering = args[0]['disk_offering']
plan_id = args[0]['plan']
if not disk_offering and plan_id:
plan = models.Plan.objects.get(id=plan_id)
if plan.disk_offering:
args[0]['disk_offering'] = plan.disk_offering.id
super(DatabaseInfraForm, self).__init__(*args, **kwargs)
| Fix database infra save method | ## Code Before:
from __future__ import absolute_import, unicode_literals
import logging
from django import forms
from .. import models
log = logging.getLogger(__name__)
class DatabaseInfraForm(forms.ModelForm):
class Meta:
model = models.DatabaseInfra
def __init__(self, *args, **kwargs):
if args:
disk_offering = args[0]['disk_offering']
plan_id = args[0]['plan']
if not disk_offering and plan_id:
plan = models.Plan.objects.get(id=plan_id)
if plan.disk_offering:
args[0]['disk_offering'] = plan.disk_offering.id
super(DatabaseInfraForm, self).__init__(*args, **kwargs)
## Instruction:
Fix database infra save method
## Code After:
from __future__ import absolute_import, unicode_literals
import logging
from django import forms
from .. import models
log = logging.getLogger(__name__)
class DatabaseInfraForm(forms.ModelForm):
class Meta:
model = models.DatabaseInfra
def __init__(self, *args, **kwargs):
if args and 'disk_offering' in args[0]:
disk_offering = args[0]['disk_offering']
plan_id = args[0]['plan']
if not disk_offering and plan_id:
plan = models.Plan.objects.get(id=plan_id)
if plan.disk_offering:
args[0]['disk_offering'] = plan.disk_offering.id
super(DatabaseInfraForm, self).__init__(*args, **kwargs)
| from __future__ import absolute_import, unicode_literals
import logging
from django import forms
from .. import models
log = logging.getLogger(__name__)
class DatabaseInfraForm(forms.ModelForm):
class Meta:
model = models.DatabaseInfra
def __init__(self, *args, **kwargs):
- if args:
+ if args and 'disk_offering' in args[0]:
disk_offering = args[0]['disk_offering']
plan_id = args[0]['plan']
if not disk_offering and plan_id:
plan = models.Plan.objects.get(id=plan_id)
if plan.disk_offering:
args[0]['disk_offering'] = plan.disk_offering.id
super(DatabaseInfraForm, self).__init__(*args, **kwargs) |
96ace17d9cd800a5649ad32a8cb496a55d73ca9f | wapps/templatetags/wagtail.py | wapps/templatetags/wagtail.py | import jinja2
from django.conf import settings
from django_jinja import library
from jinja2.ext import Extension
from wagtail.wagtailcore.models import Page
from wagtail.contrib.wagtailroutablepage.templatetags.wagtailroutablepage_tags import (
routablepageurl as dj_routablepageurl
)
from wapps.utils import get_image_url
@library.global_function
def menu():
return Page.objects.live().in_menu().filter(depth__lte=3)
@library.global_function
@jinja2.contextfunction
def is_site_root(context, page):
if 'request' not in context or not context['request'].site:
return False
site = context['request'].site
return site.root_page.pk == page.pk
@library.global_function
def image_url(image, specs):
return get_image_url(image, specs)
@library.global_function
@jinja2.contextfunction
def routablepageurl(context, page, name, *args, **kwargs):
return dj_routablepageurl(context, page, name, *args, **kwargs)
@library.extension
class WagtailSettings(Extension):
def __init__(self, environment):
super(WagtailSettings, self).__init__(environment)
environment.globals['WAGTAIL_SITE_NAME'] = getattr(settings, 'WAGTAIL_SITE_NAME', None)
| import jinja2
from django.conf import settings
from django_jinja import library
from jinja2.ext import Extension
from wagtail.wagtailcore.models import Page
from wagtail.contrib.wagtailroutablepage.templatetags.wagtailroutablepage_tags import (
routablepageurl as dj_routablepageurl
)
from wapps.utils import get_image_url
@library.global_function
def menu():
return Page.objects.live().in_menu().filter(depth__lte=3)
@library.global_function
@jinja2.contextfunction
def is_site_root(context, page):
if 'request' not in context or not context['request'].site or not page:
return False
site = context['request'].site
return site.root_page.pk == page.pk
@library.global_function
def image_url(image, specs):
return get_image_url(image, specs)
@library.global_function
@jinja2.contextfunction
def routablepageurl(context, page, name, *args, **kwargs):
return dj_routablepageurl(context, page, name, *args, **kwargs)
@library.extension
class WagtailSettings(Extension):
def __init__(self, environment):
super(WagtailSettings, self).__init__(environment)
environment.globals['WAGTAIL_SITE_NAME'] = getattr(settings, 'WAGTAIL_SITE_NAME', None)
| Fix is_site_root when no page | Fix is_site_root when no page
| Python | mit | apihackers/wapps,apihackers/wapps,apihackers/wapps,apihackers/wapps | import jinja2
from django.conf import settings
from django_jinja import library
from jinja2.ext import Extension
from wagtail.wagtailcore.models import Page
from wagtail.contrib.wagtailroutablepage.templatetags.wagtailroutablepage_tags import (
routablepageurl as dj_routablepageurl
)
from wapps.utils import get_image_url
@library.global_function
def menu():
return Page.objects.live().in_menu().filter(depth__lte=3)
@library.global_function
@jinja2.contextfunction
def is_site_root(context, page):
- if 'request' not in context or not context['request'].site:
+ if 'request' not in context or not context['request'].site or not page:
return False
site = context['request'].site
return site.root_page.pk == page.pk
@library.global_function
def image_url(image, specs):
return get_image_url(image, specs)
@library.global_function
@jinja2.contextfunction
def routablepageurl(context, page, name, *args, **kwargs):
return dj_routablepageurl(context, page, name, *args, **kwargs)
@library.extension
class WagtailSettings(Extension):
def __init__(self, environment):
super(WagtailSettings, self).__init__(environment)
environment.globals['WAGTAIL_SITE_NAME'] = getattr(settings, 'WAGTAIL_SITE_NAME', None)
| Fix is_site_root when no page | ## Code Before:
import jinja2
from django.conf import settings
from django_jinja import library
from jinja2.ext import Extension
from wagtail.wagtailcore.models import Page
from wagtail.contrib.wagtailroutablepage.templatetags.wagtailroutablepage_tags import (
routablepageurl as dj_routablepageurl
)
from wapps.utils import get_image_url
@library.global_function
def menu():
return Page.objects.live().in_menu().filter(depth__lte=3)
@library.global_function
@jinja2.contextfunction
def is_site_root(context, page):
if 'request' not in context or not context['request'].site:
return False
site = context['request'].site
return site.root_page.pk == page.pk
@library.global_function
def image_url(image, specs):
return get_image_url(image, specs)
@library.global_function
@jinja2.contextfunction
def routablepageurl(context, page, name, *args, **kwargs):
return dj_routablepageurl(context, page, name, *args, **kwargs)
@library.extension
class WagtailSettings(Extension):
def __init__(self, environment):
super(WagtailSettings, self).__init__(environment)
environment.globals['WAGTAIL_SITE_NAME'] = getattr(settings, 'WAGTAIL_SITE_NAME', None)
## Instruction:
Fix is_site_root when no page
## Code After:
import jinja2
from django.conf import settings
from django_jinja import library
from jinja2.ext import Extension
from wagtail.wagtailcore.models import Page
from wagtail.contrib.wagtailroutablepage.templatetags.wagtailroutablepage_tags import (
routablepageurl as dj_routablepageurl
)
from wapps.utils import get_image_url
@library.global_function
def menu():
return Page.objects.live().in_menu().filter(depth__lte=3)
@library.global_function
@jinja2.contextfunction
def is_site_root(context, page):
if 'request' not in context or not context['request'].site or not page:
return False
site = context['request'].site
return site.root_page.pk == page.pk
@library.global_function
def image_url(image, specs):
return get_image_url(image, specs)
@library.global_function
@jinja2.contextfunction
def routablepageurl(context, page, name, *args, **kwargs):
return dj_routablepageurl(context, page, name, *args, **kwargs)
@library.extension
class WagtailSettings(Extension):
def __init__(self, environment):
super(WagtailSettings, self).__init__(environment)
environment.globals['WAGTAIL_SITE_NAME'] = getattr(settings, 'WAGTAIL_SITE_NAME', None)
| import jinja2
from django.conf import settings
from django_jinja import library
from jinja2.ext import Extension
from wagtail.wagtailcore.models import Page
from wagtail.contrib.wagtailroutablepage.templatetags.wagtailroutablepage_tags import (
routablepageurl as dj_routablepageurl
)
from wapps.utils import get_image_url
@library.global_function
def menu():
return Page.objects.live().in_menu().filter(depth__lte=3)
@library.global_function
@jinja2.contextfunction
def is_site_root(context, page):
- if 'request' not in context or not context['request'].site:
+ if 'request' not in context or not context['request'].site or not page:
? ++++++++++++
return False
site = context['request'].site
return site.root_page.pk == page.pk
@library.global_function
def image_url(image, specs):
return get_image_url(image, specs)
@library.global_function
@jinja2.contextfunction
def routablepageurl(context, page, name, *args, **kwargs):
return dj_routablepageurl(context, page, name, *args, **kwargs)
@library.extension
class WagtailSettings(Extension):
def __init__(self, environment):
super(WagtailSettings, self).__init__(environment)
environment.globals['WAGTAIL_SITE_NAME'] = getattr(settings, 'WAGTAIL_SITE_NAME', None) |
28940582fcff57b66e702dfecfd96e83725fbab0 | leisure/__init__.py | leisure/__init__.py |
from __future__ import absolute_import
import sys
from .disco import run_script
from . import shuffle
import tempfile
def main():
script = sys.argv[1]
if len(sys.argv) == 3:
data_root = sys.argv[2]
else:
data_root = tempfile.mkdtemp()
run_script(script, data_root)
if __name__ == "__main__":
main()
|
from __future__ import absolute_import
import sys
import os
from .disco import run_script
from . import shuffle
import tempfile
def main():
script = sys.argv[1]
script_dir = os.path.abspath(os.path.dirname(script))
if script_dir not in [os.path.abspath(p) for p in sys.path]:
sys.path.append(script_dir)
if len(sys.argv) == 3:
data_root = sys.argv[2]
else:
data_root = tempfile.mkdtemp()
run_script(script, data_root)
if __name__ == "__main__":
main()
| Add script's path to the python path | Add script's path to the python path | Python | mit | trivio/leisure |
from __future__ import absolute_import
import sys
+ import os
from .disco import run_script
from . import shuffle
import tempfile
def main():
script = sys.argv[1]
+ script_dir = os.path.abspath(os.path.dirname(script))
+ if script_dir not in [os.path.abspath(p) for p in sys.path]:
+ sys.path.append(script_dir)
+
if len(sys.argv) == 3:
data_root = sys.argv[2]
else:
data_root = tempfile.mkdtemp()
run_script(script, data_root)
if __name__ == "__main__":
main()
| Add script's path to the python path | ## Code Before:
from __future__ import absolute_import
import sys
from .disco import run_script
from . import shuffle
import tempfile
def main():
script = sys.argv[1]
if len(sys.argv) == 3:
data_root = sys.argv[2]
else:
data_root = tempfile.mkdtemp()
run_script(script, data_root)
if __name__ == "__main__":
main()
## Instruction:
Add script's path to the python path
## Code After:
from __future__ import absolute_import
import sys
import os
from .disco import run_script
from . import shuffle
import tempfile
def main():
script = sys.argv[1]
script_dir = os.path.abspath(os.path.dirname(script))
if script_dir not in [os.path.abspath(p) for p in sys.path]:
sys.path.append(script_dir)
if len(sys.argv) == 3:
data_root = sys.argv[2]
else:
data_root = tempfile.mkdtemp()
run_script(script, data_root)
if __name__ == "__main__":
main()
|
from __future__ import absolute_import
import sys
+ import os
from .disco import run_script
from . import shuffle
import tempfile
def main():
script = sys.argv[1]
+ script_dir = os.path.abspath(os.path.dirname(script))
+ if script_dir not in [os.path.abspath(p) for p in sys.path]:
+ sys.path.append(script_dir)
+
if len(sys.argv) == 3:
data_root = sys.argv[2]
else:
data_root = tempfile.mkdtemp()
run_script(script, data_root)
if __name__ == "__main__":
main() |
c970cab38d846c4774aee52e52c23ed2452af96a | openfisca_france_data/tests/base.py | openfisca_france_data/tests/base.py |
from openfisca_core.tools import assert_near
from openfisca_france.tests.base import get_cached_composed_reform, get_cached_reform
from .. import france_data_tax_benefit_system, FranceDataTaxBenefitSystem
__all__ = [
'assert_near',
'france_data_tax_benefit_system',
'FranceDataTaxBenefitSystem',
'get_cached_composed_reform',
'get_cached_reform',
]
|
from openfisca_core.tools import assert_near
from openfisca_france.tests.base import get_cached_composed_reform, get_cached_reform
from .. import france_data_tax_benefit_system
__all__ = [
'assert_near',
'france_data_tax_benefit_system',
'get_cached_composed_reform',
'get_cached_reform',
]
| Remove unused and buggy import | Remove unused and buggy import
| Python | agpl-3.0 | openfisca/openfisca-france-data,openfisca/openfisca-france-data,openfisca/openfisca-france-data |
from openfisca_core.tools import assert_near
from openfisca_france.tests.base import get_cached_composed_reform, get_cached_reform
- from .. import france_data_tax_benefit_system, FranceDataTaxBenefitSystem
+ from .. import france_data_tax_benefit_system
__all__ = [
'assert_near',
'france_data_tax_benefit_system',
- 'FranceDataTaxBenefitSystem',
'get_cached_composed_reform',
'get_cached_reform',
]
| Remove unused and buggy import | ## Code Before:
from openfisca_core.tools import assert_near
from openfisca_france.tests.base import get_cached_composed_reform, get_cached_reform
from .. import france_data_tax_benefit_system, FranceDataTaxBenefitSystem
__all__ = [
'assert_near',
'france_data_tax_benefit_system',
'FranceDataTaxBenefitSystem',
'get_cached_composed_reform',
'get_cached_reform',
]
## Instruction:
Remove unused and buggy import
## Code After:
from openfisca_core.tools import assert_near
from openfisca_france.tests.base import get_cached_composed_reform, get_cached_reform
from .. import france_data_tax_benefit_system
__all__ = [
'assert_near',
'france_data_tax_benefit_system',
'get_cached_composed_reform',
'get_cached_reform',
]
|
from openfisca_core.tools import assert_near
from openfisca_france.tests.base import get_cached_composed_reform, get_cached_reform
- from .. import france_data_tax_benefit_system, FranceDataTaxBenefitSystem
? ----------------------------
+ from .. import france_data_tax_benefit_system
__all__ = [
'assert_near',
'france_data_tax_benefit_system',
- 'FranceDataTaxBenefitSystem',
'get_cached_composed_reform',
'get_cached_reform',
] |
0d8282f31b74b6546f07fa37e88b59ed12e945c8 | scripts/test_import_optional.py | scripts/test_import_optional.py |
import os
import subprocess
import sys
neonc = sys.argv[1]
executor = sys.argv[2:]
out = subprocess.check_output([neonc, "t/import-optional-missing.neon"], env={"NEONPATH": "t/compile-time-only"}, stderr=subprocess.STDOUT, universal_newlines=True)
sys.stdout.write(out)
if "not found" in out:
print("{}: Failed: expected compile step to find module2.neon".format(sys.argv[0]), file=sys.stderr)
sys.exit(1)
subprocess.check_call(executor + ["t/import-optional-missing.neonx"])
|
import os
import subprocess
import sys
neonc = sys.argv[1]
executor = sys.argv[2:]
out = subprocess.check_output([neonc, "-o", "tmp/import-optional-missing.neonx", "t/import-optional-missing.neon"], env={"NEONPATH": "t/compile-time-only"}, stderr=subprocess.STDOUT, universal_newlines=True)
sys.stdout.write(out)
if "not found" in out:
print("{}: Failed: expected compile step to find module2.neon".format(sys.argv[0]), file=sys.stderr)
sys.exit(1)
subprocess.check_call(executor + ["tmp/import-optional-missing.neonx"])
| Fix up import optional test to use temporary compiled file | Fix up import optional test to use temporary compiled file
| Python | mit | ghewgill/neon-lang,ghewgill/neon-lang,ghewgill/neon-lang,ghewgill/neon-lang,ghewgill/neon-lang,ghewgill/neon-lang,ghewgill/neon-lang,ghewgill/neon-lang,ghewgill/neon-lang,ghewgill/neon-lang |
import os
import subprocess
import sys
neonc = sys.argv[1]
executor = sys.argv[2:]
- out = subprocess.check_output([neonc, "t/import-optional-missing.neon"], env={"NEONPATH": "t/compile-time-only"}, stderr=subprocess.STDOUT, universal_newlines=True)
+ out = subprocess.check_output([neonc, "-o", "tmp/import-optional-missing.neonx", "t/import-optional-missing.neon"], env={"NEONPATH": "t/compile-time-only"}, stderr=subprocess.STDOUT, universal_newlines=True)
sys.stdout.write(out)
if "not found" in out:
print("{}: Failed: expected compile step to find module2.neon".format(sys.argv[0]), file=sys.stderr)
sys.exit(1)
- subprocess.check_call(executor + ["t/import-optional-missing.neonx"])
+ subprocess.check_call(executor + ["tmp/import-optional-missing.neonx"])
| Fix up import optional test to use temporary compiled file | ## Code Before:
import os
import subprocess
import sys
neonc = sys.argv[1]
executor = sys.argv[2:]
out = subprocess.check_output([neonc, "t/import-optional-missing.neon"], env={"NEONPATH": "t/compile-time-only"}, stderr=subprocess.STDOUT, universal_newlines=True)
sys.stdout.write(out)
if "not found" in out:
print("{}: Failed: expected compile step to find module2.neon".format(sys.argv[0]), file=sys.stderr)
sys.exit(1)
subprocess.check_call(executor + ["t/import-optional-missing.neonx"])
## Instruction:
Fix up import optional test to use temporary compiled file
## Code After:
import os
import subprocess
import sys
neonc = sys.argv[1]
executor = sys.argv[2:]
out = subprocess.check_output([neonc, "-o", "tmp/import-optional-missing.neonx", "t/import-optional-missing.neon"], env={"NEONPATH": "t/compile-time-only"}, stderr=subprocess.STDOUT, universal_newlines=True)
sys.stdout.write(out)
if "not found" in out:
print("{}: Failed: expected compile step to find module2.neon".format(sys.argv[0]), file=sys.stderr)
sys.exit(1)
subprocess.check_call(executor + ["tmp/import-optional-missing.neonx"])
|
import os
import subprocess
import sys
neonc = sys.argv[1]
executor = sys.argv[2:]
- out = subprocess.check_output([neonc, "t/import-optional-missing.neon"], env={"NEONPATH": "t/compile-time-only"}, stderr=subprocess.STDOUT, universal_newlines=True)
+ out = subprocess.check_output([neonc, "-o", "tmp/import-optional-missing.neonx", "t/import-optional-missing.neon"], env={"NEONPATH": "t/compile-time-only"}, stderr=subprocess.STDOUT, universal_newlines=True)
? +++++++++++++++++++++++++++++++++++++++++++
sys.stdout.write(out)
if "not found" in out:
print("{}: Failed: expected compile step to find module2.neon".format(sys.argv[0]), file=sys.stderr)
sys.exit(1)
- subprocess.check_call(executor + ["t/import-optional-missing.neonx"])
+ subprocess.check_call(executor + ["tmp/import-optional-missing.neonx"])
? ++
|
f70bbbdadc044a76f7b90b2cac0191353a6a5048 | depfinder.py | depfinder.py | import ast
def get_imported_libs(code):
tree = ast.parse(code)
# ast.Import represents lines like 'import foo' and 'import foo, bar'
# the extra for name in t.names is needed, because names is a list that
# would be ['foo'] for the first and ['foo', 'bar'] for the second
imports = [name.name.split('.')[0] for t in tree.body
if type(t) == ast.Import for name in t.names]
# ast.ImportFrom represents lines like 'from foo import bar'
import_froms = [t.module.split('.')[0] for t in tree.body if type(t) == ast.ImportFrom if t.module]
return imports + import_froms
| import ast
import os
from collections import deque
import sys
from stdlib_list import stdlib_list
conf = {
'ignore_relative_imports': True,
'ignore_builtin_modules': True,
'pyver': None,
}
def get_imported_libs(code):
tree = ast.parse(code)
imports = deque()
for t in tree.body:
# ast.Import represents lines like 'import foo' and 'import foo, bar'
# the extra for name in t.names is needed, because names is a list that
# would be ['foo'] for the first and ['foo', 'bar'] for the second
if type(t) == ast.Import:
imports.extend([name.name.split('.')[0] for name in t.names])
# ast.ImportFrom represents lines like 'from foo import bar'
# t.level == 0 is to get rid of 'from .foo import bar' and higher levels
# of relative importing
if type(t) == ast.ImportFrom:
if t.level > 0:
if conf['ignore_relative_imports'] or not t.module:
continue
else:
imports.append(t.module.split('.')[0])
return list(imports)
def iterate_over_library(path_to_source_code):
libs = set()
for parent, folders, files in os.walk(path_to_source_code):
for file in files:
if file.endswith('.py'):
print('.', end='')
full_file_path = os.path.join(parent, file)
with open(full_file_path, 'r') as f:
code = f.read()
libs.update(set(get_imported_libs(code)))
if conf['ignore_builtin_modules']:
if not conf['pyver']:
pyver = '%s.%s' % (sys.version_info.major, sys.version_info.minor)
std_libs = stdlib_list("3.4")
# print(std_libs)
libs = [lib for lib in libs if lib not in std_libs]
return libs | Rework the import finding logic | MNT: Rework the import finding logic
| Python | bsd-3-clause | ericdill/depfinder | import ast
+ import os
+ from collections import deque
+ import sys
+ from stdlib_list import stdlib_list
+
+ conf = {
+ 'ignore_relative_imports': True,
+ 'ignore_builtin_modules': True,
+ 'pyver': None,
+ }
def get_imported_libs(code):
tree = ast.parse(code)
+ imports = deque()
+ for t in tree.body:
- # ast.Import represents lines like 'import foo' and 'import foo, bar'
+ # ast.Import represents lines like 'import foo' and 'import foo, bar'
- # the extra for name in t.names is needed, because names is a list that
+ # the extra for name in t.names is needed, because names is a list that
- # would be ['foo'] for the first and ['foo', 'bar'] for the second
+ # would be ['foo'] for the first and ['foo', 'bar'] for the second
- imports = [name.name.split('.')[0] for t in tree.body
- if type(t) == ast.Import for name in t.names]
+ if type(t) == ast.Import:
+ imports.extend([name.name.split('.')[0] for name in t.names])
- # ast.ImportFrom represents lines like 'from foo import bar'
+ # ast.ImportFrom represents lines like 'from foo import bar'
- import_froms = [t.module.split('.')[0] for t in tree.body if type(t) == ast.ImportFrom if t.module]
- return imports + import_froms
+ # t.level == 0 is to get rid of 'from .foo import bar' and higher levels
+ # of relative importing
+ if type(t) == ast.ImportFrom:
+ if t.level > 0:
+ if conf['ignore_relative_imports'] or not t.module:
+ continue
+ else:
+ imports.append(t.module.split('.')[0])
+ return list(imports)
+
+
+ def iterate_over_library(path_to_source_code):
+ libs = set()
+ for parent, folders, files in os.walk(path_to_source_code):
+ for file in files:
+ if file.endswith('.py'):
+ print('.', end='')
+ full_file_path = os.path.join(parent, file)
+ with open(full_file_path, 'r') as f:
+ code = f.read()
+ libs.update(set(get_imported_libs(code)))
+
+ if conf['ignore_builtin_modules']:
+ if not conf['pyver']:
+ pyver = '%s.%s' % (sys.version_info.major, sys.version_info.minor)
+ std_libs = stdlib_list("3.4")
+ # print(std_libs)
+ libs = [lib for lib in libs if lib not in std_libs]
+
+ return libs | Rework the import finding logic | ## Code Before:
import ast
def get_imported_libs(code):
tree = ast.parse(code)
# ast.Import represents lines like 'import foo' and 'import foo, bar'
# the extra for name in t.names is needed, because names is a list that
# would be ['foo'] for the first and ['foo', 'bar'] for the second
imports = [name.name.split('.')[0] for t in tree.body
if type(t) == ast.Import for name in t.names]
# ast.ImportFrom represents lines like 'from foo import bar'
import_froms = [t.module.split('.')[0] for t in tree.body if type(t) == ast.ImportFrom if t.module]
return imports + import_froms
## Instruction:
Rework the import finding logic
## Code After:
import ast
import os
from collections import deque
import sys
from stdlib_list import stdlib_list
conf = {
'ignore_relative_imports': True,
'ignore_builtin_modules': True,
'pyver': None,
}
def get_imported_libs(code):
tree = ast.parse(code)
imports = deque()
for t in tree.body:
# ast.Import represents lines like 'import foo' and 'import foo, bar'
# the extra for name in t.names is needed, because names is a list that
# would be ['foo'] for the first and ['foo', 'bar'] for the second
if type(t) == ast.Import:
imports.extend([name.name.split('.')[0] for name in t.names])
# ast.ImportFrom represents lines like 'from foo import bar'
# t.level == 0 is to get rid of 'from .foo import bar' and higher levels
# of relative importing
if type(t) == ast.ImportFrom:
if t.level > 0:
if conf['ignore_relative_imports'] or not t.module:
continue
else:
imports.append(t.module.split('.')[0])
return list(imports)
def iterate_over_library(path_to_source_code):
libs = set()
for parent, folders, files in os.walk(path_to_source_code):
for file in files:
if file.endswith('.py'):
print('.', end='')
full_file_path = os.path.join(parent, file)
with open(full_file_path, 'r') as f:
code = f.read()
libs.update(set(get_imported_libs(code)))
if conf['ignore_builtin_modules']:
if not conf['pyver']:
pyver = '%s.%s' % (sys.version_info.major, sys.version_info.minor)
std_libs = stdlib_list("3.4")
# print(std_libs)
libs = [lib for lib in libs if lib not in std_libs]
return libs | import ast
+ import os
+ from collections import deque
+ import sys
+ from stdlib_list import stdlib_list
+
+ conf = {
+ 'ignore_relative_imports': True,
+ 'ignore_builtin_modules': True,
+ 'pyver': None,
+ }
def get_imported_libs(code):
tree = ast.parse(code)
+ imports = deque()
+ for t in tree.body:
- # ast.Import represents lines like 'import foo' and 'import foo, bar'
+ # ast.Import represents lines like 'import foo' and 'import foo, bar'
? ++++
- # the extra for name in t.names is needed, because names is a list that
+ # the extra for name in t.names is needed, because names is a list that
? ++++
- # would be ['foo'] for the first and ['foo', 'bar'] for the second
+ # would be ['foo'] for the first and ['foo', 'bar'] for the second
? ++++
- imports = [name.name.split('.')[0] for t in tree.body
- if type(t) == ast.Import for name in t.names]
+ if type(t) == ast.Import:
+ imports.extend([name.name.split('.')[0] for name in t.names])
- # ast.ImportFrom represents lines like 'from foo import bar'
+ # ast.ImportFrom represents lines like 'from foo import bar'
? ++++
- import_froms = [t.module.split('.')[0] for t in tree.body if type(t) == ast.ImportFrom if t.module]
- return imports + import_froms
+ # t.level == 0 is to get rid of 'from .foo import bar' and higher levels
+ # of relative importing
+ if type(t) == ast.ImportFrom:
+ if t.level > 0:
+ if conf['ignore_relative_imports'] or not t.module:
+ continue
+ else:
+ imports.append(t.module.split('.')[0])
+
+ return list(imports)
+
+
+ def iterate_over_library(path_to_source_code):
+ libs = set()
+ for parent, folders, files in os.walk(path_to_source_code):
+ for file in files:
+ if file.endswith('.py'):
+ print('.', end='')
+ full_file_path = os.path.join(parent, file)
+ with open(full_file_path, 'r') as f:
+ code = f.read()
+ libs.update(set(get_imported_libs(code)))
+
+ if conf['ignore_builtin_modules']:
+ if not conf['pyver']:
+ pyver = '%s.%s' % (sys.version_info.major, sys.version_info.minor)
+ std_libs = stdlib_list("3.4")
+ # print(std_libs)
+ libs = [lib for lib in libs if lib not in std_libs]
+
+ return libs |
0039eefbfa546f24b3f10031e664341d60e4055c | ranger/commands.py | ranger/commands.py | from ranger.api.commands import Command
class fzf_select(Command):
"""
:fzf_select
Find a file using fzf.
With a prefix argument select only directories.
See: https://github.com/junegunn/fzf
"""
def execute(self):
import subprocess
import os.path
if self.quantifier:
# match only directories
command="fd -t d --hidden | fzf +m"
# command="find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
# -o -type d -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
else:
# match files and directories
command="fd --hidden | fzf +m"
# command="find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
# -o -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
fzf = self.fm.execute_command(command, universal_newlines=True, stdout=subprocess.PIPE)
stdout, stderr = fzf.communicate()
if fzf.returncode == 0:
fzf_file = os.path.abspath(stdout.rstrip('\n'))
if os.path.isdir(fzf_file):
self.fm.cd(fzf_file)
else:
self.fm.select_file(fzf_file)
| from ranger.api.commands import Command
class fzf_select(Command):
"""
:fzf_select
Find a file using fzf.
With a prefix argument select only directories.
See: https://github.com/junegunn/fzf
"""
def execute(self):
import subprocess
import os.path
if self.quantifier:
# match only directories
command="fd -t d --hidden | fzf +m --preview 'cat {}'"
# command="find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
# -o -type d -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
else:
# match files and directories
command="fd --hidden | fzf +m --preview 'cat {}'"
# command="find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
# -o -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
fzf = self.fm.execute_command(command, universal_newlines=True, stdout=subprocess.PIPE)
stdout, stderr = fzf.communicate()
if fzf.returncode == 0:
fzf_file = os.path.abspath(stdout.rstrip('\n'))
if os.path.isdir(fzf_file):
self.fm.cd(fzf_file)
else:
self.fm.select_file(fzf_file)
| Use previews in ranger fzf | Use previews in ranger fzf
| Python | mit | darthdeus/dotfiles,darthdeus/dotfiles,darthdeus/dotfiles,darthdeus/dotfiles | from ranger.api.commands import Command
class fzf_select(Command):
"""
:fzf_select
Find a file using fzf.
With a prefix argument select only directories.
See: https://github.com/junegunn/fzf
"""
def execute(self):
import subprocess
import os.path
if self.quantifier:
# match only directories
- command="fd -t d --hidden | fzf +m"
+ command="fd -t d --hidden | fzf +m --preview 'cat {}'"
# command="find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
# -o -type d -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
else:
# match files and directories
- command="fd --hidden | fzf +m"
+ command="fd --hidden | fzf +m --preview 'cat {}'"
# command="find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
# -o -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
fzf = self.fm.execute_command(command, universal_newlines=True, stdout=subprocess.PIPE)
stdout, stderr = fzf.communicate()
if fzf.returncode == 0:
fzf_file = os.path.abspath(stdout.rstrip('\n'))
if os.path.isdir(fzf_file):
self.fm.cd(fzf_file)
else:
self.fm.select_file(fzf_file)
| Use previews in ranger fzf | ## Code Before:
from ranger.api.commands import Command
class fzf_select(Command):
"""
:fzf_select
Find a file using fzf.
With a prefix argument select only directories.
See: https://github.com/junegunn/fzf
"""
def execute(self):
import subprocess
import os.path
if self.quantifier:
# match only directories
command="fd -t d --hidden | fzf +m"
# command="find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
# -o -type d -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
else:
# match files and directories
command="fd --hidden | fzf +m"
# command="find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
# -o -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
fzf = self.fm.execute_command(command, universal_newlines=True, stdout=subprocess.PIPE)
stdout, stderr = fzf.communicate()
if fzf.returncode == 0:
fzf_file = os.path.abspath(stdout.rstrip('\n'))
if os.path.isdir(fzf_file):
self.fm.cd(fzf_file)
else:
self.fm.select_file(fzf_file)
## Instruction:
Use previews in ranger fzf
## Code After:
from ranger.api.commands import Command
class fzf_select(Command):
"""
:fzf_select
Find a file using fzf.
With a prefix argument select only directories.
See: https://github.com/junegunn/fzf
"""
def execute(self):
import subprocess
import os.path
if self.quantifier:
# match only directories
command="fd -t d --hidden | fzf +m --preview 'cat {}'"
# command="find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
# -o -type d -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
else:
# match files and directories
command="fd --hidden | fzf +m --preview 'cat {}'"
# command="find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
# -o -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
fzf = self.fm.execute_command(command, universal_newlines=True, stdout=subprocess.PIPE)
stdout, stderr = fzf.communicate()
if fzf.returncode == 0:
fzf_file = os.path.abspath(stdout.rstrip('\n'))
if os.path.isdir(fzf_file):
self.fm.cd(fzf_file)
else:
self.fm.select_file(fzf_file)
| from ranger.api.commands import Command
class fzf_select(Command):
"""
:fzf_select
Find a file using fzf.
With a prefix argument select only directories.
See: https://github.com/junegunn/fzf
"""
def execute(self):
import subprocess
import os.path
if self.quantifier:
# match only directories
- command="fd -t d --hidden | fzf +m"
+ command="fd -t d --hidden | fzf +m --preview 'cat {}'"
? +++++++++++++++++++
# command="find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
# -o -type d -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
else:
# match files and directories
- command="fd --hidden | fzf +m"
+ command="fd --hidden | fzf +m --preview 'cat {}'"
? +++++++++++++++++++
# command="find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
# -o -print 2> /dev/null | sed 1d | cut -b3- | fzf +m"
fzf = self.fm.execute_command(command, universal_newlines=True, stdout=subprocess.PIPE)
stdout, stderr = fzf.communicate()
if fzf.returncode == 0:
fzf_file = os.path.abspath(stdout.rstrip('\n'))
if os.path.isdir(fzf_file):
self.fm.cd(fzf_file)
else:
self.fm.select_file(fzf_file) |
0d37a94593a7749dca4b2553334f1b67c946d3f8 | ambassador/tests/t_lua_scripts.py | ambassador/tests/t_lua_scripts.py | from kat.harness import Query
from abstract_tests import AmbassadorTest, ServiceType, HTTP
class LuaTest(AmbassadorTest):
target: ServiceType
def init(self):
self.target = HTTP()
def manifests(self) -> str:
return super().manifests() + self.format('''
---
apiVersion: getambassador.io/v1
kind: Module
metadata:
name: ambassador
spec:
ambassador_id: {self.ambassador_id}
config:
lua_scripts: |
function envoy_on_response(response_handle)
response_handle: headers():add("Lua-Scripts-Enabled", "Processed")
end
---
apiVersion: getambassador.io/v1
kind: Mapping
metadata:
name: lua-target-mapping
spec:
ambassador_id: {self.ambassador_id}
prefix: /target/
service: {self.target.path.fqdn}
''')
def queries(self):
yield Query(self.url("target/"))
def check(self):
for r in self.results:
assert r.headers.get('Lua-Scripts-Enabled', None) == ['Processed']
| from kat.harness import Query
from abstract_tests import AmbassadorTest, ServiceType, HTTP
class LuaTest(AmbassadorTest):
target: ServiceType
def init(self):
self.target = HTTP()
self.env = ["LUA_SCRIPTS_ENABLED=Processed"]
def manifests(self) -> str:
return super().manifests() + self.format('''
---
apiVersion: getambassador.io/v1
kind: Module
metadata:
name: ambassador
spec:
ambassador_id: {self.ambassador_id}
config:
lua_scripts: |
function envoy_on_response(response_handle)
response_handle: headers():add("Lua-Scripts-Enabled", "${LUA_SCRIPTS_ENABLED}")
end
---
apiVersion: getambassador.io/v1
kind: Mapping
metadata:
name: lua-target-mapping
spec:
ambassador_id: {self.ambassador_id}
prefix: /target/
service: {self.target.path.fqdn}
''')
def queries(self):
yield Query(self.url("target/"))
def check(self):
for r in self.results:
assert r.headers.get('Lua-Scripts-Enabled', None) == ['Processed']
| Update LUA test to perform interpolation | Update LUA test to perform interpolation
| Python | apache-2.0 | datawire/ambassador,datawire/ambassador,datawire/ambassador,datawire/ambassador,datawire/ambassador | from kat.harness import Query
from abstract_tests import AmbassadorTest, ServiceType, HTTP
class LuaTest(AmbassadorTest):
target: ServiceType
def init(self):
self.target = HTTP()
+ self.env = ["LUA_SCRIPTS_ENABLED=Processed"]
def manifests(self) -> str:
return super().manifests() + self.format('''
---
apiVersion: getambassador.io/v1
kind: Module
metadata:
name: ambassador
spec:
ambassador_id: {self.ambassador_id}
config:
lua_scripts: |
function envoy_on_response(response_handle)
- response_handle: headers():add("Lua-Scripts-Enabled", "Processed")
+ response_handle: headers():add("Lua-Scripts-Enabled", "${LUA_SCRIPTS_ENABLED}")
end
---
apiVersion: getambassador.io/v1
kind: Mapping
metadata:
name: lua-target-mapping
spec:
ambassador_id: {self.ambassador_id}
prefix: /target/
service: {self.target.path.fqdn}
''')
def queries(self):
yield Query(self.url("target/"))
def check(self):
for r in self.results:
assert r.headers.get('Lua-Scripts-Enabled', None) == ['Processed']
| Update LUA test to perform interpolation | ## Code Before:
from kat.harness import Query
from abstract_tests import AmbassadorTest, ServiceType, HTTP
class LuaTest(AmbassadorTest):
target: ServiceType
def init(self):
self.target = HTTP()
def manifests(self) -> str:
return super().manifests() + self.format('''
---
apiVersion: getambassador.io/v1
kind: Module
metadata:
name: ambassador
spec:
ambassador_id: {self.ambassador_id}
config:
lua_scripts: |
function envoy_on_response(response_handle)
response_handle: headers():add("Lua-Scripts-Enabled", "Processed")
end
---
apiVersion: getambassador.io/v1
kind: Mapping
metadata:
name: lua-target-mapping
spec:
ambassador_id: {self.ambassador_id}
prefix: /target/
service: {self.target.path.fqdn}
''')
def queries(self):
yield Query(self.url("target/"))
def check(self):
for r in self.results:
assert r.headers.get('Lua-Scripts-Enabled', None) == ['Processed']
## Instruction:
Update LUA test to perform interpolation
## Code After:
from kat.harness import Query
from abstract_tests import AmbassadorTest, ServiceType, HTTP
class LuaTest(AmbassadorTest):
target: ServiceType
def init(self):
self.target = HTTP()
self.env = ["LUA_SCRIPTS_ENABLED=Processed"]
def manifests(self) -> str:
return super().manifests() + self.format('''
---
apiVersion: getambassador.io/v1
kind: Module
metadata:
name: ambassador
spec:
ambassador_id: {self.ambassador_id}
config:
lua_scripts: |
function envoy_on_response(response_handle)
response_handle: headers():add("Lua-Scripts-Enabled", "${LUA_SCRIPTS_ENABLED}")
end
---
apiVersion: getambassador.io/v1
kind: Mapping
metadata:
name: lua-target-mapping
spec:
ambassador_id: {self.ambassador_id}
prefix: /target/
service: {self.target.path.fqdn}
''')
def queries(self):
yield Query(self.url("target/"))
def check(self):
for r in self.results:
assert r.headers.get('Lua-Scripts-Enabled', None) == ['Processed']
| from kat.harness import Query
from abstract_tests import AmbassadorTest, ServiceType, HTTP
class LuaTest(AmbassadorTest):
target: ServiceType
def init(self):
self.target = HTTP()
+ self.env = ["LUA_SCRIPTS_ENABLED=Processed"]
def manifests(self) -> str:
return super().manifests() + self.format('''
---
apiVersion: getambassador.io/v1
kind: Module
metadata:
name: ambassador
spec:
ambassador_id: {self.ambassador_id}
config:
lua_scripts: |
function envoy_on_response(response_handle)
- response_handle: headers():add("Lua-Scripts-Enabled", "Processed")
? ^^^^^^^^
+ response_handle: headers():add("Lua-Scripts-Enabled", "${LUA_SCRIPTS_ENABLED}")
? ++++++++++ ^^^^^^^^^^^
end
---
apiVersion: getambassador.io/v1
kind: Mapping
metadata:
name: lua-target-mapping
spec:
ambassador_id: {self.ambassador_id}
prefix: /target/
service: {self.target.path.fqdn}
''')
def queries(self):
yield Query(self.url("target/"))
def check(self):
for r in self.results:
assert r.headers.get('Lua-Scripts-Enabled', None) == ['Processed'] |
43e4d71a193f78e83f26e9d1c5fe69cee1b289b5 | raffle.py | raffle.py | import random
import webbrowser
from pythonkc_meetups import PythonKCMeetups
from optparse import OptionParser
def raffle_time(api_key=None, event_id=None):
client = PythonKCMeetups(api_key=api_key)
attendees = client.get_event_attendees(event_id)
random.shuffle(attendees)
winner = random.choice(attendees)
if winner.photo:
webbrowser.open_new(winner.photo.url)
print "\n\nAnd the winner is, %s \n\n" % winner.name
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("-k", "--key", help="api key for meetup.com", dest="api_key", type="string")
parser.add_option("-e", "--event_id", help="event id from meetup.com", dest="event_id",
type="int")
options, args = parser.parse_args()
raffle_time(api_key=options.api_key, event_id=options.event_id)
| import random
import webbrowser
from pythonkc_meetups import PythonKCMeetups
from optparse import OptionParser
def raffle_time(api_key=None, event_id=None):
client = PythonKCMeetups(api_key=api_key)
attendees = client.get_event_attendees(event_id)
random.seed()
random.shuffle(attendees)
winner = random.choice(attendees)
if winner.photo:
webbrowser.open_new(winner.photo.url)
print("\n\nAnd the winner is, %s \n\n" % winner.name)
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("-k", "--key", help="api key for meetup.com", dest="api_key", type="string")
parser.add_option("-e", "--event_id", help="event id from meetup.com", dest="event_id",
type="int")
options, args = parser.parse_args()
raffle_time(api_key=options.api_key, event_id=options.event_id)
| Add call to random.seed() and change print statement to print function. | Add call to random.seed() and change print statement to print function.
| Python | bsd-3-clause | pythonkc/pythonkc-raffler | import random
import webbrowser
from pythonkc_meetups import PythonKCMeetups
from optparse import OptionParser
def raffle_time(api_key=None, event_id=None):
client = PythonKCMeetups(api_key=api_key)
attendees = client.get_event_attendees(event_id)
+ random.seed()
random.shuffle(attendees)
winner = random.choice(attendees)
if winner.photo:
webbrowser.open_new(winner.photo.url)
- print "\n\nAnd the winner is, %s \n\n" % winner.name
+ print("\n\nAnd the winner is, %s \n\n" % winner.name)
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("-k", "--key", help="api key for meetup.com", dest="api_key", type="string")
parser.add_option("-e", "--event_id", help="event id from meetup.com", dest="event_id",
type="int")
options, args = parser.parse_args()
raffle_time(api_key=options.api_key, event_id=options.event_id)
| Add call to random.seed() and change print statement to print function. | ## Code Before:
import random
import webbrowser
from pythonkc_meetups import PythonKCMeetups
from optparse import OptionParser
def raffle_time(api_key=None, event_id=None):
client = PythonKCMeetups(api_key=api_key)
attendees = client.get_event_attendees(event_id)
random.shuffle(attendees)
winner = random.choice(attendees)
if winner.photo:
webbrowser.open_new(winner.photo.url)
print "\n\nAnd the winner is, %s \n\n" % winner.name
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("-k", "--key", help="api key for meetup.com", dest="api_key", type="string")
parser.add_option("-e", "--event_id", help="event id from meetup.com", dest="event_id",
type="int")
options, args = parser.parse_args()
raffle_time(api_key=options.api_key, event_id=options.event_id)
## Instruction:
Add call to random.seed() and change print statement to print function.
## Code After:
import random
import webbrowser
from pythonkc_meetups import PythonKCMeetups
from optparse import OptionParser
def raffle_time(api_key=None, event_id=None):
client = PythonKCMeetups(api_key=api_key)
attendees = client.get_event_attendees(event_id)
random.seed()
random.shuffle(attendees)
winner = random.choice(attendees)
if winner.photo:
webbrowser.open_new(winner.photo.url)
print("\n\nAnd the winner is, %s \n\n" % winner.name)
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("-k", "--key", help="api key for meetup.com", dest="api_key", type="string")
parser.add_option("-e", "--event_id", help="event id from meetup.com", dest="event_id",
type="int")
options, args = parser.parse_args()
raffle_time(api_key=options.api_key, event_id=options.event_id)
| import random
import webbrowser
from pythonkc_meetups import PythonKCMeetups
from optparse import OptionParser
def raffle_time(api_key=None, event_id=None):
client = PythonKCMeetups(api_key=api_key)
attendees = client.get_event_attendees(event_id)
+ random.seed()
random.shuffle(attendees)
winner = random.choice(attendees)
if winner.photo:
webbrowser.open_new(winner.photo.url)
- print "\n\nAnd the winner is, %s \n\n" % winner.name
? ^
+ print("\n\nAnd the winner is, %s \n\n" % winner.name)
? ^ +
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("-k", "--key", help="api key for meetup.com", dest="api_key", type="string")
parser.add_option("-e", "--event_id", help="event id from meetup.com", dest="event_id",
type="int")
options, args = parser.parse_args()
raffle_time(api_key=options.api_key, event_id=options.event_id) |
e7a771011e93660c811effb8357df035bae8f9a6 | pentai/gui/settings_screen.py | pentai/gui/settings_screen.py | from kivy.uix.screenmanager import Screen
#from kivy.properties import *
from kivy.uix.settings import SettingSpacer
from my_setting import *
import audio as a_m
class SettingsScreen(Screen):
def __init__(self, *args, **kwargs):
super(SettingsScreen, self).__init__(*args, **kwargs)
def adjust_volumes(self, *args):
a_m.adjust_volumes()
def set_confirmation_popups(self, *args):
self.app.set_confirmation_popups()
| from kivy.uix.screenmanager import Screen
#from kivy.properties import *
from kivy.uix.settings import SettingSpacer
from my_setting import *
import audio as a_m
from kivy.uix.widget import Widget
class HSpacer(Widget):
pass
class VSpacer(Widget):
pass
class SettingsScreen(Screen):
def __init__(self, *args, **kwargs):
super(SettingsScreen, self).__init__(*args, **kwargs)
def adjust_volumes(self, *args):
a_m.adjust_volumes()
def set_confirmation_popups(self, *args):
self.app.set_confirmation_popups()
| Use our own spacer widgets | Use our own spacer widgets
| Python | mit | cropleyb/pentai,cropleyb/pentai,cropleyb/pentai | from kivy.uix.screenmanager import Screen
#from kivy.properties import *
from kivy.uix.settings import SettingSpacer
from my_setting import *
import audio as a_m
+
+ from kivy.uix.widget import Widget
+
+ class HSpacer(Widget):
+ pass
+
+ class VSpacer(Widget):
+ pass
class SettingsScreen(Screen):
def __init__(self, *args, **kwargs):
super(SettingsScreen, self).__init__(*args, **kwargs)
def adjust_volumes(self, *args):
a_m.adjust_volumes()
def set_confirmation_popups(self, *args):
self.app.set_confirmation_popups()
| Use our own spacer widgets | ## Code Before:
from kivy.uix.screenmanager import Screen
#from kivy.properties import *
from kivy.uix.settings import SettingSpacer
from my_setting import *
import audio as a_m
class SettingsScreen(Screen):
def __init__(self, *args, **kwargs):
super(SettingsScreen, self).__init__(*args, **kwargs)
def adjust_volumes(self, *args):
a_m.adjust_volumes()
def set_confirmation_popups(self, *args):
self.app.set_confirmation_popups()
## Instruction:
Use our own spacer widgets
## Code After:
from kivy.uix.screenmanager import Screen
#from kivy.properties import *
from kivy.uix.settings import SettingSpacer
from my_setting import *
import audio as a_m
from kivy.uix.widget import Widget
class HSpacer(Widget):
pass
class VSpacer(Widget):
pass
class SettingsScreen(Screen):
def __init__(self, *args, **kwargs):
super(SettingsScreen, self).__init__(*args, **kwargs)
def adjust_volumes(self, *args):
a_m.adjust_volumes()
def set_confirmation_popups(self, *args):
self.app.set_confirmation_popups()
| from kivy.uix.screenmanager import Screen
#from kivy.properties import *
from kivy.uix.settings import SettingSpacer
from my_setting import *
import audio as a_m
+
+ from kivy.uix.widget import Widget
+
+ class HSpacer(Widget):
+ pass
+
+ class VSpacer(Widget):
+ pass
class SettingsScreen(Screen):
def __init__(self, *args, **kwargs):
super(SettingsScreen, self).__init__(*args, **kwargs)
def adjust_volumes(self, *args):
a_m.adjust_volumes()
def set_confirmation_popups(self, *args):
self.app.set_confirmation_popups()
|
da516d06ab294dc2dde4bb671ab16653b1421314 | tests/performance.py | tests/performance.py | """Script to run performance check."""
import time
from examples.game_of_life import GameOfLife, GOLExperiment
from xentica.utils.formatters import sizeof_fmt
MODELS = [
("Conway's Life", GameOfLife, GOLExperiment),
]
NUM_STEPS = 10000
if __name__ == "__main__":
for name, model, experiment in MODELS:
ca = model(experiment)
start_time = time.time()
for j in range(NUM_STEPS):
ca.step()
time_passed = time.time() - start_time
speed = NUM_STEPS * ca.cells_num // time_passed
print("%s: %s cells/s" % (name, sizeof_fmt(speed)))
del ca
| """Script to run performance check."""
import time
from examples.game_of_life import (
GameOfLife, GOLExperiment
)
from examples.shifting_sands import (
ShiftingSands, ShiftingSandsExperiment
)
from xentica.utils.formatters import sizeof_fmt
MODELS = [
("Conway's Life", GameOfLife, GOLExperiment),
("Shifting Sands", ShiftingSands, ShiftingSandsExperiment),
]
NUM_STEPS = 10000
if __name__ == "__main__":
for name, model, experiment in MODELS:
ca = model(experiment)
start_time = time.time()
for j in range(NUM_STEPS):
ca.step()
time_passed = time.time() - start_time
speed = NUM_STEPS * ca.cells_num // time_passed
print("%s: %s cells/s" % (name, sizeof_fmt(speed)))
del ca
| Add Shifting Sands to benchmark tests | Add Shifting Sands to benchmark tests
| Python | mit | a5kin/hecate,a5kin/hecate | """Script to run performance check."""
import time
- from examples.game_of_life import GameOfLife, GOLExperiment
+ from examples.game_of_life import (
+ GameOfLife, GOLExperiment
+ )
+ from examples.shifting_sands import (
+ ShiftingSands, ShiftingSandsExperiment
+ )
from xentica.utils.formatters import sizeof_fmt
MODELS = [
("Conway's Life", GameOfLife, GOLExperiment),
+ ("Shifting Sands", ShiftingSands, ShiftingSandsExperiment),
]
NUM_STEPS = 10000
if __name__ == "__main__":
for name, model, experiment in MODELS:
ca = model(experiment)
start_time = time.time()
for j in range(NUM_STEPS):
ca.step()
time_passed = time.time() - start_time
speed = NUM_STEPS * ca.cells_num // time_passed
print("%s: %s cells/s" % (name, sizeof_fmt(speed)))
del ca
| Add Shifting Sands to benchmark tests | ## Code Before:
"""Script to run performance check."""
import time
from examples.game_of_life import GameOfLife, GOLExperiment
from xentica.utils.formatters import sizeof_fmt
MODELS = [
("Conway's Life", GameOfLife, GOLExperiment),
]
NUM_STEPS = 10000
if __name__ == "__main__":
for name, model, experiment in MODELS:
ca = model(experiment)
start_time = time.time()
for j in range(NUM_STEPS):
ca.step()
time_passed = time.time() - start_time
speed = NUM_STEPS * ca.cells_num // time_passed
print("%s: %s cells/s" % (name, sizeof_fmt(speed)))
del ca
## Instruction:
Add Shifting Sands to benchmark tests
## Code After:
"""Script to run performance check."""
import time
from examples.game_of_life import (
GameOfLife, GOLExperiment
)
from examples.shifting_sands import (
ShiftingSands, ShiftingSandsExperiment
)
from xentica.utils.formatters import sizeof_fmt
MODELS = [
("Conway's Life", GameOfLife, GOLExperiment),
("Shifting Sands", ShiftingSands, ShiftingSandsExperiment),
]
NUM_STEPS = 10000
if __name__ == "__main__":
for name, model, experiment in MODELS:
ca = model(experiment)
start_time = time.time()
for j in range(NUM_STEPS):
ca.step()
time_passed = time.time() - start_time
speed = NUM_STEPS * ca.cells_num // time_passed
print("%s: %s cells/s" % (name, sizeof_fmt(speed)))
del ca
| """Script to run performance check."""
import time
- from examples.game_of_life import GameOfLife, GOLExperiment
+ from examples.game_of_life import (
+ GameOfLife, GOLExperiment
+ )
+ from examples.shifting_sands import (
+ ShiftingSands, ShiftingSandsExperiment
+ )
from xentica.utils.formatters import sizeof_fmt
MODELS = [
("Conway's Life", GameOfLife, GOLExperiment),
+ ("Shifting Sands", ShiftingSands, ShiftingSandsExperiment),
]
NUM_STEPS = 10000
if __name__ == "__main__":
for name, model, experiment in MODELS:
ca = model(experiment)
start_time = time.time()
for j in range(NUM_STEPS):
ca.step()
time_passed = time.time() - start_time
speed = NUM_STEPS * ca.cells_num // time_passed
print("%s: %s cells/s" % (name, sizeof_fmt(speed)))
del ca |
c073bc3290bbe33ede95a23354062b48b68ca23f | kbcstorage/__init__.py | kbcstorage/__init__.py | from pkg_resources import get_distribution, DistributionNotFound
try:
__version__ = get_distribution('kbcstorage').version
except DistributionNotFound:
# package is not installed
pass
| from pkg_resources import get_distribution, DistributionNotFound
try:
release = get_distribution('kbcstorage').version
__version__ = '.'.join(release.split('.')[:2])
except DistributionNotFound:
# package is not installed
pass
| Make package version string major.minor only | Make package version string major.minor only
| Python | mit | Ogaday/sapi-python-client,Ogaday/sapi-python-client | from pkg_resources import get_distribution, DistributionNotFound
try:
- __version__ = get_distribution('kbcstorage').version
+ release = get_distribution('kbcstorage').version
+ __version__ = '.'.join(release.split('.')[:2])
except DistributionNotFound:
# package is not installed
pass
| Make package version string major.minor only | ## Code Before:
from pkg_resources import get_distribution, DistributionNotFound
try:
__version__ = get_distribution('kbcstorage').version
except DistributionNotFound:
# package is not installed
pass
## Instruction:
Make package version string major.minor only
## Code After:
from pkg_resources import get_distribution, DistributionNotFound
try:
release = get_distribution('kbcstorage').version
__version__ = '.'.join(release.split('.')[:2])
except DistributionNotFound:
# package is not installed
pass
| from pkg_resources import get_distribution, DistributionNotFound
try:
- __version__ = get_distribution('kbcstorage').version
? ^^^ ^ ^^^^^
+ release = get_distribution('kbcstorage').version
? ^ ^^^ ^
+ __version__ = '.'.join(release.split('.')[:2])
except DistributionNotFound:
# package is not installed
pass |
9f69c886a1b5d75444e2efcfa29ce636d000b0a0 | microbower/__init__.py | microbower/__init__.py |
from subprocess import check_call
import urllib
import json
import os
import os.path
def install():
with open('.bowerrc') as f:
bowerrc = json.load(f)
with open('bower.json') as f:
bower_json = json.load(f)
registry = 'https://bower.herokuapp.com'
topdir = os.path.abspath(os.curdir)
for pkg in bower_json['dependencies'].keys():
req = urllib.urlopen('%s/packages/%s' % (registry, pkg))
info = json.load(req)
os.chdir(bowerrc['directory'])
check_call(['git', 'clone', info['url']])
os.chdir(pkg)
install()
os.chdir(topdir)
|
from subprocess import check_call
import urllib
import json
import os
import os.path
def install():
with open('.bowerrc') as f:
bowerrc = json.load(f)
with open('bower.json') as f:
bower_json = json.load(f)
registry = 'https://bower.herokuapp.com'
topdir = os.path.abspath(os.curdir)
for pkg in bower_json['dependencies'].keys():
req = urllib.urlopen('%s/packages/%s' % (registry, pkg))
info = json.load(req)
if not os.path.isdir(bowerrc['directory']):
os.makedirs(bowerrc['directory'])
os.chdir(bowerrc['directory'])
check_call(['git', 'clone', info['url']])
os.chdir(pkg)
install()
os.chdir(topdir)
| Make the destination directory if it does not exist | Make the destination directory if it does not exist
| Python | isc | zenhack/microbower |
from subprocess import check_call
import urllib
import json
import os
import os.path
def install():
with open('.bowerrc') as f:
bowerrc = json.load(f)
with open('bower.json') as f:
bower_json = json.load(f)
registry = 'https://bower.herokuapp.com'
topdir = os.path.abspath(os.curdir)
for pkg in bower_json['dependencies'].keys():
req = urllib.urlopen('%s/packages/%s' % (registry, pkg))
info = json.load(req)
+ if not os.path.isdir(bowerrc['directory']):
+ os.makedirs(bowerrc['directory'])
os.chdir(bowerrc['directory'])
check_call(['git', 'clone', info['url']])
os.chdir(pkg)
install()
os.chdir(topdir)
| Make the destination directory if it does not exist | ## Code Before:
from subprocess import check_call
import urllib
import json
import os
import os.path
def install():
with open('.bowerrc') as f:
bowerrc = json.load(f)
with open('bower.json') as f:
bower_json = json.load(f)
registry = 'https://bower.herokuapp.com'
topdir = os.path.abspath(os.curdir)
for pkg in bower_json['dependencies'].keys():
req = urllib.urlopen('%s/packages/%s' % (registry, pkg))
info = json.load(req)
os.chdir(bowerrc['directory'])
check_call(['git', 'clone', info['url']])
os.chdir(pkg)
install()
os.chdir(topdir)
## Instruction:
Make the destination directory if it does not exist
## Code After:
from subprocess import check_call
import urllib
import json
import os
import os.path
def install():
with open('.bowerrc') as f:
bowerrc = json.load(f)
with open('bower.json') as f:
bower_json = json.load(f)
registry = 'https://bower.herokuapp.com'
topdir = os.path.abspath(os.curdir)
for pkg in bower_json['dependencies'].keys():
req = urllib.urlopen('%s/packages/%s' % (registry, pkg))
info = json.load(req)
if not os.path.isdir(bowerrc['directory']):
os.makedirs(bowerrc['directory'])
os.chdir(bowerrc['directory'])
check_call(['git', 'clone', info['url']])
os.chdir(pkg)
install()
os.chdir(topdir)
|
from subprocess import check_call
import urllib
import json
import os
import os.path
def install():
with open('.bowerrc') as f:
bowerrc = json.load(f)
with open('bower.json') as f:
bower_json = json.load(f)
registry = 'https://bower.herokuapp.com'
topdir = os.path.abspath(os.curdir)
for pkg in bower_json['dependencies'].keys():
req = urllib.urlopen('%s/packages/%s' % (registry, pkg))
info = json.load(req)
+ if not os.path.isdir(bowerrc['directory']):
+ os.makedirs(bowerrc['directory'])
os.chdir(bowerrc['directory'])
check_call(['git', 'clone', info['url']])
os.chdir(pkg)
install()
os.chdir(topdir) |
ee1deb28a2c32b7e35a2132542edd69f3c785c9c | django/projects/mysite/run-gevent.py | django/projects/mysite/run-gevent.py | from gevent import monkey
monkey.patch_all(httplib=True)
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
| from gevent import monkey
monkey.patch_all()
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
| Fix httplib monkey patching problem with Gevent >= 1.0 | Fix httplib monkey patching problem with Gevent >= 1.0
From v1.0 on, Gevent doesn't support monkey patching of httplib anymore.
CATMAID's example script to run a Gevent WSGI server, however, was still
expecting this to be possible. This commit fixes this.
Thanks to Mikhail Kandel for reporting.
| Python | agpl-3.0 | fzadow/CATMAID,htem/CATMAID,fzadow/CATMAID,htem/CATMAID,htem/CATMAID,fzadow/CATMAID,fzadow/CATMAID,htem/CATMAID | from gevent import monkey
- monkey.patch_all(httplib=True)
+ monkey.patch_all()
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
| Fix httplib monkey patching problem with Gevent >= 1.0 | ## Code Before:
from gevent import monkey
monkey.patch_all(httplib=True)
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
## Instruction:
Fix httplib monkey patching problem with Gevent >= 1.0
## Code After:
from gevent import monkey
monkey.patch_all()
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
| from gevent import monkey
- monkey.patch_all(httplib=True)
? ------------
+ monkey.patch_all()
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver() |
e77cb240d522da47208b60384c40f03f5c9182e3 | tests/test_encoder.py | tests/test_encoder.py | import os
import glob
import pvl
DATA_DIR = os.path.join(os.path.dirname(__file__), 'data/')
PDS_DATA_DIR = os.path.join(os.path.dirname(__file__), 'data', 'pds3')
def test_dump():
files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
for infile in files:
label = pvl.load(infile)
assert label == pvl.loads(pvl.dumps(label))
| import os
import glob
import pvl
DATA_DIR = os.path.join(os.path.dirname(__file__), 'data/')
PDS_DATA_DIR = os.path.join(os.path.dirname(__file__), 'data', 'pds3')
def test_dump():
files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
for infile in files:
label = pvl.load(infile)
assert label == pvl.loads(pvl.dumps(label))
def test_cube_dump():
files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
for infile in files:
label = pvl.load(infile)
encoder = pvl.encoder.IsisCubeLabelEncoder
assert label == pvl.loads(pvl.dumps(label, cls=encoder))
def test_pds_dump():
files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
for infile in files:
label = pvl.load(infile)
encoder = pvl.encoder.PDSLabelEncoder
assert label == pvl.loads(pvl.dumps(label, cls=encoder))
| Add tests for cube and isis encoders. | Add tests for cube and isis encoders.
| Python | bsd-3-clause | pbvarga1/pvl,bvnayak/pvl,wtolson/pvl,planetarypy/pvl | import os
import glob
import pvl
DATA_DIR = os.path.join(os.path.dirname(__file__), 'data/')
PDS_DATA_DIR = os.path.join(os.path.dirname(__file__), 'data', 'pds3')
def test_dump():
files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
for infile in files:
label = pvl.load(infile)
assert label == pvl.loads(pvl.dumps(label))
+
+ def test_cube_dump():
+ files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
+
+ for infile in files:
+ label = pvl.load(infile)
+ encoder = pvl.encoder.IsisCubeLabelEncoder
+ assert label == pvl.loads(pvl.dumps(label, cls=encoder))
+
+
+ def test_pds_dump():
+ files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
+
+ for infile in files:
+ label = pvl.load(infile)
+ encoder = pvl.encoder.PDSLabelEncoder
+ assert label == pvl.loads(pvl.dumps(label, cls=encoder))
+ | Add tests for cube and isis encoders. | ## Code Before:
import os
import glob
import pvl
DATA_DIR = os.path.join(os.path.dirname(__file__), 'data/')
PDS_DATA_DIR = os.path.join(os.path.dirname(__file__), 'data', 'pds3')
def test_dump():
files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
for infile in files:
label = pvl.load(infile)
assert label == pvl.loads(pvl.dumps(label))
## Instruction:
Add tests for cube and isis encoders.
## Code After:
import os
import glob
import pvl
DATA_DIR = os.path.join(os.path.dirname(__file__), 'data/')
PDS_DATA_DIR = os.path.join(os.path.dirname(__file__), 'data', 'pds3')
def test_dump():
files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
for infile in files:
label = pvl.load(infile)
assert label == pvl.loads(pvl.dumps(label))
def test_cube_dump():
files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
for infile in files:
label = pvl.load(infile)
encoder = pvl.encoder.IsisCubeLabelEncoder
assert label == pvl.loads(pvl.dumps(label, cls=encoder))
def test_pds_dump():
files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
for infile in files:
label = pvl.load(infile)
encoder = pvl.encoder.PDSLabelEncoder
assert label == pvl.loads(pvl.dumps(label, cls=encoder))
| import os
import glob
import pvl
DATA_DIR = os.path.join(os.path.dirname(__file__), 'data/')
PDS_DATA_DIR = os.path.join(os.path.dirname(__file__), 'data', 'pds3')
def test_dump():
files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
for infile in files:
label = pvl.load(infile)
assert label == pvl.loads(pvl.dumps(label))
+
+
+ def test_cube_dump():
+ files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
+
+ for infile in files:
+ label = pvl.load(infile)
+ encoder = pvl.encoder.IsisCubeLabelEncoder
+ assert label == pvl.loads(pvl.dumps(label, cls=encoder))
+
+
+ def test_pds_dump():
+ files = glob.glob(os.path.join(PDS_DATA_DIR, "*.lbl"))
+
+ for infile in files:
+ label = pvl.load(infile)
+ encoder = pvl.encoder.PDSLabelEncoder
+ assert label == pvl.loads(pvl.dumps(label, cls=encoder)) |
d8cb4384f32f4d0e20f3212a36cc01915260f7a8 | tests/routers.py | tests/routers.py | """Search router."""
from rest_framework.routers import DefaultRouter, Route
class SearchRouter(DefaultRouter):
"""Custom router for search endpoints.
Search endpoints don't follow REST principles and thus don't need
routes that default router provides.
"""
routes = [
Route(
url=r"^{prefix}{trailing_slash}$",
mapping={"get": "list", "post": "list_with_post"},
name="{basename}",
initkwargs={},
detail=False,
)
]
| """Search router."""
from rest_framework.routers import DefaultRouter, DynamicRoute, Route
class SearchRouter(DefaultRouter):
"""Custom router for search endpoints.
Search endpoints don't follow REST principles and thus don't need
routes that default router provides.
"""
routes = [
Route(
url=r"^{prefix}{trailing_slash}$",
mapping={"get": "list", "post": "list_with_post"},
name="{basename}",
initkwargs={},
detail=False,
),
# Dynamically generated list routes. Generated using
# @action(detail=False) decorator on methods of the viewset.
DynamicRoute(
url=r'^{prefix}/{url_path}{trailing_slash}$',
name='{basename}-{url_name}',
detail=False,
initkwargs={}
),
Route(
url=r'^{prefix}/{lookup}{trailing_slash}$',
mapping={
'get': 'retrieve',
'put': 'update',
'patch': 'partial_update',
'delete': 'destroy'
},
name='{basename}-detail',
detail=True,
initkwargs={'suffix': 'Instance'}
),
# Dynamically generated detail routes. Generated using
# @action(detail=True) decorator on methods of the viewset.
DynamicRoute(
url=r'^{prefix}/{lookup}/{url_path}{trailing_slash}$',
name='{basename}-{url_name}',
detail=True,
initkwargs={}
),
]
| Support custom actions in search router | Support custom actions in search router
| Python | apache-2.0 | genialis/resolwe-bio,genialis/resolwe-bio,genialis/resolwe-bio,genialis/resolwe-bio | """Search router."""
- from rest_framework.routers import DefaultRouter, Route
+ from rest_framework.routers import DefaultRouter, DynamicRoute, Route
class SearchRouter(DefaultRouter):
"""Custom router for search endpoints.
Search endpoints don't follow REST principles and thus don't need
routes that default router provides.
"""
routes = [
Route(
url=r"^{prefix}{trailing_slash}$",
mapping={"get": "list", "post": "list_with_post"},
name="{basename}",
initkwargs={},
detail=False,
- )
+ ),
+ # Dynamically generated list routes. Generated using
+ # @action(detail=False) decorator on methods of the viewset.
+ DynamicRoute(
+ url=r'^{prefix}/{url_path}{trailing_slash}$',
+ name='{basename}-{url_name}',
+ detail=False,
+ initkwargs={}
+ ),
+ Route(
+ url=r'^{prefix}/{lookup}{trailing_slash}$',
+ mapping={
+ 'get': 'retrieve',
+ 'put': 'update',
+ 'patch': 'partial_update',
+ 'delete': 'destroy'
+ },
+ name='{basename}-detail',
+ detail=True,
+ initkwargs={'suffix': 'Instance'}
+ ),
+ # Dynamically generated detail routes. Generated using
+ # @action(detail=True) decorator on methods of the viewset.
+ DynamicRoute(
+ url=r'^{prefix}/{lookup}/{url_path}{trailing_slash}$',
+ name='{basename}-{url_name}',
+ detail=True,
+ initkwargs={}
+ ),
]
| Support custom actions in search router | ## Code Before:
"""Search router."""
from rest_framework.routers import DefaultRouter, Route
class SearchRouter(DefaultRouter):
"""Custom router for search endpoints.
Search endpoints don't follow REST principles and thus don't need
routes that default router provides.
"""
routes = [
Route(
url=r"^{prefix}{trailing_slash}$",
mapping={"get": "list", "post": "list_with_post"},
name="{basename}",
initkwargs={},
detail=False,
)
]
## Instruction:
Support custom actions in search router
## Code After:
"""Search router."""
from rest_framework.routers import DefaultRouter, DynamicRoute, Route
class SearchRouter(DefaultRouter):
"""Custom router for search endpoints.
Search endpoints don't follow REST principles and thus don't need
routes that default router provides.
"""
routes = [
Route(
url=r"^{prefix}{trailing_slash}$",
mapping={"get": "list", "post": "list_with_post"},
name="{basename}",
initkwargs={},
detail=False,
),
# Dynamically generated list routes. Generated using
# @action(detail=False) decorator on methods of the viewset.
DynamicRoute(
url=r'^{prefix}/{url_path}{trailing_slash}$',
name='{basename}-{url_name}',
detail=False,
initkwargs={}
),
Route(
url=r'^{prefix}/{lookup}{trailing_slash}$',
mapping={
'get': 'retrieve',
'put': 'update',
'patch': 'partial_update',
'delete': 'destroy'
},
name='{basename}-detail',
detail=True,
initkwargs={'suffix': 'Instance'}
),
# Dynamically generated detail routes. Generated using
# @action(detail=True) decorator on methods of the viewset.
DynamicRoute(
url=r'^{prefix}/{lookup}/{url_path}{trailing_slash}$',
name='{basename}-{url_name}',
detail=True,
initkwargs={}
),
]
| """Search router."""
- from rest_framework.routers import DefaultRouter, Route
+ from rest_framework.routers import DefaultRouter, DynamicRoute, Route
? +++++++ +++++++
class SearchRouter(DefaultRouter):
"""Custom router for search endpoints.
Search endpoints don't follow REST principles and thus don't need
routes that default router provides.
"""
routes = [
Route(
url=r"^{prefix}{trailing_slash}$",
mapping={"get": "list", "post": "list_with_post"},
name="{basename}",
initkwargs={},
detail=False,
- )
+ ),
? +
+ # Dynamically generated list routes. Generated using
+ # @action(detail=False) decorator on methods of the viewset.
+ DynamicRoute(
+ url=r'^{prefix}/{url_path}{trailing_slash}$',
+ name='{basename}-{url_name}',
+ detail=False,
+ initkwargs={}
+ ),
+ Route(
+ url=r'^{prefix}/{lookup}{trailing_slash}$',
+ mapping={
+ 'get': 'retrieve',
+ 'put': 'update',
+ 'patch': 'partial_update',
+ 'delete': 'destroy'
+ },
+ name='{basename}-detail',
+ detail=True,
+ initkwargs={'suffix': 'Instance'}
+ ),
+ # Dynamically generated detail routes. Generated using
+ # @action(detail=True) decorator on methods of the viewset.
+ DynamicRoute(
+ url=r'^{prefix}/{lookup}/{url_path}{trailing_slash}$',
+ name='{basename}-{url_name}',
+ detail=True,
+ initkwargs={}
+ ),
] |
6500d388fa894bb0ea8cb0ca1328a73cc54ba4e8 | Challenges/chall_02.py | Challenges/chall_02.py |
def main():
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
letters = []
with open('garbage.txt', 'r') as garbage:
for line in garbage.readlines():
for c in line:
if c in alphabet:
letters.append(c)
print(''.join(letters))
return 0
if __name__ == '__main__':
main()
|
import string
def main():
'''
Hint: recognize the characters. maybe they are in the book,
but MAYBE they are in the page source.
Page source text saved in garbage.txt
'''
alphabet = string.ascii_letters
with open('garbage.txt', 'r') as garbage:
letters = [c for line in garbage.readlines() for c in line
if c in alphabet]
# Long form of nested loops:
# letters = []
# for line in garbage.readlines():
# for c in line:
# if c in alphabet:
# letters.append(c)
print(''.join(letters))
return 0
if __name__ == '__main__':
main()
| Refactor code, add page hints | Refactor code, add page hints
| Python | mit | HKuz/PythonChallenge | +
+ import string
def main():
- alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
- letters = []
+ '''
+ Hint: recognize the characters. maybe they are in the book,
+ but MAYBE they are in the page source.
+ Page source text saved in garbage.txt
+ '''
+
+ alphabet = string.ascii_letters
with open('garbage.txt', 'r') as garbage:
+ letters = [c for line in garbage.readlines() for c in line
+ if c in alphabet]
+ # Long form of nested loops:
+ # letters = []
- for line in garbage.readlines():
+ # for line in garbage.readlines():
- for c in line:
+ # for c in line:
- if c in alphabet:
+ # if c in alphabet:
- letters.append(c)
+ # letters.append(c)
print(''.join(letters))
return 0
if __name__ == '__main__':
main()
| Refactor code, add page hints | ## Code Before:
def main():
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
letters = []
with open('garbage.txt', 'r') as garbage:
for line in garbage.readlines():
for c in line:
if c in alphabet:
letters.append(c)
print(''.join(letters))
return 0
if __name__ == '__main__':
main()
## Instruction:
Refactor code, add page hints
## Code After:
import string
def main():
'''
Hint: recognize the characters. maybe they are in the book,
but MAYBE they are in the page source.
Page source text saved in garbage.txt
'''
alphabet = string.ascii_letters
with open('garbage.txt', 'r') as garbage:
letters = [c for line in garbage.readlines() for c in line
if c in alphabet]
# Long form of nested loops:
# letters = []
# for line in garbage.readlines():
# for c in line:
# if c in alphabet:
# letters.append(c)
print(''.join(letters))
return 0
if __name__ == '__main__':
main()
| +
+ import string
def main():
- alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
- letters = []
+ '''
+ Hint: recognize the characters. maybe they are in the book,
+ but MAYBE they are in the page source.
+ Page source text saved in garbage.txt
+ '''
+
+ alphabet = string.ascii_letters
with open('garbage.txt', 'r') as garbage:
+ letters = [c for line in garbage.readlines() for c in line
+ if c in alphabet]
+ # Long form of nested loops:
+ # letters = []
- for line in garbage.readlines():
+ # for line in garbage.readlines():
? ++
- for c in line:
+ # for c in line:
? ++
- if c in alphabet:
+ # if c in alphabet:
? ++
- letters.append(c)
+ # letters.append(c)
? ++
print(''.join(letters))
return 0
if __name__ == '__main__':
main() |
56d92af9ba0a9b81dd0e802d05717ec6e4f511d3 | seven23/api/views.py | seven23/api/views.py |
import json
import os
import markdown2
from django.http import HttpResponse
from django.db import models
from rest_framework.decorators import api_view
from seven23 import settings
from seven23.models.terms.models import TermsAndConditions
@api_view(["GET"])
def api_init(request):
"""
Return status on client initialisation
"""
result = {}
# Return API Version.
result['api_version'] = settings.API_VERSION
result['allow_account_creation'] = settings.ALLOW_ACCOUNT_CREATION
result['contact'] = settings.CONTACT_EMAIL
try:
terms = TermsAndConditions.objects.latest('date')
result['terms_and_conditions_date'] = terms.date
result['terms_and_conditions'] = markdown2.markdown(terms.markdown)
except TermsAndConditions.DoesNotExist:
result['terms_and_conditions_date'] = None
result['terms_and_conditions'] = None
if request.user.is_authenticated():
result['is_authenticated'] = True
result['id'] = request.user.id
else:
result['is_authenticated'] = False
# Return json format string.
j = json.dumps(result, separators=(',', ':'))
return HttpResponse(j, content_type='application/json')
|
import json
import os
import markdown2
from django.http import HttpResponse
from django.db import models
from rest_framework.decorators import api_view
from seven23 import settings
from seven23.models.terms.models import TermsAndConditions
@api_view(["GET"])
def api_init(request):
"""
Return status on client initialisation
"""
result = {}
# Return API Version.
result['api_version'] = settings.API_VERSION
result['allow_account_creation'] = settings.ALLOW_ACCOUNT_CREATION
result['contact'] = settings.CONTACT_EMAIL
try:
terms = TermsAndConditions.objects.latest('date')
result['terms_and_conditions_date'] = terms.date.strftime("%Y-%m-%d")
result['terms_and_conditions'] = markdown2.markdown(terms.markdown)
except TermsAndConditions.DoesNotExist:
result['terms_and_conditions_date'] = None
result['terms_and_conditions'] = None
if request.user.is_authenticated():
result['is_authenticated'] = True
result['id'] = request.user.id
else:
result['is_authenticated'] = False
# Return json format string.
j = json.dumps(result, separators=(',', ':'))
return HttpResponse(j, content_type='application/json')
| Fix bug on API with date in Terms and Conditions not serializable | Fix bug on API with date in Terms and Conditions not serializable
| Python | mit | sebastienbarbier/723e_server,sebastienbarbier/723e,sebastienbarbier/723e_server,sebastienbarbier/723e |
import json
import os
import markdown2
from django.http import HttpResponse
from django.db import models
from rest_framework.decorators import api_view
from seven23 import settings
from seven23.models.terms.models import TermsAndConditions
@api_view(["GET"])
def api_init(request):
"""
Return status on client initialisation
"""
result = {}
# Return API Version.
result['api_version'] = settings.API_VERSION
result['allow_account_creation'] = settings.ALLOW_ACCOUNT_CREATION
result['contact'] = settings.CONTACT_EMAIL
try:
terms = TermsAndConditions.objects.latest('date')
- result['terms_and_conditions_date'] = terms.date
+ result['terms_and_conditions_date'] = terms.date.strftime("%Y-%m-%d")
result['terms_and_conditions'] = markdown2.markdown(terms.markdown)
except TermsAndConditions.DoesNotExist:
result['terms_and_conditions_date'] = None
result['terms_and_conditions'] = None
if request.user.is_authenticated():
result['is_authenticated'] = True
result['id'] = request.user.id
else:
result['is_authenticated'] = False
# Return json format string.
j = json.dumps(result, separators=(',', ':'))
return HttpResponse(j, content_type='application/json')
| Fix bug on API with date in Terms and Conditions not serializable | ## Code Before:
import json
import os
import markdown2
from django.http import HttpResponse
from django.db import models
from rest_framework.decorators import api_view
from seven23 import settings
from seven23.models.terms.models import TermsAndConditions
@api_view(["GET"])
def api_init(request):
"""
Return status on client initialisation
"""
result = {}
# Return API Version.
result['api_version'] = settings.API_VERSION
result['allow_account_creation'] = settings.ALLOW_ACCOUNT_CREATION
result['contact'] = settings.CONTACT_EMAIL
try:
terms = TermsAndConditions.objects.latest('date')
result['terms_and_conditions_date'] = terms.date
result['terms_and_conditions'] = markdown2.markdown(terms.markdown)
except TermsAndConditions.DoesNotExist:
result['terms_and_conditions_date'] = None
result['terms_and_conditions'] = None
if request.user.is_authenticated():
result['is_authenticated'] = True
result['id'] = request.user.id
else:
result['is_authenticated'] = False
# Return json format string.
j = json.dumps(result, separators=(',', ':'))
return HttpResponse(j, content_type='application/json')
## Instruction:
Fix bug on API with date in Terms and Conditions not serializable
## Code After:
import json
import os
import markdown2
from django.http import HttpResponse
from django.db import models
from rest_framework.decorators import api_view
from seven23 import settings
from seven23.models.terms.models import TermsAndConditions
@api_view(["GET"])
def api_init(request):
"""
Return status on client initialisation
"""
result = {}
# Return API Version.
result['api_version'] = settings.API_VERSION
result['allow_account_creation'] = settings.ALLOW_ACCOUNT_CREATION
result['contact'] = settings.CONTACT_EMAIL
try:
terms = TermsAndConditions.objects.latest('date')
result['terms_and_conditions_date'] = terms.date.strftime("%Y-%m-%d")
result['terms_and_conditions'] = markdown2.markdown(terms.markdown)
except TermsAndConditions.DoesNotExist:
result['terms_and_conditions_date'] = None
result['terms_and_conditions'] = None
if request.user.is_authenticated():
result['is_authenticated'] = True
result['id'] = request.user.id
else:
result['is_authenticated'] = False
# Return json format string.
j = json.dumps(result, separators=(',', ':'))
return HttpResponse(j, content_type='application/json')
|
import json
import os
import markdown2
from django.http import HttpResponse
from django.db import models
from rest_framework.decorators import api_view
from seven23 import settings
from seven23.models.terms.models import TermsAndConditions
@api_view(["GET"])
def api_init(request):
"""
Return status on client initialisation
"""
result = {}
# Return API Version.
result['api_version'] = settings.API_VERSION
result['allow_account_creation'] = settings.ALLOW_ACCOUNT_CREATION
result['contact'] = settings.CONTACT_EMAIL
try:
terms = TermsAndConditions.objects.latest('date')
- result['terms_and_conditions_date'] = terms.date
+ result['terms_and_conditions_date'] = terms.date.strftime("%Y-%m-%d")
? +++++++++++++++++++++
result['terms_and_conditions'] = markdown2.markdown(terms.markdown)
except TermsAndConditions.DoesNotExist:
result['terms_and_conditions_date'] = None
result['terms_and_conditions'] = None
if request.user.is_authenticated():
result['is_authenticated'] = True
result['id'] = request.user.id
else:
result['is_authenticated'] = False
# Return json format string.
j = json.dumps(result, separators=(',', ':'))
return HttpResponse(j, content_type='application/json') |
13301dfe93bcdd44218166bdab1c7aeacd4e4a7c | winthrop/annotation/models.py | winthrop/annotation/models.py | from urllib.parse import urlparse
from django.db import models
from django.urls import resolve, Resolver404
from annotator_store.models import BaseAnnotation
from djiffy.models import Canvas
from winthrop.people.models import Person
class Annotation(BaseAnnotation):
# NOTE: do we want to associate explicitly with canvas in the db?
# could just use uri, but faster lookup if we associate...
canvas = models.ForeignKey(Canvas, null=True, blank=True)
author = models.ForeignKey(Person, null=True, blank=True)
def info(self):
info = super(Annotation, self).info()
info['extra_data'] = 'foo'
return info
def save(self, *args, **kwargs):
# NOTE: could set the canvas uri in javascript instead
# of using page uri, but for now determine canvas id
# based on the page uri
try:
match = resolve(urlparse(self.uri).path)
if match.url_name == 'page' and 'djiffy' in match.namespaces:
self.canvas = Canvas.objects.get(
short_id=match.kwargs['id'],
book__short_id=match.kwargs['book_id']
)
except Resolver404:
pass
super(Annotation, self).save()
| from urllib.parse import urlparse
from django.db import models
from django.urls import resolve, Resolver404
from annotator_store.models import BaseAnnotation
from djiffy.models import Canvas
from winthrop.people.models import Person
class Annotation(BaseAnnotation):
# NOTE: do we want to associate explicitly with canvas in the db?
# could just use uri, but faster lookup if we associate...
canvas = models.ForeignKey(Canvas, null=True, blank=True)
author = models.ForeignKey(Person, null=True, blank=True)
def info(self):
info = super(Annotation, self).info()
info['extra_data'] = 'foo'
return info
def save(self, *args, **kwargs):
# for image annotation, URI should be set to canvas URI; look up
# canvas by URI and associate with the record
self.canvas = None
try:
self.canvas = Canvas.objects.get(uri=self.uri)
except Canvas.DoesNotExist:
pass
super(Annotation, self).save()
def handle_extra_data(self, data, request):
'''Handle any "extra" data that is not part of the stock annotation
data model. Use this method to customize the logic for updating
an annotation from request data.'''
if 'author' in data:
self.author = Person.objects.get(id=data['author']['id'])
del data['author']
return data
def info(self):
# extend the default info impleentation (used to generate json)
# to include local database fields in the output
info = super(Annotation, self).info()
if self.author:
info['author'] = {
'name': self.author.authorized_name,
'id': self.author.id
}
return info
| Add author field & autocomplete to annotation model+interface | Add author field & autocomplete to annotation model+interface
| Python | apache-2.0 | Princeton-CDH/winthrop-django,Princeton-CDH/winthrop-django,Princeton-CDH/winthrop-django | from urllib.parse import urlparse
from django.db import models
from django.urls import resolve, Resolver404
from annotator_store.models import BaseAnnotation
from djiffy.models import Canvas
from winthrop.people.models import Person
class Annotation(BaseAnnotation):
# NOTE: do we want to associate explicitly with canvas in the db?
# could just use uri, but faster lookup if we associate...
canvas = models.ForeignKey(Canvas, null=True, blank=True)
author = models.ForeignKey(Person, null=True, blank=True)
def info(self):
info = super(Annotation, self).info()
info['extra_data'] = 'foo'
return info
def save(self, *args, **kwargs):
- # NOTE: could set the canvas uri in javascript instead
- # of using page uri, but for now determine canvas id
- # based on the page uri
+ # for image annotation, URI should be set to canvas URI; look up
+ # canvas by URI and associate with the record
+ self.canvas = None
try:
- match = resolve(urlparse(self.uri).path)
- if match.url_name == 'page' and 'djiffy' in match.namespaces:
- self.canvas = Canvas.objects.get(
+ self.canvas = Canvas.objects.get(uri=self.uri)
+ except Canvas.DoesNotExist:
- short_id=match.kwargs['id'],
- book__short_id=match.kwargs['book_id']
- )
- except Resolver404:
pass
super(Annotation, self).save()
+
+ def handle_extra_data(self, data, request):
+ '''Handle any "extra" data that is not part of the stock annotation
+ data model. Use this method to customize the logic for updating
+ an annotation from request data.'''
+ if 'author' in data:
+ self.author = Person.objects.get(id=data['author']['id'])
+ del data['author']
+
+ return data
+
+ def info(self):
+ # extend the default info impleentation (used to generate json)
+ # to include local database fields in the output
+ info = super(Annotation, self).info()
+ if self.author:
+ info['author'] = {
+ 'name': self.author.authorized_name,
+ 'id': self.author.id
+ }
+ return info
+ | Add author field & autocomplete to annotation model+interface | ## Code Before:
from urllib.parse import urlparse
from django.db import models
from django.urls import resolve, Resolver404
from annotator_store.models import BaseAnnotation
from djiffy.models import Canvas
from winthrop.people.models import Person
class Annotation(BaseAnnotation):
# NOTE: do we want to associate explicitly with canvas in the db?
# could just use uri, but faster lookup if we associate...
canvas = models.ForeignKey(Canvas, null=True, blank=True)
author = models.ForeignKey(Person, null=True, blank=True)
def info(self):
info = super(Annotation, self).info()
info['extra_data'] = 'foo'
return info
def save(self, *args, **kwargs):
# NOTE: could set the canvas uri in javascript instead
# of using page uri, but for now determine canvas id
# based on the page uri
try:
match = resolve(urlparse(self.uri).path)
if match.url_name == 'page' and 'djiffy' in match.namespaces:
self.canvas = Canvas.objects.get(
short_id=match.kwargs['id'],
book__short_id=match.kwargs['book_id']
)
except Resolver404:
pass
super(Annotation, self).save()
## Instruction:
Add author field & autocomplete to annotation model+interface
## Code After:
from urllib.parse import urlparse
from django.db import models
from django.urls import resolve, Resolver404
from annotator_store.models import BaseAnnotation
from djiffy.models import Canvas
from winthrop.people.models import Person
class Annotation(BaseAnnotation):
# NOTE: do we want to associate explicitly with canvas in the db?
# could just use uri, but faster lookup if we associate...
canvas = models.ForeignKey(Canvas, null=True, blank=True)
author = models.ForeignKey(Person, null=True, blank=True)
def info(self):
info = super(Annotation, self).info()
info['extra_data'] = 'foo'
return info
def save(self, *args, **kwargs):
# for image annotation, URI should be set to canvas URI; look up
# canvas by URI and associate with the record
self.canvas = None
try:
self.canvas = Canvas.objects.get(uri=self.uri)
except Canvas.DoesNotExist:
pass
super(Annotation, self).save()
def handle_extra_data(self, data, request):
'''Handle any "extra" data that is not part of the stock annotation
data model. Use this method to customize the logic for updating
an annotation from request data.'''
if 'author' in data:
self.author = Person.objects.get(id=data['author']['id'])
del data['author']
return data
def info(self):
# extend the default info impleentation (used to generate json)
# to include local database fields in the output
info = super(Annotation, self).info()
if self.author:
info['author'] = {
'name': self.author.authorized_name,
'id': self.author.id
}
return info
| from urllib.parse import urlparse
from django.db import models
from django.urls import resolve, Resolver404
from annotator_store.models import BaseAnnotation
from djiffy.models import Canvas
from winthrop.people.models import Person
class Annotation(BaseAnnotation):
# NOTE: do we want to associate explicitly with canvas in the db?
# could just use uri, but faster lookup if we associate...
canvas = models.ForeignKey(Canvas, null=True, blank=True)
author = models.ForeignKey(Person, null=True, blank=True)
def info(self):
info = super(Annotation, self).info()
info['extra_data'] = 'foo'
return info
def save(self, *args, **kwargs):
- # NOTE: could set the canvas uri in javascript instead
- # of using page uri, but for now determine canvas id
- # based on the page uri
+ # for image annotation, URI should be set to canvas URI; look up
+ # canvas by URI and associate with the record
+ self.canvas = None
try:
- match = resolve(urlparse(self.uri).path)
- if match.url_name == 'page' and 'djiffy' in match.namespaces:
- self.canvas = Canvas.objects.get(
? ----
+ self.canvas = Canvas.objects.get(uri=self.uri)
? +++++++++++++
+ except Canvas.DoesNotExist:
- short_id=match.kwargs['id'],
- book__short_id=match.kwargs['book_id']
- )
- except Resolver404:
pass
super(Annotation, self).save()
+ def handle_extra_data(self, data, request):
+ '''Handle any "extra" data that is not part of the stock annotation
+ data model. Use this method to customize the logic for updating
+ an annotation from request data.'''
+ if 'author' in data:
+ self.author = Person.objects.get(id=data['author']['id'])
+ del data['author']
+
+ return data
+
+ def info(self):
+ # extend the default info impleentation (used to generate json)
+ # to include local database fields in the output
+ info = super(Annotation, self).info()
+ if self.author:
+ info['author'] = {
+ 'name': self.author.authorized_name,
+ 'id': self.author.id
+ }
+ return info
+
+ |
2809f97696791f34e659dc9fc3c9e29c802082d2 | django_evolution/tests/test_evolution_models.py | django_evolution/tests/test_evolution_models.py | from datetime import datetime
from django.test.testcases import TestCase
from django_evolution.models import Version
class VersionManagerTests(TestCase):
"""Unit tests for django_evolution.models.VersionManager."""
def test_current_version_with_dup_timestamps(self):
"""Testing Version.current_version() with two entries with same timestamps"""
timestamp = datetime(year=2015, month=12, day=10, hour=12, minute=13,
second=14)
Version.objects.create(signature='abc123', when=timestamp)
version = Version.objects.create(signature='abc123-def456',
when=timestamp)
latest_version = Version.objects.current_version()
self.assertEqual(latest_version, version)
| from datetime import datetime
from django.test.testcases import TestCase
from django_evolution.models import Version
class VersionManagerTests(TestCase):
"""Unit tests for django_evolution.models.VersionManager."""
def test_current_version_with_dup_timestamps(self):
"""Testing Version.current_version() with two entries with same timestamps"""
# Remove anything that may already exist.
Version.objects.all().delete()
timestamp = datetime(year=2015, month=12, day=10, hour=12, minute=13,
second=14)
Version.objects.create(signature='abc123', when=timestamp)
version = Version.objects.create(signature='abc123-def456',
when=timestamp)
latest_version = Version.objects.current_version()
self.assertEqual(latest_version, version)
| Fix unit tests for Version.objects.get_current(). | Fix unit tests for Version.objects.get_current().
The unit tests assumed that no Version objects were present, but this
wasn't always the case. This clears them before the test runs.
| Python | bsd-3-clause | beanbaginc/django-evolution | from datetime import datetime
from django.test.testcases import TestCase
from django_evolution.models import Version
class VersionManagerTests(TestCase):
"""Unit tests for django_evolution.models.VersionManager."""
def test_current_version_with_dup_timestamps(self):
"""Testing Version.current_version() with two entries with same timestamps"""
+ # Remove anything that may already exist.
+ Version.objects.all().delete()
+
timestamp = datetime(year=2015, month=12, day=10, hour=12, minute=13,
second=14)
Version.objects.create(signature='abc123', when=timestamp)
version = Version.objects.create(signature='abc123-def456',
when=timestamp)
latest_version = Version.objects.current_version()
self.assertEqual(latest_version, version)
| Fix unit tests for Version.objects.get_current(). | ## Code Before:
from datetime import datetime
from django.test.testcases import TestCase
from django_evolution.models import Version
class VersionManagerTests(TestCase):
"""Unit tests for django_evolution.models.VersionManager."""
def test_current_version_with_dup_timestamps(self):
"""Testing Version.current_version() with two entries with same timestamps"""
timestamp = datetime(year=2015, month=12, day=10, hour=12, minute=13,
second=14)
Version.objects.create(signature='abc123', when=timestamp)
version = Version.objects.create(signature='abc123-def456',
when=timestamp)
latest_version = Version.objects.current_version()
self.assertEqual(latest_version, version)
## Instruction:
Fix unit tests for Version.objects.get_current().
## Code After:
from datetime import datetime
from django.test.testcases import TestCase
from django_evolution.models import Version
class VersionManagerTests(TestCase):
"""Unit tests for django_evolution.models.VersionManager."""
def test_current_version_with_dup_timestamps(self):
"""Testing Version.current_version() with two entries with same timestamps"""
# Remove anything that may already exist.
Version.objects.all().delete()
timestamp = datetime(year=2015, month=12, day=10, hour=12, minute=13,
second=14)
Version.objects.create(signature='abc123', when=timestamp)
version = Version.objects.create(signature='abc123-def456',
when=timestamp)
latest_version = Version.objects.current_version()
self.assertEqual(latest_version, version)
| from datetime import datetime
from django.test.testcases import TestCase
from django_evolution.models import Version
class VersionManagerTests(TestCase):
"""Unit tests for django_evolution.models.VersionManager."""
def test_current_version_with_dup_timestamps(self):
"""Testing Version.current_version() with two entries with same timestamps"""
+ # Remove anything that may already exist.
+ Version.objects.all().delete()
+
timestamp = datetime(year=2015, month=12, day=10, hour=12, minute=13,
second=14)
Version.objects.create(signature='abc123', when=timestamp)
version = Version.objects.create(signature='abc123-def456',
when=timestamp)
latest_version = Version.objects.current_version()
self.assertEqual(latest_version, version) |
3874ca578c52879d9861213e321f6ece9e67f10b | sopel/modules/ping.py | sopel/modules/ping.py | from __future__ import unicode_literals
import random
from sopel.module import rule, priority, thread
@rule(r'(?i)(hi|hello|hey),? $nickname[ \t]*$')
def hello(bot, trigger):
if trigger.owner:
greeting = random.choice(('Fuck off,', 'Screw you,', 'Go away'))
else:
greeting = random.choice(('Hi', 'Hey', 'Hello'))
punctuation = random.choice(('', '!'))
bot.say(greeting + ' ' + trigger.nick + punctuation)
@rule(r'(?i)(Fuck|Screw) you,? $nickname[ \t]*$')
def rude(bot, trigger):
bot.say('Watch your mouth, ' + trigger.nick + ', or I\'ll tell your mother!')
@rule('$nickname!')
@priority('high')
@thread(False)
def interjection(bot, trigger):
bot.say(trigger.nick + '!')
| from __future__ import unicode_literals
import random
from sopel.module import rule, priority, thread
@rule(r'(?i)(hi|hello|hey),? $nickname[ \t]*$')
def hello(bot, trigger):
greeting = random.choice(('Hi', 'Hey', 'Hello'))
punctuation = random.choice(('', '!'))
bot.say(greeting + ' ' + trigger.nick + punctuation)
@rule(r'(?i)(Fuck|Screw) you,? $nickname[ \t]*$')
def rude(bot, trigger):
bot.say('Watch your mouth, ' + trigger.nick + ', or I\'ll tell your mother!')
@rule('$nickname!')
@priority('high')
@thread(False)
def interjection(bot, trigger):
bot.say(trigger.nick + '!')
| Stop Sopel from relying rudely to the bot's owner. | Stop Sopel from relying rudely to the bot's owner.
| Python | mit | Uname-a/knife_scraper,Uname-a/knife_scraper,Uname-a/knife_scraper | from __future__ import unicode_literals
import random
from sopel.module import rule, priority, thread
@rule(r'(?i)(hi|hello|hey),? $nickname[ \t]*$')
def hello(bot, trigger):
- if trigger.owner:
- greeting = random.choice(('Fuck off,', 'Screw you,', 'Go away'))
- else:
- greeting = random.choice(('Hi', 'Hey', 'Hello'))
+ greeting = random.choice(('Hi', 'Hey', 'Hello'))
punctuation = random.choice(('', '!'))
bot.say(greeting + ' ' + trigger.nick + punctuation)
@rule(r'(?i)(Fuck|Screw) you,? $nickname[ \t]*$')
def rude(bot, trigger):
bot.say('Watch your mouth, ' + trigger.nick + ', or I\'ll tell your mother!')
@rule('$nickname!')
@priority('high')
@thread(False)
def interjection(bot, trigger):
bot.say(trigger.nick + '!')
| Stop Sopel from relying rudely to the bot's owner. | ## Code Before:
from __future__ import unicode_literals
import random
from sopel.module import rule, priority, thread
@rule(r'(?i)(hi|hello|hey),? $nickname[ \t]*$')
def hello(bot, trigger):
if trigger.owner:
greeting = random.choice(('Fuck off,', 'Screw you,', 'Go away'))
else:
greeting = random.choice(('Hi', 'Hey', 'Hello'))
punctuation = random.choice(('', '!'))
bot.say(greeting + ' ' + trigger.nick + punctuation)
@rule(r'(?i)(Fuck|Screw) you,? $nickname[ \t]*$')
def rude(bot, trigger):
bot.say('Watch your mouth, ' + trigger.nick + ', or I\'ll tell your mother!')
@rule('$nickname!')
@priority('high')
@thread(False)
def interjection(bot, trigger):
bot.say(trigger.nick + '!')
## Instruction:
Stop Sopel from relying rudely to the bot's owner.
## Code After:
from __future__ import unicode_literals
import random
from sopel.module import rule, priority, thread
@rule(r'(?i)(hi|hello|hey),? $nickname[ \t]*$')
def hello(bot, trigger):
greeting = random.choice(('Hi', 'Hey', 'Hello'))
punctuation = random.choice(('', '!'))
bot.say(greeting + ' ' + trigger.nick + punctuation)
@rule(r'(?i)(Fuck|Screw) you,? $nickname[ \t]*$')
def rude(bot, trigger):
bot.say('Watch your mouth, ' + trigger.nick + ', or I\'ll tell your mother!')
@rule('$nickname!')
@priority('high')
@thread(False)
def interjection(bot, trigger):
bot.say(trigger.nick + '!')
| from __future__ import unicode_literals
import random
from sopel.module import rule, priority, thread
@rule(r'(?i)(hi|hello|hey),? $nickname[ \t]*$')
def hello(bot, trigger):
- if trigger.owner:
- greeting = random.choice(('Fuck off,', 'Screw you,', 'Go away'))
- else:
- greeting = random.choice(('Hi', 'Hey', 'Hello'))
? ----
+ greeting = random.choice(('Hi', 'Hey', 'Hello'))
punctuation = random.choice(('', '!'))
bot.say(greeting + ' ' + trigger.nick + punctuation)
@rule(r'(?i)(Fuck|Screw) you,? $nickname[ \t]*$')
def rude(bot, trigger):
bot.say('Watch your mouth, ' + trigger.nick + ', or I\'ll tell your mother!')
@rule('$nickname!')
@priority('high')
@thread(False)
def interjection(bot, trigger):
bot.say(trigger.nick + '!') |
de4f43613b5f3a8b6f49ace6b8e9585a242d7cb2 | src/build.py | src/build.py |
import sys
import csnGUIHandler
import csnGUIOptions
import csnGenerator
# Check command line arguments
if len(sys.argv) != 3:
sys.exit("Error: not enough arguments. You need to provide an option and a configuration file.")
# Command line inputs
options_file = sys.argv[1]
config_file = sys.argv[2]
# Create GUI handler
handler = csnGUIHandler.Handler()
# Read options
options = csnGUIOptions.Options()
options.Load( options_file )
# Read settings
settings = csnGenerator.Settings()
settings.Load( config_file )
# Set the options
handler.SetOptions( options )
# Configure the project with the settings
if settings.instance == "thirdParty":
res = handler.ConfigureThirdPartyFolder(settings)
else:
res = handler.ConfigureProjectToBinFolder( settings, 1 )
sys.exit(res)
|
import sys
import csnGUIHandler
import csnGUIOptions
import csnGenerator
# Check command line arguments
if len(sys.argv) != 3:
sys.exit("Error: not enough arguments. You need to provide an option and a configuration file.")
# Command line inputs
options_file = sys.argv[1]
config_file = sys.argv[2]
# Create GUI handler
handler = csnGUIHandler.Handler()
# Read options
options = csnGUIOptions.Options()
options.Load( options_file )
# Read settings
settings = csnGenerator.Settings()
settings.Load( config_file )
# Set the options
handler.SetOptions( options )
# Configure the project with the settings
if settings.instance == "thirdParty":
res = handler.ConfigureThirdPartyFolder(settings)
else:
res = handler.ConfigureProjectToBinFolder( settings, 1 )
# exit with error if there was a problem
if res == false:
sys.exit(1)
| Exit with the proper value. | Exit with the proper value.
git-svn-id: a26c1b3dc012bc7b166f1b96505d8277332098eb@265 9ffc3505-93cb-cd4b-9e5d-8a77f6415fcf
| Python | bsd-3-clause | csnake-org/CSnake,csnake-org/CSnake,msteghofer/CSnake,msteghofer/CSnake,csnake-org/CSnake,msteghofer/CSnake |
import sys
import csnGUIHandler
import csnGUIOptions
import csnGenerator
# Check command line arguments
if len(sys.argv) != 3:
sys.exit("Error: not enough arguments. You need to provide an option and a configuration file.")
# Command line inputs
options_file = sys.argv[1]
config_file = sys.argv[2]
# Create GUI handler
handler = csnGUIHandler.Handler()
# Read options
options = csnGUIOptions.Options()
options.Load( options_file )
# Read settings
settings = csnGenerator.Settings()
settings.Load( config_file )
# Set the options
handler.SetOptions( options )
# Configure the project with the settings
if settings.instance == "thirdParty":
res = handler.ConfigureThirdPartyFolder(settings)
else:
res = handler.ConfigureProjectToBinFolder( settings, 1 )
+ # exit with error if there was a problem
+ if res == false:
- sys.exit(res)
+ sys.exit(1)
| Exit with the proper value. | ## Code Before:
import sys
import csnGUIHandler
import csnGUIOptions
import csnGenerator
# Check command line arguments
if len(sys.argv) != 3:
sys.exit("Error: not enough arguments. You need to provide an option and a configuration file.")
# Command line inputs
options_file = sys.argv[1]
config_file = sys.argv[2]
# Create GUI handler
handler = csnGUIHandler.Handler()
# Read options
options = csnGUIOptions.Options()
options.Load( options_file )
# Read settings
settings = csnGenerator.Settings()
settings.Load( config_file )
# Set the options
handler.SetOptions( options )
# Configure the project with the settings
if settings.instance == "thirdParty":
res = handler.ConfigureThirdPartyFolder(settings)
else:
res = handler.ConfigureProjectToBinFolder( settings, 1 )
sys.exit(res)
## Instruction:
Exit with the proper value.
## Code After:
import sys
import csnGUIHandler
import csnGUIOptions
import csnGenerator
# Check command line arguments
if len(sys.argv) != 3:
sys.exit("Error: not enough arguments. You need to provide an option and a configuration file.")
# Command line inputs
options_file = sys.argv[1]
config_file = sys.argv[2]
# Create GUI handler
handler = csnGUIHandler.Handler()
# Read options
options = csnGUIOptions.Options()
options.Load( options_file )
# Read settings
settings = csnGenerator.Settings()
settings.Load( config_file )
# Set the options
handler.SetOptions( options )
# Configure the project with the settings
if settings.instance == "thirdParty":
res = handler.ConfigureThirdPartyFolder(settings)
else:
res = handler.ConfigureProjectToBinFolder( settings, 1 )
# exit with error if there was a problem
if res == false:
sys.exit(1)
|
import sys
import csnGUIHandler
import csnGUIOptions
import csnGenerator
# Check command line arguments
if len(sys.argv) != 3:
sys.exit("Error: not enough arguments. You need to provide an option and a configuration file.")
# Command line inputs
options_file = sys.argv[1]
config_file = sys.argv[2]
# Create GUI handler
handler = csnGUIHandler.Handler()
# Read options
options = csnGUIOptions.Options()
options.Load( options_file )
# Read settings
settings = csnGenerator.Settings()
settings.Load( config_file )
# Set the options
handler.SetOptions( options )
# Configure the project with the settings
if settings.instance == "thirdParty":
res = handler.ConfigureThirdPartyFolder(settings)
else:
res = handler.ConfigureProjectToBinFolder( settings, 1 )
+ # exit with error if there was a problem
+ if res == false:
- sys.exit(res)
? ^^^
+ sys.exit(1)
? ++ ^
|
a31103d5001c7c6ebebddd25f9d1bb4ed0e0c2e9 | polling_stations/apps/data_importers/management/commands/import_gosport.py | polling_stations/apps/data_importers/management/commands/import_gosport.py | from data_importers.management.commands import BaseDemocracyCountsCsvImporter
class Command(BaseDemocracyCountsCsvImporter):
council_id = "GOS"
addresses_name = "2022-05-05/2022-03-07T15:47:28.644792/2022 Borough of Gosport - Democracy Club - Polling Districts v1 (07 03 2022).csv"
stations_name = "2022-05-05/2022-03-07T15:47:28.644792/2022 Borough of Gosport - Democracy Club - Polling Stations v1 (07 03 2022).csv"
elections = ["2022-05-05"]
def address_record_to_dict(self, record):
if record.addressline6 in ["PO12 2EH"]:
return None
return super().address_record_to_dict(record)
| from data_importers.management.commands import BaseDemocracyCountsCsvImporter
class Command(BaseDemocracyCountsCsvImporter):
council_id = "GOS"
addresses_name = "2022-05-05/2022-03-07T15:47:28.644792/2022 Borough of Gosport - Democracy Club - Polling Districts v1 (07 03 2022).csv"
stations_name = "2022-05-05/2022-03-07T15:47:28.644792/2022 Borough of Gosport - Democracy Club - Polling Stations v1 (07 03 2022).csv"
elections = ["2022-05-05"]
def address_record_to_dict(self, record):
if record.postcode in ["PO12 2EH"]:
return None
return super().address_record_to_dict(record)
| Fix Gosport import script error | Fix Gosport import script error
| Python | bsd-3-clause | DemocracyClub/UK-Polling-Stations,DemocracyClub/UK-Polling-Stations,DemocracyClub/UK-Polling-Stations | from data_importers.management.commands import BaseDemocracyCountsCsvImporter
class Command(BaseDemocracyCountsCsvImporter):
council_id = "GOS"
addresses_name = "2022-05-05/2022-03-07T15:47:28.644792/2022 Borough of Gosport - Democracy Club - Polling Districts v1 (07 03 2022).csv"
stations_name = "2022-05-05/2022-03-07T15:47:28.644792/2022 Borough of Gosport - Democracy Club - Polling Stations v1 (07 03 2022).csv"
elections = ["2022-05-05"]
def address_record_to_dict(self, record):
- if record.addressline6 in ["PO12 2EH"]:
+ if record.postcode in ["PO12 2EH"]:
return None
return super().address_record_to_dict(record)
| Fix Gosport import script error | ## Code Before:
from data_importers.management.commands import BaseDemocracyCountsCsvImporter
class Command(BaseDemocracyCountsCsvImporter):
council_id = "GOS"
addresses_name = "2022-05-05/2022-03-07T15:47:28.644792/2022 Borough of Gosport - Democracy Club - Polling Districts v1 (07 03 2022).csv"
stations_name = "2022-05-05/2022-03-07T15:47:28.644792/2022 Borough of Gosport - Democracy Club - Polling Stations v1 (07 03 2022).csv"
elections = ["2022-05-05"]
def address_record_to_dict(self, record):
if record.addressline6 in ["PO12 2EH"]:
return None
return super().address_record_to_dict(record)
## Instruction:
Fix Gosport import script error
## Code After:
from data_importers.management.commands import BaseDemocracyCountsCsvImporter
class Command(BaseDemocracyCountsCsvImporter):
council_id = "GOS"
addresses_name = "2022-05-05/2022-03-07T15:47:28.644792/2022 Borough of Gosport - Democracy Club - Polling Districts v1 (07 03 2022).csv"
stations_name = "2022-05-05/2022-03-07T15:47:28.644792/2022 Borough of Gosport - Democracy Club - Polling Stations v1 (07 03 2022).csv"
elections = ["2022-05-05"]
def address_record_to_dict(self, record):
if record.postcode in ["PO12 2EH"]:
return None
return super().address_record_to_dict(record)
| from data_importers.management.commands import BaseDemocracyCountsCsvImporter
class Command(BaseDemocracyCountsCsvImporter):
council_id = "GOS"
addresses_name = "2022-05-05/2022-03-07T15:47:28.644792/2022 Borough of Gosport - Democracy Club - Polling Districts v1 (07 03 2022).csv"
stations_name = "2022-05-05/2022-03-07T15:47:28.644792/2022 Borough of Gosport - Democracy Club - Polling Stations v1 (07 03 2022).csv"
elections = ["2022-05-05"]
def address_record_to_dict(self, record):
- if record.addressline6 in ["PO12 2EH"]:
? ^ -- -------
+ if record.postcode in ["PO12 2EH"]:
? ^^^^^^
return None
return super().address_record_to_dict(record) |
f1266219af530d1cc65019e7b7d40367c3daa024 | observatory/emaillist/methods.py | observatory/emaillist/methods.py | from django.core.mail import EmailMessage
from emaillist.models import EmailExclusion
def send_mail(subject, body, from_email, recipient_list, fail_silently=False):
to = [addr for addr in recipient_list if not EmailExclusion.excluded(addr)]
for addr in to:
#For now use default email body with an unsubscribe link
html_content = '%s <br><a href="http://rcos.rpi.edu/email/remove/%s"> Unsubscribe From RCOS Emails</a>' % (body, addr)
msg = EmailMessage(subject, html_content, from_email, [addr])
msg.content_subtype = "html" # Main content is now text/html
msg.send(fail_silently = fail_silently)
| from django.core.mail import EmailMessage
from emaillist.models import EmailExclusion
from django.core.urlresolvers import reverse
def send_mail(subject, body, from_email, recipient_list, fail_silently=False):
to = [addr for addr in recipient_list if not EmailExclusion.excluded(addr)]
#Doing a separate email for each person so we can allow unsubscription links
for addr in to:
#For now use default email body with an unsubscribe link
html_content = '%s <br><a href="%s"> Unsubscribe From RCOS Emails</a>' % (body, reverse('emaillist.views.remove', args=[addr]), addr)
msg = EmailMessage(subject, html_content, from_email, [addr])
msg.content_subtype = "html" # Main content is now text/html
msg.send(fail_silently = fail_silently)
| Update format to produce a valid link | Update format to produce a valid link
| Python | isc | rcos/Observatory,rcos/Observatory,rcos/Observatory,rcos/Observatory,rcos/Observatory,rcos/Observatory | from django.core.mail import EmailMessage
from emaillist.models import EmailExclusion
+ from django.core.urlresolvers import reverse
def send_mail(subject, body, from_email, recipient_list, fail_silently=False):
to = [addr for addr in recipient_list if not EmailExclusion.excluded(addr)]
+ #Doing a separate email for each person so we can allow unsubscription links
for addr in to:
#For now use default email body with an unsubscribe link
- html_content = '%s <br><a href="http://rcos.rpi.edu/email/remove/%s"> Unsubscribe From RCOS Emails</a>' % (body, addr)
+ html_content = '%s <br><a href="%s"> Unsubscribe From RCOS Emails</a>' % (body, reverse('emaillist.views.remove', args=[addr]), addr)
msg = EmailMessage(subject, html_content, from_email, [addr])
msg.content_subtype = "html" # Main content is now text/html
msg.send(fail_silently = fail_silently)
| Update format to produce a valid link | ## Code Before:
from django.core.mail import EmailMessage
from emaillist.models import EmailExclusion
def send_mail(subject, body, from_email, recipient_list, fail_silently=False):
to = [addr for addr in recipient_list if not EmailExclusion.excluded(addr)]
for addr in to:
#For now use default email body with an unsubscribe link
html_content = '%s <br><a href="http://rcos.rpi.edu/email/remove/%s"> Unsubscribe From RCOS Emails</a>' % (body, addr)
msg = EmailMessage(subject, html_content, from_email, [addr])
msg.content_subtype = "html" # Main content is now text/html
msg.send(fail_silently = fail_silently)
## Instruction:
Update format to produce a valid link
## Code After:
from django.core.mail import EmailMessage
from emaillist.models import EmailExclusion
from django.core.urlresolvers import reverse
def send_mail(subject, body, from_email, recipient_list, fail_silently=False):
to = [addr for addr in recipient_list if not EmailExclusion.excluded(addr)]
#Doing a separate email for each person so we can allow unsubscription links
for addr in to:
#For now use default email body with an unsubscribe link
html_content = '%s <br><a href="%s"> Unsubscribe From RCOS Emails</a>' % (body, reverse('emaillist.views.remove', args=[addr]), addr)
msg = EmailMessage(subject, html_content, from_email, [addr])
msg.content_subtype = "html" # Main content is now text/html
msg.send(fail_silently = fail_silently)
| from django.core.mail import EmailMessage
from emaillist.models import EmailExclusion
+ from django.core.urlresolvers import reverse
def send_mail(subject, body, from_email, recipient_list, fail_silently=False):
to = [addr for addr in recipient_list if not EmailExclusion.excluded(addr)]
+ #Doing a separate email for each person so we can allow unsubscription links
for addr in to:
#For now use default email body with an unsubscribe link
- html_content = '%s <br><a href="http://rcos.rpi.edu/email/remove/%s"> Unsubscribe From RCOS Emails</a>' % (body, addr)
+ html_content = '%s <br><a href="%s"> Unsubscribe From RCOS Emails</a>' % (body, reverse('emaillist.views.remove', args=[addr]), addr)
msg = EmailMessage(subject, html_content, from_email, [addr])
msg.content_subtype = "html" # Main content is now text/html
msg.send(fail_silently = fail_silently) |
da097ed41010961cc0814d55d8784787f3ea8a63 | skimage/util/arraypad.py | skimage/util/arraypad.py | from __future__ import division, absolute_import, print_function
from numpy import pad as numpy_pad
def pad(array, pad_width, mode, **kwargs):
return numpy_pad(array, pad_width, mode, **kwargs)
# Pull function info / docs from NumPy
pad.__doc__ = numpy_pad.__doc__
| from __future__ import division, absolute_import, print_function
import numpy as np
def pad(array, pad_width, mode, **kwargs):
return np.pad(array, pad_width, mode, **kwargs)
# Pull function info / docs from NumPy
pad.__doc__ = np.pad.__doc__
| Change import structure for doctests | Change import structure for doctests
| Python | bsd-3-clause | rjeli/scikit-image,paalge/scikit-image,rjeli/scikit-image,vighneshbirodkar/scikit-image,vighneshbirodkar/scikit-image,vighneshbirodkar/scikit-image,paalge/scikit-image,rjeli/scikit-image,paalge/scikit-image | from __future__ import division, absolute_import, print_function
- from numpy import pad as numpy_pad
+ import numpy as np
def pad(array, pad_width, mode, **kwargs):
- return numpy_pad(array, pad_width, mode, **kwargs)
+ return np.pad(array, pad_width, mode, **kwargs)
# Pull function info / docs from NumPy
- pad.__doc__ = numpy_pad.__doc__
+ pad.__doc__ = np.pad.__doc__
| Change import structure for doctests | ## Code Before:
from __future__ import division, absolute_import, print_function
from numpy import pad as numpy_pad
def pad(array, pad_width, mode, **kwargs):
return numpy_pad(array, pad_width, mode, **kwargs)
# Pull function info / docs from NumPy
pad.__doc__ = numpy_pad.__doc__
## Instruction:
Change import structure for doctests
## Code After:
from __future__ import division, absolute_import, print_function
import numpy as np
def pad(array, pad_width, mode, **kwargs):
return np.pad(array, pad_width, mode, **kwargs)
# Pull function info / docs from NumPy
pad.__doc__ = np.pad.__doc__
| from __future__ import division, absolute_import, print_function
- from numpy import pad as numpy_pad
+ import numpy as np
def pad(array, pad_width, mode, **kwargs):
- return numpy_pad(array, pad_width, mode, **kwargs)
? -- ^^
+ return np.pad(array, pad_width, mode, **kwargs)
? ^
# Pull function info / docs from NumPy
- pad.__doc__ = numpy_pad.__doc__
? -- ^^
+ pad.__doc__ = np.pad.__doc__
? ^
|
603f2204327c5cac8dbae0a567676465e1ab0f70 | data/settings.py | data/settings.py | import os
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(PROJECT_ROOT, 'operations.db'),
}
}
INSTALLED_APPS = (
'data',
)
SECRET_KEY = '63cFWu$$lhT3bVP9U1k1Iv@Jo02SuM'
LOG_FILE = os.path.join(PROJECT_ROOT, 'sorter.logs')
SORTER_IGNORE_FILENAME = '.signore' # Should start with a dot
SORTER_FOLDER_IDENTITY_FILENAME = '.sorter' # Should start with a dot
| import os
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(PROJECT_ROOT, 'operations.db'),
}
}
INSTALLED_APPS = (
'data',
)
SECRET_KEY = '63cFWu$$lhT3bVP9U1k1Iv@Jo02SuM'
LOG_FILE = os.path.join(PROJECT_ROOT, 'sorter.logs')
SORTER_IGNORE_FILENAME = '.signore' # Should start with a dot
SORTER_FOLDER_IDENTITY_FILENAME = '.sorter' # Should start with a dot
MIDDLEWARE_CLASSES = []
| Set MIDDLEWARE_CLASSES to empty list | Set MIDDLEWARE_CLASSES to empty list
| Python | bsd-3-clause | giantas/sorter,giantas/sorter | import os
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(PROJECT_ROOT, 'operations.db'),
}
}
INSTALLED_APPS = (
'data',
)
SECRET_KEY = '63cFWu$$lhT3bVP9U1k1Iv@Jo02SuM'
LOG_FILE = os.path.join(PROJECT_ROOT, 'sorter.logs')
SORTER_IGNORE_FILENAME = '.signore' # Should start with a dot
SORTER_FOLDER_IDENTITY_FILENAME = '.sorter' # Should start with a dot
+ MIDDLEWARE_CLASSES = []
+ | Set MIDDLEWARE_CLASSES to empty list | ## Code Before:
import os
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(PROJECT_ROOT, 'operations.db'),
}
}
INSTALLED_APPS = (
'data',
)
SECRET_KEY = '63cFWu$$lhT3bVP9U1k1Iv@Jo02SuM'
LOG_FILE = os.path.join(PROJECT_ROOT, 'sorter.logs')
SORTER_IGNORE_FILENAME = '.signore' # Should start with a dot
SORTER_FOLDER_IDENTITY_FILENAME = '.sorter' # Should start with a dot
## Instruction:
Set MIDDLEWARE_CLASSES to empty list
## Code After:
import os
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(PROJECT_ROOT, 'operations.db'),
}
}
INSTALLED_APPS = (
'data',
)
SECRET_KEY = '63cFWu$$lhT3bVP9U1k1Iv@Jo02SuM'
LOG_FILE = os.path.join(PROJECT_ROOT, 'sorter.logs')
SORTER_IGNORE_FILENAME = '.signore' # Should start with a dot
SORTER_FOLDER_IDENTITY_FILENAME = '.sorter' # Should start with a dot
MIDDLEWARE_CLASSES = []
| import os
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(PROJECT_ROOT, 'operations.db'),
}
}
INSTALLED_APPS = (
'data',
)
SECRET_KEY = '63cFWu$$lhT3bVP9U1k1Iv@Jo02SuM'
LOG_FILE = os.path.join(PROJECT_ROOT, 'sorter.logs')
SORTER_IGNORE_FILENAME = '.signore' # Should start with a dot
SORTER_FOLDER_IDENTITY_FILENAME = '.sorter' # Should start with a dot
+
+ MIDDLEWARE_CLASSES = [] |
3e1408affa823af2ed95decf52b002614d060a26 | pombola/core/tests/test_templatetags.py | pombola/core/tests/test_templatetags.py |
from django.test import TestCase
from ..templatetags.breadcrumbs import breadcrumbs
class BreadcrumbTest(TestCase):
def test_breadcrumbs(self):
"""Check that the breadcrumbs are generated as expected"""
home_li = '<li><a href="/" title="Breadcrumb link to the homepage.">Home</a> <span class="sep">»</span> </li>'
tests = (
# input, expected output
( '/', '<li>Home</li>'),
( '/foo', home_li + '<li>Foo</li>'),
( '/foo/bar', home_li + '<li><a href="foo/" title="Breadcrumb link to Foo">Foo</a> <span class="sep">»</span> </li><li>Bar</li>'),
# Test that coordinates are passed through correctly
# (don't drop '-', put space after ',')
# See issue #762
( '/-1.23,4.56', home_li + '<li>-1.23, 4.56</li>'),
)
for url, expected in tests:
actual = breadcrumbs(url)
self.assertEqual(actual, expected)
|
from django.test import TestCase
from ..templatetags.breadcrumbs import breadcrumbs
from ..templatetags.active_class import active_class
class BreadcrumbTest(TestCase):
def test_breadcrumbs(self):
"""Check that the breadcrumbs are generated as expected"""
home_li = '<li><a href="/" title="Breadcrumb link to the homepage.">Home</a> <span class="sep">»</span> </li>'
tests = (
# input, expected output
( '/', '<li>Home</li>'),
( '/foo', home_li + '<li>Foo</li>'),
( '/foo/bar', home_li + '<li><a href="foo/" title="Breadcrumb link to Foo">Foo</a> <span class="sep">»</span> </li><li>Bar</li>'),
# Test that coordinates are passed through correctly
# (don't drop '-', put space after ',')
# See issue #762
( '/-1.23,4.56', home_li + '<li>-1.23, 4.56</li>'),
)
for url, expected in tests:
actual = breadcrumbs(url)
self.assertEqual(actual, expected)
class ActiveClassTest(TestCase):
def test_active(self):
"""Check that active is returned when the url matches the input"""
tests = (
('/', 'home', {}),
('/place/foo/', 'place', {'slug': 'foo'}),
)
for current_url, route_name, kwargs in tests:
actual = active_class(current_url, route_name, **kwargs)
self.assertEqual(' active ', actual)
self.assertEqual(active_class('/foo', 'home'), '')
| Add tests for active_class templatetag | Add tests for active_class templatetag
| Python | agpl-3.0 | hzj123/56th,geoffkilpin/pombola,hzj123/56th,geoffkilpin/pombola,mysociety/pombola,hzj123/56th,mysociety/pombola,hzj123/56th,geoffkilpin/pombola,hzj123/56th,patricmutwiri/pombola,patricmutwiri/pombola,mysociety/pombola,geoffkilpin/pombola,patricmutwiri/pombola,ken-muturi/pombola,ken-muturi/pombola,mysociety/pombola,ken-muturi/pombola,ken-muturi/pombola,patricmutwiri/pombola,patricmutwiri/pombola,ken-muturi/pombola,patricmutwiri/pombola,geoffkilpin/pombola,hzj123/56th,geoffkilpin/pombola,ken-muturi/pombola,mysociety/pombola,mysociety/pombola |
from django.test import TestCase
from ..templatetags.breadcrumbs import breadcrumbs
+ from ..templatetags.active_class import active_class
+
class BreadcrumbTest(TestCase):
def test_breadcrumbs(self):
"""Check that the breadcrumbs are generated as expected"""
home_li = '<li><a href="/" title="Breadcrumb link to the homepage.">Home</a> <span class="sep">»</span> </li>'
tests = (
# input, expected output
( '/', '<li>Home</li>'),
( '/foo', home_li + '<li>Foo</li>'),
( '/foo/bar', home_li + '<li><a href="foo/" title="Breadcrumb link to Foo">Foo</a> <span class="sep">»</span> </li><li>Bar</li>'),
# Test that coordinates are passed through correctly
# (don't drop '-', put space after ',')
# See issue #762
( '/-1.23,4.56', home_li + '<li>-1.23, 4.56</li>'),
)
for url, expected in tests:
actual = breadcrumbs(url)
self.assertEqual(actual, expected)
+ class ActiveClassTest(TestCase):
+
+ def test_active(self):
+ """Check that active is returned when the url matches the input"""
+
+ tests = (
+ ('/', 'home', {}),
+ ('/place/foo/', 'place', {'slug': 'foo'}),
+ )
+
+ for current_url, route_name, kwargs in tests:
+ actual = active_class(current_url, route_name, **kwargs)
+ self.assertEqual(' active ', actual)
+
+ self.assertEqual(active_class('/foo', 'home'), '')
+ | Add tests for active_class templatetag | ## Code Before:
from django.test import TestCase
from ..templatetags.breadcrumbs import breadcrumbs
class BreadcrumbTest(TestCase):
def test_breadcrumbs(self):
"""Check that the breadcrumbs are generated as expected"""
home_li = '<li><a href="/" title="Breadcrumb link to the homepage.">Home</a> <span class="sep">»</span> </li>'
tests = (
# input, expected output
( '/', '<li>Home</li>'),
( '/foo', home_li + '<li>Foo</li>'),
( '/foo/bar', home_li + '<li><a href="foo/" title="Breadcrumb link to Foo">Foo</a> <span class="sep">»</span> </li><li>Bar</li>'),
# Test that coordinates are passed through correctly
# (don't drop '-', put space after ',')
# See issue #762
( '/-1.23,4.56', home_li + '<li>-1.23, 4.56</li>'),
)
for url, expected in tests:
actual = breadcrumbs(url)
self.assertEqual(actual, expected)
## Instruction:
Add tests for active_class templatetag
## Code After:
from django.test import TestCase
from ..templatetags.breadcrumbs import breadcrumbs
from ..templatetags.active_class import active_class
class BreadcrumbTest(TestCase):
def test_breadcrumbs(self):
"""Check that the breadcrumbs are generated as expected"""
home_li = '<li><a href="/" title="Breadcrumb link to the homepage.">Home</a> <span class="sep">»</span> </li>'
tests = (
# input, expected output
( '/', '<li>Home</li>'),
( '/foo', home_li + '<li>Foo</li>'),
( '/foo/bar', home_li + '<li><a href="foo/" title="Breadcrumb link to Foo">Foo</a> <span class="sep">»</span> </li><li>Bar</li>'),
# Test that coordinates are passed through correctly
# (don't drop '-', put space after ',')
# See issue #762
( '/-1.23,4.56', home_li + '<li>-1.23, 4.56</li>'),
)
for url, expected in tests:
actual = breadcrumbs(url)
self.assertEqual(actual, expected)
class ActiveClassTest(TestCase):
def test_active(self):
"""Check that active is returned when the url matches the input"""
tests = (
('/', 'home', {}),
('/place/foo/', 'place', {'slug': 'foo'}),
)
for current_url, route_name, kwargs in tests:
actual = active_class(current_url, route_name, **kwargs)
self.assertEqual(' active ', actual)
self.assertEqual(active_class('/foo', 'home'), '')
|
from django.test import TestCase
from ..templatetags.breadcrumbs import breadcrumbs
+ from ..templatetags.active_class import active_class
+
class BreadcrumbTest(TestCase):
def test_breadcrumbs(self):
"""Check that the breadcrumbs are generated as expected"""
home_li = '<li><a href="/" title="Breadcrumb link to the homepage.">Home</a> <span class="sep">»</span> </li>'
tests = (
# input, expected output
( '/', '<li>Home</li>'),
( '/foo', home_li + '<li>Foo</li>'),
( '/foo/bar', home_li + '<li><a href="foo/" title="Breadcrumb link to Foo">Foo</a> <span class="sep">»</span> </li><li>Bar</li>'),
# Test that coordinates are passed through correctly
# (don't drop '-', put space after ',')
# See issue #762
( '/-1.23,4.56', home_li + '<li>-1.23, 4.56</li>'),
)
for url, expected in tests:
actual = breadcrumbs(url)
self.assertEqual(actual, expected)
+
+ class ActiveClassTest(TestCase):
+
+ def test_active(self):
+ """Check that active is returned when the url matches the input"""
+
+ tests = (
+ ('/', 'home', {}),
+ ('/place/foo/', 'place', {'slug': 'foo'}),
+ )
+
+ for current_url, route_name, kwargs in tests:
+ actual = active_class(current_url, route_name, **kwargs)
+ self.assertEqual(' active ', actual)
+
+ self.assertEqual(active_class('/foo', 'home'), '') |
347681637c7c9d28ba1c787bb77da1296a02d13f | ckanext/archiver/default_settings.py | ckanext/archiver/default_settings.py | CKAN_CONFIG = '/home/okfn/pyenv/src/ckan/ckan.ini'
# directory to save downloaded files to
ARCHIVE_DIR = '/tmp/archive'
# Use this user name when requesting data from ckan
ARCHIVE_USER = u'okfn_maintenance'
# Max content-length of archived files, larger files will be ignored
MAX_CONTENT_LENGTH = 500000
| CKAN_URL = 'http://127.0.0.1:5000'
# API key for the CKAN user that the archiver will authenticate as.
# This user must be a system administrator
API_KEY = ''
# directory to save downloaded files to
ARCHIVE_DIR = '/tmp/archive'
# Max content-length of archived files, larger files will be ignored
MAX_CONTENT_LENGTH = 500000
| Change settings to use API key and CKAN URL | Change settings to use API key and CKAN URL | Python | mit | ckan/ckanext-archiver,ckan/ckanext-archiver,DanePubliczneGovPl/ckanext-archiver,ckan/ckanext-archiver,datagovuk/ckanext-archiver,datagovuk/ckanext-archiver,datagovuk/ckanext-archiver,DanePubliczneGovPl/ckanext-archiver,DanePubliczneGovPl/ckanext-archiver | - CKAN_CONFIG = '/home/okfn/pyenv/src/ckan/ckan.ini'
+ CKAN_URL = 'http://127.0.0.1:5000'
+
+ # API key for the CKAN user that the archiver will authenticate as.
+ # This user must be a system administrator
+ API_KEY = ''
# directory to save downloaded files to
ARCHIVE_DIR = '/tmp/archive'
- # Use this user name when requesting data from ckan
- ARCHIVE_USER = u'okfn_maintenance'
-
# Max content-length of archived files, larger files will be ignored
MAX_CONTENT_LENGTH = 500000
| Change settings to use API key and CKAN URL | ## Code Before:
CKAN_CONFIG = '/home/okfn/pyenv/src/ckan/ckan.ini'
# directory to save downloaded files to
ARCHIVE_DIR = '/tmp/archive'
# Use this user name when requesting data from ckan
ARCHIVE_USER = u'okfn_maintenance'
# Max content-length of archived files, larger files will be ignored
MAX_CONTENT_LENGTH = 500000
## Instruction:
Change settings to use API key and CKAN URL
## Code After:
CKAN_URL = 'http://127.0.0.1:5000'
# API key for the CKAN user that the archiver will authenticate as.
# This user must be a system administrator
API_KEY = ''
# directory to save downloaded files to
ARCHIVE_DIR = '/tmp/archive'
# Max content-length of archived files, larger files will be ignored
MAX_CONTENT_LENGTH = 500000
| - CKAN_CONFIG = '/home/okfn/pyenv/src/ckan/ckan.ini'
+ CKAN_URL = 'http://127.0.0.1:5000'
+
+ # API key for the CKAN user that the archiver will authenticate as.
+ # This user must be a system administrator
+ API_KEY = ''
# directory to save downloaded files to
ARCHIVE_DIR = '/tmp/archive'
- # Use this user name when requesting data from ckan
- ARCHIVE_USER = u'okfn_maintenance'
-
# Max content-length of archived files, larger files will be ignored
MAX_CONTENT_LENGTH = 500000 |
c5683cb2bf8635c6ad26aac807f47c8f1fb4c68a | http_prompt/cli.py | http_prompt/cli.py | import click
from prompt_toolkit import prompt
from prompt_toolkit.history import InMemoryHistory
from prompt_toolkit.layout.lexers import PygmentsLexer
from prompt_toolkit.styles.from_pygments import style_from_pygments
from pygments.styles import get_style_by_name
from .completer import HttpPromptCompleter
from .context import Context
from .execution import execute
from .lexer import HttpPromptLexer
@click.command()
@click.argument('url')
def cli(url):
click.echo("Welcome to HTTP Prompt!")
context = Context(url)
# For prompt-toolkit
history = InMemoryHistory()
lexer = PygmentsLexer(HttpPromptLexer)
completer = HttpPromptCompleter(context)
style = style_from_pygments(get_style_by_name('monokai'))
while True:
try:
text = prompt('%s> ' % context.url, completer=completer,
lexer=lexer, style=style, history=history)
except EOFError:
break # Control-D pressed
else:
execute(text, context)
click.echo("Goodbye!")
| import click
from prompt_toolkit import prompt
from prompt_toolkit.history import InMemoryHistory
from prompt_toolkit.layout.lexers import PygmentsLexer
from prompt_toolkit.styles.from_pygments import style_from_pygments
from pygments.styles import get_style_by_name
from .completer import HttpPromptCompleter
from .context import Context
from .execution import execute
from .lexer import HttpPromptLexer
def fix_incomplete_url(url):
if url.startswith('s://') or url.startswith('://'):
url = 'http' + url
elif url.startswith('//'):
url = 'http:' + url
elif not url.startswith('http://') and not url.startswith('https://'):
url = 'http://' + url
return url
@click.command()
@click.argument('url', default='http://localhost')
def cli(url):
click.echo("Welcome to HTTP Prompt!")
url = fix_incomplete_url(url)
context = Context(url)
# For prompt-toolkit
history = InMemoryHistory()
lexer = PygmentsLexer(HttpPromptLexer)
completer = HttpPromptCompleter(context)
style = style_from_pygments(get_style_by_name('monokai'))
while True:
try:
text = prompt('%s> ' % context.url, completer=completer,
lexer=lexer, style=style, history=history)
except EOFError:
break # Control-D pressed
else:
execute(text, context)
click.echo("Goodbye!")
| Fix incomplete URL from command line | Fix incomplete URL from command line
| Python | mit | eliangcs/http-prompt,Yegorov/http-prompt | import click
from prompt_toolkit import prompt
from prompt_toolkit.history import InMemoryHistory
from prompt_toolkit.layout.lexers import PygmentsLexer
from prompt_toolkit.styles.from_pygments import style_from_pygments
from pygments.styles import get_style_by_name
from .completer import HttpPromptCompleter
from .context import Context
from .execution import execute
from .lexer import HttpPromptLexer
+ def fix_incomplete_url(url):
+ if url.startswith('s://') or url.startswith('://'):
+ url = 'http' + url
+ elif url.startswith('//'):
+ url = 'http:' + url
+ elif not url.startswith('http://') and not url.startswith('https://'):
+ url = 'http://' + url
+ return url
+
+
@click.command()
- @click.argument('url')
+ @click.argument('url', default='http://localhost')
def cli(url):
click.echo("Welcome to HTTP Prompt!")
+
+ url = fix_incomplete_url(url)
context = Context(url)
# For prompt-toolkit
history = InMemoryHistory()
lexer = PygmentsLexer(HttpPromptLexer)
completer = HttpPromptCompleter(context)
style = style_from_pygments(get_style_by_name('monokai'))
while True:
try:
text = prompt('%s> ' % context.url, completer=completer,
lexer=lexer, style=style, history=history)
except EOFError:
break # Control-D pressed
else:
execute(text, context)
click.echo("Goodbye!")
| Fix incomplete URL from command line | ## Code Before:
import click
from prompt_toolkit import prompt
from prompt_toolkit.history import InMemoryHistory
from prompt_toolkit.layout.lexers import PygmentsLexer
from prompt_toolkit.styles.from_pygments import style_from_pygments
from pygments.styles import get_style_by_name
from .completer import HttpPromptCompleter
from .context import Context
from .execution import execute
from .lexer import HttpPromptLexer
@click.command()
@click.argument('url')
def cli(url):
click.echo("Welcome to HTTP Prompt!")
context = Context(url)
# For prompt-toolkit
history = InMemoryHistory()
lexer = PygmentsLexer(HttpPromptLexer)
completer = HttpPromptCompleter(context)
style = style_from_pygments(get_style_by_name('monokai'))
while True:
try:
text = prompt('%s> ' % context.url, completer=completer,
lexer=lexer, style=style, history=history)
except EOFError:
break # Control-D pressed
else:
execute(text, context)
click.echo("Goodbye!")
## Instruction:
Fix incomplete URL from command line
## Code After:
import click
from prompt_toolkit import prompt
from prompt_toolkit.history import InMemoryHistory
from prompt_toolkit.layout.lexers import PygmentsLexer
from prompt_toolkit.styles.from_pygments import style_from_pygments
from pygments.styles import get_style_by_name
from .completer import HttpPromptCompleter
from .context import Context
from .execution import execute
from .lexer import HttpPromptLexer
def fix_incomplete_url(url):
if url.startswith('s://') or url.startswith('://'):
url = 'http' + url
elif url.startswith('//'):
url = 'http:' + url
elif not url.startswith('http://') and not url.startswith('https://'):
url = 'http://' + url
return url
@click.command()
@click.argument('url', default='http://localhost')
def cli(url):
click.echo("Welcome to HTTP Prompt!")
url = fix_incomplete_url(url)
context = Context(url)
# For prompt-toolkit
history = InMemoryHistory()
lexer = PygmentsLexer(HttpPromptLexer)
completer = HttpPromptCompleter(context)
style = style_from_pygments(get_style_by_name('monokai'))
while True:
try:
text = prompt('%s> ' % context.url, completer=completer,
lexer=lexer, style=style, history=history)
except EOFError:
break # Control-D pressed
else:
execute(text, context)
click.echo("Goodbye!")
| import click
from prompt_toolkit import prompt
from prompt_toolkit.history import InMemoryHistory
from prompt_toolkit.layout.lexers import PygmentsLexer
from prompt_toolkit.styles.from_pygments import style_from_pygments
from pygments.styles import get_style_by_name
from .completer import HttpPromptCompleter
from .context import Context
from .execution import execute
from .lexer import HttpPromptLexer
+ def fix_incomplete_url(url):
+ if url.startswith('s://') or url.startswith('://'):
+ url = 'http' + url
+ elif url.startswith('//'):
+ url = 'http:' + url
+ elif not url.startswith('http://') and not url.startswith('https://'):
+ url = 'http://' + url
+ return url
+
+
@click.command()
- @click.argument('url')
+ @click.argument('url', default='http://localhost')
def cli(url):
click.echo("Welcome to HTTP Prompt!")
+
+ url = fix_incomplete_url(url)
context = Context(url)
# For prompt-toolkit
history = InMemoryHistory()
lexer = PygmentsLexer(HttpPromptLexer)
completer = HttpPromptCompleter(context)
style = style_from_pygments(get_style_by_name('monokai'))
while True:
try:
text = prompt('%s> ' % context.url, completer=completer,
lexer=lexer, style=style, history=history)
except EOFError:
break # Control-D pressed
else:
execute(text, context)
click.echo("Goodbye!") |
d40ba3bcceb1dcc7338b689194cd7214d7b2d5ff | syncano_cli/execute/commands.py | syncano_cli/execute/commands.py | from __future__ import print_function
import json
import sys
from ConfigParser import NoOptionError
import click
from syncano_cli import LOG
from .connection import create_connection
@click.group()
def top_execute():
pass
@top_execute.command()
@click.option('--config', help=u'Account configuration file.')
@click.argument('instance_name', envvar='SYNCANO_INSTANCE')
@click.argument('script_endpoint_name')
@click.option('--payload', help=u'Script payload in JSON format.')
def execute(config, instance_name, script_endpoint_name, payload):
"""
Execute script endpoint in given instance
"""
try:
connection = create_connection(config)
except NoOptionError:
LOG.error('Do a login first: syncano login.')
sys.exit(1)
instance = connection.Instance.please.get(instance_name)
se = instance.script_endpoints.get(instance_name, script_endpoint_name)
data = json.loads(payload.strip() or '{}')
response = se.run(**data)
print(json.dumps(response.result, indent=4, sort_keys=True))
| from __future__ import print_function
import json
import sys
from ConfigParser import NoOptionError
import click
from syncano.exceptions import SyncanoDoesNotExist
from syncano_cli import LOG
from .connection import create_connection
@click.group()
def top_execute():
pass
@top_execute.command()
@click.option('--config', help=u'Account configuration file.')
@click.argument('instance_name', envvar='SYNCANO_INSTANCE')
@click.argument('script_endpoint_name')
@click.option('--payload', help=u'Script payload in JSON format.')
def execute(config, instance_name, script_endpoint_name, payload):
"""
Execute script endpoint in given instance
"""
try:
connection = create_connection(config)
instance = connection.Instance.please.get(instance_name)
se = instance.script_endpoints.get(instance_name, script_endpoint_name)
data = json.loads((payload or '').strip() or '{}')
response = se.run(**data)
if response.status == 'success':
print(json.dumps(response.result['stdout'], indent=4, sort_keys=True))
else:
LOG.error(response.result['stderr'])
except NoOptionError:
LOG.error('Do a login first: syncano login.')
sys.exit(1)
except SyncanoDoesNotExist as e:
LOG.error(e)
sys.exit(1)
except ValueError as e:
LOG.error('Invalid payload format: {error}'.format(error=e))
sys.exit(1)
| Refactor the code: add error handling of invalid or empty parameters, improve output format. | Refactor the code: add error handling of invalid or empty parameters, improve output format.
| Python | mit | Syncano/syncano-cli,Syncano/syncano-cli,Syncano/syncano-cli | from __future__ import print_function
import json
import sys
from ConfigParser import NoOptionError
import click
+ from syncano.exceptions import SyncanoDoesNotExist
from syncano_cli import LOG
from .connection import create_connection
@click.group()
def top_execute():
pass
@top_execute.command()
@click.option('--config', help=u'Account configuration file.')
@click.argument('instance_name', envvar='SYNCANO_INSTANCE')
@click.argument('script_endpoint_name')
@click.option('--payload', help=u'Script payload in JSON format.')
def execute(config, instance_name, script_endpoint_name, payload):
"""
Execute script endpoint in given instance
"""
try:
connection = create_connection(config)
+ instance = connection.Instance.please.get(instance_name)
+ se = instance.script_endpoints.get(instance_name, script_endpoint_name)
+ data = json.loads((payload or '').strip() or '{}')
+ response = se.run(**data)
+ if response.status == 'success':
+ print(json.dumps(response.result['stdout'], indent=4, sort_keys=True))
+ else:
+ LOG.error(response.result['stderr'])
except NoOptionError:
LOG.error('Do a login first: syncano login.')
sys.exit(1)
- instance = connection.Instance.please.get(instance_name)
- se = instance.script_endpoints.get(instance_name, script_endpoint_name)
- data = json.loads(payload.strip() or '{}')
- response = se.run(**data)
- print(json.dumps(response.result, indent=4, sort_keys=True))
+ except SyncanoDoesNotExist as e:
+ LOG.error(e)
+ sys.exit(1)
+ except ValueError as e:
+ LOG.error('Invalid payload format: {error}'.format(error=e))
+ sys.exit(1)
| Refactor the code: add error handling of invalid or empty parameters, improve output format. | ## Code Before:
from __future__ import print_function
import json
import sys
from ConfigParser import NoOptionError
import click
from syncano_cli import LOG
from .connection import create_connection
@click.group()
def top_execute():
pass
@top_execute.command()
@click.option('--config', help=u'Account configuration file.')
@click.argument('instance_name', envvar='SYNCANO_INSTANCE')
@click.argument('script_endpoint_name')
@click.option('--payload', help=u'Script payload in JSON format.')
def execute(config, instance_name, script_endpoint_name, payload):
"""
Execute script endpoint in given instance
"""
try:
connection = create_connection(config)
except NoOptionError:
LOG.error('Do a login first: syncano login.')
sys.exit(1)
instance = connection.Instance.please.get(instance_name)
se = instance.script_endpoints.get(instance_name, script_endpoint_name)
data = json.loads(payload.strip() or '{}')
response = se.run(**data)
print(json.dumps(response.result, indent=4, sort_keys=True))
## Instruction:
Refactor the code: add error handling of invalid or empty parameters, improve output format.
## Code After:
from __future__ import print_function
import json
import sys
from ConfigParser import NoOptionError
import click
from syncano.exceptions import SyncanoDoesNotExist
from syncano_cli import LOG
from .connection import create_connection
@click.group()
def top_execute():
pass
@top_execute.command()
@click.option('--config', help=u'Account configuration file.')
@click.argument('instance_name', envvar='SYNCANO_INSTANCE')
@click.argument('script_endpoint_name')
@click.option('--payload', help=u'Script payload in JSON format.')
def execute(config, instance_name, script_endpoint_name, payload):
"""
Execute script endpoint in given instance
"""
try:
connection = create_connection(config)
instance = connection.Instance.please.get(instance_name)
se = instance.script_endpoints.get(instance_name, script_endpoint_name)
data = json.loads((payload or '').strip() or '{}')
response = se.run(**data)
if response.status == 'success':
print(json.dumps(response.result['stdout'], indent=4, sort_keys=True))
else:
LOG.error(response.result['stderr'])
except NoOptionError:
LOG.error('Do a login first: syncano login.')
sys.exit(1)
except SyncanoDoesNotExist as e:
LOG.error(e)
sys.exit(1)
except ValueError as e:
LOG.error('Invalid payload format: {error}'.format(error=e))
sys.exit(1)
| from __future__ import print_function
import json
import sys
from ConfigParser import NoOptionError
import click
+ from syncano.exceptions import SyncanoDoesNotExist
from syncano_cli import LOG
from .connection import create_connection
@click.group()
def top_execute():
pass
@top_execute.command()
@click.option('--config', help=u'Account configuration file.')
@click.argument('instance_name', envvar='SYNCANO_INSTANCE')
@click.argument('script_endpoint_name')
@click.option('--payload', help=u'Script payload in JSON format.')
def execute(config, instance_name, script_endpoint_name, payload):
"""
Execute script endpoint in given instance
"""
try:
connection = create_connection(config)
+ instance = connection.Instance.please.get(instance_name)
+ se = instance.script_endpoints.get(instance_name, script_endpoint_name)
+ data = json.loads((payload or '').strip() or '{}')
+ response = se.run(**data)
+ if response.status == 'success':
+ print(json.dumps(response.result['stdout'], indent=4, sort_keys=True))
+ else:
+ LOG.error(response.result['stderr'])
except NoOptionError:
LOG.error('Do a login first: syncano login.')
sys.exit(1)
- instance = connection.Instance.please.get(instance_name)
- se = instance.script_endpoints.get(instance_name, script_endpoint_name)
- data = json.loads(payload.strip() or '{}')
- response = se.run(**data)
- print(json.dumps(response.result, indent=4, sort_keys=True))
+ except SyncanoDoesNotExist as e:
+ LOG.error(e)
+ sys.exit(1)
+ except ValueError as e:
+ LOG.error('Invalid payload format: {error}'.format(error=e))
+ sys.exit(1) |
19a58255f247199d0e60408cab8220a8c2a1ff3b | qxlc/minifier.py | qxlc/minifier.py | import htmlmin
from markupsafe import Markup
from qxlc import app
@app.template_filter("minify")
def minify_filter(text):
return Markup(htmlmin.minify(text.unescape(), remove_comments=True, remove_empty_space=True))
| import htmlmin
from markupsafe import Markup
from qxlc import app
@app.template_filter("minify")
def minify_filter(s):
return Markup(htmlmin.minify(str(s), remove_comments=True, remove_empty_space=True))
| Use str(s) instead of s.unescape() to add support for escaping things inside. (took me a while to find that str() worked) | Use str(s) instead of s.unescape() to add support for escaping things inside. (took me a while to find that str() worked)
| Python | apache-2.0 | daboross/qxlc,daboross/qxlc | import htmlmin
from markupsafe import Markup
from qxlc import app
@app.template_filter("minify")
- def minify_filter(text):
+ def minify_filter(s):
- return Markup(htmlmin.minify(text.unescape(), remove_comments=True, remove_empty_space=True))
+ return Markup(htmlmin.minify(str(s), remove_comments=True, remove_empty_space=True))
| Use str(s) instead of s.unescape() to add support for escaping things inside. (took me a while to find that str() worked) | ## Code Before:
import htmlmin
from markupsafe import Markup
from qxlc import app
@app.template_filter("minify")
def minify_filter(text):
return Markup(htmlmin.minify(text.unescape(), remove_comments=True, remove_empty_space=True))
## Instruction:
Use str(s) instead of s.unescape() to add support for escaping things inside. (took me a while to find that str() worked)
## Code After:
import htmlmin
from markupsafe import Markup
from qxlc import app
@app.template_filter("minify")
def minify_filter(s):
return Markup(htmlmin.minify(str(s), remove_comments=True, remove_empty_space=True))
| import htmlmin
from markupsafe import Markup
from qxlc import app
@app.template_filter("minify")
- def minify_filter(text):
? ^^^^
+ def minify_filter(s):
? ^
- return Markup(htmlmin.minify(text.unescape(), remove_comments=True, remove_empty_space=True))
? ^^^^^^^ -----
+ return Markup(htmlmin.minify(str(s), remove_comments=True, remove_empty_space=True))
? + ^^
|
a7fcc89755e01bf3dbe7090e2bf7f1211ce9af84 | test/test_property.py | test/test_property.py | import unittest
from odml import Property, Section, Document
class TestProperty(unittest.TestCase):
def setUp(self):
pass
def test_value(self):
p = Property("property", 100)
assert(p.value[0] == 100)
def test_name(self):
pass
def test_parent(self):
pass
def test_dtype(self):
pass
def test_path(self):
pass
if __name__ == "__main__":
print("TestProperty")
tp = TestProperty()
tp.test_value()
| import unittest
from odml import Property, Section, Document
from odml.doc import BaseDocument
from odml.section import BaseSection
class TestProperty(unittest.TestCase):
def setUp(self):
pass
def test_value(self):
p = Property("property", 100)
self.assertEqual(p.value[0], 100)
def test_name(self):
pass
def test_parent(self):
p = Property("property_section", parent=Section("S"))
self.assertIsInstance(p.parent, BaseSection)
self.assertEqual(len(p.parent._props), 1)
with self.assertRaises(ValueError):
Property("property_prop", parent=Property("P"))
with self.assertRaises(ValueError):
Property("property_doc", parent=Document())
def test_dtype(self):
pass
def test_path(self):
pass
class TestSection(unittest.TestCase):
def setUp(self):
pass
def test_value(self):
pass
def test_name(self):
pass
def test_parent(self):
s = Section("Section")
self.assertIsNone(s.parent)
s = Section("section_doc", parent=Document())
self.assertIsInstance(s.parent, BaseDocument)
self.assertEqual(len(s.parent._sections), 1)
s = Section("section_sec", parent=Section("S"))
self.assertIsInstance(s.parent, BaseSection)
self.assertEqual(len(s.parent._sections), 1)
with self.assertRaises(ValueError):
Section("section_property", parent=Property("P"))
def test_dtype(self):
pass
def test_path(self):
pass
if __name__ == "__main__":
print("TestProperty")
tp = TestProperty()
tp.test_value()
tp.test_parent()
print("TestSection")
ts = TestSection()
ts.test_parent()
| Add tests to cover update parent functionality. | Add tests to cover update parent functionality.
| Python | bsd-3-clause | lzehl/python-odml | import unittest
from odml import Property, Section, Document
+ from odml.doc import BaseDocument
+ from odml.section import BaseSection
class TestProperty(unittest.TestCase):
def setUp(self):
pass
def test_value(self):
p = Property("property", 100)
- assert(p.value[0] == 100)
+ self.assertEqual(p.value[0], 100)
def test_name(self):
pass
def test_parent(self):
+ p = Property("property_section", parent=Section("S"))
+ self.assertIsInstance(p.parent, BaseSection)
+ self.assertEqual(len(p.parent._props), 1)
+ with self.assertRaises(ValueError):
+ Property("property_prop", parent=Property("P"))
+ with self.assertRaises(ValueError):
+ Property("property_doc", parent=Document())
+
+ def test_dtype(self):
pass
+
+ def test_path(self):
+ pass
+
+
+ class TestSection(unittest.TestCase):
+ def setUp(self):
+ pass
+
+ def test_value(self):
+ pass
+
+ def test_name(self):
+ pass
+
+ def test_parent(self):
+ s = Section("Section")
+ self.assertIsNone(s.parent)
+
+ s = Section("section_doc", parent=Document())
+ self.assertIsInstance(s.parent, BaseDocument)
+ self.assertEqual(len(s.parent._sections), 1)
+
+ s = Section("section_sec", parent=Section("S"))
+ self.assertIsInstance(s.parent, BaseSection)
+ self.assertEqual(len(s.parent._sections), 1)
+
+ with self.assertRaises(ValueError):
+ Section("section_property", parent=Property("P"))
def test_dtype(self):
pass
def test_path(self):
pass
if __name__ == "__main__":
print("TestProperty")
tp = TestProperty()
tp.test_value()
+ tp.test_parent()
+ print("TestSection")
+ ts = TestSection()
+ ts.test_parent()
+
+
+ | Add tests to cover update parent functionality. | ## Code Before:
import unittest
from odml import Property, Section, Document
class TestProperty(unittest.TestCase):
def setUp(self):
pass
def test_value(self):
p = Property("property", 100)
assert(p.value[0] == 100)
def test_name(self):
pass
def test_parent(self):
pass
def test_dtype(self):
pass
def test_path(self):
pass
if __name__ == "__main__":
print("TestProperty")
tp = TestProperty()
tp.test_value()
## Instruction:
Add tests to cover update parent functionality.
## Code After:
import unittest
from odml import Property, Section, Document
from odml.doc import BaseDocument
from odml.section import BaseSection
class TestProperty(unittest.TestCase):
def setUp(self):
pass
def test_value(self):
p = Property("property", 100)
self.assertEqual(p.value[0], 100)
def test_name(self):
pass
def test_parent(self):
p = Property("property_section", parent=Section("S"))
self.assertIsInstance(p.parent, BaseSection)
self.assertEqual(len(p.parent._props), 1)
with self.assertRaises(ValueError):
Property("property_prop", parent=Property("P"))
with self.assertRaises(ValueError):
Property("property_doc", parent=Document())
def test_dtype(self):
pass
def test_path(self):
pass
class TestSection(unittest.TestCase):
def setUp(self):
pass
def test_value(self):
pass
def test_name(self):
pass
def test_parent(self):
s = Section("Section")
self.assertIsNone(s.parent)
s = Section("section_doc", parent=Document())
self.assertIsInstance(s.parent, BaseDocument)
self.assertEqual(len(s.parent._sections), 1)
s = Section("section_sec", parent=Section("S"))
self.assertIsInstance(s.parent, BaseSection)
self.assertEqual(len(s.parent._sections), 1)
with self.assertRaises(ValueError):
Section("section_property", parent=Property("P"))
def test_dtype(self):
pass
def test_path(self):
pass
if __name__ == "__main__":
print("TestProperty")
tp = TestProperty()
tp.test_value()
tp.test_parent()
print("TestSection")
ts = TestSection()
ts.test_parent()
| import unittest
from odml import Property, Section, Document
+ from odml.doc import BaseDocument
+ from odml.section import BaseSection
class TestProperty(unittest.TestCase):
def setUp(self):
pass
def test_value(self):
p = Property("property", 100)
- assert(p.value[0] == 100)
? ^^^
+ self.assertEqual(p.value[0], 100)
? +++++ +++++ ^
def test_name(self):
pass
def test_parent(self):
+ p = Property("property_section", parent=Section("S"))
+ self.assertIsInstance(p.parent, BaseSection)
+ self.assertEqual(len(p.parent._props), 1)
+ with self.assertRaises(ValueError):
+ Property("property_prop", parent=Property("P"))
+ with self.assertRaises(ValueError):
+ Property("property_doc", parent=Document())
+
+ def test_dtype(self):
pass
+
+ def test_path(self):
+ pass
+
+
+ class TestSection(unittest.TestCase):
+ def setUp(self):
+ pass
+
+ def test_value(self):
+ pass
+
+ def test_name(self):
+ pass
+
+ def test_parent(self):
+ s = Section("Section")
+ self.assertIsNone(s.parent)
+
+ s = Section("section_doc", parent=Document())
+ self.assertIsInstance(s.parent, BaseDocument)
+ self.assertEqual(len(s.parent._sections), 1)
+
+ s = Section("section_sec", parent=Section("S"))
+ self.assertIsInstance(s.parent, BaseSection)
+ self.assertEqual(len(s.parent._sections), 1)
+
+ with self.assertRaises(ValueError):
+ Section("section_property", parent=Property("P"))
def test_dtype(self):
pass
def test_path(self):
pass
if __name__ == "__main__":
print("TestProperty")
tp = TestProperty()
tp.test_value()
+ tp.test_parent()
+
+ print("TestSection")
+ ts = TestSection()
+ ts.test_parent()
+
+ |
8e75605e0511b85dfd500b644613739f29705da6 | cfnf.py | cfnf.py | import sublime, sublime_plugin
import time
class cfnewfile(sublime_plugin.TextCommand):
def run(self, edit):
localtime = time.asctime( time.localtime(time.time()) )
self.view.insert(edit,0,"<!---\r\n Name:\r\n Description:\r\n Written By:\r\n Date Created: "+localtime+"\r\n History:\r\n--->\r\n")
|
import sublime, sublime_plugin
import time
class cfnfCommand(sublime_plugin.WindowCommand):
def run(self):
a = self.window.new_file()
a.run_command("addheader")
class addheaderCommand(sublime_plugin.TextCommand):
def run(self, edit):
localtime = time.asctime( time.localtime(time.time()) )
self.view.insert(edit,0,"<!---\n Name:\n Description:\n Written By:\n Date Created: "+localtime+"\n History:\n--->\n")
| Send text to new file | Send text to new file
| Python | bsd-2-clause | dwkd/SublimeCFNewFile | +
import sublime, sublime_plugin
import time
- class cfnewfile(sublime_plugin.TextCommand):
+ class cfnfCommand(sublime_plugin.WindowCommand):
+ def run(self):
+ a = self.window.new_file()
+ a.run_command("addheader")
+
+ class addheaderCommand(sublime_plugin.TextCommand):
- def run(self, edit):
+ def run(self, edit):
localtime = time.asctime( time.localtime(time.time()) )
- self.view.insert(edit,0,"<!---\r\n Name:\r\n Description:\r\n Written By:\r\n Date Created: "+localtime+"\r\n History:\r\n--->\r\n")
+ self.view.insert(edit,0,"<!---\n Name:\n Description:\n Written By:\n Date Created: "+localtime+"\n History:\n--->\n")
| Send text to new file | ## Code Before:
import sublime, sublime_plugin
import time
class cfnewfile(sublime_plugin.TextCommand):
def run(self, edit):
localtime = time.asctime( time.localtime(time.time()) )
self.view.insert(edit,0,"<!---\r\n Name:\r\n Description:\r\n Written By:\r\n Date Created: "+localtime+"\r\n History:\r\n--->\r\n")
## Instruction:
Send text to new file
## Code After:
import sublime, sublime_plugin
import time
class cfnfCommand(sublime_plugin.WindowCommand):
def run(self):
a = self.window.new_file()
a.run_command("addheader")
class addheaderCommand(sublime_plugin.TextCommand):
def run(self, edit):
localtime = time.asctime( time.localtime(time.time()) )
self.view.insert(edit,0,"<!---\n Name:\n Description:\n Written By:\n Date Created: "+localtime+"\n History:\n--->\n")
| +
import sublime, sublime_plugin
import time
- class cfnewfile(sublime_plugin.TextCommand):
? -- ^^^ ^^^^
+ class cfnfCommand(sublime_plugin.WindowCommand):
? ^^^^^^^ ^^^^^^
+ def run(self):
+ a = self.window.new_file()
+ a.run_command("addheader")
+
+ class addheaderCommand(sublime_plugin.TextCommand):
- def run(self, edit):
+ def run(self, edit):
? ++
localtime = time.asctime( time.localtime(time.time()) )
- self.view.insert(edit,0,"<!---\r\n Name:\r\n Description:\r\n Written By:\r\n Date Created: "+localtime+"\r\n History:\r\n--->\r\n")
? -- -- -- -- -- -- --
+ self.view.insert(edit,0,"<!---\n Name:\n Description:\n Written By:\n Date Created: "+localtime+"\n History:\n--->\n") |
dbc09d03f62bf2d5ee1661492a4c20a7942f81a9 | tests/basics/list_slice.py | tests/basics/list_slice.py | x = list(range(10))
a = 2
b = 4
c = 3
print(x[:])
print(x[::])
#print(x[::c])
print(x[:b])
print(x[:b:])
#print(x[:b:c])
print(x[a])
print(x[a:])
print(x[a::])
#print(x[a::c])
print(x[a:b])
print(x[a:b:])
#print(x[a:b:c])
# these should not raise IndexError
print([][1:])
print([][-1:])
|
x = list(range(10))
a = 2
b = 4
c = 3
print(x[:])
print(x[::])
print(x[::c])
print(x[:b])
print(x[:b:])
print(x[:b:c])
print(x[a])
print(x[a:])
print(x[a::])
print(x[a::c])
print(x[a:b])
print(x[a:b:])
print(x[a:b:c])
# these should not raise IndexError
print([][1:])
print([][-1:])
try:
[][::0]
except ValueError:
print('ValueError')
| Enable tests for list slice getting with 3rd arg. | tests/basics: Enable tests for list slice getting with 3rd arg.
Also add a test to check case when 3rd arg is 0.
| Python | mit | tuc-osg/micropython,mhoffma/micropython,trezor/micropython,blazewicz/micropython,AriZuu/micropython,kerneltask/micropython,swegener/micropython,MrSurly/micropython,mhoffma/micropython,hiway/micropython,alex-robbins/micropython,henriknelson/micropython,tuc-osg/micropython,adafruit/micropython,selste/micropython,ryannathans/micropython,tobbad/micropython,kerneltask/micropython,cwyark/micropython,bvernoux/micropython,SHA2017-badge/micropython-esp32,tobbad/micropython,oopy/micropython,chrisdearman/micropython,hiway/micropython,bvernoux/micropython,tralamazza/micropython,ryannathans/micropython,SHA2017-badge/micropython-esp32,MrSurly/micropython-esp32,tralamazza/micropython,chrisdearman/micropython,TDAbboud/micropython,adafruit/circuitpython,puuu/micropython,lowRISC/micropython,torwag/micropython,MrSurly/micropython,kerneltask/micropython,mhoffma/micropython,tobbad/micropython,puuu/micropython,alex-robbins/micropython,puuu/micropython,henriknelson/micropython,HenrikSolver/micropython,tuc-osg/micropython,Timmenem/micropython,pfalcon/micropython,toolmacher/micropython,infinnovation/micropython,mhoffma/micropython,selste/micropython,adafruit/micropython,pozetroninc/micropython,torwag/micropython,HenrikSolver/micropython,pramasoul/micropython,Peetz0r/micropython-esp32,swegener/micropython,pramasoul/micropython,AriZuu/micropython,PappaPeppar/micropython,oopy/micropython,TDAbboud/micropython,adafruit/micropython,bvernoux/micropython,lowRISC/micropython,blazewicz/micropython,pramasoul/micropython,pozetroninc/micropython,tuc-osg/micropython,hiway/micropython,Timmenem/micropython,blazewicz/micropython,trezor/micropython,Timmenem/micropython,selste/micropython,tralamazza/micropython,infinnovation/micropython,tobbad/micropython,deshipu/micropython,deshipu/micropython,torwag/micropython,lowRISC/micropython,dmazzella/micropython,TDAbboud/micropython,swegener/micropython,deshipu/micropython,mhoffma/micropython,selste/micropython,MrSurly/micropython-esp32,Peetz0r/micropython-esp32,adafruit/circuitpython,SHA2017-badge/micropython-esp32,tuc-osg/micropython,MrSurly/micropython,tobbad/micropython,selste/micropython,swegener/micropython,tralamazza/micropython,deshipu/micropython,oopy/micropython,henriknelson/micropython,Timmenem/micropython,lowRISC/micropython,kerneltask/micropython,Peetz0r/micropython-esp32,adafruit/circuitpython,henriknelson/micropython,cwyark/micropython,blazewicz/micropython,lowRISC/micropython,puuu/micropython,PappaPeppar/micropython,MrSurly/micropython,adafruit/micropython,MrSurly/micropython-esp32,PappaPeppar/micropython,PappaPeppar/micropython,SHA2017-badge/micropython-esp32,trezor/micropython,chrisdearman/micropython,hiway/micropython,infinnovation/micropython,puuu/micropython,dmazzella/micropython,blazewicz/micropython,henriknelson/micropython,pramasoul/micropython,HenrikSolver/micropython,micropython/micropython-esp32,chrisdearman/micropython,toolmacher/micropython,toolmacher/micropython,Timmenem/micropython,pozetroninc/micropython,chrisdearman/micropython,MrSurly/micropython-esp32,SHA2017-badge/micropython-esp32,micropython/micropython-esp32,TDAbboud/micropython,PappaPeppar/micropython,deshipu/micropython,ryannathans/micropython,infinnovation/micropython,pfalcon/micropython,Peetz0r/micropython-esp32,micropython/micropython-esp32,trezor/micropython,infinnovation/micropython,torwag/micropython,ryannathans/micropython,AriZuu/micropython,pozetroninc/micropython,adafruit/micropython,trezor/micropython,HenrikSolver/micropython,bvernoux/micropython,cwyark/micropython,alex-robbins/micropython,ryannathans/micropython,alex-robbins/micropython,HenrikSolver/micropython,pramasoul/micropython,adafruit/circuitpython,toolmacher/micropython,toolmacher/micropython,pfalcon/micropython,MrSurly/micropython-esp32,micropython/micropython-esp32,pfalcon/micropython,MrSurly/micropython,pfalcon/micropython,cwyark/micropython,torwag/micropython,AriZuu/micropython,bvernoux/micropython,oopy/micropython,hiway/micropython,TDAbboud/micropython,dmazzella/micropython,alex-robbins/micropython,adafruit/circuitpython,oopy/micropython,pozetroninc/micropython,dmazzella/micropython,swegener/micropython,micropython/micropython-esp32,cwyark/micropython,AriZuu/micropython,adafruit/circuitpython,Peetz0r/micropython-esp32,kerneltask/micropython | +
x = list(range(10))
a = 2
b = 4
c = 3
print(x[:])
print(x[::])
- #print(x[::c])
+ print(x[::c])
print(x[:b])
print(x[:b:])
- #print(x[:b:c])
+ print(x[:b:c])
print(x[a])
print(x[a:])
print(x[a::])
- #print(x[a::c])
+ print(x[a::c])
print(x[a:b])
print(x[a:b:])
- #print(x[a:b:c])
+ print(x[a:b:c])
# these should not raise IndexError
print([][1:])
print([][-1:])
+ try:
+ [][::0]
+ except ValueError:
+ print('ValueError')
+ | Enable tests for list slice getting with 3rd arg. | ## Code Before:
x = list(range(10))
a = 2
b = 4
c = 3
print(x[:])
print(x[::])
#print(x[::c])
print(x[:b])
print(x[:b:])
#print(x[:b:c])
print(x[a])
print(x[a:])
print(x[a::])
#print(x[a::c])
print(x[a:b])
print(x[a:b:])
#print(x[a:b:c])
# these should not raise IndexError
print([][1:])
print([][-1:])
## Instruction:
Enable tests for list slice getting with 3rd arg.
## Code After:
x = list(range(10))
a = 2
b = 4
c = 3
print(x[:])
print(x[::])
print(x[::c])
print(x[:b])
print(x[:b:])
print(x[:b:c])
print(x[a])
print(x[a:])
print(x[a::])
print(x[a::c])
print(x[a:b])
print(x[a:b:])
print(x[a:b:c])
# these should not raise IndexError
print([][1:])
print([][-1:])
try:
[][::0]
except ValueError:
print('ValueError')
| +
x = list(range(10))
a = 2
b = 4
c = 3
print(x[:])
print(x[::])
- #print(x[::c])
? -
+ print(x[::c])
print(x[:b])
print(x[:b:])
- #print(x[:b:c])
? -
+ print(x[:b:c])
print(x[a])
print(x[a:])
print(x[a::])
- #print(x[a::c])
? -
+ print(x[a::c])
print(x[a:b])
print(x[a:b:])
- #print(x[a:b:c])
? -
+ print(x[a:b:c])
# these should not raise IndexError
print([][1:])
print([][-1:])
+
+ try:
+ [][::0]
+ except ValueError:
+ print('ValueError') |
7dced29bcf8b2b5f5220f5dbfeaf631d9d5fc409 | examples/backtest.py | examples/backtest.py | import time
import logging
from pythonjsonlogger import jsonlogger
from flumine import FlumineBacktest, clients
from strategies.lowestlayer import LowestLayer
logger = logging.getLogger()
custom_format = "%(asctime) %(levelname) %(message)"
log_handler = logging.StreamHandler()
formatter = jsonlogger.JsonFormatter(custom_format)
formatter.converter = time.gmtime
log_handler.setFormatter(formatter)
logger.addHandler(log_handler)
logger.setLevel(logging.INFO)
client = clients.BacktestClient()
framework = FlumineBacktest(client=client)
markets = ["tests/resources/PRO-1.170258213"]
strategy = LowestLayer(
market_filter={"markets": markets},
max_order_exposure=1000,
max_selection_exposure=105,
context={"stake": 2},
)
framework.add_strategy(strategy)
framework.run()
for market in framework.markets:
print("Profit: {0:.2f}".format(sum([o.simulated.profit for o in market.blotter])))
for order in market.blotter:
print(
order.selection_id,
order.responses.date_time_placed,
order.status,
order.order_type.price,
order.average_price_matched,
order.size_matched,
order.simulated.profit,
)
| import time
import logging
from pythonjsonlogger import jsonlogger
from flumine import FlumineBacktest, clients
from strategies.lowestlayer import LowestLayer
logger = logging.getLogger()
custom_format = "%(asctime) %(levelname) %(message)"
log_handler = logging.StreamHandler()
formatter = jsonlogger.JsonFormatter(custom_format)
formatter.converter = time.gmtime
log_handler.setFormatter(formatter)
logger.addHandler(log_handler)
logger.setLevel(logging.INFO) # Set to logging.CRITICAL to speed up backtest
client = clients.BacktestClient()
framework = FlumineBacktest(client=client)
markets = ["tests/resources/PRO-1.170258213"]
strategy = LowestLayer(
market_filter={"markets": markets},
max_order_exposure=1000,
max_selection_exposure=105,
context={"stake": 2},
)
framework.add_strategy(strategy)
framework.run()
for market in framework.markets:
print("Profit: {0:.2f}".format(sum([o.simulated.profit for o in market.blotter])))
for order in market.blotter:
print(
order.selection_id,
order.responses.date_time_placed,
order.status,
order.order_type.price,
order.average_price_matched,
order.size_matched,
order.simulated.profit,
)
| Comment to say using logging.CRITICAL is faster | Comment to say using logging.CRITICAL is faster
| Python | mit | liampauling/flumine | import time
import logging
from pythonjsonlogger import jsonlogger
from flumine import FlumineBacktest, clients
from strategies.lowestlayer import LowestLayer
logger = logging.getLogger()
custom_format = "%(asctime) %(levelname) %(message)"
log_handler = logging.StreamHandler()
formatter = jsonlogger.JsonFormatter(custom_format)
formatter.converter = time.gmtime
log_handler.setFormatter(formatter)
logger.addHandler(log_handler)
- logger.setLevel(logging.INFO)
+ logger.setLevel(logging.INFO) # Set to logging.CRITICAL to speed up backtest
client = clients.BacktestClient()
framework = FlumineBacktest(client=client)
markets = ["tests/resources/PRO-1.170258213"]
strategy = LowestLayer(
market_filter={"markets": markets},
max_order_exposure=1000,
max_selection_exposure=105,
context={"stake": 2},
)
framework.add_strategy(strategy)
framework.run()
for market in framework.markets:
print("Profit: {0:.2f}".format(sum([o.simulated.profit for o in market.blotter])))
for order in market.blotter:
print(
order.selection_id,
order.responses.date_time_placed,
order.status,
order.order_type.price,
order.average_price_matched,
order.size_matched,
order.simulated.profit,
)
| Comment to say using logging.CRITICAL is faster | ## Code Before:
import time
import logging
from pythonjsonlogger import jsonlogger
from flumine import FlumineBacktest, clients
from strategies.lowestlayer import LowestLayer
logger = logging.getLogger()
custom_format = "%(asctime) %(levelname) %(message)"
log_handler = logging.StreamHandler()
formatter = jsonlogger.JsonFormatter(custom_format)
formatter.converter = time.gmtime
log_handler.setFormatter(formatter)
logger.addHandler(log_handler)
logger.setLevel(logging.INFO)
client = clients.BacktestClient()
framework = FlumineBacktest(client=client)
markets = ["tests/resources/PRO-1.170258213"]
strategy = LowestLayer(
market_filter={"markets": markets},
max_order_exposure=1000,
max_selection_exposure=105,
context={"stake": 2},
)
framework.add_strategy(strategy)
framework.run()
for market in framework.markets:
print("Profit: {0:.2f}".format(sum([o.simulated.profit for o in market.blotter])))
for order in market.blotter:
print(
order.selection_id,
order.responses.date_time_placed,
order.status,
order.order_type.price,
order.average_price_matched,
order.size_matched,
order.simulated.profit,
)
## Instruction:
Comment to say using logging.CRITICAL is faster
## Code After:
import time
import logging
from pythonjsonlogger import jsonlogger
from flumine import FlumineBacktest, clients
from strategies.lowestlayer import LowestLayer
logger = logging.getLogger()
custom_format = "%(asctime) %(levelname) %(message)"
log_handler = logging.StreamHandler()
formatter = jsonlogger.JsonFormatter(custom_format)
formatter.converter = time.gmtime
log_handler.setFormatter(formatter)
logger.addHandler(log_handler)
logger.setLevel(logging.INFO) # Set to logging.CRITICAL to speed up backtest
client = clients.BacktestClient()
framework = FlumineBacktest(client=client)
markets = ["tests/resources/PRO-1.170258213"]
strategy = LowestLayer(
market_filter={"markets": markets},
max_order_exposure=1000,
max_selection_exposure=105,
context={"stake": 2},
)
framework.add_strategy(strategy)
framework.run()
for market in framework.markets:
print("Profit: {0:.2f}".format(sum([o.simulated.profit for o in market.blotter])))
for order in market.blotter:
print(
order.selection_id,
order.responses.date_time_placed,
order.status,
order.order_type.price,
order.average_price_matched,
order.size_matched,
order.simulated.profit,
)
| import time
import logging
from pythonjsonlogger import jsonlogger
from flumine import FlumineBacktest, clients
from strategies.lowestlayer import LowestLayer
logger = logging.getLogger()
custom_format = "%(asctime) %(levelname) %(message)"
log_handler = logging.StreamHandler()
formatter = jsonlogger.JsonFormatter(custom_format)
formatter.converter = time.gmtime
log_handler.setFormatter(formatter)
logger.addHandler(log_handler)
- logger.setLevel(logging.INFO)
+ logger.setLevel(logging.INFO) # Set to logging.CRITICAL to speed up backtest
client = clients.BacktestClient()
framework = FlumineBacktest(client=client)
markets = ["tests/resources/PRO-1.170258213"]
strategy = LowestLayer(
market_filter={"markets": markets},
max_order_exposure=1000,
max_selection_exposure=105,
context={"stake": 2},
)
framework.add_strategy(strategy)
framework.run()
for market in framework.markets:
print("Profit: {0:.2f}".format(sum([o.simulated.profit for o in market.blotter])))
for order in market.blotter:
print(
order.selection_id,
order.responses.date_time_placed,
order.status,
order.order_type.price,
order.average_price_matched,
order.size_matched,
order.simulated.profit,
) |
07ba597a106e60a77ec28debd093079daa55df8f | node.py | node.py | class Node(object):
def __init__(self):
# Node(s) from which this Node receives values
self.inbound_nodes = inbound_nodes
# Node(s) to which this Node passes values
self.outbound_nodes = []
# For each inbound Node here, add this Node as an outbound to that Node.
for n in self.inbound_nodes:
n.outbound_nodes.append(self)
| class Node(object):
def __init__(self):
# Node(s) from which this Node receives values
self.inbound_nodes = inbound_nodes
# Node(s) to which this Node passes values
self.outbound_nodes = []
# For each inbound Node here, add this Node as an outbound to that Node.
for n in self.inbound_nodes:
n.outbound_nodes.append(self)
# A calculated value
self.value = None
| Add value property to class Node | Add value property to class Node
value is the calculated output of a Node.
| Python | mit | YabinHu/miniflow | class Node(object):
def __init__(self):
# Node(s) from which this Node receives values
self.inbound_nodes = inbound_nodes
# Node(s) to which this Node passes values
self.outbound_nodes = []
# For each inbound Node here, add this Node as an outbound to that Node.
for n in self.inbound_nodes:
n.outbound_nodes.append(self)
+ # A calculated value
+ self.value = None
+ | Add value property to class Node | ## Code Before:
class Node(object):
def __init__(self):
# Node(s) from which this Node receives values
self.inbound_nodes = inbound_nodes
# Node(s) to which this Node passes values
self.outbound_nodes = []
# For each inbound Node here, add this Node as an outbound to that Node.
for n in self.inbound_nodes:
n.outbound_nodes.append(self)
## Instruction:
Add value property to class Node
## Code After:
class Node(object):
def __init__(self):
# Node(s) from which this Node receives values
self.inbound_nodes = inbound_nodes
# Node(s) to which this Node passes values
self.outbound_nodes = []
# For each inbound Node here, add this Node as an outbound to that Node.
for n in self.inbound_nodes:
n.outbound_nodes.append(self)
# A calculated value
self.value = None
| class Node(object):
def __init__(self):
# Node(s) from which this Node receives values
self.inbound_nodes = inbound_nodes
# Node(s) to which this Node passes values
self.outbound_nodes = []
# For each inbound Node here, add this Node as an outbound to that Node.
for n in self.inbound_nodes:
n.outbound_nodes.append(self)
+
+ # A calculated value
+ self.value = None |
27423205b06b031572b675ee29a487f4b900fe56 | cura_app.py | cura_app.py |
import sys
def exceptHook(type, value, traceback):
import cura.CrashHandler
cura.CrashHandler.show(type, value, traceback)
sys.excepthook = exceptHook
# Workaround for a race condition on certain systems where there
# is a race condition between Arcus and PyQt. Importing Arcus
# first seems to prevent Sip from going into a state where it
# tries to create PyQt objects on a non-main thread.
import Arcus
import cura.CuraApplication
if sys.platform == "win32" and hasattr(sys, "frozen"):
import os
dirpath = os.path.expanduser("~/AppData/Local/cura/")
os.makedirs(dirpath, exist_ok = True)
sys.stdout = open(os.path.join(dirpath, "stdout.log"), "w")
sys.stderr = open(os.path.join(dirpath, "stderr.log"), "w")
app = cura.CuraApplication.CuraApplication.getInstance()
app.run()
|
import sys
def exceptHook(hook_type, value, traceback):
import cura.CrashHandler
cura.CrashHandler.show(hook_type, value, traceback)
sys.excepthook = exceptHook
# Workaround for a race condition on certain systems where there
# is a race condition between Arcus and PyQt. Importing Arcus
# first seems to prevent Sip from going into a state where it
# tries to create PyQt objects on a non-main thread.
import Arcus
import cura.CuraApplication
if sys.platform == "win32" and hasattr(sys, "frozen"):
import os
dirpath = os.path.expanduser("~/AppData/Local/cura/")
os.makedirs(dirpath, exist_ok = True)
sys.stdout = open(os.path.join(dirpath, "stdout.log"), "w")
sys.stderr = open(os.path.join(dirpath, "stderr.log"), "w")
app = cura.CuraApplication.CuraApplication.getInstance()
app.run()
| Rename type into hook_type "type" itself if a built-in function. Using this name could be unsave. | Rename type into hook_type
"type" itself if a built-in function. Using this name could be unsave.
| Python | agpl-3.0 | hmflash/Cura,Curahelper/Cura,ynotstartups/Wanhao,senttech/Cura,totalretribution/Cura,fieldOfView/Cura,hmflash/Cura,Curahelper/Cura,ynotstartups/Wanhao,totalretribution/Cura,senttech/Cura,fieldOfView/Cura |
import sys
- def exceptHook(type, value, traceback):
+ def exceptHook(hook_type, value, traceback):
import cura.CrashHandler
- cura.CrashHandler.show(type, value, traceback)
+ cura.CrashHandler.show(hook_type, value, traceback)
sys.excepthook = exceptHook
# Workaround for a race condition on certain systems where there
# is a race condition between Arcus and PyQt. Importing Arcus
# first seems to prevent Sip from going into a state where it
# tries to create PyQt objects on a non-main thread.
import Arcus
import cura.CuraApplication
if sys.platform == "win32" and hasattr(sys, "frozen"):
import os
dirpath = os.path.expanduser("~/AppData/Local/cura/")
os.makedirs(dirpath, exist_ok = True)
sys.stdout = open(os.path.join(dirpath, "stdout.log"), "w")
sys.stderr = open(os.path.join(dirpath, "stderr.log"), "w")
app = cura.CuraApplication.CuraApplication.getInstance()
app.run()
| Rename type into hook_type "type" itself if a built-in function. Using this name could be unsave. | ## Code Before:
import sys
def exceptHook(type, value, traceback):
import cura.CrashHandler
cura.CrashHandler.show(type, value, traceback)
sys.excepthook = exceptHook
# Workaround for a race condition on certain systems where there
# is a race condition between Arcus and PyQt. Importing Arcus
# first seems to prevent Sip from going into a state where it
# tries to create PyQt objects on a non-main thread.
import Arcus
import cura.CuraApplication
if sys.platform == "win32" and hasattr(sys, "frozen"):
import os
dirpath = os.path.expanduser("~/AppData/Local/cura/")
os.makedirs(dirpath, exist_ok = True)
sys.stdout = open(os.path.join(dirpath, "stdout.log"), "w")
sys.stderr = open(os.path.join(dirpath, "stderr.log"), "w")
app = cura.CuraApplication.CuraApplication.getInstance()
app.run()
## Instruction:
Rename type into hook_type "type" itself if a built-in function. Using this name could be unsave.
## Code After:
import sys
def exceptHook(hook_type, value, traceback):
import cura.CrashHandler
cura.CrashHandler.show(hook_type, value, traceback)
sys.excepthook = exceptHook
# Workaround for a race condition on certain systems where there
# is a race condition between Arcus and PyQt. Importing Arcus
# first seems to prevent Sip from going into a state where it
# tries to create PyQt objects on a non-main thread.
import Arcus
import cura.CuraApplication
if sys.platform == "win32" and hasattr(sys, "frozen"):
import os
dirpath = os.path.expanduser("~/AppData/Local/cura/")
os.makedirs(dirpath, exist_ok = True)
sys.stdout = open(os.path.join(dirpath, "stdout.log"), "w")
sys.stderr = open(os.path.join(dirpath, "stderr.log"), "w")
app = cura.CuraApplication.CuraApplication.getInstance()
app.run()
|
import sys
- def exceptHook(type, value, traceback):
+ def exceptHook(hook_type, value, traceback):
? +++++
import cura.CrashHandler
- cura.CrashHandler.show(type, value, traceback)
+ cura.CrashHandler.show(hook_type, value, traceback)
? +++++
sys.excepthook = exceptHook
# Workaround for a race condition on certain systems where there
# is a race condition between Arcus and PyQt. Importing Arcus
# first seems to prevent Sip from going into a state where it
# tries to create PyQt objects on a non-main thread.
import Arcus
import cura.CuraApplication
if sys.platform == "win32" and hasattr(sys, "frozen"):
import os
dirpath = os.path.expanduser("~/AppData/Local/cura/")
os.makedirs(dirpath, exist_ok = True)
sys.stdout = open(os.path.join(dirpath, "stdout.log"), "w")
sys.stderr = open(os.path.join(dirpath, "stderr.log"), "w")
app = cura.CuraApplication.CuraApplication.getInstance()
app.run() |
b33222fd9d16efa88864d0c1f28cce9d0a8c3f68 | fastentrypoints.py | fastentrypoints.py | '''
Monkey patch setuptools to write faster console_scripts with this format:
from mymodule import entry_function
entry_function()
This is better.
'''
from setuptools.command import easy_install
@classmethod
def get_args(cls, dist, header=None):
"""
Yield write_script() argument tuples for a distribution's
console_scripts and gui_scripts entry points.
"""
template = 'import sys\nfrom {0} import {1}\nsys.exit({1}())'
if header is None:
header = cls.get_header()
spec = str(dist.as_requirement())
for type_ in 'console', 'gui':
group = type_ + '_scripts'
for name, ep in dist.get_entry_map(group).items():
cls._ensure_safe_name(name)
script_text = template.format(
ep.module_name, ep.attrs[0])
args = cls._get_script_args(type_, name, header, script_text)
for res in args:
yield res
easy_install.ScriptWriter.get_args = get_args
def main():
import shutil
import sys
dests = sys.argv[1:] or ['.']
print(__name__)
for dst in dests:
shutil.copy(__file__, dst)
with open(dst + '/MANIFEST.in', 'a') as manifest:
manifest.write('\ninclude fastentrypoints.py')
| '''
Monkey patch setuptools to write faster console_scripts with this format:
from mymodule import entry_function
entry_function()
This is better.
'''
from setuptools.command import easy_install
@classmethod
def get_args(cls, dist, header=None):
"""
Yield write_script() argument tuples for a distribution's
console_scripts and gui_scripts entry points.
"""
template = 'import sys\nfrom {0} import {1}\nsys.exit({1}())'
if header is None:
header = cls.get_header()
spec = str(dist.as_requirement())
for type_ in 'console', 'gui':
group = type_ + '_scripts'
for name, ep in dist.get_entry_map(group).items():
cls._ensure_safe_name(name)
script_text = template.format(
ep.module_name, ep.attrs[0])
args = cls._get_script_args(type_, name, header, script_text)
for res in args:
yield res
easy_install.ScriptWriter.get_args = get_args
def main():
import re
import shutil
import sys
dests = sys.argv[1:] or ['.']
filename = re.sub('\.pyc$', '.py', __file__)
for dst in dests:
shutil.copy(filename, dst)
with open(dst + '/MANIFEST.in', 'a') as manifest:
manifest.write('\ninclude fastentrypoints.py')
| Make sure that .py file is used, even if .pyc got executed | Make sure that .py file is used, even if .pyc got executed
If python already byte-compiled the source code to .pyc file,
the __file__ points to .pyc, rather than to .py, which breaks the
copying mechanism.
Use regex substitution to make sure we're always copying the original
source file.
| Python | bsd-2-clause | ninjaaron/fast-entry_points | '''
Monkey patch setuptools to write faster console_scripts with this format:
from mymodule import entry_function
entry_function()
This is better.
'''
from setuptools.command import easy_install
@classmethod
def get_args(cls, dist, header=None):
"""
Yield write_script() argument tuples for a distribution's
console_scripts and gui_scripts entry points.
"""
template = 'import sys\nfrom {0} import {1}\nsys.exit({1}())'
if header is None:
header = cls.get_header()
spec = str(dist.as_requirement())
for type_ in 'console', 'gui':
group = type_ + '_scripts'
for name, ep in dist.get_entry_map(group).items():
cls._ensure_safe_name(name)
script_text = template.format(
ep.module_name, ep.attrs[0])
args = cls._get_script_args(type_, name, header, script_text)
for res in args:
yield res
easy_install.ScriptWriter.get_args = get_args
def main():
+ import re
import shutil
import sys
dests = sys.argv[1:] or ['.']
- print(__name__)
+ filename = re.sub('\.pyc$', '.py', __file__)
for dst in dests:
- shutil.copy(__file__, dst)
+ shutil.copy(filename, dst)
with open(dst + '/MANIFEST.in', 'a') as manifest:
manifest.write('\ninclude fastentrypoints.py')
| Make sure that .py file is used, even if .pyc got executed | ## Code Before:
'''
Monkey patch setuptools to write faster console_scripts with this format:
from mymodule import entry_function
entry_function()
This is better.
'''
from setuptools.command import easy_install
@classmethod
def get_args(cls, dist, header=None):
"""
Yield write_script() argument tuples for a distribution's
console_scripts and gui_scripts entry points.
"""
template = 'import sys\nfrom {0} import {1}\nsys.exit({1}())'
if header is None:
header = cls.get_header()
spec = str(dist.as_requirement())
for type_ in 'console', 'gui':
group = type_ + '_scripts'
for name, ep in dist.get_entry_map(group).items():
cls._ensure_safe_name(name)
script_text = template.format(
ep.module_name, ep.attrs[0])
args = cls._get_script_args(type_, name, header, script_text)
for res in args:
yield res
easy_install.ScriptWriter.get_args = get_args
def main():
import shutil
import sys
dests = sys.argv[1:] or ['.']
print(__name__)
for dst in dests:
shutil.copy(__file__, dst)
with open(dst + '/MANIFEST.in', 'a') as manifest:
manifest.write('\ninclude fastentrypoints.py')
## Instruction:
Make sure that .py file is used, even if .pyc got executed
## Code After:
'''
Monkey patch setuptools to write faster console_scripts with this format:
from mymodule import entry_function
entry_function()
This is better.
'''
from setuptools.command import easy_install
@classmethod
def get_args(cls, dist, header=None):
"""
Yield write_script() argument tuples for a distribution's
console_scripts and gui_scripts entry points.
"""
template = 'import sys\nfrom {0} import {1}\nsys.exit({1}())'
if header is None:
header = cls.get_header()
spec = str(dist.as_requirement())
for type_ in 'console', 'gui':
group = type_ + '_scripts'
for name, ep in dist.get_entry_map(group).items():
cls._ensure_safe_name(name)
script_text = template.format(
ep.module_name, ep.attrs[0])
args = cls._get_script_args(type_, name, header, script_text)
for res in args:
yield res
easy_install.ScriptWriter.get_args = get_args
def main():
import re
import shutil
import sys
dests = sys.argv[1:] or ['.']
filename = re.sub('\.pyc$', '.py', __file__)
for dst in dests:
shutil.copy(filename, dst)
with open(dst + '/MANIFEST.in', 'a') as manifest:
manifest.write('\ninclude fastentrypoints.py')
| '''
Monkey patch setuptools to write faster console_scripts with this format:
from mymodule import entry_function
entry_function()
This is better.
'''
from setuptools.command import easy_install
@classmethod
def get_args(cls, dist, header=None):
"""
Yield write_script() argument tuples for a distribution's
console_scripts and gui_scripts entry points.
"""
template = 'import sys\nfrom {0} import {1}\nsys.exit({1}())'
if header is None:
header = cls.get_header()
spec = str(dist.as_requirement())
for type_ in 'console', 'gui':
group = type_ + '_scripts'
for name, ep in dist.get_entry_map(group).items():
cls._ensure_safe_name(name)
script_text = template.format(
ep.module_name, ep.attrs[0])
args = cls._get_script_args(type_, name, header, script_text)
for res in args:
yield res
easy_install.ScriptWriter.get_args = get_args
def main():
+ import re
import shutil
import sys
dests = sys.argv[1:] or ['.']
- print(__name__)
+ filename = re.sub('\.pyc$', '.py', __file__)
for dst in dests:
- shutil.copy(__file__, dst)
? -- ^^
+ shutil.copy(filename, dst)
? ^^^^
with open(dst + '/MANIFEST.in', 'a') as manifest:
manifest.write('\ninclude fastentrypoints.py') |
78807533031cf46acb5e73b695c0e492cf2c3e20 | gnsq/httpclient.py | gnsq/httpclient.py | from __future__ import absolute_import
import urllib3
try:
import simplejson as json
except ImportError:
import json # pyflakes.ignore
from .errors import NSQHttpError
class HTTPClient(object):
base_url = None
__http = None
@property
def http(self):
if self.__http is None:
self.__http = urllib3.connection_from_url(url=self.base_url)
return self.__http
def http_request(self, method, url, **kwargs):
response = self.http.request_encode_url(method, url, **kwargs)
if 'application/json' in response.getheader('content-type', ''):
return self._http_check_json(response)
return self._http_check(response)
def _http_check(self, response):
if response.status != 200:
raise NSQHttpError('http error <%s>' % response.status)
return response.data
def _http_check_json(self, response):
try:
data = json.loads(response.data)
except ValueError:
return self._http_check(response)
if response.status != 200:
status_txt = data.get('status_txt', 'http error')
raise NSQHttpError('%s <%s>' % (status_txt, response.status))
return data['data']
def http_get(self, url, **kwargs):
return self.http_request('GET', url, **kwargs)
def http_post(self, url, **kwargs):
return self.http_request('POST', url, **kwargs)
| from __future__ import absolute_import
import urllib3
try:
import simplejson as json
except ImportError:
import json # pyflakes.ignore
from .decorators import cached_property
from .errors import NSQHttpError
class HTTPClient(object):
@cached_property
def http(self):
return urllib3.connection_from_url(url=self.base_url)
def http_request(self, method, url, **kwargs):
response = self.http.request_encode_url(method, url, **kwargs)
if 'application/json' in response.getheader('content-type', ''):
return self._http_check_json(response)
return self._http_check(response)
def _http_check(self, response):
if response.status != 200:
raise NSQHttpError('http error <%s>' % response.status)
return response.data
def _http_check_json(self, response):
try:
data = json.loads(response.data)
except ValueError:
return self._http_check(response)
if response.status != 200:
status_txt = data.get('status_txt', 'http error')
raise NSQHttpError('%s <%s>' % (status_txt, response.status))
return data['data']
def http_get(self, url, **kwargs):
return self.http_request('GET', url, **kwargs)
def http_post(self, url, **kwargs):
return self.http_request('POST', url, **kwargs)
| Use cached property decorator connection pool. | Use cached property decorator connection pool.
| Python | bsd-3-clause | hiringsolved/gnsq,wtolson/gnsq,wtolson/gnsq | from __future__ import absolute_import
import urllib3
try:
import simplejson as json
except ImportError:
import json # pyflakes.ignore
+ from .decorators import cached_property
from .errors import NSQHttpError
class HTTPClient(object):
- base_url = None
- __http = None
-
- @property
+ @cached_property
def http(self):
- if self.__http is None:
- self.__http = urllib3.connection_from_url(url=self.base_url)
+ return urllib3.connection_from_url(url=self.base_url)
- return self.__http
def http_request(self, method, url, **kwargs):
response = self.http.request_encode_url(method, url, **kwargs)
if 'application/json' in response.getheader('content-type', ''):
return self._http_check_json(response)
return self._http_check(response)
def _http_check(self, response):
if response.status != 200:
raise NSQHttpError('http error <%s>' % response.status)
return response.data
def _http_check_json(self, response):
try:
data = json.loads(response.data)
except ValueError:
return self._http_check(response)
if response.status != 200:
status_txt = data.get('status_txt', 'http error')
raise NSQHttpError('%s <%s>' % (status_txt, response.status))
return data['data']
def http_get(self, url, **kwargs):
return self.http_request('GET', url, **kwargs)
def http_post(self, url, **kwargs):
return self.http_request('POST', url, **kwargs)
| Use cached property decorator connection pool. | ## Code Before:
from __future__ import absolute_import
import urllib3
try:
import simplejson as json
except ImportError:
import json # pyflakes.ignore
from .errors import NSQHttpError
class HTTPClient(object):
base_url = None
__http = None
@property
def http(self):
if self.__http is None:
self.__http = urllib3.connection_from_url(url=self.base_url)
return self.__http
def http_request(self, method, url, **kwargs):
response = self.http.request_encode_url(method, url, **kwargs)
if 'application/json' in response.getheader('content-type', ''):
return self._http_check_json(response)
return self._http_check(response)
def _http_check(self, response):
if response.status != 200:
raise NSQHttpError('http error <%s>' % response.status)
return response.data
def _http_check_json(self, response):
try:
data = json.loads(response.data)
except ValueError:
return self._http_check(response)
if response.status != 200:
status_txt = data.get('status_txt', 'http error')
raise NSQHttpError('%s <%s>' % (status_txt, response.status))
return data['data']
def http_get(self, url, **kwargs):
return self.http_request('GET', url, **kwargs)
def http_post(self, url, **kwargs):
return self.http_request('POST', url, **kwargs)
## Instruction:
Use cached property decorator connection pool.
## Code After:
from __future__ import absolute_import
import urllib3
try:
import simplejson as json
except ImportError:
import json # pyflakes.ignore
from .decorators import cached_property
from .errors import NSQHttpError
class HTTPClient(object):
@cached_property
def http(self):
return urllib3.connection_from_url(url=self.base_url)
def http_request(self, method, url, **kwargs):
response = self.http.request_encode_url(method, url, **kwargs)
if 'application/json' in response.getheader('content-type', ''):
return self._http_check_json(response)
return self._http_check(response)
def _http_check(self, response):
if response.status != 200:
raise NSQHttpError('http error <%s>' % response.status)
return response.data
def _http_check_json(self, response):
try:
data = json.loads(response.data)
except ValueError:
return self._http_check(response)
if response.status != 200:
status_txt = data.get('status_txt', 'http error')
raise NSQHttpError('%s <%s>' % (status_txt, response.status))
return data['data']
def http_get(self, url, **kwargs):
return self.http_request('GET', url, **kwargs)
def http_post(self, url, **kwargs):
return self.http_request('POST', url, **kwargs)
| from __future__ import absolute_import
import urllib3
try:
import simplejson as json
except ImportError:
import json # pyflakes.ignore
+ from .decorators import cached_property
from .errors import NSQHttpError
class HTTPClient(object):
- base_url = None
- __http = None
-
- @property
+ @cached_property
? +++++++
def http(self):
- if self.__http is None:
- self.__http = urllib3.connection_from_url(url=self.base_url)
? ^^^^^ ------ ^^^^
+ return urllib3.connection_from_url(url=self.base_url)
? ^ ^^^
- return self.__http
def http_request(self, method, url, **kwargs):
response = self.http.request_encode_url(method, url, **kwargs)
if 'application/json' in response.getheader('content-type', ''):
return self._http_check_json(response)
return self._http_check(response)
def _http_check(self, response):
if response.status != 200:
raise NSQHttpError('http error <%s>' % response.status)
return response.data
def _http_check_json(self, response):
try:
data = json.loads(response.data)
except ValueError:
return self._http_check(response)
if response.status != 200:
status_txt = data.get('status_txt', 'http error')
raise NSQHttpError('%s <%s>' % (status_txt, response.status))
return data['data']
def http_get(self, url, **kwargs):
return self.http_request('GET', url, **kwargs)
def http_post(self, url, **kwargs):
return self.http_request('POST', url, **kwargs) |
fdd57913aa11c29ecf160f32a9091e59de598899 | plugins/YTranslate.py | plugins/YTranslate.py | import logging
from urllib.parse import quote
from telegram import Bot, Update
from telegram.ext import Updater
from requests import post
import constants # pylint: disable=E0401
import settings
LOGGER = logging.getLogger("YTranslate")
YAURL = "https://translate.yandex.net/api/v1.5/tr.json/translate?"
YAURL += "key=%s" % settings.YANDEX_TRANSLATION_TOKEN
def preload(updater: Updater, level):
"""
This loads whenever plugin starts
Even if you dont need it, you SHOULD put at least
return None, otherwise your plugin wont load
"""
return
def translate(bot: Bot, update: Update, user, args): # pylint: disable=W0613
"""/tl"""
if update.message.reply_to_message:
if len(args) > 0:
lang = args[0].lower()
else:
lang = "en"
yandex = post(YAURL, params={"text":update.message.reply_to_message.text, "lang":lang}).json()
try:
return yandex["lang"].upper() + "\n" + yandex["text"][0], constants.TEXT
except KeyError:
return "Unknown language:%s" % args[0].upper(), constants.TEXT
COMMANDS = [
{
"command":"/tl",
"function":translate,
"description":"Translates message to english. Example: [In Reply To Message] /tl",
"inline_support":True
}
]
| import logging
from urllib.parse import quote
from telegram import Bot, Update
from telegram.ext import Updater
from requests import post
import constants # pylint: disable=E0401
import settings
import octeon
LOGGER = logging.getLogger("YTranslate")
YAURL = "https://translate.yandex.net/api/v1.5/tr.json/translate?"
YAURL += "key=%s" % settings.YANDEX_TRANSLATION_TOKEN
def preload(updater: Updater, level):
"""
This loads whenever plugin starts
Even if you dont need it, you SHOULD put at least
return None, otherwise your plugin wont load
"""
return
def translate(bot: Bot, update: Update, user, args): # pylint: disable=W0613
"""/tl"""
if update.message.reply_to_message:
if len(args) > 0:
lang = args[0].lower()
else:
lang = "en"
yandex = post(YAURL, params={"text":update.message.reply_to_message.text, "lang":lang}).json()
try:
return octeon.message(yandex["lang"].upper() + "\n" + yandex["text"][0])
except KeyError:
return octeon.message(yandex["error"], failed=True)
COMMANDS = [
{
"command":"/tl",
"function":translate,
"description":"Translates message to english. Example: [In Reply To Message] /tl",
"inline_support":True
}
]
| Update translate plugin to new message format | Update translate plugin to new message format
| Python | mit | ProtoxiDe22/Octeon | import logging
from urllib.parse import quote
from telegram import Bot, Update
from telegram.ext import Updater
from requests import post
import constants # pylint: disable=E0401
import settings
+ import octeon
LOGGER = logging.getLogger("YTranslate")
YAURL = "https://translate.yandex.net/api/v1.5/tr.json/translate?"
YAURL += "key=%s" % settings.YANDEX_TRANSLATION_TOKEN
def preload(updater: Updater, level):
"""
This loads whenever plugin starts
Even if you dont need it, you SHOULD put at least
return None, otherwise your plugin wont load
"""
return
def translate(bot: Bot, update: Update, user, args): # pylint: disable=W0613
"""/tl"""
if update.message.reply_to_message:
if len(args) > 0:
lang = args[0].lower()
else:
lang = "en"
yandex = post(YAURL, params={"text":update.message.reply_to_message.text, "lang":lang}).json()
try:
- return yandex["lang"].upper() + "\n" + yandex["text"][0], constants.TEXT
+ return octeon.message(yandex["lang"].upper() + "\n" + yandex["text"][0])
except KeyError:
- return "Unknown language:%s" % args[0].upper(), constants.TEXT
+ return octeon.message(yandex["error"], failed=True)
COMMANDS = [
{
"command":"/tl",
"function":translate,
"description":"Translates message to english. Example: [In Reply To Message] /tl",
"inline_support":True
}
]
| Update translate plugin to new message format | ## Code Before:
import logging
from urllib.parse import quote
from telegram import Bot, Update
from telegram.ext import Updater
from requests import post
import constants # pylint: disable=E0401
import settings
LOGGER = logging.getLogger("YTranslate")
YAURL = "https://translate.yandex.net/api/v1.5/tr.json/translate?"
YAURL += "key=%s" % settings.YANDEX_TRANSLATION_TOKEN
def preload(updater: Updater, level):
"""
This loads whenever plugin starts
Even if you dont need it, you SHOULD put at least
return None, otherwise your plugin wont load
"""
return
def translate(bot: Bot, update: Update, user, args): # pylint: disable=W0613
"""/tl"""
if update.message.reply_to_message:
if len(args) > 0:
lang = args[0].lower()
else:
lang = "en"
yandex = post(YAURL, params={"text":update.message.reply_to_message.text, "lang":lang}).json()
try:
return yandex["lang"].upper() + "\n" + yandex["text"][0], constants.TEXT
except KeyError:
return "Unknown language:%s" % args[0].upper(), constants.TEXT
COMMANDS = [
{
"command":"/tl",
"function":translate,
"description":"Translates message to english. Example: [In Reply To Message] /tl",
"inline_support":True
}
]
## Instruction:
Update translate plugin to new message format
## Code After:
import logging
from urllib.parse import quote
from telegram import Bot, Update
from telegram.ext import Updater
from requests import post
import constants # pylint: disable=E0401
import settings
import octeon
LOGGER = logging.getLogger("YTranslate")
YAURL = "https://translate.yandex.net/api/v1.5/tr.json/translate?"
YAURL += "key=%s" % settings.YANDEX_TRANSLATION_TOKEN
def preload(updater: Updater, level):
"""
This loads whenever plugin starts
Even if you dont need it, you SHOULD put at least
return None, otherwise your plugin wont load
"""
return
def translate(bot: Bot, update: Update, user, args): # pylint: disable=W0613
"""/tl"""
if update.message.reply_to_message:
if len(args) > 0:
lang = args[0].lower()
else:
lang = "en"
yandex = post(YAURL, params={"text":update.message.reply_to_message.text, "lang":lang}).json()
try:
return octeon.message(yandex["lang"].upper() + "\n" + yandex["text"][0])
except KeyError:
return octeon.message(yandex["error"], failed=True)
COMMANDS = [
{
"command":"/tl",
"function":translate,
"description":"Translates message to english. Example: [In Reply To Message] /tl",
"inline_support":True
}
]
| import logging
from urllib.parse import quote
from telegram import Bot, Update
from telegram.ext import Updater
from requests import post
import constants # pylint: disable=E0401
import settings
+ import octeon
LOGGER = logging.getLogger("YTranslate")
YAURL = "https://translate.yandex.net/api/v1.5/tr.json/translate?"
YAURL += "key=%s" % settings.YANDEX_TRANSLATION_TOKEN
def preload(updater: Updater, level):
"""
This loads whenever plugin starts
Even if you dont need it, you SHOULD put at least
return None, otherwise your plugin wont load
"""
return
def translate(bot: Bot, update: Update, user, args): # pylint: disable=W0613
"""/tl"""
if update.message.reply_to_message:
if len(args) > 0:
lang = args[0].lower()
else:
lang = "en"
yandex = post(YAURL, params={"text":update.message.reply_to_message.text, "lang":lang}).json()
try:
- return yandex["lang"].upper() + "\n" + yandex["text"][0], constants.TEXT
? ^^^^^^^^^^^^^^^^
+ return octeon.message(yandex["lang"].upper() + "\n" + yandex["text"][0])
? +++++++++++++++ ^
except KeyError:
- return "Unknown language:%s" % args[0].upper(), constants.TEXT
+ return octeon.message(yandex["error"], failed=True)
COMMANDS = [
{
"command":"/tl",
"function":translate,
"description":"Translates message to english. Example: [In Reply To Message] /tl",
"inline_support":True
}
] |
116d9565050ad69888cb38c302f8ae0d9232eec3 | gameserver/utils.py | gameserver/utils.py | import random as orig_random
from decorator import decorator
import binascii
import struct
import hashlib
from gameserver.database import db
db_session = db.session
random = orig_random.Random()
random.seed()
def node_to_dict(node):
connections = []
for edge in node.lower_edges:
connections.append(
{"to_id": edge.higher_node.id,
"from_id": node.id,
"weight": "{:.2f}".format(edge.weight),
}
)
data = {"id": node.id,
"name": node.name,
"short_name": node.short_name,
"group": node.group,
"leakage": "{:.2f}".format(node.leak),
"max_amount": "{:.2f}".format(node.max_level),
"activation_amount": "{:.2f}".format(node.activation),
"balance": "{:.2f}".format(node.balance),
"connections": connections
}
return data
def pack_amount(value):
return binascii.hexlify(struct.pack("f", value)).decode('ascii')
def unpack_amount(value):
return struct.unpack("f", binascii.unhexlify(value))[0]
def checksum(seller_id, policy_id, price, salt):
input = "{}{}{}{}".format(seller_id, policy_id, pack_amount(price), salt)
return hashlib.sha1(input).hexdigest()
| import random as orig_random
from decorator import decorator
import binascii
import struct
import hashlib
from gameserver.database import db
db_session = db.session
random = orig_random.Random()
random.seed()
def node_to_dict(node):
connections = []
for edge in node.lower_edges:
connections.append(
{"to_id": edge.higher_node.id,
"from_id": node.id,
"weight": "{:.2f}".format(edge.weight),
}
)
data = {"id": node.id,
"name": node.name,
"short_name": node.short_name,
"group": node.group,
"leakage": "{:.2f}".format(node.leak),
"max_amount": "{:.2f}".format(node.max_level),
"activation_amount": "{:.2f}".format(node.activation),
"active_level": "{:.2f}".format(node.active_level),
"balance": "{:.2f}".format(node.balance),
"connections": connections
}
return data
def pack_amount(value):
return binascii.hexlify(struct.pack("f", value)).decode('ascii')
def unpack_amount(value):
return struct.unpack("f", binascii.unhexlify(value))[0]
def checksum(seller_id, policy_id, price, salt):
input = "{}{}{}{}".format(seller_id, policy_id, pack_amount(price), salt)
return hashlib.sha1(input).hexdigest()
| Add in the active level to json output for the mobile game to use | Add in the active level to json output for the mobile game to use
| Python | apache-2.0 | hammertoe/didactic-spork,hammertoe/didactic-spork,hammertoe/didactic-spork,hammertoe/didactic-spork | import random as orig_random
from decorator import decorator
import binascii
import struct
import hashlib
from gameserver.database import db
db_session = db.session
random = orig_random.Random()
random.seed()
def node_to_dict(node):
connections = []
for edge in node.lower_edges:
connections.append(
{"to_id": edge.higher_node.id,
"from_id": node.id,
"weight": "{:.2f}".format(edge.weight),
}
)
data = {"id": node.id,
"name": node.name,
"short_name": node.short_name,
"group": node.group,
"leakage": "{:.2f}".format(node.leak),
"max_amount": "{:.2f}".format(node.max_level),
"activation_amount": "{:.2f}".format(node.activation),
+ "active_level": "{:.2f}".format(node.active_level),
"balance": "{:.2f}".format(node.balance),
"connections": connections
}
return data
def pack_amount(value):
return binascii.hexlify(struct.pack("f", value)).decode('ascii')
def unpack_amount(value):
return struct.unpack("f", binascii.unhexlify(value))[0]
def checksum(seller_id, policy_id, price, salt):
input = "{}{}{}{}".format(seller_id, policy_id, pack_amount(price), salt)
return hashlib.sha1(input).hexdigest()
| Add in the active level to json output for the mobile game to use | ## Code Before:
import random as orig_random
from decorator import decorator
import binascii
import struct
import hashlib
from gameserver.database import db
db_session = db.session
random = orig_random.Random()
random.seed()
def node_to_dict(node):
connections = []
for edge in node.lower_edges:
connections.append(
{"to_id": edge.higher_node.id,
"from_id": node.id,
"weight": "{:.2f}".format(edge.weight),
}
)
data = {"id": node.id,
"name": node.name,
"short_name": node.short_name,
"group": node.group,
"leakage": "{:.2f}".format(node.leak),
"max_amount": "{:.2f}".format(node.max_level),
"activation_amount": "{:.2f}".format(node.activation),
"balance": "{:.2f}".format(node.balance),
"connections": connections
}
return data
def pack_amount(value):
return binascii.hexlify(struct.pack("f", value)).decode('ascii')
def unpack_amount(value):
return struct.unpack("f", binascii.unhexlify(value))[0]
def checksum(seller_id, policy_id, price, salt):
input = "{}{}{}{}".format(seller_id, policy_id, pack_amount(price), salt)
return hashlib.sha1(input).hexdigest()
## Instruction:
Add in the active level to json output for the mobile game to use
## Code After:
import random as orig_random
from decorator import decorator
import binascii
import struct
import hashlib
from gameserver.database import db
db_session = db.session
random = orig_random.Random()
random.seed()
def node_to_dict(node):
connections = []
for edge in node.lower_edges:
connections.append(
{"to_id": edge.higher_node.id,
"from_id": node.id,
"weight": "{:.2f}".format(edge.weight),
}
)
data = {"id": node.id,
"name": node.name,
"short_name": node.short_name,
"group": node.group,
"leakage": "{:.2f}".format(node.leak),
"max_amount": "{:.2f}".format(node.max_level),
"activation_amount": "{:.2f}".format(node.activation),
"active_level": "{:.2f}".format(node.active_level),
"balance": "{:.2f}".format(node.balance),
"connections": connections
}
return data
def pack_amount(value):
return binascii.hexlify(struct.pack("f", value)).decode('ascii')
def unpack_amount(value):
return struct.unpack("f", binascii.unhexlify(value))[0]
def checksum(seller_id, policy_id, price, salt):
input = "{}{}{}{}".format(seller_id, policy_id, pack_amount(price), salt)
return hashlib.sha1(input).hexdigest()
| import random as orig_random
from decorator import decorator
import binascii
import struct
import hashlib
from gameserver.database import db
db_session = db.session
random = orig_random.Random()
random.seed()
def node_to_dict(node):
connections = []
for edge in node.lower_edges:
connections.append(
{"to_id": edge.higher_node.id,
"from_id": node.id,
"weight": "{:.2f}".format(edge.weight),
}
)
data = {"id": node.id,
"name": node.name,
"short_name": node.short_name,
"group": node.group,
"leakage": "{:.2f}".format(node.leak),
"max_amount": "{:.2f}".format(node.max_level),
"activation_amount": "{:.2f}".format(node.activation),
+ "active_level": "{:.2f}".format(node.active_level),
"balance": "{:.2f}".format(node.balance),
"connections": connections
}
return data
def pack_amount(value):
return binascii.hexlify(struct.pack("f", value)).decode('ascii')
def unpack_amount(value):
return struct.unpack("f", binascii.unhexlify(value))[0]
def checksum(seller_id, policy_id, price, salt):
input = "{}{}{}{}".format(seller_id, policy_id, pack_amount(price), salt)
return hashlib.sha1(input).hexdigest() |
562a0868b3648e3ba40c29289ba7f4ebd4c75800 | pyinfra/api/__init__.py | pyinfra/api/__init__.py |
from .config import Config # noqa: F401
from .deploy import deploy # noqa: F401
from .exceptions import ( # noqa: F401
DeployError,
InventoryError,
OperationError,
)
from .facts import FactBase # noqa: F401
from .inventory import Inventory # noqa: F401
from .operation import operation # noqa: F401
from .state import State # noqa: F401
|
from .config import Config # noqa: F401
from .deploy import deploy # noqa: F401
from .exceptions import ( # noqa: F401
DeployError,
InventoryError,
OperationError,
)
from .facts import FactBase, ShortFactBase # noqa: F401
from .inventory import Inventory # noqa: F401
from .operation import operation # noqa: F401
from .state import State # noqa: F401
| Add `ShortFactBase` import to `pyinfra.api`. | Add `ShortFactBase` import to `pyinfra.api`.
| Python | mit | Fizzadar/pyinfra,Fizzadar/pyinfra |
from .config import Config # noqa: F401
from .deploy import deploy # noqa: F401
from .exceptions import ( # noqa: F401
DeployError,
InventoryError,
OperationError,
)
- from .facts import FactBase # noqa: F401
+ from .facts import FactBase, ShortFactBase # noqa: F401
from .inventory import Inventory # noqa: F401
from .operation import operation # noqa: F401
from .state import State # noqa: F401
| Add `ShortFactBase` import to `pyinfra.api`. | ## Code Before:
from .config import Config # noqa: F401
from .deploy import deploy # noqa: F401
from .exceptions import ( # noqa: F401
DeployError,
InventoryError,
OperationError,
)
from .facts import FactBase # noqa: F401
from .inventory import Inventory # noqa: F401
from .operation import operation # noqa: F401
from .state import State # noqa: F401
## Instruction:
Add `ShortFactBase` import to `pyinfra.api`.
## Code After:
from .config import Config # noqa: F401
from .deploy import deploy # noqa: F401
from .exceptions import ( # noqa: F401
DeployError,
InventoryError,
OperationError,
)
from .facts import FactBase, ShortFactBase # noqa: F401
from .inventory import Inventory # noqa: F401
from .operation import operation # noqa: F401
from .state import State # noqa: F401
|
from .config import Config # noqa: F401
from .deploy import deploy # noqa: F401
from .exceptions import ( # noqa: F401
DeployError,
InventoryError,
OperationError,
)
- from .facts import FactBase # noqa: F401
+ from .facts import FactBase, ShortFactBase # noqa: F401
? +++++++++++++++
from .inventory import Inventory # noqa: F401
from .operation import operation # noqa: F401
from .state import State # noqa: F401 |
7574528d839dc627ea53032b547e0e1c23a51f6b | rdioexport/_client/__init__.py | rdioexport/_client/__init__.py | import json
from ._base import get_base_rdio_client
class _RdioExportClient(object):
def __init__(self, base_client):
self.base_client = base_client
def get_current_user_key(self):
return self.base_client.call('currentUser')['key']
def get_collection_by_album(self, batch_size=100):
current_user_key = self.get_current_user_key()
start = 0
result = []
while True:
batch = self.base_client.call(
'getAlbumsInCollection',
user=current_user_key,
sort='dateAdded',
start=start,
count=batch_size,
extras=json.dumps([
{'field': '*', 'exclude': True},
{'field': 'key'},
{'field': 'artist'},
{'field': 'trackKeys'},
]),
)
for album in batch:
yield album
if (len(batch) < batch_size):
break
else:
start += batch_size
def get_album_data(self, album_key):
return self.base_client.call(
'get',
keys=album_key,
extras=json.dumps([
{'field': '*'},
{
'field': 'track',
'extras': [
{'field': '*'},
],
},
]),
)
def get_rdio_client():
base_client = get_base_rdio_client()
return _RdioExportClient(base_client)
| import json
from ._base import get_base_rdio_client
class _RdioExportClient(object):
def __init__(self, base_client):
self.base_client = base_client
def get_current_user_key(self):
return self.base_client.call('currentUser')['key']
def get_collection_by_album(self, batch_size=100):
current_user_key = self.get_current_user_key()
start = 0
result = []
while True:
batch = self.base_client.call(
'getAlbumsInCollection',
user=current_user_key,
sort='dateAdded',
start=start,
count=batch_size,
extras=json.dumps([
{'field': '*', 'exclude': True},
{'field': 'key'},
{'field': 'trackKeys'},
]),
)
for album in batch:
yield album
if (len(batch) < batch_size):
break
else:
start += batch_size
def get_album_data(self, album_key):
return self.base_client.call(
'get',
keys=album_key,
extras=json.dumps([
{'field': '*'},
{
'field': 'track',
'extras': [
{'field': '*'},
],
},
]),
)
def get_rdio_client():
base_client = get_base_rdio_client()
return _RdioExportClient(base_client)
| Remove unused field from request. | Remove unused field from request.
| Python | isc | alexhanson/rdio-export | import json
from ._base import get_base_rdio_client
class _RdioExportClient(object):
def __init__(self, base_client):
self.base_client = base_client
def get_current_user_key(self):
return self.base_client.call('currentUser')['key']
def get_collection_by_album(self, batch_size=100):
current_user_key = self.get_current_user_key()
start = 0
result = []
while True:
batch = self.base_client.call(
'getAlbumsInCollection',
user=current_user_key,
sort='dateAdded',
start=start,
count=batch_size,
extras=json.dumps([
{'field': '*', 'exclude': True},
{'field': 'key'},
- {'field': 'artist'},
{'field': 'trackKeys'},
]),
)
for album in batch:
yield album
if (len(batch) < batch_size):
break
else:
start += batch_size
def get_album_data(self, album_key):
return self.base_client.call(
'get',
keys=album_key,
extras=json.dumps([
{'field': '*'},
{
'field': 'track',
'extras': [
{'field': '*'},
],
},
]),
)
def get_rdio_client():
base_client = get_base_rdio_client()
return _RdioExportClient(base_client)
| Remove unused field from request. | ## Code Before:
import json
from ._base import get_base_rdio_client
class _RdioExportClient(object):
def __init__(self, base_client):
self.base_client = base_client
def get_current_user_key(self):
return self.base_client.call('currentUser')['key']
def get_collection_by_album(self, batch_size=100):
current_user_key = self.get_current_user_key()
start = 0
result = []
while True:
batch = self.base_client.call(
'getAlbumsInCollection',
user=current_user_key,
sort='dateAdded',
start=start,
count=batch_size,
extras=json.dumps([
{'field': '*', 'exclude': True},
{'field': 'key'},
{'field': 'artist'},
{'field': 'trackKeys'},
]),
)
for album in batch:
yield album
if (len(batch) < batch_size):
break
else:
start += batch_size
def get_album_data(self, album_key):
return self.base_client.call(
'get',
keys=album_key,
extras=json.dumps([
{'field': '*'},
{
'field': 'track',
'extras': [
{'field': '*'},
],
},
]),
)
def get_rdio_client():
base_client = get_base_rdio_client()
return _RdioExportClient(base_client)
## Instruction:
Remove unused field from request.
## Code After:
import json
from ._base import get_base_rdio_client
class _RdioExportClient(object):
def __init__(self, base_client):
self.base_client = base_client
def get_current_user_key(self):
return self.base_client.call('currentUser')['key']
def get_collection_by_album(self, batch_size=100):
current_user_key = self.get_current_user_key()
start = 0
result = []
while True:
batch = self.base_client.call(
'getAlbumsInCollection',
user=current_user_key,
sort='dateAdded',
start=start,
count=batch_size,
extras=json.dumps([
{'field': '*', 'exclude': True},
{'field': 'key'},
{'field': 'trackKeys'},
]),
)
for album in batch:
yield album
if (len(batch) < batch_size):
break
else:
start += batch_size
def get_album_data(self, album_key):
return self.base_client.call(
'get',
keys=album_key,
extras=json.dumps([
{'field': '*'},
{
'field': 'track',
'extras': [
{'field': '*'},
],
},
]),
)
def get_rdio_client():
base_client = get_base_rdio_client()
return _RdioExportClient(base_client)
| import json
from ._base import get_base_rdio_client
class _RdioExportClient(object):
def __init__(self, base_client):
self.base_client = base_client
def get_current_user_key(self):
return self.base_client.call('currentUser')['key']
def get_collection_by_album(self, batch_size=100):
current_user_key = self.get_current_user_key()
start = 0
result = []
while True:
batch = self.base_client.call(
'getAlbumsInCollection',
user=current_user_key,
sort='dateAdded',
start=start,
count=batch_size,
extras=json.dumps([
{'field': '*', 'exclude': True},
{'field': 'key'},
- {'field': 'artist'},
{'field': 'trackKeys'},
]),
)
for album in batch:
yield album
if (len(batch) < batch_size):
break
else:
start += batch_size
def get_album_data(self, album_key):
return self.base_client.call(
'get',
keys=album_key,
extras=json.dumps([
{'field': '*'},
{
'field': 'track',
'extras': [
{'field': '*'},
],
},
]),
)
def get_rdio_client():
base_client = get_base_rdio_client()
return _RdioExportClient(base_client) |
d98cdb7eae40b5bb11b5d1fc0eacc35ef6bf310d | wye/reports/views.py | wye/reports/views.py | from django.shortcuts import render
from django.contrib.auth.decorators import login_required
from wye.organisations.models import Organisation
from wye.workshops.models import Workshop
from wye.profiles.models import Profile
import datetime
from wye.base.constants import WorkshopStatus
@login_required
def index(request, days):
print(request.user.is_staff)
if not request.user.is_staff:
return ""
d = datetime.datetime.now() - datetime.timedelta(days=int(days))
organisations = Organisation.objects.filter(
active=True).filter(created_at__gte=d)
workshops = Workshop.objects.filter(
is_active=True).filter(
expected_date__gte=d).filter(
expected_date__lt=datetime.datetime.now()).filter(
status__in=[WorkshopStatus.COMPLETED,
WorkshopStatus.FEEDBACK_PENDING])
profiles = Profile.objects.filter(user__date_joined__gte=d)
no_of_participants = sum([w.no_of_participants for w in workshops])
template_name = 'reports/index.html'
context_dict = {}
context_dict['organisations'] = organisations
context_dict['workshops'] = workshops
context_dict['profiles'] = profiles
context_dict['no_of_participants'] = no_of_participants
context_dict['date'] = d
workshops = Workshop.objects.filter(
is_active=True)
return render(request, template_name, context_dict)
| from django.shortcuts import render
from django.contrib.auth.decorators import login_required
from wye.organisations.models import Organisation
from wye.workshops.models import Workshop
from wye.profiles.models import Profile
import datetime
from wye.base.constants import WorkshopStatus
@login_required
def index(request, days):
print(request.user.is_staff)
if not request.user.is_staff:
return ""
d = datetime.datetime.now() - datetime.timedelta(days=int(days))
organisations = Organisation.objects.filter(
active=True).filter(created_at__gte=d)
workshops = Workshop.objects.filter(
is_active=True).filter(
expected_date__gte=d).filter(
expected_date__lt=datetime.datetime.now()).filter(
status__in=[WorkshopStatus.COMPLETED,
WorkshopStatus.FEEDBACK_PENDING]).order_by('expected_date')
profiles = Profile.objects.filter(user__date_joined__gte=d)
no_of_participants = sum([w.no_of_participants for w in workshops])
template_name = 'reports/index.html'
context_dict = {}
context_dict['organisations'] = organisations
context_dict['workshops'] = workshops
context_dict['profiles'] = profiles
context_dict['no_of_participants'] = no_of_participants
context_dict['date'] = d
workshops = Workshop.objects.filter(
is_active=True)
return render(request, template_name, context_dict)
| Order filter for report page | Order filter for report page
| Python | mit | pythonindia/wye,pythonindia/wye,pythonindia/wye,pythonindia/wye | from django.shortcuts import render
from django.contrib.auth.decorators import login_required
from wye.organisations.models import Organisation
from wye.workshops.models import Workshop
from wye.profiles.models import Profile
import datetime
from wye.base.constants import WorkshopStatus
@login_required
def index(request, days):
print(request.user.is_staff)
if not request.user.is_staff:
return ""
d = datetime.datetime.now() - datetime.timedelta(days=int(days))
organisations = Organisation.objects.filter(
active=True).filter(created_at__gte=d)
workshops = Workshop.objects.filter(
is_active=True).filter(
expected_date__gte=d).filter(
expected_date__lt=datetime.datetime.now()).filter(
status__in=[WorkshopStatus.COMPLETED,
- WorkshopStatus.FEEDBACK_PENDING])
+ WorkshopStatus.FEEDBACK_PENDING]).order_by('expected_date')
profiles = Profile.objects.filter(user__date_joined__gte=d)
no_of_participants = sum([w.no_of_participants for w in workshops])
template_name = 'reports/index.html'
context_dict = {}
context_dict['organisations'] = organisations
context_dict['workshops'] = workshops
context_dict['profiles'] = profiles
context_dict['no_of_participants'] = no_of_participants
context_dict['date'] = d
workshops = Workshop.objects.filter(
is_active=True)
return render(request, template_name, context_dict)
| Order filter for report page | ## Code Before:
from django.shortcuts import render
from django.contrib.auth.decorators import login_required
from wye.organisations.models import Organisation
from wye.workshops.models import Workshop
from wye.profiles.models import Profile
import datetime
from wye.base.constants import WorkshopStatus
@login_required
def index(request, days):
print(request.user.is_staff)
if not request.user.is_staff:
return ""
d = datetime.datetime.now() - datetime.timedelta(days=int(days))
organisations = Organisation.objects.filter(
active=True).filter(created_at__gte=d)
workshops = Workshop.objects.filter(
is_active=True).filter(
expected_date__gte=d).filter(
expected_date__lt=datetime.datetime.now()).filter(
status__in=[WorkshopStatus.COMPLETED,
WorkshopStatus.FEEDBACK_PENDING])
profiles = Profile.objects.filter(user__date_joined__gte=d)
no_of_participants = sum([w.no_of_participants for w in workshops])
template_name = 'reports/index.html'
context_dict = {}
context_dict['organisations'] = organisations
context_dict['workshops'] = workshops
context_dict['profiles'] = profiles
context_dict['no_of_participants'] = no_of_participants
context_dict['date'] = d
workshops = Workshop.objects.filter(
is_active=True)
return render(request, template_name, context_dict)
## Instruction:
Order filter for report page
## Code After:
from django.shortcuts import render
from django.contrib.auth.decorators import login_required
from wye.organisations.models import Organisation
from wye.workshops.models import Workshop
from wye.profiles.models import Profile
import datetime
from wye.base.constants import WorkshopStatus
@login_required
def index(request, days):
print(request.user.is_staff)
if not request.user.is_staff:
return ""
d = datetime.datetime.now() - datetime.timedelta(days=int(days))
organisations = Organisation.objects.filter(
active=True).filter(created_at__gte=d)
workshops = Workshop.objects.filter(
is_active=True).filter(
expected_date__gte=d).filter(
expected_date__lt=datetime.datetime.now()).filter(
status__in=[WorkshopStatus.COMPLETED,
WorkshopStatus.FEEDBACK_PENDING]).order_by('expected_date')
profiles = Profile.objects.filter(user__date_joined__gte=d)
no_of_participants = sum([w.no_of_participants for w in workshops])
template_name = 'reports/index.html'
context_dict = {}
context_dict['organisations'] = organisations
context_dict['workshops'] = workshops
context_dict['profiles'] = profiles
context_dict['no_of_participants'] = no_of_participants
context_dict['date'] = d
workshops = Workshop.objects.filter(
is_active=True)
return render(request, template_name, context_dict)
| from django.shortcuts import render
from django.contrib.auth.decorators import login_required
from wye.organisations.models import Organisation
from wye.workshops.models import Workshop
from wye.profiles.models import Profile
import datetime
from wye.base.constants import WorkshopStatus
@login_required
def index(request, days):
print(request.user.is_staff)
if not request.user.is_staff:
return ""
d = datetime.datetime.now() - datetime.timedelta(days=int(days))
organisations = Organisation.objects.filter(
active=True).filter(created_at__gte=d)
workshops = Workshop.objects.filter(
is_active=True).filter(
expected_date__gte=d).filter(
expected_date__lt=datetime.datetime.now()).filter(
status__in=[WorkshopStatus.COMPLETED,
- WorkshopStatus.FEEDBACK_PENDING])
+ WorkshopStatus.FEEDBACK_PENDING]).order_by('expected_date')
? ++++++++++++++++++++++++++
profiles = Profile.objects.filter(user__date_joined__gte=d)
no_of_participants = sum([w.no_of_participants for w in workshops])
template_name = 'reports/index.html'
context_dict = {}
context_dict['organisations'] = organisations
context_dict['workshops'] = workshops
context_dict['profiles'] = profiles
context_dict['no_of_participants'] = no_of_participants
context_dict['date'] = d
workshops = Workshop.objects.filter(
is_active=True)
return render(request, template_name, context_dict) |
6e80bcef30b6b4485fa5e3f269f13fc62380c422 | tests/test_evaluate.py | tests/test_evaluate.py | import numpy as np
from numpy.testing import assert_equal
from gala import evaluate as ev
def test_contingency_table():
seg = np.array([0, 1, 1, 1, 2, 2, 2, 3])
gt = np.array([1, 1, 1, 2, 2, 2, 2, 0])
ct = ev.contingency_table(seg, gt, ignore_seg=[], ignore_gt=[])
ct0 = ev.contingency_table(seg, gt, ignore_seg=[0], ignore_gt=[0])
ctd = ct.todense()
assert_equal(ctd, np.array([[0. , 0.125, 0. ],
[0. , 0.25 , 0.125],
[0. , 0. , 0.375],
[0.125, 0. , 0. ]]))
assert ct.shape == ct0.shape
def test_vi():
seg = np.array([1, 2, 3, 4])
gt = np.array([1, 1, 8, 8])
assert_equal(ev.vi(seg, gt), 1)
def test_are():
seg = np.eye(3)
gt = np.eye(3)
seg[1][1] = 0
assert seg.shape == gt.shape
| import numpy as np
from numpy.testing import assert_equal
from gala import evaluate as ev
def test_contingency_table():
seg = np.array([0, 1, 1, 1, 2, 2, 2, 3])
gt = np.array([1, 1, 1, 2, 2, 2, 2, 0])
ct = ev.contingency_table(seg, gt, ignore_seg=[], ignore_gt=[])
ct0 = ev.contingency_table(seg, gt, ignore_seg=[0], ignore_gt=[0])
ctd = ct.todense()
assert_equal(ctd, np.array([[0. , 0.125, 0. ],
[0. , 0.25 , 0.125],
[0. , 0. , 0.375],
[0.125, 0. , 0. ]]))
assert ct.shape == ct0.shape
def test_vi():
seg = np.array([1, 2, 3, 4])
gt = np.array([1, 1, 8, 8])
assert_equal(ev.vi(seg, gt), 1)
def test_are():
seg = np.array([[0,1], [1,0]])
gt = np.array([[1,2],[0,1]])
assert_almost_equal(ev.adapted_rand_error(seg,gt),0.081)
assert seg.shape == gt.shape
| Add in test for ARE | Add in test for ARE
| Python | bsd-3-clause | jni/gala,janelia-flyem/gala | import numpy as np
from numpy.testing import assert_equal
from gala import evaluate as ev
def test_contingency_table():
seg = np.array([0, 1, 1, 1, 2, 2, 2, 3])
gt = np.array([1, 1, 1, 2, 2, 2, 2, 0])
ct = ev.contingency_table(seg, gt, ignore_seg=[], ignore_gt=[])
ct0 = ev.contingency_table(seg, gt, ignore_seg=[0], ignore_gt=[0])
ctd = ct.todense()
assert_equal(ctd, np.array([[0. , 0.125, 0. ],
[0. , 0.25 , 0.125],
[0. , 0. , 0.375],
[0.125, 0. , 0. ]]))
assert ct.shape == ct0.shape
def test_vi():
seg = np.array([1, 2, 3, 4])
gt = np.array([1, 1, 8, 8])
assert_equal(ev.vi(seg, gt), 1)
def test_are():
- seg = np.eye(3)
- gt = np.eye(3)
- seg[1][1] = 0
+ seg = np.array([[0,1], [1,0]])
+ gt = np.array([[1,2],[0,1]])
+ assert_almost_equal(ev.adapted_rand_error(seg,gt),0.081)
assert seg.shape == gt.shape
| Add in test for ARE | ## Code Before:
import numpy as np
from numpy.testing import assert_equal
from gala import evaluate as ev
def test_contingency_table():
seg = np.array([0, 1, 1, 1, 2, 2, 2, 3])
gt = np.array([1, 1, 1, 2, 2, 2, 2, 0])
ct = ev.contingency_table(seg, gt, ignore_seg=[], ignore_gt=[])
ct0 = ev.contingency_table(seg, gt, ignore_seg=[0], ignore_gt=[0])
ctd = ct.todense()
assert_equal(ctd, np.array([[0. , 0.125, 0. ],
[0. , 0.25 , 0.125],
[0. , 0. , 0.375],
[0.125, 0. , 0. ]]))
assert ct.shape == ct0.shape
def test_vi():
seg = np.array([1, 2, 3, 4])
gt = np.array([1, 1, 8, 8])
assert_equal(ev.vi(seg, gt), 1)
def test_are():
seg = np.eye(3)
gt = np.eye(3)
seg[1][1] = 0
assert seg.shape == gt.shape
## Instruction:
Add in test for ARE
## Code After:
import numpy as np
from numpy.testing import assert_equal
from gala import evaluate as ev
def test_contingency_table():
seg = np.array([0, 1, 1, 1, 2, 2, 2, 3])
gt = np.array([1, 1, 1, 2, 2, 2, 2, 0])
ct = ev.contingency_table(seg, gt, ignore_seg=[], ignore_gt=[])
ct0 = ev.contingency_table(seg, gt, ignore_seg=[0], ignore_gt=[0])
ctd = ct.todense()
assert_equal(ctd, np.array([[0. , 0.125, 0. ],
[0. , 0.25 , 0.125],
[0. , 0. , 0.375],
[0.125, 0. , 0. ]]))
assert ct.shape == ct0.shape
def test_vi():
seg = np.array([1, 2, 3, 4])
gt = np.array([1, 1, 8, 8])
assert_equal(ev.vi(seg, gt), 1)
def test_are():
seg = np.array([[0,1], [1,0]])
gt = np.array([[1,2],[0,1]])
assert_almost_equal(ev.adapted_rand_error(seg,gt),0.081)
assert seg.shape == gt.shape
| import numpy as np
from numpy.testing import assert_equal
from gala import evaluate as ev
def test_contingency_table():
seg = np.array([0, 1, 1, 1, 2, 2, 2, 3])
gt = np.array([1, 1, 1, 2, 2, 2, 2, 0])
ct = ev.contingency_table(seg, gt, ignore_seg=[], ignore_gt=[])
ct0 = ev.contingency_table(seg, gt, ignore_seg=[0], ignore_gt=[0])
ctd = ct.todense()
assert_equal(ctd, np.array([[0. , 0.125, 0. ],
[0. , 0.25 , 0.125],
[0. , 0. , 0.375],
[0.125, 0. , 0. ]]))
assert ct.shape == ct0.shape
def test_vi():
seg = np.array([1, 2, 3, 4])
gt = np.array([1, 1, 8, 8])
assert_equal(ev.vi(seg, gt), 1)
def test_are():
- seg = np.eye(3)
- gt = np.eye(3)
- seg[1][1] = 0
+ seg = np.array([[0,1], [1,0]])
+ gt = np.array([[1,2],[0,1]])
+ assert_almost_equal(ev.adapted_rand_error(seg,gt),0.081)
assert seg.shape == gt.shape |
6122a8488613bdd7d5aaf80e7238cd2d80687a91 | stock.py | stock.py | class Stock:
def __init__(self, symbol):
self.symbol = symbol
self.price = None
def update(self, timestamp, price):
if price < 0:
raise ValueError("price should not be negative")
self.price = price
| class Stock:
def __init__(self, symbol):
self.symbol = symbol
self.price_history = []
@property
def price(self):
if self.price_history:
return self.price_history[-1]
else:
return None
def update(self, timestamp, price):
if price < 0:
raise ValueError("price should not be negative")
self.price_history.append(price)
| Update price attribute to price_history list as well as update function accordingly. | Update price attribute to price_history list as well as update function accordingly.
| Python | mit | bsmukasa/stock_alerter | class Stock:
def __init__(self, symbol):
self.symbol = symbol
- self.price = None
+ self.price_history = []
+
+ @property
+ def price(self):
+ if self.price_history:
+ return self.price_history[-1]
+ else:
+ return None
def update(self, timestamp, price):
if price < 0:
raise ValueError("price should not be negative")
- self.price = price
+ self.price_history.append(price)
| Update price attribute to price_history list as well as update function accordingly. | ## Code Before:
class Stock:
def __init__(self, symbol):
self.symbol = symbol
self.price = None
def update(self, timestamp, price):
if price < 0:
raise ValueError("price should not be negative")
self.price = price
## Instruction:
Update price attribute to price_history list as well as update function accordingly.
## Code After:
class Stock:
def __init__(self, symbol):
self.symbol = symbol
self.price_history = []
@property
def price(self):
if self.price_history:
return self.price_history[-1]
else:
return None
def update(self, timestamp, price):
if price < 0:
raise ValueError("price should not be negative")
self.price_history.append(price)
| class Stock:
def __init__(self, symbol):
self.symbol = symbol
- self.price = None
? ^^^^
+ self.price_history = []
? ++++++++ ^^
+
+ @property
+ def price(self):
+ if self.price_history:
+ return self.price_history[-1]
+ else:
+ return None
def update(self, timestamp, price):
if price < 0:
raise ValueError("price should not be negative")
- self.price = price
+ self.price_history.append(price) |
a6a88fac6300b92c82e797f72477df1df6b87dbe | faq/views.py | faq/views.py | from django.http import Http404
from django.views.generic import ListView, DetailView
from faq.models import Question, Category
class FAQQuestionListView(ListView):
context_object_name = "question_list"
template_name = "faq/question_list.html"
def get_queryset(self):
return Question.objects.all()
class FAQQuestionDetailView(DetailView):
context_object_name = 'question'
template_name = 'faq/question_detail.html'
def get_object(self):
return Question.objects.get(slug__iexact=self.kwargs['slug'])
class FAQCategoryListView(ListView):
context_object_name = "category_list"
template_name = "faq/category_list.html"
def get_queryset(self):
return Category.objects.all()
class FAQCategoryDetailView(ListView):
context_object_name = 'question_list'
template_name = "faq/question_list.html"
def get_queryset(self):
try:
self.category = Category.objects.get(slug__iexact=self.kwargs['slug'])
except Category.DoesNotExist:
raise Http404
return Question.objects.get(category=self.category) | from django.http import Http404
from django.views.generic import ListView, DetailView
from faq.models import Question, Category
class FAQQuestionListView(ListView):
context_object_name = "question_list"
template_name = "faq/question_list.html"
def get_queryset(self):
return Question.objects.filter(categories=None)
class FAQQuestionDetailView(DetailView):
context_object_name = 'question'
template_name = 'faq/question_detail.html'
def get_object(self):
return Question.objects.get(slug__iexact=self.kwargs['slug'])
class FAQCategoryListView(ListView):
context_object_name = "category_list"
template_name = "faq/category_list.html"
def get_queryset(self):
return Category.objects.all()
class FAQCategoryDetailView(ListView):
context_object_name = 'question_list'
template_name = "faq/question_list.html"
def get_queryset(self):
try:
self.category = Category.objects.get(slug__iexact=self.kwargs['slug'])
except Category.DoesNotExist:
raise Http404
return Question.objects.get(category=self.category) | Index should be ones without a category. | Index should be ones without a category.
| Python | bsd-3-clause | myles-archive/django-faq,asgardproject/django-faq | from django.http import Http404
from django.views.generic import ListView, DetailView
from faq.models import Question, Category
class FAQQuestionListView(ListView):
context_object_name = "question_list"
template_name = "faq/question_list.html"
def get_queryset(self):
- return Question.objects.all()
+ return Question.objects.filter(categories=None)
class FAQQuestionDetailView(DetailView):
context_object_name = 'question'
template_name = 'faq/question_detail.html'
def get_object(self):
return Question.objects.get(slug__iexact=self.kwargs['slug'])
class FAQCategoryListView(ListView):
context_object_name = "category_list"
template_name = "faq/category_list.html"
def get_queryset(self):
return Category.objects.all()
class FAQCategoryDetailView(ListView):
context_object_name = 'question_list'
template_name = "faq/question_list.html"
def get_queryset(self):
try:
self.category = Category.objects.get(slug__iexact=self.kwargs['slug'])
except Category.DoesNotExist:
raise Http404
return Question.objects.get(category=self.category) | Index should be ones without a category. | ## Code Before:
from django.http import Http404
from django.views.generic import ListView, DetailView
from faq.models import Question, Category
class FAQQuestionListView(ListView):
context_object_name = "question_list"
template_name = "faq/question_list.html"
def get_queryset(self):
return Question.objects.all()
class FAQQuestionDetailView(DetailView):
context_object_name = 'question'
template_name = 'faq/question_detail.html'
def get_object(self):
return Question.objects.get(slug__iexact=self.kwargs['slug'])
class FAQCategoryListView(ListView):
context_object_name = "category_list"
template_name = "faq/category_list.html"
def get_queryset(self):
return Category.objects.all()
class FAQCategoryDetailView(ListView):
context_object_name = 'question_list'
template_name = "faq/question_list.html"
def get_queryset(self):
try:
self.category = Category.objects.get(slug__iexact=self.kwargs['slug'])
except Category.DoesNotExist:
raise Http404
return Question.objects.get(category=self.category)
## Instruction:
Index should be ones without a category.
## Code After:
from django.http import Http404
from django.views.generic import ListView, DetailView
from faq.models import Question, Category
class FAQQuestionListView(ListView):
context_object_name = "question_list"
template_name = "faq/question_list.html"
def get_queryset(self):
return Question.objects.filter(categories=None)
class FAQQuestionDetailView(DetailView):
context_object_name = 'question'
template_name = 'faq/question_detail.html'
def get_object(self):
return Question.objects.get(slug__iexact=self.kwargs['slug'])
class FAQCategoryListView(ListView):
context_object_name = "category_list"
template_name = "faq/category_list.html"
def get_queryset(self):
return Category.objects.all()
class FAQCategoryDetailView(ListView):
context_object_name = 'question_list'
template_name = "faq/question_list.html"
def get_queryset(self):
try:
self.category = Category.objects.get(slug__iexact=self.kwargs['slug'])
except Category.DoesNotExist:
raise Http404
return Question.objects.get(category=self.category) | from django.http import Http404
from django.views.generic import ListView, DetailView
from faq.models import Question, Category
class FAQQuestionListView(ListView):
context_object_name = "question_list"
template_name = "faq/question_list.html"
def get_queryset(self):
- return Question.objects.all()
+ return Question.objects.filter(categories=None)
class FAQQuestionDetailView(DetailView):
context_object_name = 'question'
template_name = 'faq/question_detail.html'
def get_object(self):
return Question.objects.get(slug__iexact=self.kwargs['slug'])
class FAQCategoryListView(ListView):
context_object_name = "category_list"
template_name = "faq/category_list.html"
def get_queryset(self):
return Category.objects.all()
class FAQCategoryDetailView(ListView):
context_object_name = 'question_list'
template_name = "faq/question_list.html"
def get_queryset(self):
try:
self.category = Category.objects.get(slug__iexact=self.kwargs['slug'])
except Category.DoesNotExist:
raise Http404
return Question.objects.get(category=self.category) |
0fa33bb58d6b042e79c52a6f33454140a7150f64 | lithium/blog/views.py | lithium/blog/views.py | from lithium.blog.models import Post
def decorator(request, view, author=None, tag=None, *args, **kwargs):
"""
A view decotator to change the queryset depending on whether
a user may read private posts.
"""
if request.user.has_perm('blog.can_read_private'):
kwargs['queryset'] = Post.on_site.all(allow_private=True)
if author:
kwargs['queryset'] = kwargs['queryset'].filter(author__username=author)
if tag:
kwargs['queryset'] = kwargs['queryset'].filter(category__slug=tag)
return view(request, *args, **kwargs)
| from lithium.blog.models import Post
def decorator(request, view, author=None, tag=None, *args, **kwargs):
"""
A view decotator to change the queryset depending on whether
a user may read private posts.
"""
if request.user.has_perm('blog.can_read_private'):
kwargs['queryset'] = Post.on_site.all(allow_private=True)
kwargs['allow_future'] = True
if author:
kwargs['queryset'] = kwargs['queryset'].filter(author__username=author)
if tag:
kwargs['queryset'] = kwargs['queryset'].filter(category__slug=tag)
return view(request, *args, **kwargs)
| Allow users with the permission 'blog.can_read_private' to see posts from the future. | Allow users with the permission 'blog.can_read_private' to see posts from the future.
| Python | bsd-2-clause | kylef/lithium | from lithium.blog.models import Post
def decorator(request, view, author=None, tag=None, *args, **kwargs):
"""
A view decotator to change the queryset depending on whether
a user may read private posts.
"""
if request.user.has_perm('blog.can_read_private'):
kwargs['queryset'] = Post.on_site.all(allow_private=True)
+ kwargs['allow_future'] = True
if author:
kwargs['queryset'] = kwargs['queryset'].filter(author__username=author)
if tag:
kwargs['queryset'] = kwargs['queryset'].filter(category__slug=tag)
return view(request, *args, **kwargs)
| Allow users with the permission 'blog.can_read_private' to see posts from the future. | ## Code Before:
from lithium.blog.models import Post
def decorator(request, view, author=None, tag=None, *args, **kwargs):
"""
A view decotator to change the queryset depending on whether
a user may read private posts.
"""
if request.user.has_perm('blog.can_read_private'):
kwargs['queryset'] = Post.on_site.all(allow_private=True)
if author:
kwargs['queryset'] = kwargs['queryset'].filter(author__username=author)
if tag:
kwargs['queryset'] = kwargs['queryset'].filter(category__slug=tag)
return view(request, *args, **kwargs)
## Instruction:
Allow users with the permission 'blog.can_read_private' to see posts from the future.
## Code After:
from lithium.blog.models import Post
def decorator(request, view, author=None, tag=None, *args, **kwargs):
"""
A view decotator to change the queryset depending on whether
a user may read private posts.
"""
if request.user.has_perm('blog.can_read_private'):
kwargs['queryset'] = Post.on_site.all(allow_private=True)
kwargs['allow_future'] = True
if author:
kwargs['queryset'] = kwargs['queryset'].filter(author__username=author)
if tag:
kwargs['queryset'] = kwargs['queryset'].filter(category__slug=tag)
return view(request, *args, **kwargs)
| from lithium.blog.models import Post
def decorator(request, view, author=None, tag=None, *args, **kwargs):
"""
A view decotator to change the queryset depending on whether
a user may read private posts.
"""
if request.user.has_perm('blog.can_read_private'):
kwargs['queryset'] = Post.on_site.all(allow_private=True)
+ kwargs['allow_future'] = True
if author:
kwargs['queryset'] = kwargs['queryset'].filter(author__username=author)
if tag:
kwargs['queryset'] = kwargs['queryset'].filter(category__slug=tag)
return view(request, *args, **kwargs) |
77dc80e60b252833940dc6b2a1c512684ed8decd | doc/conf.py | doc/conf.py | extensions = [
'nbsphinx',
'sphinx.ext.mathjax',
]
# Exclude build directory and Jupyter backup files:
exclude_patterns = ['_build', '**.ipynb_checkpoints']
# -- The settings below this line are not specific to nbsphinx ------------
master_doc = 'index'
project = 'nbsphinx'
author = 'Matthias Geier'
copyright = '2016, ' + author
# -- Get version information from Git -------------------------------------
try:
from subprocess import check_output
release = check_output(['git', 'describe', '--tags', '--always'])
release = release.decode().strip()
except Exception:
release = '<unknown>'
# -- Options for HTML output ----------------------------------------------
html_title = project + ' version ' + release
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
'papersize': 'a4paper',
'preamble': r'\setcounter{tocdepth}{3}',
}
latex_documents = [
(master_doc, 'nbsphinx.tex', project, author, 'howto'),
]
latex_show_urls = 'footnote'
| extensions = [
'nbsphinx',
'sphinx.ext.mathjax',
]
# Exclude build directory and Jupyter backup files:
exclude_patterns = ['_build', '**.ipynb_checkpoints']
# Default language for syntax highlighting (e.g. in Markdown cells)
highlight_language = 'none'
# -- The settings below this line are not specific to nbsphinx ------------
master_doc = 'index'
project = 'nbsphinx'
author = 'Matthias Geier'
copyright = '2016, ' + author
# -- Get version information from Git -------------------------------------
try:
from subprocess import check_output
release = check_output(['git', 'describe', '--tags', '--always'])
release = release.decode().strip()
except Exception:
release = '<unknown>'
# -- Options for HTML output ----------------------------------------------
html_title = project + ' version ' + release
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
'papersize': 'a4paper',
'preamble': r'\setcounter{tocdepth}{3}',
}
latex_documents = [
(master_doc, 'nbsphinx.tex', project, author, 'howto'),
]
latex_show_urls = 'footnote'
| Set default syntax highlighting language to 'none' | DOC: Set default syntax highlighting language to 'none'
| Python | mit | spatialaudio/nbsphinx,spatialaudio/nbsphinx,spatialaudio/nbsphinx | extensions = [
'nbsphinx',
'sphinx.ext.mathjax',
]
# Exclude build directory and Jupyter backup files:
exclude_patterns = ['_build', '**.ipynb_checkpoints']
+
+ # Default language for syntax highlighting (e.g. in Markdown cells)
+ highlight_language = 'none'
# -- The settings below this line are not specific to nbsphinx ------------
master_doc = 'index'
project = 'nbsphinx'
author = 'Matthias Geier'
copyright = '2016, ' + author
# -- Get version information from Git -------------------------------------
try:
from subprocess import check_output
release = check_output(['git', 'describe', '--tags', '--always'])
release = release.decode().strip()
except Exception:
release = '<unknown>'
# -- Options for HTML output ----------------------------------------------
html_title = project + ' version ' + release
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
'papersize': 'a4paper',
'preamble': r'\setcounter{tocdepth}{3}',
}
latex_documents = [
(master_doc, 'nbsphinx.tex', project, author, 'howto'),
]
latex_show_urls = 'footnote'
| Set default syntax highlighting language to 'none' | ## Code Before:
extensions = [
'nbsphinx',
'sphinx.ext.mathjax',
]
# Exclude build directory and Jupyter backup files:
exclude_patterns = ['_build', '**.ipynb_checkpoints']
# -- The settings below this line are not specific to nbsphinx ------------
master_doc = 'index'
project = 'nbsphinx'
author = 'Matthias Geier'
copyright = '2016, ' + author
# -- Get version information from Git -------------------------------------
try:
from subprocess import check_output
release = check_output(['git', 'describe', '--tags', '--always'])
release = release.decode().strip()
except Exception:
release = '<unknown>'
# -- Options for HTML output ----------------------------------------------
html_title = project + ' version ' + release
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
'papersize': 'a4paper',
'preamble': r'\setcounter{tocdepth}{3}',
}
latex_documents = [
(master_doc, 'nbsphinx.tex', project, author, 'howto'),
]
latex_show_urls = 'footnote'
## Instruction:
Set default syntax highlighting language to 'none'
## Code After:
extensions = [
'nbsphinx',
'sphinx.ext.mathjax',
]
# Exclude build directory and Jupyter backup files:
exclude_patterns = ['_build', '**.ipynb_checkpoints']
# Default language for syntax highlighting (e.g. in Markdown cells)
highlight_language = 'none'
# -- The settings below this line are not specific to nbsphinx ------------
master_doc = 'index'
project = 'nbsphinx'
author = 'Matthias Geier'
copyright = '2016, ' + author
# -- Get version information from Git -------------------------------------
try:
from subprocess import check_output
release = check_output(['git', 'describe', '--tags', '--always'])
release = release.decode().strip()
except Exception:
release = '<unknown>'
# -- Options for HTML output ----------------------------------------------
html_title = project + ' version ' + release
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
'papersize': 'a4paper',
'preamble': r'\setcounter{tocdepth}{3}',
}
latex_documents = [
(master_doc, 'nbsphinx.tex', project, author, 'howto'),
]
latex_show_urls = 'footnote'
| extensions = [
'nbsphinx',
'sphinx.ext.mathjax',
]
# Exclude build directory and Jupyter backup files:
exclude_patterns = ['_build', '**.ipynb_checkpoints']
+
+ # Default language for syntax highlighting (e.g. in Markdown cells)
+ highlight_language = 'none'
# -- The settings below this line are not specific to nbsphinx ------------
master_doc = 'index'
project = 'nbsphinx'
author = 'Matthias Geier'
copyright = '2016, ' + author
# -- Get version information from Git -------------------------------------
try:
from subprocess import check_output
release = check_output(['git', 'describe', '--tags', '--always'])
release = release.decode().strip()
except Exception:
release = '<unknown>'
# -- Options for HTML output ----------------------------------------------
html_title = project + ' version ' + release
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
'papersize': 'a4paper',
'preamble': r'\setcounter{tocdepth}{3}',
}
latex_documents = [
(master_doc, 'nbsphinx.tex', project, author, 'howto'),
]
latex_show_urls = 'footnote' |
43b46f1e3ded3972dede7226cf0255b904d028bd | django/notejam/pads/tests.py | django/notejam/pads/tests.py |
from django.test import TestCase
class SimpleTest(TestCase):
def test_basic_addition(self):
"""
Tests that 1 + 1 always equals 2.
"""
self.assertEqual(1 + 1, 2)
| from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
from django.test import TestCase
class PadTest(TestCase):
def setUp(self):
user_data = {
'email': 'user@example.com',
'password': 'secure_password'
}
user = User.objects.create(username=user_data['email'], **user_data)
user.set_password(user_data['password'])
user.save()
self.client.login(**user_data)
def _get_pad_data(self):
pass
def test_create_pad_success(self):
pass
| Test improvementes. Empty Pad test class added. | Django: Test improvementes. Empty Pad test class added.
| Python | mit | hstaugaard/notejam,nadavge/notejam,lefloh/notejam,lefloh/notejam,williamn/notejam,hstaugaard/notejam,nadavge/notejam,williamn/notejam,hstaugaard/notejam,hstaugaard/notejam,lefloh/notejam,lefloh/notejam,williamn/notejam,nadavge/notejam,lefloh/notejam,hstaugaard/notejam,williamn/notejam,shikhardb/notejam,williamn/notejam,williamn/notejam,hstaugaard/notejam,shikhardb/notejam,lefloh/notejam,hstaugaard/notejam,lefloh/notejam,williamn/notejam,shikhardb/notejam,shikhardb/notejam,nadavge/notejam,hstaugaard/notejam,nadavge/notejam,shikhardb/notejam | -
+ from django.contrib.auth.models import User
+ from django.core.urlresolvers import reverse
from django.test import TestCase
- class SimpleTest(TestCase):
+ class PadTest(TestCase):
- def test_basic_addition(self):
+ def setUp(self):
+ user_data = {
+ 'email': 'user@example.com',
+ 'password': 'secure_password'
- """
+ }
- Tests that 1 + 1 always equals 2.
- """
- self.assertEqual(1 + 1, 2)
+ user = User.objects.create(username=user_data['email'], **user_data)
+ user.set_password(user_data['password'])
+ user.save()
+ self.client.login(**user_data)
+
+ def _get_pad_data(self):
+ pass
+
+ def test_create_pad_success(self):
+ pass
+ | Test improvementes. Empty Pad test class added. | ## Code Before:
from django.test import TestCase
class SimpleTest(TestCase):
def test_basic_addition(self):
"""
Tests that 1 + 1 always equals 2.
"""
self.assertEqual(1 + 1, 2)
## Instruction:
Test improvementes. Empty Pad test class added.
## Code After:
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
from django.test import TestCase
class PadTest(TestCase):
def setUp(self):
user_data = {
'email': 'user@example.com',
'password': 'secure_password'
}
user = User.objects.create(username=user_data['email'], **user_data)
user.set_password(user_data['password'])
user.save()
self.client.login(**user_data)
def _get_pad_data(self):
pass
def test_create_pad_success(self):
pass
| -
+ from django.contrib.auth.models import User
+ from django.core.urlresolvers import reverse
from django.test import TestCase
- class SimpleTest(TestCase):
? ^^^^^^
+ class PadTest(TestCase):
? ^^^
- def test_basic_addition(self):
+ def setUp(self):
+ user_data = {
+ 'email': 'user@example.com',
+ 'password': 'secure_password'
- """
? ^^^
+ }
? ^
- Tests that 1 + 1 always equals 2.
- """
- self.assertEqual(1 + 1, 2)
+ user = User.objects.create(username=user_data['email'], **user_data)
+ user.set_password(user_data['password'])
+ user.save()
+
+ self.client.login(**user_data)
+
+ def _get_pad_data(self):
+ pass
+
+ def test_create_pad_success(self):
+ pass |
cbafc968343cd2b001bcee354d418c9886fe94b4 | tests/test_network.py | tests/test_network.py | from nose.tools import eq_, ok_
import unittest
import openxc.measurements
from openxc.sources import NetworkDataSource
from openxc.sources import DataSourceError
class NetworkDataSourceTests(unittest.TestCase):
def setUp(self):
super(NetworkDataSourceTests, self).setUp()
def test_create(self):
def callback(message):
pass
try:
s = NetworkDataSource(callback)
except DataSourceError as e:
pass
| from nose.tools import eq_, ok_
import unittest
import openxc.measurements
from openxc.sources import NetworkDataSource
from openxc.sources import DataSourceError
class NetworkDataSourceTests(unittest.TestCase):
def setUp(self):
super(NetworkDataSourceTests, self).setUp()
def test_create(self):
def callback(message):
pass
try:
s = NetworkDataSource(callback, host='localhost')
except DataSourceError as e:
pass
| Use localhost for network source tests to avoid waiting for DNS. | Use localhost for network source tests to avoid waiting for DNS.
| Python | bsd-3-clause | openxc/openxc-python,openxc/openxc-python,openxc/openxc-python | from nose.tools import eq_, ok_
import unittest
import openxc.measurements
from openxc.sources import NetworkDataSource
from openxc.sources import DataSourceError
class NetworkDataSourceTests(unittest.TestCase):
def setUp(self):
super(NetworkDataSourceTests, self).setUp()
def test_create(self):
def callback(message):
pass
try:
- s = NetworkDataSource(callback)
+ s = NetworkDataSource(callback, host='localhost')
except DataSourceError as e:
pass
| Use localhost for network source tests to avoid waiting for DNS. | ## Code Before:
from nose.tools import eq_, ok_
import unittest
import openxc.measurements
from openxc.sources import NetworkDataSource
from openxc.sources import DataSourceError
class NetworkDataSourceTests(unittest.TestCase):
def setUp(self):
super(NetworkDataSourceTests, self).setUp()
def test_create(self):
def callback(message):
pass
try:
s = NetworkDataSource(callback)
except DataSourceError as e:
pass
## Instruction:
Use localhost for network source tests to avoid waiting for DNS.
## Code After:
from nose.tools import eq_, ok_
import unittest
import openxc.measurements
from openxc.sources import NetworkDataSource
from openxc.sources import DataSourceError
class NetworkDataSourceTests(unittest.TestCase):
def setUp(self):
super(NetworkDataSourceTests, self).setUp()
def test_create(self):
def callback(message):
pass
try:
s = NetworkDataSource(callback, host='localhost')
except DataSourceError as e:
pass
| from nose.tools import eq_, ok_
import unittest
import openxc.measurements
from openxc.sources import NetworkDataSource
from openxc.sources import DataSourceError
class NetworkDataSourceTests(unittest.TestCase):
def setUp(self):
super(NetworkDataSourceTests, self).setUp()
def test_create(self):
def callback(message):
pass
try:
- s = NetworkDataSource(callback)
+ s = NetworkDataSource(callback, host='localhost')
? ++++++++++++++++++
except DataSourceError as e:
pass |
51757c8a893640e2a9fa3a7b9f8e617b22e6db87 | test/test_api.py | test/test_api.py | import unittest
import appdirs
class Test_AppDir(unittest.TestCase):
def test_metadata(self):
self.assertTrue(hasattr(appdirs, "__version__"))
self.assertTrue(hasattr(appdirs, "__version_info__"))
def test_helpers(self):
self.assertTrue(isinstance(
appdirs.user_data_dir('MyApp', 'MyCompany'), str))
self.assertTrue(isinstance(
appdirs.site_data_dir('MyApp', 'MyCompany'), str))
self.assertTrue(isinstance(
appdirs.user_cache_dir('MyApp', 'MyCompany'), str))
self.assertTrue(isinstance(
appdirs.user_log_dir('MyApp', 'MyCompany'), str))
def test_dirs(self):
dirs = appdirs.AppDirs('MyApp', 'MyCompany', version='1.0')
self.assertTrue(isinstance(dirs.user_data_dir, str))
self.assertTrue(isinstance(dirs.site_data_dir, str))
self.assertTrue(isinstance(dirs.user_cache_dir, str))
self.assertTrue(isinstance(dirs.user_log_dir, str))
if __name__=="__main__":
unittest.main()
| import unittest
import appdirs
class Test_AppDir(unittest.TestCase):
def test_metadata(self):
self.assertTrue(hasattr(appdirs, "__version__"))
self.assertTrue(hasattr(appdirs, "__version_info__"))
def test_helpers(self):
self.assertIsInstance(
appdirs.user_data_dir('MyApp', 'MyCompany'), str)
self.assertIsInstance(
appdirs.site_data_dir('MyApp', 'MyCompany'), str)
self.assertIsInstance(
appdirs.user_cache_dir('MyApp', 'MyCompany'), str)
self.assertIsInstance(
appdirs.user_log_dir('MyApp', 'MyCompany'), str)
def test_dirs(self):
dirs = appdirs.AppDirs('MyApp', 'MyCompany', version='1.0')
self.assertIsInstance(dirs.user_data_dir, str)
self.assertIsInstance(dirs.site_data_dir, str)
self.assertIsInstance(dirs.user_cache_dir, str)
self.assertIsInstance(dirs.user_log_dir, str)
if __name__=="__main__":
unittest.main()
| Use assertIsInstance() instead of assertTrue(isinstance()). | Use assertIsInstance() instead of assertTrue(isinstance()).
| Python | mit | platformdirs/platformdirs | import unittest
import appdirs
class Test_AppDir(unittest.TestCase):
def test_metadata(self):
self.assertTrue(hasattr(appdirs, "__version__"))
self.assertTrue(hasattr(appdirs, "__version_info__"))
def test_helpers(self):
- self.assertTrue(isinstance(
+ self.assertIsInstance(
- appdirs.user_data_dir('MyApp', 'MyCompany'), str))
+ appdirs.user_data_dir('MyApp', 'MyCompany'), str)
- self.assertTrue(isinstance(
+ self.assertIsInstance(
- appdirs.site_data_dir('MyApp', 'MyCompany'), str))
+ appdirs.site_data_dir('MyApp', 'MyCompany'), str)
- self.assertTrue(isinstance(
+ self.assertIsInstance(
- appdirs.user_cache_dir('MyApp', 'MyCompany'), str))
+ appdirs.user_cache_dir('MyApp', 'MyCompany'), str)
- self.assertTrue(isinstance(
+ self.assertIsInstance(
- appdirs.user_log_dir('MyApp', 'MyCompany'), str))
+ appdirs.user_log_dir('MyApp', 'MyCompany'), str)
def test_dirs(self):
dirs = appdirs.AppDirs('MyApp', 'MyCompany', version='1.0')
- self.assertTrue(isinstance(dirs.user_data_dir, str))
+ self.assertIsInstance(dirs.user_data_dir, str)
- self.assertTrue(isinstance(dirs.site_data_dir, str))
+ self.assertIsInstance(dirs.site_data_dir, str)
- self.assertTrue(isinstance(dirs.user_cache_dir, str))
+ self.assertIsInstance(dirs.user_cache_dir, str)
- self.assertTrue(isinstance(dirs.user_log_dir, str))
+ self.assertIsInstance(dirs.user_log_dir, str)
if __name__=="__main__":
unittest.main()
| Use assertIsInstance() instead of assertTrue(isinstance()). | ## Code Before:
import unittest
import appdirs
class Test_AppDir(unittest.TestCase):
def test_metadata(self):
self.assertTrue(hasattr(appdirs, "__version__"))
self.assertTrue(hasattr(appdirs, "__version_info__"))
def test_helpers(self):
self.assertTrue(isinstance(
appdirs.user_data_dir('MyApp', 'MyCompany'), str))
self.assertTrue(isinstance(
appdirs.site_data_dir('MyApp', 'MyCompany'), str))
self.assertTrue(isinstance(
appdirs.user_cache_dir('MyApp', 'MyCompany'), str))
self.assertTrue(isinstance(
appdirs.user_log_dir('MyApp', 'MyCompany'), str))
def test_dirs(self):
dirs = appdirs.AppDirs('MyApp', 'MyCompany', version='1.0')
self.assertTrue(isinstance(dirs.user_data_dir, str))
self.assertTrue(isinstance(dirs.site_data_dir, str))
self.assertTrue(isinstance(dirs.user_cache_dir, str))
self.assertTrue(isinstance(dirs.user_log_dir, str))
if __name__=="__main__":
unittest.main()
## Instruction:
Use assertIsInstance() instead of assertTrue(isinstance()).
## Code After:
import unittest
import appdirs
class Test_AppDir(unittest.TestCase):
def test_metadata(self):
self.assertTrue(hasattr(appdirs, "__version__"))
self.assertTrue(hasattr(appdirs, "__version_info__"))
def test_helpers(self):
self.assertIsInstance(
appdirs.user_data_dir('MyApp', 'MyCompany'), str)
self.assertIsInstance(
appdirs.site_data_dir('MyApp', 'MyCompany'), str)
self.assertIsInstance(
appdirs.user_cache_dir('MyApp', 'MyCompany'), str)
self.assertIsInstance(
appdirs.user_log_dir('MyApp', 'MyCompany'), str)
def test_dirs(self):
dirs = appdirs.AppDirs('MyApp', 'MyCompany', version='1.0')
self.assertIsInstance(dirs.user_data_dir, str)
self.assertIsInstance(dirs.site_data_dir, str)
self.assertIsInstance(dirs.user_cache_dir, str)
self.assertIsInstance(dirs.user_log_dir, str)
if __name__=="__main__":
unittest.main()
| import unittest
import appdirs
class Test_AppDir(unittest.TestCase):
def test_metadata(self):
self.assertTrue(hasattr(appdirs, "__version__"))
self.assertTrue(hasattr(appdirs, "__version_info__"))
def test_helpers(self):
- self.assertTrue(isinstance(
? ^^^^^^ ^
+ self.assertIsInstance(
? ^ ^
- appdirs.user_data_dir('MyApp', 'MyCompany'), str))
? -
+ appdirs.user_data_dir('MyApp', 'MyCompany'), str)
- self.assertTrue(isinstance(
? ^^^^^^ ^
+ self.assertIsInstance(
? ^ ^
- appdirs.site_data_dir('MyApp', 'MyCompany'), str))
? -
+ appdirs.site_data_dir('MyApp', 'MyCompany'), str)
- self.assertTrue(isinstance(
? ^^^^^^ ^
+ self.assertIsInstance(
? ^ ^
- appdirs.user_cache_dir('MyApp', 'MyCompany'), str))
? -
+ appdirs.user_cache_dir('MyApp', 'MyCompany'), str)
- self.assertTrue(isinstance(
? ^^^^^^ ^
+ self.assertIsInstance(
? ^ ^
- appdirs.user_log_dir('MyApp', 'MyCompany'), str))
? -
+ appdirs.user_log_dir('MyApp', 'MyCompany'), str)
def test_dirs(self):
dirs = appdirs.AppDirs('MyApp', 'MyCompany', version='1.0')
- self.assertTrue(isinstance(dirs.user_data_dir, str))
? ^^^^^^ ^ -
+ self.assertIsInstance(dirs.user_data_dir, str)
? ^ ^
- self.assertTrue(isinstance(dirs.site_data_dir, str))
? ^^^^^^ ^ -
+ self.assertIsInstance(dirs.site_data_dir, str)
? ^ ^
- self.assertTrue(isinstance(dirs.user_cache_dir, str))
? ^^^^^^ ^ -
+ self.assertIsInstance(dirs.user_cache_dir, str)
? ^ ^
- self.assertTrue(isinstance(dirs.user_log_dir, str))
? ^^^^^^ ^ -
+ self.assertIsInstance(dirs.user_log_dir, str)
? ^ ^
if __name__=="__main__":
unittest.main() |
92759e9df89664ae515e51825982141750921ce3 | src/sample_xblocks/basic/test/test_view_counter.py | src/sample_xblocks/basic/test/test_view_counter.py | """ Simple test for the view counter that verifies that it is updating properly """
from collections import namedtuple
from mock import Mock
from xblock.runtime import KvsFieldData, DictKeyValueStore
from xblock.view_counter import ViewCounter
from xblock.test.tools import assert_in, assert_equals
TestUsage = namedtuple('TestUsage', 'id, def_id') # pylint: disable=C0103
def test_view_counter_state():
key_store = DictKeyValueStore()
db_model = KvsFieldData(key_store)
tester = ViewCounter(Mock(), db_model, Mock())
assert_equals(tester.views, 0)
# View the XBlock five times
for i in xrange(5):
generated_html = tester.student_view({})
# Make sure the html fragment we're expecting appears in the body_html
assert_in('<span class="views">{0}</span>'.format(i + 1), generated_html.body_html())
assert_equals(tester.views, i + 1)
| """ Simple test for the view counter that verifies that it is updating properly """
from collections import namedtuple
from mock import Mock
from xblock.runtime import KvsFieldData, DictKeyValueStore
from sample_xblocks.basic.view_counter import ViewCounter
from xblock.test.tools import assert_in, assert_equals
TestUsage = namedtuple('TestUsage', 'id, def_id') # pylint: disable=C0103
def test_view_counter_state():
key_store = DictKeyValueStore()
db_model = KvsFieldData(key_store)
tester = ViewCounter(Mock(), db_model, Mock())
assert_equals(tester.views, 0)
# View the XBlock five times
for i in xrange(5):
generated_html = tester.student_view({})
# Make sure the html fragment we're expecting appears in the body_html
assert_in('<span class="views">{0}</span>'.format(i + 1), generated_html.body_html())
assert_equals(tester.views, i + 1)
| Use the correct location of view_counter in test | Use the correct location of view_counter in test
| Python | apache-2.0 | stvstnfrd/xblock-sdk,dcadams/xblock-sdk,edx/xblock-sdk,jamiefolsom/xblock-sdk,edx/xblock-sdk,stvstnfrd/xblock-sdk,nagyistoce/edx-xblock-sdk,lovehhf/xblock-sdk,edx-solutions/xblock-sdk,Pilou81715/hackathon_edX,Pilou81715/hackathon_edX,edx-solutions/xblock-sdk,lovehhf/xblock-sdk,lovehhf/xblock-sdk,nagyistoce/edx-xblock-sdk,dcadams/xblock-sdk,jamiefolsom/xblock-sdk,jamiefolsom/xblock-sdk,Lyla-Fischer/xblock-sdk,Lyla-Fischer/xblock-sdk,stvstnfrd/xblock-sdk,lovehhf/xblock-sdk,Lyla-Fischer/xblock-sdk,edx/xblock-sdk,Pilou81715/hackathon_edX,nagyistoce/edx-xblock-sdk,edx-solutions/xblock-sdk,Pilou81715/hackathon_edX,dcadams/xblock-sdk,nagyistoce/edx-xblock-sdk,edx-solutions/xblock-sdk,jamiefolsom/xblock-sdk | """ Simple test for the view counter that verifies that it is updating properly """
from collections import namedtuple
from mock import Mock
from xblock.runtime import KvsFieldData, DictKeyValueStore
- from xblock.view_counter import ViewCounter
+ from sample_xblocks.basic.view_counter import ViewCounter
from xblock.test.tools import assert_in, assert_equals
TestUsage = namedtuple('TestUsage', 'id, def_id') # pylint: disable=C0103
def test_view_counter_state():
key_store = DictKeyValueStore()
db_model = KvsFieldData(key_store)
tester = ViewCounter(Mock(), db_model, Mock())
assert_equals(tester.views, 0)
# View the XBlock five times
for i in xrange(5):
generated_html = tester.student_view({})
# Make sure the html fragment we're expecting appears in the body_html
assert_in('<span class="views">{0}</span>'.format(i + 1), generated_html.body_html())
assert_equals(tester.views, i + 1)
| Use the correct location of view_counter in test | ## Code Before:
""" Simple test for the view counter that verifies that it is updating properly """
from collections import namedtuple
from mock import Mock
from xblock.runtime import KvsFieldData, DictKeyValueStore
from xblock.view_counter import ViewCounter
from xblock.test.tools import assert_in, assert_equals
TestUsage = namedtuple('TestUsage', 'id, def_id') # pylint: disable=C0103
def test_view_counter_state():
key_store = DictKeyValueStore()
db_model = KvsFieldData(key_store)
tester = ViewCounter(Mock(), db_model, Mock())
assert_equals(tester.views, 0)
# View the XBlock five times
for i in xrange(5):
generated_html = tester.student_view({})
# Make sure the html fragment we're expecting appears in the body_html
assert_in('<span class="views">{0}</span>'.format(i + 1), generated_html.body_html())
assert_equals(tester.views, i + 1)
## Instruction:
Use the correct location of view_counter in test
## Code After:
""" Simple test for the view counter that verifies that it is updating properly """
from collections import namedtuple
from mock import Mock
from xblock.runtime import KvsFieldData, DictKeyValueStore
from sample_xblocks.basic.view_counter import ViewCounter
from xblock.test.tools import assert_in, assert_equals
TestUsage = namedtuple('TestUsage', 'id, def_id') # pylint: disable=C0103
def test_view_counter_state():
key_store = DictKeyValueStore()
db_model = KvsFieldData(key_store)
tester = ViewCounter(Mock(), db_model, Mock())
assert_equals(tester.views, 0)
# View the XBlock five times
for i in xrange(5):
generated_html = tester.student_view({})
# Make sure the html fragment we're expecting appears in the body_html
assert_in('<span class="views">{0}</span>'.format(i + 1), generated_html.body_html())
assert_equals(tester.views, i + 1)
| """ Simple test for the view counter that verifies that it is updating properly """
from collections import namedtuple
from mock import Mock
from xblock.runtime import KvsFieldData, DictKeyValueStore
- from xblock.view_counter import ViewCounter
+ from sample_xblocks.basic.view_counter import ViewCounter
? +++++++ +++++++
from xblock.test.tools import assert_in, assert_equals
TestUsage = namedtuple('TestUsage', 'id, def_id') # pylint: disable=C0103
def test_view_counter_state():
key_store = DictKeyValueStore()
db_model = KvsFieldData(key_store)
tester = ViewCounter(Mock(), db_model, Mock())
assert_equals(tester.views, 0)
# View the XBlock five times
for i in xrange(5):
generated_html = tester.student_view({})
# Make sure the html fragment we're expecting appears in the body_html
assert_in('<span class="views">{0}</span>'.format(i + 1), generated_html.body_html())
assert_equals(tester.views, i + 1) |
2aa415cae1cb7ed0bb2b7fdaf51d9d5eaceaa768 | sweettooth/extensions/admin.py | sweettooth/extensions/admin.py |
from django.contrib import admin
from extensions.models import Extension, ExtensionVersion
from extensions.models import STATUS_ACTIVE, STATUS_REJECTED
from review.models import CodeReview
class CodeReviewAdmin(admin.TabularInline):
model = CodeReview
fields = 'reviewer', 'comments',
class ExtensionVersionAdmin(admin.ModelAdmin):
list_display = 'title', 'status',
list_display_links = 'title',
actions = 'approve', 'reject',
def title(self, ver):
return "%s (%d)" % (ver.extension.uuid, ver.version)
title.short_description = "Extension (version)"
inlines = [CodeReviewAdmin]
def approve(self, request, queryset):
queryset.update(status=STATUS_ACTIVE)
def reject(self, request, queryset):
queryset.update(status=STATUS_REJECTED)
admin.site.register(ExtensionVersion, ExtensionVersionAdmin)
class ExtensionVersionInline(admin.TabularInline):
model = ExtensionVersion
fields = 'version', 'status',
extra = 0
class ExtensionAdmin(admin.ModelAdmin):
list_display = 'name', 'uuid', 'num_versions', 'creator',
list_display_links = 'name', 'uuid',
search_fields = ('uuid', 'name')
def num_versions(self, ext):
return ext.versions.count()
num_versions.short_description = "#V"
inlines = [ExtensionVersionInline]
admin.site.register(Extension, ExtensionAdmin)
|
from django.contrib import admin
from extensions.models import Extension, ExtensionVersion
from extensions.models import STATUS_ACTIVE, STATUS_REJECTED
from review.models import CodeReview
class CodeReviewAdmin(admin.TabularInline):
model = CodeReview
fields = 'reviewer', 'comments',
class ExtensionVersionAdmin(admin.ModelAdmin):
list_display = 'title', 'status',
list_display_links = 'title',
actions = 'approve', 'reject',
def title(self, ver):
return "%s (%d)" % (ver.extension.uuid, ver.version)
title.short_description = "Extension (version)"
inlines = [CodeReviewAdmin]
def approve(self, request, queryset):
queryset.update(status=STATUS_ACTIVE)
def reject(self, request, queryset):
queryset.update(status=STATUS_REJECTED)
admin.site.register(ExtensionVersion, ExtensionVersionAdmin)
class ExtensionVersionInline(admin.TabularInline):
model = ExtensionVersion
fields = 'version', 'status',
extra = 0
class ExtensionAdmin(admin.ModelAdmin):
list_display = 'name', 'uuid', 'num_versions', 'creator',
list_display_links = 'name', 'uuid',
search_fields = ('uuid', 'name')
raw_id_fields = ('user',)
def num_versions(self, ext):
return ext.versions.count()
num_versions.short_description = "#V"
inlines = [ExtensionVersionInline]
admin.site.register(Extension, ExtensionAdmin)
| Make the user field into a raw field | extensions: Make the user field into a raw field
It's a bit annoying having to navigate through a 20,000 line combobox.
| Python | agpl-3.0 | GNOME/extensions-web,GNOME/extensions-web,GNOME/extensions-web,GNOME/extensions-web,magcius/sweettooth,magcius/sweettooth |
from django.contrib import admin
from extensions.models import Extension, ExtensionVersion
from extensions.models import STATUS_ACTIVE, STATUS_REJECTED
from review.models import CodeReview
class CodeReviewAdmin(admin.TabularInline):
model = CodeReview
fields = 'reviewer', 'comments',
class ExtensionVersionAdmin(admin.ModelAdmin):
list_display = 'title', 'status',
list_display_links = 'title',
actions = 'approve', 'reject',
def title(self, ver):
return "%s (%d)" % (ver.extension.uuid, ver.version)
title.short_description = "Extension (version)"
inlines = [CodeReviewAdmin]
def approve(self, request, queryset):
queryset.update(status=STATUS_ACTIVE)
def reject(self, request, queryset):
queryset.update(status=STATUS_REJECTED)
admin.site.register(ExtensionVersion, ExtensionVersionAdmin)
class ExtensionVersionInline(admin.TabularInline):
model = ExtensionVersion
fields = 'version', 'status',
extra = 0
class ExtensionAdmin(admin.ModelAdmin):
list_display = 'name', 'uuid', 'num_versions', 'creator',
list_display_links = 'name', 'uuid',
search_fields = ('uuid', 'name')
+ raw_id_fields = ('user',)
def num_versions(self, ext):
return ext.versions.count()
num_versions.short_description = "#V"
inlines = [ExtensionVersionInline]
admin.site.register(Extension, ExtensionAdmin)
| Make the user field into a raw field | ## Code Before:
from django.contrib import admin
from extensions.models import Extension, ExtensionVersion
from extensions.models import STATUS_ACTIVE, STATUS_REJECTED
from review.models import CodeReview
class CodeReviewAdmin(admin.TabularInline):
model = CodeReview
fields = 'reviewer', 'comments',
class ExtensionVersionAdmin(admin.ModelAdmin):
list_display = 'title', 'status',
list_display_links = 'title',
actions = 'approve', 'reject',
def title(self, ver):
return "%s (%d)" % (ver.extension.uuid, ver.version)
title.short_description = "Extension (version)"
inlines = [CodeReviewAdmin]
def approve(self, request, queryset):
queryset.update(status=STATUS_ACTIVE)
def reject(self, request, queryset):
queryset.update(status=STATUS_REJECTED)
admin.site.register(ExtensionVersion, ExtensionVersionAdmin)
class ExtensionVersionInline(admin.TabularInline):
model = ExtensionVersion
fields = 'version', 'status',
extra = 0
class ExtensionAdmin(admin.ModelAdmin):
list_display = 'name', 'uuid', 'num_versions', 'creator',
list_display_links = 'name', 'uuid',
search_fields = ('uuid', 'name')
def num_versions(self, ext):
return ext.versions.count()
num_versions.short_description = "#V"
inlines = [ExtensionVersionInline]
admin.site.register(Extension, ExtensionAdmin)
## Instruction:
Make the user field into a raw field
## Code After:
from django.contrib import admin
from extensions.models import Extension, ExtensionVersion
from extensions.models import STATUS_ACTIVE, STATUS_REJECTED
from review.models import CodeReview
class CodeReviewAdmin(admin.TabularInline):
model = CodeReview
fields = 'reviewer', 'comments',
class ExtensionVersionAdmin(admin.ModelAdmin):
list_display = 'title', 'status',
list_display_links = 'title',
actions = 'approve', 'reject',
def title(self, ver):
return "%s (%d)" % (ver.extension.uuid, ver.version)
title.short_description = "Extension (version)"
inlines = [CodeReviewAdmin]
def approve(self, request, queryset):
queryset.update(status=STATUS_ACTIVE)
def reject(self, request, queryset):
queryset.update(status=STATUS_REJECTED)
admin.site.register(ExtensionVersion, ExtensionVersionAdmin)
class ExtensionVersionInline(admin.TabularInline):
model = ExtensionVersion
fields = 'version', 'status',
extra = 0
class ExtensionAdmin(admin.ModelAdmin):
list_display = 'name', 'uuid', 'num_versions', 'creator',
list_display_links = 'name', 'uuid',
search_fields = ('uuid', 'name')
raw_id_fields = ('user',)
def num_versions(self, ext):
return ext.versions.count()
num_versions.short_description = "#V"
inlines = [ExtensionVersionInline]
admin.site.register(Extension, ExtensionAdmin)
|
from django.contrib import admin
from extensions.models import Extension, ExtensionVersion
from extensions.models import STATUS_ACTIVE, STATUS_REJECTED
from review.models import CodeReview
class CodeReviewAdmin(admin.TabularInline):
model = CodeReview
fields = 'reviewer', 'comments',
class ExtensionVersionAdmin(admin.ModelAdmin):
list_display = 'title', 'status',
list_display_links = 'title',
actions = 'approve', 'reject',
def title(self, ver):
return "%s (%d)" % (ver.extension.uuid, ver.version)
title.short_description = "Extension (version)"
inlines = [CodeReviewAdmin]
def approve(self, request, queryset):
queryset.update(status=STATUS_ACTIVE)
def reject(self, request, queryset):
queryset.update(status=STATUS_REJECTED)
admin.site.register(ExtensionVersion, ExtensionVersionAdmin)
class ExtensionVersionInline(admin.TabularInline):
model = ExtensionVersion
fields = 'version', 'status',
extra = 0
class ExtensionAdmin(admin.ModelAdmin):
list_display = 'name', 'uuid', 'num_versions', 'creator',
list_display_links = 'name', 'uuid',
search_fields = ('uuid', 'name')
+ raw_id_fields = ('user',)
def num_versions(self, ext):
return ext.versions.count()
num_versions.short_description = "#V"
inlines = [ExtensionVersionInline]
admin.site.register(Extension, ExtensionAdmin) |
ecce15f103b51ece25f33490af5adaa666017a86 | booksite/urls.py | booksite/urls.py | from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^$', views.tale_list, name='tale_list'),
url(r'^create-book/(?P<tale_id>[0-9]+)$', views.create_book, name='create_book'),
]
| from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^$', views.tale_list, name='tale_list'),
url(r'^create-tale/(?P<tale_id>[0-9]+)$', views.create_tale, name='create_tale'),
]
| Rename links from *book* to *tale* | Rename links from *book* to *tale*
| Python | apache-2.0 | mark-graciov/bookit,mark-graciov/bookit | from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^$', views.tale_list, name='tale_list'),
- url(r'^create-book/(?P<tale_id>[0-9]+)$', views.create_book, name='create_book'),
+ url(r'^create-tale/(?P<tale_id>[0-9]+)$', views.create_tale, name='create_tale'),
]
| Rename links from *book* to *tale* | ## Code Before:
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^$', views.tale_list, name='tale_list'),
url(r'^create-book/(?P<tale_id>[0-9]+)$', views.create_book, name='create_book'),
]
## Instruction:
Rename links from *book* to *tale*
## Code After:
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^$', views.tale_list, name='tale_list'),
url(r'^create-tale/(?P<tale_id>[0-9]+)$', views.create_tale, name='create_tale'),
]
| from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^$', views.tale_list, name='tale_list'),
- url(r'^create-book/(?P<tale_id>[0-9]+)$', views.create_book, name='create_book'),
? ^^^^ ^^^^ ^^^^
+ url(r'^create-tale/(?P<tale_id>[0-9]+)$', views.create_tale, name='create_tale'),
? ^^^^ ^^^^ ^^^^
] |
fdf559007b9596e8d075d3de7f6e9f27e8a24ed6 | rippl/legislature/api.py | rippl/legislature/api.py | from django.http import JsonResponse, HttpResponseBadRequest
from legislature.sunlight.district import DistrictMatcher
def find_district(request):
try:
latitude = request.GET['lat']
longitude = request.GET['lng']
except KeyError:
return HttpResponseBadRequest('Need both "lat" and "lng" query params')
matcher = DistrictMatcher()
district = matcher.find_district(latitude, longitude)
return JsonResponse({
'state': district.state.abbr,
'state_name': district.state.name,
'district': district.number,
'str': str(district)
})
| from django.http import JsonResponse, HttpResponseBadRequest
from legislature.sunlight.district import DistrictMatcher
def find_district(request):
try:
latitude = request.GET['lat']
longitude = request.GET['lng']
except KeyError:
return HttpResponseBadRequest('Need both "lat" and "lng" query params')
matcher = DistrictMatcher()
district = matcher.find_district(latitude, longitude)
return JsonResponse({
'state': district.state.abbr,
'state_name': district.state.name,
'district': district.number,
'district_id': district.id,
'str': str(district)
})
| Add district id to find_district response | Add district id to find_district response
| Python | mit | gnmerritt/dailyrippl,gnmerritt/dailyrippl,gnmerritt/dailyrippl,gnmerritt/dailyrippl | from django.http import JsonResponse, HttpResponseBadRequest
from legislature.sunlight.district import DistrictMatcher
def find_district(request):
try:
latitude = request.GET['lat']
longitude = request.GET['lng']
except KeyError:
return HttpResponseBadRequest('Need both "lat" and "lng" query params')
matcher = DistrictMatcher()
district = matcher.find_district(latitude, longitude)
return JsonResponse({
'state': district.state.abbr,
'state_name': district.state.name,
'district': district.number,
+ 'district_id': district.id,
'str': str(district)
})
| Add district id to find_district response | ## Code Before:
from django.http import JsonResponse, HttpResponseBadRequest
from legislature.sunlight.district import DistrictMatcher
def find_district(request):
try:
latitude = request.GET['lat']
longitude = request.GET['lng']
except KeyError:
return HttpResponseBadRequest('Need both "lat" and "lng" query params')
matcher = DistrictMatcher()
district = matcher.find_district(latitude, longitude)
return JsonResponse({
'state': district.state.abbr,
'state_name': district.state.name,
'district': district.number,
'str': str(district)
})
## Instruction:
Add district id to find_district response
## Code After:
from django.http import JsonResponse, HttpResponseBadRequest
from legislature.sunlight.district import DistrictMatcher
def find_district(request):
try:
latitude = request.GET['lat']
longitude = request.GET['lng']
except KeyError:
return HttpResponseBadRequest('Need both "lat" and "lng" query params')
matcher = DistrictMatcher()
district = matcher.find_district(latitude, longitude)
return JsonResponse({
'state': district.state.abbr,
'state_name': district.state.name,
'district': district.number,
'district_id': district.id,
'str': str(district)
})
| from django.http import JsonResponse, HttpResponseBadRequest
from legislature.sunlight.district import DistrictMatcher
def find_district(request):
try:
latitude = request.GET['lat']
longitude = request.GET['lng']
except KeyError:
return HttpResponseBadRequest('Need both "lat" and "lng" query params')
matcher = DistrictMatcher()
district = matcher.find_district(latitude, longitude)
return JsonResponse({
'state': district.state.abbr,
'state_name': district.state.name,
'district': district.number,
+ 'district_id': district.id,
'str': str(district)
}) |
b6389de5f531fa49e911b344cbaea29599260c82 | src/tests/test_cleanup_marathon_orphaned_containers.py | src/tests/test_cleanup_marathon_orphaned_containers.py |
import cleanup_marathon_orphaned_images
# These should be left running
mesos_deployed_old = {
'Names': ['/mesos-deployed-old', ],
}
mesos_undeployed_young = {
'Names': ['/mesos-undeployed-young', ],
}
nonmesos_undeployed_old = {
'Names': ['/nonmesos-undeployed-old', ],
}
# These should be cleaned up
mesos_undeployed_old = {
'Names': ['/mesos-undeployed-old', ],
}
running_images = [
mesos_deployed_old,
nonmesos_undeployed_old,
mesos_undeployed_young,
mesos_undeployed_old,
]
def test_get_mesos_images():
actual = cleanup_marathon_orphaned_images.get_mesos_images(running_images)
assert nonmesos_undeployed_old not in actual
def test_get_old_images():
pass
|
import cleanup_marathon_orphaned_images
# These should be left running
mesos_deployed_old = {
'Names': ['/mesos-deployed-old', ],
}
mesos_undeployed_young = {
'Names': ['/mesos-undeployed-young', ],
}
nonmesos_undeployed_old = {
'Names': ['/nonmesos-undeployed-old', ],
}
# These should be cleaned up
mesos_undeployed_old = {
'Names': ['/mesos-undeployed-old', ],
}
running_images = [
mesos_deployed_old,
nonmesos_undeployed_old,
mesos_undeployed_young,
mesos_undeployed_old,
]
def test_get_mesos_images():
assert nonmesos_undeployed_old in running_images
actual = cleanup_marathon_orphaned_images.get_mesos_images(running_images)
assert nonmesos_undeployed_old not in actual
def test_get_old_images():
pass
| Clarify intent and fail fast | Clarify intent and fail fast
| Python | apache-2.0 | Yelp/paasta,somic/paasta,gstarnberger/paasta,somic/paasta,gstarnberger/paasta,Yelp/paasta |
import cleanup_marathon_orphaned_images
# These should be left running
mesos_deployed_old = {
'Names': ['/mesos-deployed-old', ],
}
mesos_undeployed_young = {
'Names': ['/mesos-undeployed-young', ],
}
nonmesos_undeployed_old = {
'Names': ['/nonmesos-undeployed-old', ],
}
# These should be cleaned up
mesos_undeployed_old = {
'Names': ['/mesos-undeployed-old', ],
}
running_images = [
mesos_deployed_old,
nonmesos_undeployed_old,
mesos_undeployed_young,
mesos_undeployed_old,
]
def test_get_mesos_images():
+ assert nonmesos_undeployed_old in running_images
actual = cleanup_marathon_orphaned_images.get_mesos_images(running_images)
assert nonmesos_undeployed_old not in actual
def test_get_old_images():
pass
| Clarify intent and fail fast | ## Code Before:
import cleanup_marathon_orphaned_images
# These should be left running
mesos_deployed_old = {
'Names': ['/mesos-deployed-old', ],
}
mesos_undeployed_young = {
'Names': ['/mesos-undeployed-young', ],
}
nonmesos_undeployed_old = {
'Names': ['/nonmesos-undeployed-old', ],
}
# These should be cleaned up
mesos_undeployed_old = {
'Names': ['/mesos-undeployed-old', ],
}
running_images = [
mesos_deployed_old,
nonmesos_undeployed_old,
mesos_undeployed_young,
mesos_undeployed_old,
]
def test_get_mesos_images():
actual = cleanup_marathon_orphaned_images.get_mesos_images(running_images)
assert nonmesos_undeployed_old not in actual
def test_get_old_images():
pass
## Instruction:
Clarify intent and fail fast
## Code After:
import cleanup_marathon_orphaned_images
# These should be left running
mesos_deployed_old = {
'Names': ['/mesos-deployed-old', ],
}
mesos_undeployed_young = {
'Names': ['/mesos-undeployed-young', ],
}
nonmesos_undeployed_old = {
'Names': ['/nonmesos-undeployed-old', ],
}
# These should be cleaned up
mesos_undeployed_old = {
'Names': ['/mesos-undeployed-old', ],
}
running_images = [
mesos_deployed_old,
nonmesos_undeployed_old,
mesos_undeployed_young,
mesos_undeployed_old,
]
def test_get_mesos_images():
assert nonmesos_undeployed_old in running_images
actual = cleanup_marathon_orphaned_images.get_mesos_images(running_images)
assert nonmesos_undeployed_old not in actual
def test_get_old_images():
pass
|
import cleanup_marathon_orphaned_images
# These should be left running
mesos_deployed_old = {
'Names': ['/mesos-deployed-old', ],
}
mesos_undeployed_young = {
'Names': ['/mesos-undeployed-young', ],
}
nonmesos_undeployed_old = {
'Names': ['/nonmesos-undeployed-old', ],
}
# These should be cleaned up
mesos_undeployed_old = {
'Names': ['/mesos-undeployed-old', ],
}
running_images = [
mesos_deployed_old,
nonmesos_undeployed_old,
mesos_undeployed_young,
mesos_undeployed_old,
]
def test_get_mesos_images():
+ assert nonmesos_undeployed_old in running_images
actual = cleanup_marathon_orphaned_images.get_mesos_images(running_images)
assert nonmesos_undeployed_old not in actual
def test_get_old_images():
pass |
77c245240fcccf1c7c6f3251168801de45182b8d | klaxer/__init__.py | klaxer/__init__.py | """Entry point for all things Klaxer"""
__author__ = 'Aru Sahni, Kevin Dwyer, Justin Shelton, Dylan Bernard, Will Schneider, et al'
__version__ = '0.0.1'
__license__ = 'MIT'
APP_NAME = 'Klaxer'
| """Entry point for all things Klaxer"""
__author__ = 'Aru Sahni, Kevin Dwyer, Justin Shelton, Dylan Bernard, et al'
__version__ = '0.0.1'
__license__ = 'MIT'
APP_NAME = 'Klaxer'
| Adjust author list to only include contributors. | Adjust author list to only include contributors.
| Python | mit | klaxer/klaxer | """Entry point for all things Klaxer"""
- __author__ = 'Aru Sahni, Kevin Dwyer, Justin Shelton, Dylan Bernard, Will Schneider, et al'
+ __author__ = 'Aru Sahni, Kevin Dwyer, Justin Shelton, Dylan Bernard, et al'
__version__ = '0.0.1'
__license__ = 'MIT'
APP_NAME = 'Klaxer'
| Adjust author list to only include contributors. | ## Code Before:
"""Entry point for all things Klaxer"""
__author__ = 'Aru Sahni, Kevin Dwyer, Justin Shelton, Dylan Bernard, Will Schneider, et al'
__version__ = '0.0.1'
__license__ = 'MIT'
APP_NAME = 'Klaxer'
## Instruction:
Adjust author list to only include contributors.
## Code After:
"""Entry point for all things Klaxer"""
__author__ = 'Aru Sahni, Kevin Dwyer, Justin Shelton, Dylan Bernard, et al'
__version__ = '0.0.1'
__license__ = 'MIT'
APP_NAME = 'Klaxer'
| """Entry point for all things Klaxer"""
- __author__ = 'Aru Sahni, Kevin Dwyer, Justin Shelton, Dylan Bernard, Will Schneider, et al'
? ----------------
+ __author__ = 'Aru Sahni, Kevin Dwyer, Justin Shelton, Dylan Bernard, et al'
__version__ = '0.0.1'
__license__ = 'MIT'
APP_NAME = 'Klaxer' |
74ac965c451f29faa344be0161ebb419395faa6e | entities/context_processors.py | entities/context_processors.py | from . import models
from django.conf import settings
def groups(request):
return {
'about_group': models.Group.objects.filter(id=settings.ABOUT_GROUP_ID).first(),
'all_sidebar_groups': models.Group.objects.scored().order_by('-score'),
}
def statistics(request):
return {
'gestalt_count': models.Gestalt.objects.count,
'group_count': models.Group.objects.count
}
| from . import models
from django.conf import settings
from django.contrib.auth import hashers
def groups(request):
return {
'about_group': models.Group.objects.filter(id=settings.ABOUT_GROUP_ID).first(),
'all_sidebar_groups': models.Group.objects.scored().order_by('-score'),
}
def statistics(request):
return {
'gestalt_count': models.Gestalt.objects.exclude(user__password__startswith=hashers.UNUSABLE_PASSWORD_PREFIX).count,
'group_count': models.Group.objects.count
}
| Exclude unusable users from stats | Exclude unusable users from stats
| Python | agpl-3.0 | stadtgestalten/stadtgestalten,stadtgestalten/stadtgestalten,stadtgestalten/stadtgestalten | from . import models
from django.conf import settings
+ from django.contrib.auth import hashers
def groups(request):
return {
'about_group': models.Group.objects.filter(id=settings.ABOUT_GROUP_ID).first(),
'all_sidebar_groups': models.Group.objects.scored().order_by('-score'),
}
def statistics(request):
return {
- 'gestalt_count': models.Gestalt.objects.count,
+ 'gestalt_count': models.Gestalt.objects.exclude(user__password__startswith=hashers.UNUSABLE_PASSWORD_PREFIX).count,
'group_count': models.Group.objects.count
}
| Exclude unusable users from stats | ## Code Before:
from . import models
from django.conf import settings
def groups(request):
return {
'about_group': models.Group.objects.filter(id=settings.ABOUT_GROUP_ID).first(),
'all_sidebar_groups': models.Group.objects.scored().order_by('-score'),
}
def statistics(request):
return {
'gestalt_count': models.Gestalt.objects.count,
'group_count': models.Group.objects.count
}
## Instruction:
Exclude unusable users from stats
## Code After:
from . import models
from django.conf import settings
from django.contrib.auth import hashers
def groups(request):
return {
'about_group': models.Group.objects.filter(id=settings.ABOUT_GROUP_ID).first(),
'all_sidebar_groups': models.Group.objects.scored().order_by('-score'),
}
def statistics(request):
return {
'gestalt_count': models.Gestalt.objects.exclude(user__password__startswith=hashers.UNUSABLE_PASSWORD_PREFIX).count,
'group_count': models.Group.objects.count
}
| from . import models
from django.conf import settings
+ from django.contrib.auth import hashers
def groups(request):
return {
'about_group': models.Group.objects.filter(id=settings.ABOUT_GROUP_ID).first(),
'all_sidebar_groups': models.Group.objects.scored().order_by('-score'),
}
def statistics(request):
return {
- 'gestalt_count': models.Gestalt.objects.count,
+ 'gestalt_count': models.Gestalt.objects.exclude(user__password__startswith=hashers.UNUSABLE_PASSWORD_PREFIX).count,
'group_count': models.Group.objects.count
} |
8c97ffed1531315dd50639c40b0bccad0fc1ef2d | textual_runtime.py | textual_runtime.py |
from game import DiscState
class TextualRuntime:
def __init__(self, game):
self.game = game
self.state = {
"continue": True
}
def start(self):
while self.state["continue"]:
self.render()
self.eval(self.get_input())
def render(self):
str_repr = ["Current board state:\n"]
str_repr += [" %i " % col_index for col_index in range(self.game.grid.width)]
for row in self.game.grid:
row_repr = []
for disc_value in row:
if disc_value is DiscState.empty:
row_repr.append("| |")
elif disc_value is DiscState.red:
row_repr.append("|O|")
else: # disc_value is black
row_repr.append("|X|")
row_repr.append("\n")
str_repr += row_repr
print("".join(str_repr))
def get_input(self):
return input("--> ")
def eval(self, command):
tokens = command.split()
if len(tokens) == 1:
if tokens[0] == "quit":
self.state["continue"] = False
|
from game import DiscState
class TextualRuntime:
def __init__(self, game):
self.game = game
self.state = {
"continue": True
}
def start(self):
while self.state["continue"]:
self.render()
self.eval(self.get_input())
def render(self):
str_repr = ["Current board state:\n"]
str_repr += [" %i " % col_index for col_index in range(self.game.grid.width)] + ["\n"]
for row in self.game.grid:
row_repr = []
for disc_value in row:
if disc_value is DiscState.empty:
row_repr.append("| |")
elif disc_value is DiscState.red:
row_repr.append("|O|")
else: # disc_value is black
row_repr.append("|X|")
row_repr.append("\n")
str_repr += row_repr
print("".join(str_repr))
def get_input(self):
return input("--> ")
def eval(self, command):
tokens = command.split()
if len(tokens) == 1:
if tokens[0] == "quit":
self.state["continue"] = False
elif tokens[0].isdigit():
col_index = int(tokens[0])
new_point = self.game.try_turn(self.game.current_player, col_index)
| Add ability to drop discs on slots | Add ability to drop discs on slots
| Python | mit | misterwilliam/connect-four |
from game import DiscState
class TextualRuntime:
def __init__(self, game):
self.game = game
self.state = {
"continue": True
}
def start(self):
while self.state["continue"]:
self.render()
self.eval(self.get_input())
def render(self):
str_repr = ["Current board state:\n"]
- str_repr += [" %i " % col_index for col_index in range(self.game.grid.width)]
+ str_repr += [" %i " % col_index for col_index in range(self.game.grid.width)] + ["\n"]
for row in self.game.grid:
row_repr = []
for disc_value in row:
if disc_value is DiscState.empty:
row_repr.append("| |")
elif disc_value is DiscState.red:
row_repr.append("|O|")
else: # disc_value is black
row_repr.append("|X|")
row_repr.append("\n")
str_repr += row_repr
print("".join(str_repr))
def get_input(self):
return input("--> ")
def eval(self, command):
tokens = command.split()
if len(tokens) == 1:
if tokens[0] == "quit":
self.state["continue"] = False
+ elif tokens[0].isdigit():
+ col_index = int(tokens[0])
+ new_point = self.game.try_turn(self.game.current_player, col_index)
| Add ability to drop discs on slots | ## Code Before:
from game import DiscState
class TextualRuntime:
def __init__(self, game):
self.game = game
self.state = {
"continue": True
}
def start(self):
while self.state["continue"]:
self.render()
self.eval(self.get_input())
def render(self):
str_repr = ["Current board state:\n"]
str_repr += [" %i " % col_index for col_index in range(self.game.grid.width)]
for row in self.game.grid:
row_repr = []
for disc_value in row:
if disc_value is DiscState.empty:
row_repr.append("| |")
elif disc_value is DiscState.red:
row_repr.append("|O|")
else: # disc_value is black
row_repr.append("|X|")
row_repr.append("\n")
str_repr += row_repr
print("".join(str_repr))
def get_input(self):
return input("--> ")
def eval(self, command):
tokens = command.split()
if len(tokens) == 1:
if tokens[0] == "quit":
self.state["continue"] = False
## Instruction:
Add ability to drop discs on slots
## Code After:
from game import DiscState
class TextualRuntime:
def __init__(self, game):
self.game = game
self.state = {
"continue": True
}
def start(self):
while self.state["continue"]:
self.render()
self.eval(self.get_input())
def render(self):
str_repr = ["Current board state:\n"]
str_repr += [" %i " % col_index for col_index in range(self.game.grid.width)] + ["\n"]
for row in self.game.grid:
row_repr = []
for disc_value in row:
if disc_value is DiscState.empty:
row_repr.append("| |")
elif disc_value is DiscState.red:
row_repr.append("|O|")
else: # disc_value is black
row_repr.append("|X|")
row_repr.append("\n")
str_repr += row_repr
print("".join(str_repr))
def get_input(self):
return input("--> ")
def eval(self, command):
tokens = command.split()
if len(tokens) == 1:
if tokens[0] == "quit":
self.state["continue"] = False
elif tokens[0].isdigit():
col_index = int(tokens[0])
new_point = self.game.try_turn(self.game.current_player, col_index)
|
from game import DiscState
class TextualRuntime:
def __init__(self, game):
self.game = game
self.state = {
"continue": True
}
def start(self):
while self.state["continue"]:
self.render()
self.eval(self.get_input())
def render(self):
str_repr = ["Current board state:\n"]
- str_repr += [" %i " % col_index for col_index in range(self.game.grid.width)]
+ str_repr += [" %i " % col_index for col_index in range(self.game.grid.width)] + ["\n"]
? +++++++++
for row in self.game.grid:
row_repr = []
for disc_value in row:
if disc_value is DiscState.empty:
row_repr.append("| |")
elif disc_value is DiscState.red:
row_repr.append("|O|")
else: # disc_value is black
row_repr.append("|X|")
row_repr.append("\n")
str_repr += row_repr
print("".join(str_repr))
def get_input(self):
return input("--> ")
def eval(self, command):
tokens = command.split()
if len(tokens) == 1:
if tokens[0] == "quit":
self.state["continue"] = False
+ elif tokens[0].isdigit():
+ col_index = int(tokens[0])
+ new_point = self.game.try_turn(self.game.current_player, col_index)
|
6c211bce96eaca17de770b82aab8dac07ff0c2fd | src/dictsdiff/cli.py | src/dictsdiff/cli.py |
from __future__ import print_function
import sys
def dictsdiff_cli(files):
import pandas
from .loader import diff_files, diff_ndjson
if files:
dd = diff_files(files)
else:
dd = diff_ndjson(sys.stdin)
with pandas.option_context('display.max_rows', None,
'display.max_columns', None):
print(dd.pretty_diff())
def make_parser(doc=__doc__):
import argparse
parser = argparse.ArgumentParser(
formatter_class=type('FormatterClass',
(argparse.RawDescriptionHelpFormatter,
argparse.ArgumentDefaultsHelpFormatter),
{}),
description=doc)
parser.add_argument(
'files', metavar='FILE', nargs='*',
)
return parser
def main(args=None):
parser = make_parser()
ns = parser.parse_args(args)
dictsdiff_cli(**vars(ns))
|
from __future__ import print_function
import sys
try:
from shutil import get_terminal_size
except ImportError:
def get_terminal_size():
from subprocess import check_output
out = check_output(['stty', 'size'], universal_newlines=True)
rows, columns = map(int, out.strip().split())
return columns, rows
def dictsdiff_cli(files):
import pandas
from .loader import diff_files, diff_ndjson
if files:
dd = diff_files(files)
else:
dd = diff_ndjson(sys.stdin)
# Manually detect terminal size, since passing "'display.width',
# None" does not detect terminal size (as advertised in
# https://pandas.pydata.org/pandas-docs/stable/options.html):
width, _ = get_terminal_size()
with pandas.option_context('display.max_rows', None,
'display.max_columns', None,
'display.width', width):
print(dd.pretty_diff())
def make_parser(doc=__doc__):
import argparse
parser = argparse.ArgumentParser(
formatter_class=type('FormatterClass',
(argparse.RawDescriptionHelpFormatter,
argparse.ArgumentDefaultsHelpFormatter),
{}),
description=doc)
parser.add_argument(
'files', metavar='FILE', nargs='*',
)
return parser
def main(args=None):
parser = make_parser()
ns = parser.parse_args(args)
dictsdiff_cli(**vars(ns))
| Set display.width based on terminal size | Set display.width based on terminal size
| Python | bsd-2-clause | tkf/dictsdiff |
from __future__ import print_function
import sys
+
+ try:
+ from shutil import get_terminal_size
+ except ImportError:
+ def get_terminal_size():
+ from subprocess import check_output
+ out = check_output(['stty', 'size'], universal_newlines=True)
+ rows, columns = map(int, out.strip().split())
+ return columns, rows
def dictsdiff_cli(files):
import pandas
from .loader import diff_files, diff_ndjson
if files:
dd = diff_files(files)
else:
dd = diff_ndjson(sys.stdin)
+ # Manually detect terminal size, since passing "'display.width',
+ # None" does not detect terminal size (as advertised in
+ # https://pandas.pydata.org/pandas-docs/stable/options.html):
+ width, _ = get_terminal_size()
+
with pandas.option_context('display.max_rows', None,
- 'display.max_columns', None):
+ 'display.max_columns', None,
+ 'display.width', width):
print(dd.pretty_diff())
def make_parser(doc=__doc__):
import argparse
parser = argparse.ArgumentParser(
formatter_class=type('FormatterClass',
(argparse.RawDescriptionHelpFormatter,
argparse.ArgumentDefaultsHelpFormatter),
{}),
description=doc)
parser.add_argument(
'files', metavar='FILE', nargs='*',
)
return parser
def main(args=None):
parser = make_parser()
ns = parser.parse_args(args)
dictsdiff_cli(**vars(ns))
| Set display.width based on terminal size | ## Code Before:
from __future__ import print_function
import sys
def dictsdiff_cli(files):
import pandas
from .loader import diff_files, diff_ndjson
if files:
dd = diff_files(files)
else:
dd = diff_ndjson(sys.stdin)
with pandas.option_context('display.max_rows', None,
'display.max_columns', None):
print(dd.pretty_diff())
def make_parser(doc=__doc__):
import argparse
parser = argparse.ArgumentParser(
formatter_class=type('FormatterClass',
(argparse.RawDescriptionHelpFormatter,
argparse.ArgumentDefaultsHelpFormatter),
{}),
description=doc)
parser.add_argument(
'files', metavar='FILE', nargs='*',
)
return parser
def main(args=None):
parser = make_parser()
ns = parser.parse_args(args)
dictsdiff_cli(**vars(ns))
## Instruction:
Set display.width based on terminal size
## Code After:
from __future__ import print_function
import sys
try:
from shutil import get_terminal_size
except ImportError:
def get_terminal_size():
from subprocess import check_output
out = check_output(['stty', 'size'], universal_newlines=True)
rows, columns = map(int, out.strip().split())
return columns, rows
def dictsdiff_cli(files):
import pandas
from .loader import diff_files, diff_ndjson
if files:
dd = diff_files(files)
else:
dd = diff_ndjson(sys.stdin)
# Manually detect terminal size, since passing "'display.width',
# None" does not detect terminal size (as advertised in
# https://pandas.pydata.org/pandas-docs/stable/options.html):
width, _ = get_terminal_size()
with pandas.option_context('display.max_rows', None,
'display.max_columns', None,
'display.width', width):
print(dd.pretty_diff())
def make_parser(doc=__doc__):
import argparse
parser = argparse.ArgumentParser(
formatter_class=type('FormatterClass',
(argparse.RawDescriptionHelpFormatter,
argparse.ArgumentDefaultsHelpFormatter),
{}),
description=doc)
parser.add_argument(
'files', metavar='FILE', nargs='*',
)
return parser
def main(args=None):
parser = make_parser()
ns = parser.parse_args(args)
dictsdiff_cli(**vars(ns))
|
from __future__ import print_function
import sys
+
+ try:
+ from shutil import get_terminal_size
+ except ImportError:
+ def get_terminal_size():
+ from subprocess import check_output
+ out = check_output(['stty', 'size'], universal_newlines=True)
+ rows, columns = map(int, out.strip().split())
+ return columns, rows
def dictsdiff_cli(files):
import pandas
from .loader import diff_files, diff_ndjson
if files:
dd = diff_files(files)
else:
dd = diff_ndjson(sys.stdin)
+ # Manually detect terminal size, since passing "'display.width',
+ # None" does not detect terminal size (as advertised in
+ # https://pandas.pydata.org/pandas-docs/stable/options.html):
+ width, _ = get_terminal_size()
+
with pandas.option_context('display.max_rows', None,
- 'display.max_columns', None):
? ^^
+ 'display.max_columns', None,
? ^
+ 'display.width', width):
print(dd.pretty_diff())
def make_parser(doc=__doc__):
import argparse
parser = argparse.ArgumentParser(
formatter_class=type('FormatterClass',
(argparse.RawDescriptionHelpFormatter,
argparse.ArgumentDefaultsHelpFormatter),
{}),
description=doc)
parser.add_argument(
'files', metavar='FILE', nargs='*',
)
return parser
def main(args=None):
parser = make_parser()
ns = parser.parse_args(args)
dictsdiff_cli(**vars(ns)) |
5d9eabe588231444083d13dc50371ea6952d445e | mirrit/web/models.py | mirrit/web/models.py | from bson.objectid import ObjectId
from humbledb import Mongo, Document
class ClassProperty (property):
"""Subclass property to make classmethod properties possible"""
def __get__(self, cls, owner):
return self.fget.__get__(None, owner)()
class User(Document):
username = ''
password = ''
email = ''
config_database = 'mirrit'
config_collection = 'users'
@property
def id(self):
return unicode(self._id)
@property
def user_id(self):
return unicode(self._id)
@staticmethod
def get_by_login(cls, username, password):
with Mongo:
return cls.find({'username': username,
'password': password})
def persist(self):
with Mongo:
if self._id:
super(User, self).__self_class__.update(
{'_id': self._id}, self, w=1)
else:
super(User, self).__self_class__.insert(self, w=1)
class Wrapper(object):
def get(self, id):
with Mongo:
return User.find({'_id': ObjectId(id)})
wrapper = Wrapper()
User.query = wrapper
| from bson.objectid import ObjectId
from humbledb import Mongo, Document
class ClassProperty (property):
"""Subclass property to make classmethod properties possible"""
def __get__(self, cls, owner):
return self.fget.__get__(None, owner)()
class User(Document):
username = ''
password = ''
email = ''
github_access_token = ''
config_database = 'mirrit'
config_collection = 'users'
@property
def id(self):
return unicode(self._id)
@property
def user_id(self):
return unicode(self._id)
@staticmethod
def get_by_login(cls, username, password):
with Mongo:
return cls.find({'username': username,
'password': password})
def persist(self):
with Mongo:
if self._id:
super(User, self).__self_class__.update(
{'_id': self._id}, self, w=1)
else:
super(User, self).__self_class__.insert(self, w=1)
class Wrapper(object):
def get(self, id):
with Mongo:
return User.find({'_id': ObjectId(id)})
wrapper = Wrapper()
User.query = wrapper
| Add github token to model | Add github token to model
| Python | bsd-3-clause | 1stvamp/mirrit | from bson.objectid import ObjectId
from humbledb import Mongo, Document
class ClassProperty (property):
"""Subclass property to make classmethod properties possible"""
def __get__(self, cls, owner):
return self.fget.__get__(None, owner)()
class User(Document):
username = ''
password = ''
email = ''
+ github_access_token = ''
config_database = 'mirrit'
config_collection = 'users'
@property
def id(self):
return unicode(self._id)
@property
def user_id(self):
return unicode(self._id)
@staticmethod
def get_by_login(cls, username, password):
with Mongo:
return cls.find({'username': username,
'password': password})
def persist(self):
with Mongo:
if self._id:
super(User, self).__self_class__.update(
{'_id': self._id}, self, w=1)
else:
super(User, self).__self_class__.insert(self, w=1)
class Wrapper(object):
def get(self, id):
with Mongo:
return User.find({'_id': ObjectId(id)})
wrapper = Wrapper()
User.query = wrapper
| Add github token to model | ## Code Before:
from bson.objectid import ObjectId
from humbledb import Mongo, Document
class ClassProperty (property):
"""Subclass property to make classmethod properties possible"""
def __get__(self, cls, owner):
return self.fget.__get__(None, owner)()
class User(Document):
username = ''
password = ''
email = ''
config_database = 'mirrit'
config_collection = 'users'
@property
def id(self):
return unicode(self._id)
@property
def user_id(self):
return unicode(self._id)
@staticmethod
def get_by_login(cls, username, password):
with Mongo:
return cls.find({'username': username,
'password': password})
def persist(self):
with Mongo:
if self._id:
super(User, self).__self_class__.update(
{'_id': self._id}, self, w=1)
else:
super(User, self).__self_class__.insert(self, w=1)
class Wrapper(object):
def get(self, id):
with Mongo:
return User.find({'_id': ObjectId(id)})
wrapper = Wrapper()
User.query = wrapper
## Instruction:
Add github token to model
## Code After:
from bson.objectid import ObjectId
from humbledb import Mongo, Document
class ClassProperty (property):
"""Subclass property to make classmethod properties possible"""
def __get__(self, cls, owner):
return self.fget.__get__(None, owner)()
class User(Document):
username = ''
password = ''
email = ''
github_access_token = ''
config_database = 'mirrit'
config_collection = 'users'
@property
def id(self):
return unicode(self._id)
@property
def user_id(self):
return unicode(self._id)
@staticmethod
def get_by_login(cls, username, password):
with Mongo:
return cls.find({'username': username,
'password': password})
def persist(self):
with Mongo:
if self._id:
super(User, self).__self_class__.update(
{'_id': self._id}, self, w=1)
else:
super(User, self).__self_class__.insert(self, w=1)
class Wrapper(object):
def get(self, id):
with Mongo:
return User.find({'_id': ObjectId(id)})
wrapper = Wrapper()
User.query = wrapper
| from bson.objectid import ObjectId
from humbledb import Mongo, Document
class ClassProperty (property):
"""Subclass property to make classmethod properties possible"""
def __get__(self, cls, owner):
return self.fget.__get__(None, owner)()
class User(Document):
username = ''
password = ''
email = ''
+ github_access_token = ''
config_database = 'mirrit'
config_collection = 'users'
@property
def id(self):
return unicode(self._id)
@property
def user_id(self):
return unicode(self._id)
@staticmethod
def get_by_login(cls, username, password):
with Mongo:
return cls.find({'username': username,
'password': password})
def persist(self):
with Mongo:
if self._id:
super(User, self).__self_class__.update(
{'_id': self._id}, self, w=1)
else:
super(User, self).__self_class__.insert(self, w=1)
class Wrapper(object):
def get(self, id):
with Mongo:
return User.find({'_id': ObjectId(id)})
wrapper = Wrapper()
User.query = wrapper |
7afedf19ff9dfcbf8872a7a9a6090c4ed235a206 | phantasy/apps/__init__.py | phantasy/apps/__init__.py |
from .latticemodel import lmapp
from phantasy_apps import *
|
from .latticemodel import lmapp
try:
from phantasy_apps import *
except ImportError:
print("Package 'python-phantasy-apps' is required.")
| Add warning if 'phantasy_apps' cannot be found. | Add warning if 'phantasy_apps' cannot be found.
| Python | bsd-3-clause | archman/phantasy,archman/phantasy |
from .latticemodel import lmapp
+ try:
- from phantasy_apps import *
+ from phantasy_apps import *
+ except ImportError:
+ print("Package 'python-phantasy-apps' is required.")
| Add warning if 'phantasy_apps' cannot be found. | ## Code Before:
from .latticemodel import lmapp
from phantasy_apps import *
## Instruction:
Add warning if 'phantasy_apps' cannot be found.
## Code After:
from .latticemodel import lmapp
try:
from phantasy_apps import *
except ImportError:
print("Package 'python-phantasy-apps' is required.")
|
from .latticemodel import lmapp
+ try:
- from phantasy_apps import *
+ from phantasy_apps import *
? ++++
+ except ImportError:
+ print("Package 'python-phantasy-apps' is required.") |
c147629b4a0a5b405f7568b9278f288fa09fd97b | tests/aggregation/models.py | tests/aggregation/models.py | from django.db import models
class Author(models.Model):
name = models.CharField(max_length=100)
age = models.IntegerField()
friends = models.ManyToManyField('self', blank=True)
def __unicode__(self):
return self.name
class Publisher(models.Model):
name = models.CharField(max_length=255)
num_awards = models.IntegerField()
def __unicode__(self):
return self.name
class Book(models.Model):
isbn = models.CharField(max_length=9)
name = models.CharField(max_length=255)
pages = models.IntegerField()
rating = models.FloatField()
price = models.DecimalField(decimal_places=2, max_digits=6)
authors = models.ManyToManyField(Author)
contact = models.ForeignKey(Author, related_name='book_contact_set')
publisher = models.ForeignKey(Publisher)
pubdate = models.DateField()
def __unicode__(self):
return self.name
class Store(models.Model):
name = models.CharField(max_length=255)
books = models.ManyToManyField(Book)
original_opening = models.DateTimeField()
friday_night_closing = models.TimeField()
def __unicode__(self):
return self.name
| from django.db import models
class Author(models.Model):
name = models.CharField(max_length=100)
age = models.IntegerField()
friends = models.ManyToManyField('self', blank=True)
def __unicode__(self):
return self.name
class Publisher(models.Model):
name = models.CharField(max_length=255)
num_awards = models.IntegerField()
def __unicode__(self):
return self.name
class Book(models.Model):
isbn = models.CharField(max_length=9)
name = models.CharField(max_length=255)
pages = models.IntegerField()
rating = models.FloatField()
price = models.DecimalField(decimal_places=2, max_digits=6)
authors = models.ManyToManyField(Author)
contact = models.ForeignKey(Author, related_name='book_contact_set')
publisher = models.ForeignKey(Publisher)
pubdate = models.DateField()
def __unicode__(self):
return self.name
class Store(models.Model):
name = models.CharField(max_length=255)
books = models.ManyToManyField(Book)
original_opening = models.DateTimeField()
friday_night_closing = models.TimeField()
has_coffee = models.BooleanField()
def __unicode__(self):
return self.name
| Add a boolean field to Store model (store.has_coffee) | Add a boolean field to Store model (store.has_coffee)
| Python | mit | henriquebastos/django-aggregate-if | from django.db import models
class Author(models.Model):
name = models.CharField(max_length=100)
age = models.IntegerField()
friends = models.ManyToManyField('self', blank=True)
def __unicode__(self):
return self.name
class Publisher(models.Model):
name = models.CharField(max_length=255)
num_awards = models.IntegerField()
def __unicode__(self):
return self.name
class Book(models.Model):
isbn = models.CharField(max_length=9)
name = models.CharField(max_length=255)
pages = models.IntegerField()
rating = models.FloatField()
price = models.DecimalField(decimal_places=2, max_digits=6)
authors = models.ManyToManyField(Author)
contact = models.ForeignKey(Author, related_name='book_contact_set')
publisher = models.ForeignKey(Publisher)
pubdate = models.DateField()
def __unicode__(self):
return self.name
class Store(models.Model):
name = models.CharField(max_length=255)
books = models.ManyToManyField(Book)
original_opening = models.DateTimeField()
friday_night_closing = models.TimeField()
+ has_coffee = models.BooleanField()
def __unicode__(self):
return self.name
| Add a boolean field to Store model (store.has_coffee) | ## Code Before:
from django.db import models
class Author(models.Model):
name = models.CharField(max_length=100)
age = models.IntegerField()
friends = models.ManyToManyField('self', blank=True)
def __unicode__(self):
return self.name
class Publisher(models.Model):
name = models.CharField(max_length=255)
num_awards = models.IntegerField()
def __unicode__(self):
return self.name
class Book(models.Model):
isbn = models.CharField(max_length=9)
name = models.CharField(max_length=255)
pages = models.IntegerField()
rating = models.FloatField()
price = models.DecimalField(decimal_places=2, max_digits=6)
authors = models.ManyToManyField(Author)
contact = models.ForeignKey(Author, related_name='book_contact_set')
publisher = models.ForeignKey(Publisher)
pubdate = models.DateField()
def __unicode__(self):
return self.name
class Store(models.Model):
name = models.CharField(max_length=255)
books = models.ManyToManyField(Book)
original_opening = models.DateTimeField()
friday_night_closing = models.TimeField()
def __unicode__(self):
return self.name
## Instruction:
Add a boolean field to Store model (store.has_coffee)
## Code After:
from django.db import models
class Author(models.Model):
name = models.CharField(max_length=100)
age = models.IntegerField()
friends = models.ManyToManyField('self', blank=True)
def __unicode__(self):
return self.name
class Publisher(models.Model):
name = models.CharField(max_length=255)
num_awards = models.IntegerField()
def __unicode__(self):
return self.name
class Book(models.Model):
isbn = models.CharField(max_length=9)
name = models.CharField(max_length=255)
pages = models.IntegerField()
rating = models.FloatField()
price = models.DecimalField(decimal_places=2, max_digits=6)
authors = models.ManyToManyField(Author)
contact = models.ForeignKey(Author, related_name='book_contact_set')
publisher = models.ForeignKey(Publisher)
pubdate = models.DateField()
def __unicode__(self):
return self.name
class Store(models.Model):
name = models.CharField(max_length=255)
books = models.ManyToManyField(Book)
original_opening = models.DateTimeField()
friday_night_closing = models.TimeField()
has_coffee = models.BooleanField()
def __unicode__(self):
return self.name
| from django.db import models
class Author(models.Model):
name = models.CharField(max_length=100)
age = models.IntegerField()
friends = models.ManyToManyField('self', blank=True)
def __unicode__(self):
return self.name
class Publisher(models.Model):
name = models.CharField(max_length=255)
num_awards = models.IntegerField()
def __unicode__(self):
return self.name
class Book(models.Model):
isbn = models.CharField(max_length=9)
name = models.CharField(max_length=255)
pages = models.IntegerField()
rating = models.FloatField()
price = models.DecimalField(decimal_places=2, max_digits=6)
authors = models.ManyToManyField(Author)
contact = models.ForeignKey(Author, related_name='book_contact_set')
publisher = models.ForeignKey(Publisher)
pubdate = models.DateField()
def __unicode__(self):
return self.name
class Store(models.Model):
name = models.CharField(max_length=255)
books = models.ManyToManyField(Book)
original_opening = models.DateTimeField()
friday_night_closing = models.TimeField()
+ has_coffee = models.BooleanField()
def __unicode__(self):
return self.name
|
fb837585264e6abe4b0488e3a9dd5c5507e69bf6 | tensorflow/python/distribute/__init__.py | tensorflow/python/distribute/__init__.py | """Distribution Strategy library."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
# pylint: disable=unused-import
from tensorflow.python.distribute import cluster_resolver
from tensorflow.python.distribute import cross_device_ops
from tensorflow.python.distribute import distribute_lib
from tensorflow.python.distribute import distribution_strategy_context
from tensorflow.python.distribute import mirrored_strategy
from tensorflow.python.distribute import one_device_strategy
from tensorflow.python.distribute.client import parameter_server_client
from tensorflow.python.distribute.experimental import collective_all_reduce_strategy
from tensorflow.python.distribute.experimental import parameter_server_strategy
# pylint: enable=unused-import
| """Distribution Strategy library."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
# pylint: disable=unused-import
from tensorflow.python.distribute import cluster_resolver
from tensorflow.python.distribute import cross_device_ops
from tensorflow.python.distribute import distribute_lib
from tensorflow.python.distribute import distribution_strategy_context
from tensorflow.python.distribute import mirrored_strategy
from tensorflow.python.distribute import one_device_strategy
from tensorflow.python.distribute.experimental import collective_all_reduce_strategy
from tensorflow.python.distribute.experimental import parameter_server_strategy
# pylint: enable=unused-import
| Fix asan test for various targets. | PSv2: Fix asan test for various targets.
PiperOrigin-RevId: 325441069
Change-Id: I1fa1b2b10670f34739323292eab623d5b538142e
| Python | apache-2.0 | aam-at/tensorflow,cxxgtxy/tensorflow,frreiss/tensorflow-fred,paolodedios/tensorflow,paolodedios/tensorflow,karllessard/tensorflow,yongtang/tensorflow,tensorflow/tensorflow-experimental_link_static_libraries_once,Intel-Corporation/tensorflow,aldian/tensorflow,sarvex/tensorflow,aldian/tensorflow,davidzchen/tensorflow,tensorflow/tensorflow-experimental_link_static_libraries_once,petewarden/tensorflow,karllessard/tensorflow,Intel-tensorflow/tensorflow,davidzchen/tensorflow,yongtang/tensorflow,yongtang/tensorflow,yongtang/tensorflow,davidzchen/tensorflow,Intel-Corporation/tensorflow,frreiss/tensorflow-fred,freedomtan/tensorflow,aam-at/tensorflow,petewarden/tensorflow,freedomtan/tensorflow,paolodedios/tensorflow,tensorflow/tensorflow-experimental_link_static_libraries_once,davidzchen/tensorflow,Intel-Corporation/tensorflow,annarev/tensorflow,gautam1858/tensorflow,freedomtan/tensorflow,tensorflow/tensorflow-pywrap_saved_model,tensorflow/tensorflow,freedomtan/tensorflow,karllessard/tensorflow,karllessard/tensorflow,tensorflow/tensorflow-pywrap_saved_model,Intel-tensorflow/tensorflow,tensorflow/tensorflow-pywrap_tf_optimizer,tensorflow/tensorflow,annarev/tensorflow,tensorflow/tensorflow-pywrap_tf_optimizer,tensorflow/tensorflow-pywrap_tf_optimizer,aldian/tensorflow,aam-at/tensorflow,tensorflow/tensorflow-pywrap_tf_optimizer,aam-at/tensorflow,gautam1858/tensorflow,Intel-tensorflow/tensorflow,Intel-Corporation/tensorflow,aam-at/tensorflow,tensorflow/tensorflow,sarvex/tensorflow,paolodedios/tensorflow,gautam1858/tensorflow,annarev/tensorflow,Intel-Corporation/tensorflow,petewarden/tensorflow,cxxgtxy/tensorflow,aldian/tensorflow,frreiss/tensorflow-fred,freedomtan/tensorflow,aldian/tensorflow,tensorflow/tensorflow-experimental_link_static_libraries_once,paolodedios/tensorflow,cxxgtxy/tensorflow,tensorflow/tensorflow,aam-at/tensorflow,tensorflow/tensorflow-pywrap_saved_model,petewarden/tensorflow,cxxgtxy/tensorflow,tensorflow/tensorflow-experimental_link_static_libraries_once,freedomtan/tensorflow,tensorflow/tensorflow-pywrap_saved_model,karllessard/tensorflow,tensorflow/tensorflow-pywrap_saved_model,freedomtan/tensorflow,cxxgtxy/tensorflow,freedomtan/tensorflow,annarev/tensorflow,tensorflow/tensorflow,tensorflow/tensorflow-experimental_link_static_libraries_once,annarev/tensorflow,tensorflow/tensorflow-pywrap_tf_optimizer,freedomtan/tensorflow,tensorflow/tensorflow-experimental_link_static_libraries_once,petewarden/tensorflow,tensorflow/tensorflow-pywrap_saved_model,aam-at/tensorflow,annarev/tensorflow,aldian/tensorflow,petewarden/tensorflow,frreiss/tensorflow-fred,tensorflow/tensorflow-pywrap_saved_model,yongtang/tensorflow,karllessard/tensorflow,tensorflow/tensorflow-pywrap_tf_optimizer,davidzchen/tensorflow,annarev/tensorflow,Intel-Corporation/tensorflow,cxxgtxy/tensorflow,davidzchen/tensorflow,frreiss/tensorflow-fred,cxxgtxy/tensorflow,tensorflow/tensorflow,paolodedios/tensorflow,davidzchen/tensorflow,aldian/tensorflow,gautam1858/tensorflow,davidzchen/tensorflow,frreiss/tensorflow-fred,annarev/tensorflow,karllessard/tensorflow,Intel-Corporation/tensorflow,Intel-tensorflow/tensorflow,tensorflow/tensorflow-pywrap_tf_optimizer,Intel-tensorflow/tensorflow,tensorflow/tensorflow-pywrap_tf_optimizer,tensorflow/tensorflow,tensorflow/tensorflow-experimental_link_static_libraries_once,gautam1858/tensorflow,frreiss/tensorflow-fred,tensorflow/tensorflow-pywrap_saved_model,Intel-Corporation/tensorflow,frreiss/tensorflow-fred,annarev/tensorflow,Intel-tensorflow/tensorflow,Intel-tensorflow/tensorflow,Intel-tensorflow/tensorflow,aam-at/tensorflow,petewarden/tensorflow,sarvex/tensorflow,cxxgtxy/tensorflow,aldian/tensorflow,annarev/tensorflow,freedomtan/tensorflow,tensorflow/tensorflow-experimental_link_static_libraries_once,paolodedios/tensorflow,yongtang/tensorflow,tensorflow/tensorflow-pywrap_tf_optimizer,tensorflow/tensorflow-experimental_link_static_libraries_once,yongtang/tensorflow,tensorflow/tensorflow-pywrap_saved_model,sarvex/tensorflow,tensorflow/tensorflow-pywrap_saved_model,gautam1858/tensorflow,karllessard/tensorflow,sarvex/tensorflow,gautam1858/tensorflow,Intel-tensorflow/tensorflow,tensorflow/tensorflow,yongtang/tensorflow,gautam1858/tensorflow,tensorflow/tensorflow-pywrap_tf_optimizer,tensorflow/tensorflow,petewarden/tensorflow,Intel-tensorflow/tensorflow,gautam1858/tensorflow,karllessard/tensorflow,davidzchen/tensorflow,paolodedios/tensorflow,davidzchen/tensorflow,petewarden/tensorflow,annarev/tensorflow,frreiss/tensorflow-fred,Intel-tensorflow/tensorflow,aam-at/tensorflow,karllessard/tensorflow,petewarden/tensorflow,davidzchen/tensorflow,sarvex/tensorflow,sarvex/tensorflow,aam-at/tensorflow,tensorflow/tensorflow-experimental_link_static_libraries_once,yongtang/tensorflow,sarvex/tensorflow,frreiss/tensorflow-fred,aam-at/tensorflow,freedomtan/tensorflow,freedomtan/tensorflow,tensorflow/tensorflow,tensorflow/tensorflow-pywrap_saved_model,davidzchen/tensorflow,paolodedios/tensorflow,frreiss/tensorflow-fred,tensorflow/tensorflow,petewarden/tensorflow,karllessard/tensorflow,aam-at/tensorflow,paolodedios/tensorflow,frreiss/tensorflow-fred,petewarden/tensorflow,gautam1858/tensorflow,gautam1858/tensorflow,tensorflow/tensorflow-pywrap_tf_optimizer,yongtang/tensorflow,paolodedios/tensorflow,yongtang/tensorflow,gautam1858/tensorflow | """Distribution Strategy library."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
# pylint: disable=unused-import
from tensorflow.python.distribute import cluster_resolver
from tensorflow.python.distribute import cross_device_ops
from tensorflow.python.distribute import distribute_lib
from tensorflow.python.distribute import distribution_strategy_context
from tensorflow.python.distribute import mirrored_strategy
from tensorflow.python.distribute import one_device_strategy
- from tensorflow.python.distribute.client import parameter_server_client
from tensorflow.python.distribute.experimental import collective_all_reduce_strategy
from tensorflow.python.distribute.experimental import parameter_server_strategy
# pylint: enable=unused-import
| Fix asan test for various targets. | ## Code Before:
"""Distribution Strategy library."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
# pylint: disable=unused-import
from tensorflow.python.distribute import cluster_resolver
from tensorflow.python.distribute import cross_device_ops
from tensorflow.python.distribute import distribute_lib
from tensorflow.python.distribute import distribution_strategy_context
from tensorflow.python.distribute import mirrored_strategy
from tensorflow.python.distribute import one_device_strategy
from tensorflow.python.distribute.client import parameter_server_client
from tensorflow.python.distribute.experimental import collective_all_reduce_strategy
from tensorflow.python.distribute.experimental import parameter_server_strategy
# pylint: enable=unused-import
## Instruction:
Fix asan test for various targets.
## Code After:
"""Distribution Strategy library."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
# pylint: disable=unused-import
from tensorflow.python.distribute import cluster_resolver
from tensorflow.python.distribute import cross_device_ops
from tensorflow.python.distribute import distribute_lib
from tensorflow.python.distribute import distribution_strategy_context
from tensorflow.python.distribute import mirrored_strategy
from tensorflow.python.distribute import one_device_strategy
from tensorflow.python.distribute.experimental import collective_all_reduce_strategy
from tensorflow.python.distribute.experimental import parameter_server_strategy
# pylint: enable=unused-import
| """Distribution Strategy library."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
# pylint: disable=unused-import
from tensorflow.python.distribute import cluster_resolver
from tensorflow.python.distribute import cross_device_ops
from tensorflow.python.distribute import distribute_lib
from tensorflow.python.distribute import distribution_strategy_context
from tensorflow.python.distribute import mirrored_strategy
from tensorflow.python.distribute import one_device_strategy
- from tensorflow.python.distribute.client import parameter_server_client
from tensorflow.python.distribute.experimental import collective_all_reduce_strategy
from tensorflow.python.distribute.experimental import parameter_server_strategy
# pylint: enable=unused-import |
74a3fe9d83c3ccf2f6972277df3a34c47bc06c26 | slave/skia_slave_scripts/run_gyp.py | slave/skia_slave_scripts/run_gyp.py |
""" Run GYP to generate project files. """
from build_step import BuildStep
import sys
class RunGYP(BuildStep):
def _Run(self):
self._flavor_utils.RunGYP()
if '__main__' == __name__:
sys.exit(BuildStep.RunBuildStep(RunGYP)) |
""" Run GYP to generate project files. """
from build_step import BuildStep
import sys
class RunGYP(BuildStep):
def __init__(self, timeout=15000, no_output_timeout=10000,
**kwargs):
super(RunGYP, self).__init__(timeout=timeout,
no_output_timeout=no_output_timeout,
**kwargs)
def _Run(self):
self._flavor_utils.RunGYP()
if '__main__' == __name__:
sys.exit(BuildStep.RunBuildStep(RunGYP))
| Increase timeout for RunGYP step BUG=skia:1631 (SkipBuildbotRuns) | Increase timeout for RunGYP step
BUG=skia:1631
(SkipBuildbotRuns)
git-svn-id: 32fc27f4dcfb6c0385cd9719852b95fe6680452d@11229 2bbb7eff-a529-9590-31e7-b0007b416f81
| Python | bsd-3-clause | Tiger66639/skia-buildbot,Tiger66639/skia-buildbot,google/skia-buildbot,Tiger66639/skia-buildbot,google/skia-buildbot,Tiger66639/skia-buildbot,google/skia-buildbot,Tiger66639/skia-buildbot,google/skia-buildbot,google/skia-buildbot,Tiger66639/skia-buildbot,google/skia-buildbot,Tiger66639/skia-buildbot,google/skia-buildbot,google/skia-buildbot |
""" Run GYP to generate project files. """
from build_step import BuildStep
import sys
class RunGYP(BuildStep):
+ def __init__(self, timeout=15000, no_output_timeout=10000,
+ **kwargs):
+ super(RunGYP, self).__init__(timeout=timeout,
+ no_output_timeout=no_output_timeout,
+ **kwargs)
+
def _Run(self):
self._flavor_utils.RunGYP()
if '__main__' == __name__:
sys.exit(BuildStep.RunBuildStep(RunGYP))
+ | Increase timeout for RunGYP step BUG=skia:1631 (SkipBuildbotRuns) | ## Code Before:
""" Run GYP to generate project files. """
from build_step import BuildStep
import sys
class RunGYP(BuildStep):
def _Run(self):
self._flavor_utils.RunGYP()
if '__main__' == __name__:
sys.exit(BuildStep.RunBuildStep(RunGYP))
## Instruction:
Increase timeout for RunGYP step BUG=skia:1631 (SkipBuildbotRuns)
## Code After:
""" Run GYP to generate project files. """
from build_step import BuildStep
import sys
class RunGYP(BuildStep):
def __init__(self, timeout=15000, no_output_timeout=10000,
**kwargs):
super(RunGYP, self).__init__(timeout=timeout,
no_output_timeout=no_output_timeout,
**kwargs)
def _Run(self):
self._flavor_utils.RunGYP()
if '__main__' == __name__:
sys.exit(BuildStep.RunBuildStep(RunGYP))
|
""" Run GYP to generate project files. """
from build_step import BuildStep
import sys
class RunGYP(BuildStep):
+ def __init__(self, timeout=15000, no_output_timeout=10000,
+ **kwargs):
+ super(RunGYP, self).__init__(timeout=timeout,
+ no_output_timeout=no_output_timeout,
+ **kwargs)
+
def _Run(self):
self._flavor_utils.RunGYP()
if '__main__' == __name__:
sys.exit(BuildStep.RunBuildStep(RunGYP)) |
c04b8932ec65480ba90dd4578d5f6bb8c3baa690 | demosys/project/default.py | demosys/project/default.py | from demosys.project.base import BaseProject
from demosys.effects.registry import effects, parse_package_string
class Project(BaseProject):
"""
The project what will be assigned when no project are specified.
This is mainly used when the ``runeffect`` command is used
"""
def __init__(self, effect_package):
super().__init__()
self.path = effect_package
self.effect_package_name, self.effect_class_name = parse_package_string(effect_package)
self.effect_packages = [self.effect_package_name]
self.effect = None
def get_default_effect(self):
return self.effect
def create_resources(self):
pass
def create_effect_instances(self):
cls = effects.find_effect_class(self.path)
if not cls.runnable:
raise ValueError("Effect doesn't have the runnable flag set:", self.path)
self.effect = self.create_effect('default', cls.__name__)
| from demosys.project.base import BaseProject
from demosys.effects.registry import effects, parse_package_string
class Project(BaseProject):
"""
The project what will be assigned when no project are specified.
This is mainly used when the ``runeffect`` command is used
"""
def __init__(self, effect_package):
super().__init__()
self.path = effect_package
self.effect_package_name, self.effect_class_name = parse_package_string(effect_package)
self.effect_packages = [self.effect_package_name]
self.effect = None
def get_default_effect(self):
return self.effect
def create_resources(self):
pass
def create_effect_instances(self):
if self.effect_class_name:
cls = effects.find_effect_class(self.path)
if not cls.runnable:
raise ValueError("Effect doesn't have the runnable flag set:", self.path)
else:
effect_package = effects.get_package(self.effect_package_name)
runnable_effects = effect_package.runnable_effects()
if not runnable_effects:
raise ValueError("No runnable effects found in effect package", self.effect_package_name)
cls = runnable_effects[-1]
self.effect = self.create_effect('default', cls.__name__)
| Improve errors when effect packages or effects are not found | Improve errors when effect packages or effects are not found
| Python | isc | Contraz/demosys-py | from demosys.project.base import BaseProject
from demosys.effects.registry import effects, parse_package_string
class Project(BaseProject):
"""
The project what will be assigned when no project are specified.
This is mainly used when the ``runeffect`` command is used
"""
def __init__(self, effect_package):
super().__init__()
self.path = effect_package
self.effect_package_name, self.effect_class_name = parse_package_string(effect_package)
self.effect_packages = [self.effect_package_name]
self.effect = None
def get_default_effect(self):
return self.effect
def create_resources(self):
pass
def create_effect_instances(self):
+ if self.effect_class_name:
- cls = effects.find_effect_class(self.path)
+ cls = effects.find_effect_class(self.path)
+ if not cls.runnable:
+ raise ValueError("Effect doesn't have the runnable flag set:", self.path)
+ else:
+ effect_package = effects.get_package(self.effect_package_name)
+ runnable_effects = effect_package.runnable_effects()
- if not cls.runnable:
+ if not runnable_effects:
- raise ValueError("Effect doesn't have the runnable flag set:", self.path)
+ raise ValueError("No runnable effects found in effect package", self.effect_package_name)
+
+ cls = runnable_effects[-1]
self.effect = self.create_effect('default', cls.__name__)
| Improve errors when effect packages or effects are not found | ## Code Before:
from demosys.project.base import BaseProject
from demosys.effects.registry import effects, parse_package_string
class Project(BaseProject):
"""
The project what will be assigned when no project are specified.
This is mainly used when the ``runeffect`` command is used
"""
def __init__(self, effect_package):
super().__init__()
self.path = effect_package
self.effect_package_name, self.effect_class_name = parse_package_string(effect_package)
self.effect_packages = [self.effect_package_name]
self.effect = None
def get_default_effect(self):
return self.effect
def create_resources(self):
pass
def create_effect_instances(self):
cls = effects.find_effect_class(self.path)
if not cls.runnable:
raise ValueError("Effect doesn't have the runnable flag set:", self.path)
self.effect = self.create_effect('default', cls.__name__)
## Instruction:
Improve errors when effect packages or effects are not found
## Code After:
from demosys.project.base import BaseProject
from demosys.effects.registry import effects, parse_package_string
class Project(BaseProject):
"""
The project what will be assigned when no project are specified.
This is mainly used when the ``runeffect`` command is used
"""
def __init__(self, effect_package):
super().__init__()
self.path = effect_package
self.effect_package_name, self.effect_class_name = parse_package_string(effect_package)
self.effect_packages = [self.effect_package_name]
self.effect = None
def get_default_effect(self):
return self.effect
def create_resources(self):
pass
def create_effect_instances(self):
if self.effect_class_name:
cls = effects.find_effect_class(self.path)
if not cls.runnable:
raise ValueError("Effect doesn't have the runnable flag set:", self.path)
else:
effect_package = effects.get_package(self.effect_package_name)
runnable_effects = effect_package.runnable_effects()
if not runnable_effects:
raise ValueError("No runnable effects found in effect package", self.effect_package_name)
cls = runnable_effects[-1]
self.effect = self.create_effect('default', cls.__name__)
| from demosys.project.base import BaseProject
from demosys.effects.registry import effects, parse_package_string
class Project(BaseProject):
"""
The project what will be assigned when no project are specified.
This is mainly used when the ``runeffect`` command is used
"""
def __init__(self, effect_package):
super().__init__()
self.path = effect_package
self.effect_package_name, self.effect_class_name = parse_package_string(effect_package)
self.effect_packages = [self.effect_package_name]
self.effect = None
def get_default_effect(self):
return self.effect
def create_resources(self):
pass
def create_effect_instances(self):
+ if self.effect_class_name:
- cls = effects.find_effect_class(self.path)
+ cls = effects.find_effect_class(self.path)
? ++++
+ if not cls.runnable:
+ raise ValueError("Effect doesn't have the runnable flag set:", self.path)
+ else:
+ effect_package = effects.get_package(self.effect_package_name)
+ runnable_effects = effect_package.runnable_effects()
- if not cls.runnable:
? ----
+ if not runnable_effects:
? ++++ ++++++++
- raise ValueError("Effect doesn't have the runnable flag set:", self.path)
+ raise ValueError("No runnable effects found in effect package", self.effect_package_name)
+
+ cls = runnable_effects[-1]
self.effect = self.create_effect('default', cls.__name__) |
194e01f54c710c7eebc0105942c10337dedb90d9 | setup.py | setup.py |
from distutils.core import setup
import os
from deflect import __version__ as version
def read_file(filename):
"""
Utility function to read a provided filename.
"""
return open(os.path.join(os.path.dirname(__file__), filename)).read()
packages = [
'deflect',
]
package_data = {
'': ['LICENSE', 'README.rst'],
}
setup(
name='django-deflect',
version=version,
description='A Django short URL redirection application',
long_description=read_file('README.rst'),
author='Jason Bittel',
author_email='jason.bittel@gmail.com',
url='https://github.com/jbittel/django-deflect',
download_url='https://github.com/jbittel/django-deflect/downloads',
package_dir={'deflect': 'deflect'},
packages=packages,
package_data=package_data,
license='BSD',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Environment :: Web Environment',
'Programming Language :: Python',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Topic :: Software Development :: Libraries :: Python Modules',
],
keywords=['django'],
)
|
from distutils.core import setup
import os
from deflect import __version__ as version
def read_file(filename):
"""
Utility function to read a provided filename.
"""
return open(os.path.join(os.path.dirname(__file__), filename)).read()
packages = [
'deflect',
'deflect.tests',
]
package_data = {
'': ['LICENSE', 'README.rst'],
}
setup(
name='django-deflect',
version=version,
description='A Django short URL redirection application',
long_description=read_file('README.rst'),
author='Jason Bittel',
author_email='jason.bittel@gmail.com',
url='https://github.com/jbittel/django-deflect',
download_url='https://github.com/jbittel/django-deflect/downloads',
package_dir={'deflect': 'deflect'},
packages=packages,
package_data=package_data,
license='BSD',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Environment :: Web Environment',
'Programming Language :: Python',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Topic :: Software Development :: Libraries :: Python Modules',
],
keywords=['django'],
)
| Add tests module to packaging list | Add tests module to packaging list
| Python | bsd-3-clause | jbittel/django-deflect |
from distutils.core import setup
import os
from deflect import __version__ as version
def read_file(filename):
"""
Utility function to read a provided filename.
"""
return open(os.path.join(os.path.dirname(__file__), filename)).read()
packages = [
'deflect',
+ 'deflect.tests',
]
package_data = {
'': ['LICENSE', 'README.rst'],
}
setup(
name='django-deflect',
version=version,
description='A Django short URL redirection application',
long_description=read_file('README.rst'),
author='Jason Bittel',
author_email='jason.bittel@gmail.com',
url='https://github.com/jbittel/django-deflect',
download_url='https://github.com/jbittel/django-deflect/downloads',
package_dir={'deflect': 'deflect'},
packages=packages,
package_data=package_data,
license='BSD',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Environment :: Web Environment',
'Programming Language :: Python',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Topic :: Software Development :: Libraries :: Python Modules',
],
keywords=['django'],
)
| Add tests module to packaging list | ## Code Before:
from distutils.core import setup
import os
from deflect import __version__ as version
def read_file(filename):
"""
Utility function to read a provided filename.
"""
return open(os.path.join(os.path.dirname(__file__), filename)).read()
packages = [
'deflect',
]
package_data = {
'': ['LICENSE', 'README.rst'],
}
setup(
name='django-deflect',
version=version,
description='A Django short URL redirection application',
long_description=read_file('README.rst'),
author='Jason Bittel',
author_email='jason.bittel@gmail.com',
url='https://github.com/jbittel/django-deflect',
download_url='https://github.com/jbittel/django-deflect/downloads',
package_dir={'deflect': 'deflect'},
packages=packages,
package_data=package_data,
license='BSD',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Environment :: Web Environment',
'Programming Language :: Python',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Topic :: Software Development :: Libraries :: Python Modules',
],
keywords=['django'],
)
## Instruction:
Add tests module to packaging list
## Code After:
from distutils.core import setup
import os
from deflect import __version__ as version
def read_file(filename):
"""
Utility function to read a provided filename.
"""
return open(os.path.join(os.path.dirname(__file__), filename)).read()
packages = [
'deflect',
'deflect.tests',
]
package_data = {
'': ['LICENSE', 'README.rst'],
}
setup(
name='django-deflect',
version=version,
description='A Django short URL redirection application',
long_description=read_file('README.rst'),
author='Jason Bittel',
author_email='jason.bittel@gmail.com',
url='https://github.com/jbittel/django-deflect',
download_url='https://github.com/jbittel/django-deflect/downloads',
package_dir={'deflect': 'deflect'},
packages=packages,
package_data=package_data,
license='BSD',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Environment :: Web Environment',
'Programming Language :: Python',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Topic :: Software Development :: Libraries :: Python Modules',
],
keywords=['django'],
)
|
from distutils.core import setup
import os
from deflect import __version__ as version
def read_file(filename):
"""
Utility function to read a provided filename.
"""
return open(os.path.join(os.path.dirname(__file__), filename)).read()
packages = [
'deflect',
+ 'deflect.tests',
]
package_data = {
'': ['LICENSE', 'README.rst'],
}
setup(
name='django-deflect',
version=version,
description='A Django short URL redirection application',
long_description=read_file('README.rst'),
author='Jason Bittel',
author_email='jason.bittel@gmail.com',
url='https://github.com/jbittel/django-deflect',
download_url='https://github.com/jbittel/django-deflect/downloads',
package_dir={'deflect': 'deflect'},
packages=packages,
package_data=package_data,
license='BSD',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Environment :: Web Environment',
'Programming Language :: Python',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Topic :: Software Development :: Libraries :: Python Modules',
],
keywords=['django'],
) |
eb1daa3edfaa72cad2cb39507b2db0bf95204561 | markitup/renderers.py | markitup/renderers.py | from __future__ import unicode_literals
try:
from docutils.core import publish_parts
def render_rest(markup, **docutils_settings):
parts = publish_parts(source=markup, writer_name="html4css1", settings_overrides=docutils_settings)
return parts["html_body"]
except ImportError:
pass
| from __future__ import unicode_literals
try:
from docutils.core import publish_parts
def render_rest(markup, **docutils_settings):
docutils_settings.update({
'raw_enabled': False,
'file_insertion_enabled': False,
})
parts = publish_parts(
source=markup,
writer_name="html4css1",
settings_overrides=docutils_settings,
)
return parts["html_body"]
except ImportError:
pass
| Enforce better security in sample ReST renderer. | Enforce better security in sample ReST renderer.
| Python | bsd-3-clause | WimpyAnalytics/django-markitup,carljm/django-markitup,WimpyAnalytics/django-markitup,zsiciarz/django-markitup,zsiciarz/django-markitup,carljm/django-markitup,WimpyAnalytics/django-markitup,carljm/django-markitup,zsiciarz/django-markitup | from __future__ import unicode_literals
try:
from docutils.core import publish_parts
+
def render_rest(markup, **docutils_settings):
- parts = publish_parts(source=markup, writer_name="html4css1", settings_overrides=docutils_settings)
+ docutils_settings.update({
+ 'raw_enabled': False,
+ 'file_insertion_enabled': False,
+ })
+
+ parts = publish_parts(
+ source=markup,
+ writer_name="html4css1",
+ settings_overrides=docutils_settings,
+ )
return parts["html_body"]
except ImportError:
pass
| Enforce better security in sample ReST renderer. | ## Code Before:
from __future__ import unicode_literals
try:
from docutils.core import publish_parts
def render_rest(markup, **docutils_settings):
parts = publish_parts(source=markup, writer_name="html4css1", settings_overrides=docutils_settings)
return parts["html_body"]
except ImportError:
pass
## Instruction:
Enforce better security in sample ReST renderer.
## Code After:
from __future__ import unicode_literals
try:
from docutils.core import publish_parts
def render_rest(markup, **docutils_settings):
docutils_settings.update({
'raw_enabled': False,
'file_insertion_enabled': False,
})
parts = publish_parts(
source=markup,
writer_name="html4css1",
settings_overrides=docutils_settings,
)
return parts["html_body"]
except ImportError:
pass
| from __future__ import unicode_literals
try:
from docutils.core import publish_parts
+
def render_rest(markup, **docutils_settings):
- parts = publish_parts(source=markup, writer_name="html4css1", settings_overrides=docutils_settings)
+ docutils_settings.update({
+ 'raw_enabled': False,
+ 'file_insertion_enabled': False,
+ })
+
+ parts = publish_parts(
+ source=markup,
+ writer_name="html4css1",
+ settings_overrides=docutils_settings,
+ )
return parts["html_body"]
except ImportError:
pass |
afb8aadcc1dbea109c7882c1a1d65fc328372a74 | resources/Dependencies/DecoraterBotCore/Core.py | resources/Dependencies/DecoraterBotCore/Core.py | from DecoraterBotUtils.utils import BaseClient, config
__all__ = ['main', 'BotClient']
class BotClient(BaseClient):
"""
Bot Main client Class.
This is where the Events are Registered.
"""
def __init__(self, **kwargs):
super(BotClient, self).__init__(**kwargs)
def main():
"""
EntryPoint to DecoraterBot.
"""
BotClient(command_prefix=config.bot_prefix,
description=config.description,
pm_help=False)
| from DecoraterBotUtils.utils import BotClient, config
__all__ = ['main']
def main():
"""
EntryPoint to DecoraterBot.
"""
BotClient(command_prefix=config.bot_prefix,
description=config.description,
pm_help=False)
| Update to use new client class name on the DecoraterBotUtils.utils module. | Update to use new client class name on the DecoraterBotUtils.utils module.
| Python | mit | DecoraterBot-devs/DecoraterBot | - from DecoraterBotUtils.utils import BaseClient, config
+ from DecoraterBotUtils.utils import BotClient, config
+ __all__ = ['main']
- __all__ = ['main', 'BotClient']
-
-
- class BotClient(BaseClient):
- """
- Bot Main client Class.
- This is where the Events are Registered.
- """
- def __init__(self, **kwargs):
- super(BotClient, self).__init__(**kwargs)
def main():
"""
EntryPoint to DecoraterBot.
"""
BotClient(command_prefix=config.bot_prefix,
description=config.description,
pm_help=False)
| Update to use new client class name on the DecoraterBotUtils.utils module. | ## Code Before:
from DecoraterBotUtils.utils import BaseClient, config
__all__ = ['main', 'BotClient']
class BotClient(BaseClient):
"""
Bot Main client Class.
This is where the Events are Registered.
"""
def __init__(self, **kwargs):
super(BotClient, self).__init__(**kwargs)
def main():
"""
EntryPoint to DecoraterBot.
"""
BotClient(command_prefix=config.bot_prefix,
description=config.description,
pm_help=False)
## Instruction:
Update to use new client class name on the DecoraterBotUtils.utils module.
## Code After:
from DecoraterBotUtils.utils import BotClient, config
__all__ = ['main']
def main():
"""
EntryPoint to DecoraterBot.
"""
BotClient(command_prefix=config.bot_prefix,
description=config.description,
pm_help=False)
| - from DecoraterBotUtils.utils import BaseClient, config
? ^^^
+ from DecoraterBotUtils.utils import BotClient, config
? ^^
+ __all__ = ['main']
- __all__ = ['main', 'BotClient']
-
-
- class BotClient(BaseClient):
- """
- Bot Main client Class.
- This is where the Events are Registered.
- """
- def __init__(self, **kwargs):
- super(BotClient, self).__init__(**kwargs)
def main():
"""
EntryPoint to DecoraterBot.
"""
BotClient(command_prefix=config.bot_prefix,
description=config.description,
pm_help=False) |
add6013c8484e56545ed2f11c8c6e042c1384429 | swf/exceptions.py | swf/exceptions.py |
class PollTimeout(Exception):
pass
class InvalidCredentialsError(Exception):
pass
class ResponseError(Exception):
pass
class DoesNotExistError(Exception):
pass
class AlreadyExistsError(Exception):
pass
class InvalidKeywordArgumentError(Exception):
pass
|
class SWFError(Exception):
def __init__(self, message, raw_error, *args):
Exception.__init__(self, message, *args)
self.kind, self.details = raw_error.split(':')
def __repr__(self):
msg = self.message
if self.kind and self.details:
msg += '\nReason: {}, {}'.format(self.kind, self.details)
return msg
def __str__(self):
msg = self.message
if self.kind and self.details:
msg += '\nReason: {}, {}'.format(self.kind, self.details)
return msg
class PollTimeout(SWFError):
pass
class InvalidCredentialsError(SWFError):
pass
class ResponseError(SWFError):
pass
class DoesNotExistError(SWFError):
pass
class AlreadyExistsError(SWFError):
pass
class InvalidKeywordArgumentError(SWFError):
pass
| Enhance swf errors wrapping via an exception helper | Enhance swf errors wrapping via an exception helper
| Python | mit | botify-labs/python-simple-workflow,botify-labs/python-simple-workflow | +
+ class SWFError(Exception):
+ def __init__(self, message, raw_error, *args):
+ Exception.__init__(self, message, *args)
+ self.kind, self.details = raw_error.split(':')
+
+ def __repr__(self):
+ msg = self.message
+
+ if self.kind and self.details:
+ msg += '\nReason: {}, {}'.format(self.kind, self.details)
+
+ return msg
+
+ def __str__(self):
+ msg = self.message
+
+ if self.kind and self.details:
+ msg += '\nReason: {}, {}'.format(self.kind, self.details)
+
+ return msg
- class PollTimeout(Exception):
+ class PollTimeout(SWFError):
pass
- class InvalidCredentialsError(Exception):
+ class InvalidCredentialsError(SWFError):
pass
- class ResponseError(Exception):
+ class ResponseError(SWFError):
pass
- class DoesNotExistError(Exception):
+ class DoesNotExistError(SWFError):
pass
- class AlreadyExistsError(Exception):
+ class AlreadyExistsError(SWFError):
pass
- class InvalidKeywordArgumentError(Exception):
+ class InvalidKeywordArgumentError(SWFError):
pass
| Enhance swf errors wrapping via an exception helper | ## Code Before:
class PollTimeout(Exception):
pass
class InvalidCredentialsError(Exception):
pass
class ResponseError(Exception):
pass
class DoesNotExistError(Exception):
pass
class AlreadyExistsError(Exception):
pass
class InvalidKeywordArgumentError(Exception):
pass
## Instruction:
Enhance swf errors wrapping via an exception helper
## Code After:
class SWFError(Exception):
def __init__(self, message, raw_error, *args):
Exception.__init__(self, message, *args)
self.kind, self.details = raw_error.split(':')
def __repr__(self):
msg = self.message
if self.kind and self.details:
msg += '\nReason: {}, {}'.format(self.kind, self.details)
return msg
def __str__(self):
msg = self.message
if self.kind and self.details:
msg += '\nReason: {}, {}'.format(self.kind, self.details)
return msg
class PollTimeout(SWFError):
pass
class InvalidCredentialsError(SWFError):
pass
class ResponseError(SWFError):
pass
class DoesNotExistError(SWFError):
pass
class AlreadyExistsError(SWFError):
pass
class InvalidKeywordArgumentError(SWFError):
pass
| +
+ class SWFError(Exception):
+ def __init__(self, message, raw_error, *args):
+ Exception.__init__(self, message, *args)
+ self.kind, self.details = raw_error.split(':')
+
+ def __repr__(self):
+ msg = self.message
+
+ if self.kind and self.details:
+ msg += '\nReason: {}, {}'.format(self.kind, self.details)
+
+ return msg
+
+ def __str__(self):
+ msg = self.message
+
+ if self.kind and self.details:
+ msg += '\nReason: {}, {}'.format(self.kind, self.details)
+
+ return msg
- class PollTimeout(Exception):
? ^^^^^^ ^
+ class PollTimeout(SWFError):
? +++ ^^ ^
pass
- class InvalidCredentialsError(Exception):
? ^^^^^^ ^
+ class InvalidCredentialsError(SWFError):
? +++ ^^ ^
pass
- class ResponseError(Exception):
? ^^^^^^ ^
+ class ResponseError(SWFError):
? +++ ^^ ^
pass
- class DoesNotExistError(Exception):
? ^^^^^^ ^
+ class DoesNotExistError(SWFError):
? +++ ^^ ^
pass
- class AlreadyExistsError(Exception):
? ^^^^^^ ^
+ class AlreadyExistsError(SWFError):
? +++ ^^ ^
pass
- class InvalidKeywordArgumentError(Exception):
? ^^^^^^ ^
+ class InvalidKeywordArgumentError(SWFError):
? +++ ^^ ^
pass |
8209b77a16c899436418dbc85dc891f671949bfc | bot/logger/message_sender/asynchronous.py | bot/logger/message_sender/asynchronous.py | from bot.logger.message_sender import IntermediateMessageSender, MessageSender
from bot.multithreading.work import Work
from bot.multithreading.worker import Worker
class AsynchronousMessageSender(IntermediateMessageSender):
def __init__(self, sender: MessageSender, worker: Worker):
super().__init__(sender)
self.worker = worker
def send(self, text):
self.worker.post(Work(lambda: self.sender.send(text), "async_message_send"))
| from bot.logger.message_sender import IntermediateMessageSender, MessageSender
from bot.multithreading.work import Work
from bot.multithreading.worker import Worker
class AsynchronousMessageSender(IntermediateMessageSender):
def __init__(self, sender: MessageSender, worker: Worker):
super().__init__(sender)
self.worker = worker
def send(self, text):
self.worker.post(Work(lambda: self.sender.send(text), "asynchronous_message_sender:send"))
| Clarify work action in AsynchronousMessageSender | Clarify work action in AsynchronousMessageSender
| Python | agpl-3.0 | alvarogzp/telegram-bot,alvarogzp/telegram-bot | from bot.logger.message_sender import IntermediateMessageSender, MessageSender
from bot.multithreading.work import Work
from bot.multithreading.worker import Worker
class AsynchronousMessageSender(IntermediateMessageSender):
def __init__(self, sender: MessageSender, worker: Worker):
super().__init__(sender)
self.worker = worker
def send(self, text):
- self.worker.post(Work(lambda: self.sender.send(text), "async_message_send"))
+ self.worker.post(Work(lambda: self.sender.send(text), "asynchronous_message_sender:send"))
| Clarify work action in AsynchronousMessageSender | ## Code Before:
from bot.logger.message_sender import IntermediateMessageSender, MessageSender
from bot.multithreading.work import Work
from bot.multithreading.worker import Worker
class AsynchronousMessageSender(IntermediateMessageSender):
def __init__(self, sender: MessageSender, worker: Worker):
super().__init__(sender)
self.worker = worker
def send(self, text):
self.worker.post(Work(lambda: self.sender.send(text), "async_message_send"))
## Instruction:
Clarify work action in AsynchronousMessageSender
## Code After:
from bot.logger.message_sender import IntermediateMessageSender, MessageSender
from bot.multithreading.work import Work
from bot.multithreading.worker import Worker
class AsynchronousMessageSender(IntermediateMessageSender):
def __init__(self, sender: MessageSender, worker: Worker):
super().__init__(sender)
self.worker = worker
def send(self, text):
self.worker.post(Work(lambda: self.sender.send(text), "asynchronous_message_sender:send"))
| from bot.logger.message_sender import IntermediateMessageSender, MessageSender
from bot.multithreading.work import Work
from bot.multithreading.worker import Worker
class AsynchronousMessageSender(IntermediateMessageSender):
def __init__(self, sender: MessageSender, worker: Worker):
super().__init__(sender)
self.worker = worker
def send(self, text):
- self.worker.post(Work(lambda: self.sender.send(text), "async_message_send"))
+ self.worker.post(Work(lambda: self.sender.send(text), "asynchronous_message_sender:send"))
? +++++++ +++++++
|
2a6399a74110b6a9e0d48349c68775986c13a579 | pyservice/context.py | pyservice/context.py | import collections
class Container(collections.defaultdict):
DEFAULT_FACTORY = lambda: None
def __init__(self):
super().__init__(self, Container.DEFAULT_FACTORY)
def __getattr__(self, name):
return self[name]
def __setattr__(self, name, value):
self[name] = value
class Context(object):
def __init__(self, service, operation):
self.service = service
self.operation = operation
def execute(self):
self.service.continue_execution(self)
| import ujson
import collections
class Container(collections.defaultdict):
DEFAULT_FACTORY = lambda: None
def __init__(self):
super().__init__(self, Container.DEFAULT_FACTORY)
def __getattr__(self, name):
return self[name]
def __setattr__(self, name, value):
self[name] = value
class Context(object):
def __init__(self, service, operation, processor):
self.service = service
self.operation = operation
self.processor = processor
def process_request(self):
self.processor.continue_execution()
class Processor(object):
def __init__(self, service, operation, request_body):
self.service = service
self.operation = operation
self.context = Context(service, operation, self)
self.request = Container()
self.request_body = request_body
self.response = Container()
self.response_body = None
self.plugins = service.get_plugins(operation)
self.index = -1
self.state = "request" # request -> operation -> function
def execute(self):
self.context.process_request()
def continue_execution(self):
self.index += 1
plugins = self.plugins[self.state]
n = len(plugins)
if self.index > n:
# Terminal point so that service.invoke
# can safely call context.process_request()
return
elif self.index == n:
if self.state == "request":
self.index = -1
self.state = "operation"
self._deserialize_request()
self.continue_execution()
self._serialize_response()
elif self.state == "operation":
self.service.invoke(self.operation, self.request,
self.response, self.context)
# index < n
else:
if self.state == "request":
plugins[self.index](self.context)
elif self.state == "operation":
plugins[self.index](self.request, self.response, self.context)
def _deserialize_request(self):
self.request.update(ujson.loads(self.request_body))
def _serialize_response(self):
self.response_body = ujson.dumps(self.response)
| Create class for request process recursion | Create class for request process recursion
| Python | mit | numberoverzero/pyservice | + import ujson
import collections
class Container(collections.defaultdict):
DEFAULT_FACTORY = lambda: None
def __init__(self):
super().__init__(self, Container.DEFAULT_FACTORY)
def __getattr__(self, name):
return self[name]
def __setattr__(self, name, value):
self[name] = value
class Context(object):
- def __init__(self, service, operation):
+ def __init__(self, service, operation, processor):
+ self.service = service
+ self.operation = operation
+ self.processor = processor
+
+ def process_request(self):
+ self.processor.continue_execution()
+
+
+ class Processor(object):
+ def __init__(self, service, operation, request_body):
self.service = service
self.operation = operation
+ self.context = Context(service, operation, self)
+ self.request = Container()
+ self.request_body = request_body
+ self.response = Container()
+ self.response_body = None
+
+ self.plugins = service.get_plugins(operation)
+
+ self.index = -1
+ self.state = "request" # request -> operation -> function
+
def execute(self):
- self.service.continue_execution(self)
+ self.context.process_request()
+ def continue_execution(self):
+ self.index += 1
+ plugins = self.plugins[self.state]
+ n = len(plugins)
+
+ if self.index > n:
+ # Terminal point so that service.invoke
+ # can safely call context.process_request()
+ return
+ elif self.index == n:
+ if self.state == "request":
+ self.index = -1
+ self.state = "operation"
+
+ self._deserialize_request()
+ self.continue_execution()
+ self._serialize_response()
+ elif self.state == "operation":
+ self.service.invoke(self.operation, self.request,
+ self.response, self.context)
+ # index < n
+ else:
+ if self.state == "request":
+ plugins[self.index](self.context)
+ elif self.state == "operation":
+ plugins[self.index](self.request, self.response, self.context)
+
+ def _deserialize_request(self):
+ self.request.update(ujson.loads(self.request_body))
+
+ def _serialize_response(self):
+ self.response_body = ujson.dumps(self.response)
+ | Create class for request process recursion | ## Code Before:
import collections
class Container(collections.defaultdict):
DEFAULT_FACTORY = lambda: None
def __init__(self):
super().__init__(self, Container.DEFAULT_FACTORY)
def __getattr__(self, name):
return self[name]
def __setattr__(self, name, value):
self[name] = value
class Context(object):
def __init__(self, service, operation):
self.service = service
self.operation = operation
def execute(self):
self.service.continue_execution(self)
## Instruction:
Create class for request process recursion
## Code After:
import ujson
import collections
class Container(collections.defaultdict):
DEFAULT_FACTORY = lambda: None
def __init__(self):
super().__init__(self, Container.DEFAULT_FACTORY)
def __getattr__(self, name):
return self[name]
def __setattr__(self, name, value):
self[name] = value
class Context(object):
def __init__(self, service, operation, processor):
self.service = service
self.operation = operation
self.processor = processor
def process_request(self):
self.processor.continue_execution()
class Processor(object):
def __init__(self, service, operation, request_body):
self.service = service
self.operation = operation
self.context = Context(service, operation, self)
self.request = Container()
self.request_body = request_body
self.response = Container()
self.response_body = None
self.plugins = service.get_plugins(operation)
self.index = -1
self.state = "request" # request -> operation -> function
def execute(self):
self.context.process_request()
def continue_execution(self):
self.index += 1
plugins = self.plugins[self.state]
n = len(plugins)
if self.index > n:
# Terminal point so that service.invoke
# can safely call context.process_request()
return
elif self.index == n:
if self.state == "request":
self.index = -1
self.state = "operation"
self._deserialize_request()
self.continue_execution()
self._serialize_response()
elif self.state == "operation":
self.service.invoke(self.operation, self.request,
self.response, self.context)
# index < n
else:
if self.state == "request":
plugins[self.index](self.context)
elif self.state == "operation":
plugins[self.index](self.request, self.response, self.context)
def _deserialize_request(self):
self.request.update(ujson.loads(self.request_body))
def _serialize_response(self):
self.response_body = ujson.dumps(self.response)
| + import ujson
import collections
class Container(collections.defaultdict):
DEFAULT_FACTORY = lambda: None
def __init__(self):
super().__init__(self, Container.DEFAULT_FACTORY)
def __getattr__(self, name):
return self[name]
def __setattr__(self, name, value):
self[name] = value
class Context(object):
- def __init__(self, service, operation):
+ def __init__(self, service, operation, processor):
? +++++++++++
+ self.service = service
+ self.operation = operation
+ self.processor = processor
+
+ def process_request(self):
+ self.processor.continue_execution()
+
+
+ class Processor(object):
+ def __init__(self, service, operation, request_body):
self.service = service
self.operation = operation
+ self.context = Context(service, operation, self)
+ self.request = Container()
+ self.request_body = request_body
+ self.response = Container()
+ self.response_body = None
+
+ self.plugins = service.get_plugins(operation)
+
+ self.index = -1
+ self.state = "request" # request -> operation -> function
+
def execute(self):
+ self.context.process_request()
+
+ def continue_execution(self):
+ self.index += 1
+ plugins = self.plugins[self.state]
+ n = len(plugins)
+
+ if self.index > n:
+ # Terminal point so that service.invoke
+ # can safely call context.process_request()
+ return
+ elif self.index == n:
+ if self.state == "request":
+ self.index = -1
+ self.state = "operation"
+
+ self._deserialize_request()
- self.service.continue_execution(self)
? -------- ----
+ self.continue_execution()
? ++++++++
+ self._serialize_response()
+ elif self.state == "operation":
+ self.service.invoke(self.operation, self.request,
+ self.response, self.context)
+ # index < n
+ else:
+ if self.state == "request":
+ plugins[self.index](self.context)
+ elif self.state == "operation":
+ plugins[self.index](self.request, self.response, self.context)
+
+ def _deserialize_request(self):
+ self.request.update(ujson.loads(self.request_body))
+
+ def _serialize_response(self):
+ self.response_body = ujson.dumps(self.response) |
89a5f257cd1fb285db78b6178e9418fbf48fdaf4 | YouKnowShit/DownloadFilesRename.py | YouKnowShit/DownloadFilesRename.py | import requests
import bs4
import os
import urllib.request
import shutil
import re
distDir = 'F:\\utorrent\\WEST'
p = re.compile(r'(\D+\d+)\w*(.\w+)')
filenames = os.listdir(distDir)
upperfilenames = []
print(filenames)
for filenamepref in filenames:
if (filenamepref.find('_') > 0):
filenameprefit = filenamepref[filenamepref.index('_'):]
else:
filenameprefit = filenamepref
filenamepost = filenameprefit.replace('-', '').replace('_', '')\
.replace(' ', '').replace('.1080p', '').replace('.720p', '')
distname = p.search(filenamepost).group(1).upper() + p.search(filenamepost).group(2).lower()
print(distname)
os.rename(distDir + os.sep + filenamepref, distDir + os.sep + distname) | import os
import re
distDir = 'H:\\temp'
p = re.compile(r'(\D+\d+)\w*(.\w+)')
filenames = os.listdir(distDir)
upperfilenames = []
print(filenames)
for filenamepref in filenames:
if filenamepref.find('_') > 0:
filenameprefit = filenamepref[filenamepref.index('_'):]
else:
filenameprefit = filenamepref
filenamepost = filenameprefit.replace('-', '').replace('_', '')\
.replace(' ', '').replace('.1080p', '').replace('.720p', '')\
.replace('[thz.la]', '').replace('[Thz.la]', '')
distname = p.search(filenamepost).group(1).upper() + p.search(filenamepost).group(2).lower()
print(distname)
os.rename(distDir + os.sep + filenamepref, distDir + os.sep + distname)
| Remove [thz.la] from file names. | Remove [thz.la] from file names.
| Python | mit | jiangtianyu2009/PiSoftCake | - import requests
- import bs4
import os
- import urllib.request
- import shutil
import re
- distDir = 'F:\\utorrent\\WEST'
+ distDir = 'H:\\temp'
p = re.compile(r'(\D+\d+)\w*(.\w+)')
filenames = os.listdir(distDir)
upperfilenames = []
print(filenames)
for filenamepref in filenames:
- if (filenamepref.find('_') > 0):
+ if filenamepref.find('_') > 0:
filenameprefit = filenamepref[filenamepref.index('_'):]
else:
filenameprefit = filenamepref
filenamepost = filenameprefit.replace('-', '').replace('_', '')\
- .replace(' ', '').replace('.1080p', '').replace('.720p', '')
+ .replace(' ', '').replace('.1080p', '').replace('.720p', '')\
+ .replace('[thz.la]', '').replace('[Thz.la]', '')
distname = p.search(filenamepost).group(1).upper() + p.search(filenamepost).group(2).lower()
print(distname)
os.rename(distDir + os.sep + filenamepref, distDir + os.sep + distname)
+ | Remove [thz.la] from file names. | ## Code Before:
import requests
import bs4
import os
import urllib.request
import shutil
import re
distDir = 'F:\\utorrent\\WEST'
p = re.compile(r'(\D+\d+)\w*(.\w+)')
filenames = os.listdir(distDir)
upperfilenames = []
print(filenames)
for filenamepref in filenames:
if (filenamepref.find('_') > 0):
filenameprefit = filenamepref[filenamepref.index('_'):]
else:
filenameprefit = filenamepref
filenamepost = filenameprefit.replace('-', '').replace('_', '')\
.replace(' ', '').replace('.1080p', '').replace('.720p', '')
distname = p.search(filenamepost).group(1).upper() + p.search(filenamepost).group(2).lower()
print(distname)
os.rename(distDir + os.sep + filenamepref, distDir + os.sep + distname)
## Instruction:
Remove [thz.la] from file names.
## Code After:
import os
import re
distDir = 'H:\\temp'
p = re.compile(r'(\D+\d+)\w*(.\w+)')
filenames = os.listdir(distDir)
upperfilenames = []
print(filenames)
for filenamepref in filenames:
if filenamepref.find('_') > 0:
filenameprefit = filenamepref[filenamepref.index('_'):]
else:
filenameprefit = filenamepref
filenamepost = filenameprefit.replace('-', '').replace('_', '')\
.replace(' ', '').replace('.1080p', '').replace('.720p', '')\
.replace('[thz.la]', '').replace('[Thz.la]', '')
distname = p.search(filenamepost).group(1).upper() + p.search(filenamepost).group(2).lower()
print(distname)
os.rename(distDir + os.sep + filenamepref, distDir + os.sep + distname)
| - import requests
- import bs4
import os
- import urllib.request
- import shutil
import re
- distDir = 'F:\\utorrent\\WEST'
+ distDir = 'H:\\temp'
p = re.compile(r'(\D+\d+)\w*(.\w+)')
filenames = os.listdir(distDir)
upperfilenames = []
print(filenames)
for filenamepref in filenames:
- if (filenamepref.find('_') > 0):
? - -
+ if filenamepref.find('_') > 0:
filenameprefit = filenamepref[filenamepref.index('_'):]
else:
filenameprefit = filenamepref
filenamepost = filenameprefit.replace('-', '').replace('_', '')\
- .replace(' ', '').replace('.1080p', '').replace('.720p', '')
+ .replace(' ', '').replace('.1080p', '').replace('.720p', '')\
? +
+ .replace('[thz.la]', '').replace('[Thz.la]', '')
distname = p.search(filenamepost).group(1).upper() + p.search(filenamepost).group(2).lower()
print(distname)
os.rename(distDir + os.sep + filenamepref, distDir + os.sep + distname) |
9ad98b4bbed0c67f25576187996e7e1d534f6a90 | mammoth/__init__.py | mammoth/__init__.py | from .results import Result
from . import docx, conversion, style_reader
def convert_to_html(fileobj):
return docx.read(fileobj).bind(lambda document:
conversion.convert_document_element_to_html(document, styles=_create_default_styles())
)
def _create_default_styles():
lines = filter(None, map(lambda line: line.strip(), _default_styles.split("\n")))
return map(style_reader.read_style, lines)
_default_styles = """
p:unordered-list(1) => ul > li:fresh
"""
| from .results import Result
from . import docx, conversion, style_reader
def convert_to_html(fileobj):
return docx.read(fileobj).bind(lambda document:
conversion.convert_document_element_to_html(document, styles=_create_default_styles())
)
def _create_default_styles():
lines = filter(None, map(lambda line: line.strip(), _default_styles.split("\n")))
return map(style_reader.read_style, lines)
_default_styles = """
p.Heading1 => h1:fresh
p.Heading2 => h2:fresh
p.Heading3 => h3:fresh
p.Heading4 => h4:fresh
p:unordered-list(1) => ul > li:fresh
p:unordered-list(2) => ul|ol > li > ul > li:fresh
p:unordered-list(3) => ul|ol > li > ul|ol > li > ul > li:fresh
p:unordered-list(4) => ul|ol > li > ul|ol > li > ul|ol > li > ul > li:fresh
p:unordered-list(5) => ul|ol > li > ul|ol > li > ul|ol > li > ul|ol > li > ul > li:fresh
p:ordered-list(1) => ol > li:fresh
p:ordered-list(2) => ul|ol > li > ol > li:fresh
p:ordered-list(3) => ul|ol > li > ul|ol > li > ol > li:fresh
p:ordered-list(4) => ul|ol > li > ul|ol > li > ul|ol > li > ol > li:fresh
p:ordered-list(5) => ul|ol > li > ul|ol > li > ul|ol > li > ul|ol > li > ol > li:fresh
"""
| Add full list of default styles | Add full list of default styles
| Python | bsd-2-clause | mwilliamson/python-mammoth,JoshBarr/python-mammoth | from .results import Result
from . import docx, conversion, style_reader
def convert_to_html(fileobj):
return docx.read(fileobj).bind(lambda document:
conversion.convert_document_element_to_html(document, styles=_create_default_styles())
)
def _create_default_styles():
lines = filter(None, map(lambda line: line.strip(), _default_styles.split("\n")))
return map(style_reader.read_style, lines)
_default_styles = """
+ p.Heading1 => h1:fresh
+ p.Heading2 => h2:fresh
+ p.Heading3 => h3:fresh
+ p.Heading4 => h4:fresh
p:unordered-list(1) => ul > li:fresh
+ p:unordered-list(2) => ul|ol > li > ul > li:fresh
+ p:unordered-list(3) => ul|ol > li > ul|ol > li > ul > li:fresh
+ p:unordered-list(4) => ul|ol > li > ul|ol > li > ul|ol > li > ul > li:fresh
+ p:unordered-list(5) => ul|ol > li > ul|ol > li > ul|ol > li > ul|ol > li > ul > li:fresh
+ p:ordered-list(1) => ol > li:fresh
+ p:ordered-list(2) => ul|ol > li > ol > li:fresh
+ p:ordered-list(3) => ul|ol > li > ul|ol > li > ol > li:fresh
+ p:ordered-list(4) => ul|ol > li > ul|ol > li > ul|ol > li > ol > li:fresh
+ p:ordered-list(5) => ul|ol > li > ul|ol > li > ul|ol > li > ul|ol > li > ol > li:fresh
"""
| Add full list of default styles | ## Code Before:
from .results import Result
from . import docx, conversion, style_reader
def convert_to_html(fileobj):
return docx.read(fileobj).bind(lambda document:
conversion.convert_document_element_to_html(document, styles=_create_default_styles())
)
def _create_default_styles():
lines = filter(None, map(lambda line: line.strip(), _default_styles.split("\n")))
return map(style_reader.read_style, lines)
_default_styles = """
p:unordered-list(1) => ul > li:fresh
"""
## Instruction:
Add full list of default styles
## Code After:
from .results import Result
from . import docx, conversion, style_reader
def convert_to_html(fileobj):
return docx.read(fileobj).bind(lambda document:
conversion.convert_document_element_to_html(document, styles=_create_default_styles())
)
def _create_default_styles():
lines = filter(None, map(lambda line: line.strip(), _default_styles.split("\n")))
return map(style_reader.read_style, lines)
_default_styles = """
p.Heading1 => h1:fresh
p.Heading2 => h2:fresh
p.Heading3 => h3:fresh
p.Heading4 => h4:fresh
p:unordered-list(1) => ul > li:fresh
p:unordered-list(2) => ul|ol > li > ul > li:fresh
p:unordered-list(3) => ul|ol > li > ul|ol > li > ul > li:fresh
p:unordered-list(4) => ul|ol > li > ul|ol > li > ul|ol > li > ul > li:fresh
p:unordered-list(5) => ul|ol > li > ul|ol > li > ul|ol > li > ul|ol > li > ul > li:fresh
p:ordered-list(1) => ol > li:fresh
p:ordered-list(2) => ul|ol > li > ol > li:fresh
p:ordered-list(3) => ul|ol > li > ul|ol > li > ol > li:fresh
p:ordered-list(4) => ul|ol > li > ul|ol > li > ul|ol > li > ol > li:fresh
p:ordered-list(5) => ul|ol > li > ul|ol > li > ul|ol > li > ul|ol > li > ol > li:fresh
"""
| from .results import Result
from . import docx, conversion, style_reader
def convert_to_html(fileobj):
return docx.read(fileobj).bind(lambda document:
conversion.convert_document_element_to_html(document, styles=_create_default_styles())
)
def _create_default_styles():
lines = filter(None, map(lambda line: line.strip(), _default_styles.split("\n")))
return map(style_reader.read_style, lines)
_default_styles = """
+ p.Heading1 => h1:fresh
+ p.Heading2 => h2:fresh
+ p.Heading3 => h3:fresh
+ p.Heading4 => h4:fresh
p:unordered-list(1) => ul > li:fresh
+ p:unordered-list(2) => ul|ol > li > ul > li:fresh
+ p:unordered-list(3) => ul|ol > li > ul|ol > li > ul > li:fresh
+ p:unordered-list(4) => ul|ol > li > ul|ol > li > ul|ol > li > ul > li:fresh
+ p:unordered-list(5) => ul|ol > li > ul|ol > li > ul|ol > li > ul|ol > li > ul > li:fresh
+ p:ordered-list(1) => ol > li:fresh
+ p:ordered-list(2) => ul|ol > li > ol > li:fresh
+ p:ordered-list(3) => ul|ol > li > ul|ol > li > ol > li:fresh
+ p:ordered-list(4) => ul|ol > li > ul|ol > li > ul|ol > li > ol > li:fresh
+ p:ordered-list(5) => ul|ol > li > ul|ol > li > ul|ol > li > ul|ol > li > ol > li:fresh
""" |
ebf52caf6ee09ef1f15cb88815a1fb8008899c79 | tests/test_reactjs.py | tests/test_reactjs.py | import dukpy
class TestReactJS(object):
def test_hello_world(self):
jsx = dukpy.jsx_compile('var react_hello = <h1>Hello, world!</h1>;')
jsi = dukpy.JSInterpreter()
result = jsi.evaljs([
'''
var React = require('react/react'),
ReactDOM = require('react/react-dom-server');
''',
jsx,
'ReactDOM.renderToStaticMarkup(react_hello, null);'
])
assert result == '<h1>Hello, world!</h1>'
| import dukpy
class TestReactJS(object):
def test_hello_world(self):
jsx = dukpy.jsx_compile('var react_hello = <h1>Hello, world!</h1>;')
jsi = dukpy.JSInterpreter()
result = jsi.evaljs([
'''
var React = require('react/react'),
ReactDOM = require('react/react-dom-server');
''',
jsx,
'ReactDOM.renderToStaticMarkup(react_hello, null);'
])
assert result == '<h1>Hello, world!</h1>', res
def test_jsx_mixed(self):
code = '''
var React = require('react/react'),
ReactDOM = require('react/react-dom-server');
ReactDOM.renderToStaticMarkup(<h1>Hello, world!</h1>, null);
'''
jsx = dukpy.jsx_compile(code)
res = dukpy.evaljs(jsx)
assert res == '<h1>Hello, world!</h1>', res
def test_react_binding(self):
code = '''
var React = require('react/react'),
ReactDOM = require('react/react-dom-server');
var HelloWorld = React.createClass({
render: function() {
return (
<div className="helloworld">
Hello {this.props.data.name}
</div>
);
}
});
ReactDOM.renderToStaticMarkup(<HelloWorld data={dukpy.data}/>, null);
'''
jsx = dukpy.jsx_compile(code)
res = dukpy.evaljs(jsx, data={'id': 1, 'name': "Alessandro"})
assert res == '<div class="helloworld">Hello Alessandro</div>', res | Add tests for a React Component | Add tests for a React Component
| Python | mit | amol-/dukpy,amol-/dukpy,amol-/dukpy | import dukpy
class TestReactJS(object):
def test_hello_world(self):
jsx = dukpy.jsx_compile('var react_hello = <h1>Hello, world!</h1>;')
jsi = dukpy.JSInterpreter()
result = jsi.evaljs([
'''
var React = require('react/react'),
ReactDOM = require('react/react-dom-server');
''',
jsx,
'ReactDOM.renderToStaticMarkup(react_hello, null);'
])
- assert result == '<h1>Hello, world!</h1>'
+ assert result == '<h1>Hello, world!</h1>', res
+ def test_jsx_mixed(self):
+ code = '''
+ var React = require('react/react'),
+ ReactDOM = require('react/react-dom-server');
+ ReactDOM.renderToStaticMarkup(<h1>Hello, world!</h1>, null);
+ '''
+ jsx = dukpy.jsx_compile(code)
+ res = dukpy.evaljs(jsx)
+ assert res == '<h1>Hello, world!</h1>', res
+
+ def test_react_binding(self):
+ code = '''
+ var React = require('react/react'),
+ ReactDOM = require('react/react-dom-server');
+
+ var HelloWorld = React.createClass({
+ render: function() {
+ return (
+ <div className="helloworld">
+ Hello {this.props.data.name}
+ </div>
+ );
+ }
+ });
+
+ ReactDOM.renderToStaticMarkup(<HelloWorld data={dukpy.data}/>, null);
+ '''
+ jsx = dukpy.jsx_compile(code)
+ res = dukpy.evaljs(jsx, data={'id': 1, 'name': "Alessandro"})
+ assert res == '<div class="helloworld">Hello Alessandro</div>', res | Add tests for a React Component | ## Code Before:
import dukpy
class TestReactJS(object):
def test_hello_world(self):
jsx = dukpy.jsx_compile('var react_hello = <h1>Hello, world!</h1>;')
jsi = dukpy.JSInterpreter()
result = jsi.evaljs([
'''
var React = require('react/react'),
ReactDOM = require('react/react-dom-server');
''',
jsx,
'ReactDOM.renderToStaticMarkup(react_hello, null);'
])
assert result == '<h1>Hello, world!</h1>'
## Instruction:
Add tests for a React Component
## Code After:
import dukpy
class TestReactJS(object):
def test_hello_world(self):
jsx = dukpy.jsx_compile('var react_hello = <h1>Hello, world!</h1>;')
jsi = dukpy.JSInterpreter()
result = jsi.evaljs([
'''
var React = require('react/react'),
ReactDOM = require('react/react-dom-server');
''',
jsx,
'ReactDOM.renderToStaticMarkup(react_hello, null);'
])
assert result == '<h1>Hello, world!</h1>', res
def test_jsx_mixed(self):
code = '''
var React = require('react/react'),
ReactDOM = require('react/react-dom-server');
ReactDOM.renderToStaticMarkup(<h1>Hello, world!</h1>, null);
'''
jsx = dukpy.jsx_compile(code)
res = dukpy.evaljs(jsx)
assert res == '<h1>Hello, world!</h1>', res
def test_react_binding(self):
code = '''
var React = require('react/react'),
ReactDOM = require('react/react-dom-server');
var HelloWorld = React.createClass({
render: function() {
return (
<div className="helloworld">
Hello {this.props.data.name}
</div>
);
}
});
ReactDOM.renderToStaticMarkup(<HelloWorld data={dukpy.data}/>, null);
'''
jsx = dukpy.jsx_compile(code)
res = dukpy.evaljs(jsx, data={'id': 1, 'name': "Alessandro"})
assert res == '<div class="helloworld">Hello Alessandro</div>', res | import dukpy
class TestReactJS(object):
def test_hello_world(self):
jsx = dukpy.jsx_compile('var react_hello = <h1>Hello, world!</h1>;')
jsi = dukpy.JSInterpreter()
result = jsi.evaljs([
'''
var React = require('react/react'),
ReactDOM = require('react/react-dom-server');
''',
jsx,
'ReactDOM.renderToStaticMarkup(react_hello, null);'
])
- assert result == '<h1>Hello, world!</h1>'
+ assert result == '<h1>Hello, world!</h1>', res
? +++++
+
+ def test_jsx_mixed(self):
+ code = '''
+ var React = require('react/react'),
+ ReactDOM = require('react/react-dom-server');
+ ReactDOM.renderToStaticMarkup(<h1>Hello, world!</h1>, null);
+ '''
+ jsx = dukpy.jsx_compile(code)
+ res = dukpy.evaljs(jsx)
+ assert res == '<h1>Hello, world!</h1>', res
+
+ def test_react_binding(self):
+ code = '''
+ var React = require('react/react'),
+ ReactDOM = require('react/react-dom-server');
+
+ var HelloWorld = React.createClass({
+ render: function() {
+ return (
+ <div className="helloworld">
+ Hello {this.props.data.name}
+ </div>
+ );
+ }
+ });
+
+ ReactDOM.renderToStaticMarkup(<HelloWorld data={dukpy.data}/>, null);
+ '''
+ jsx = dukpy.jsx_compile(code)
+ res = dukpy.evaljs(jsx, data={'id': 1, 'name': "Alessandro"})
+ assert res == '<div class="helloworld">Hello Alessandro</div>', res |
14b9ef43fd244d4709d14478ec0714325ca37cdb | tests/builtins/test_sum.py | tests/builtins/test_sum.py | from .. utils import TranspileTestCase, BuiltinFunctionTestCase
class SumTests(TranspileTestCase):
def test_sum_list(self):
self.assertCodeExecution("""
print(sum([1, 2, 3, 4, 5, 6, 7]))
""")
def test_sum_tuple(self):
self.assertCodeExecution("""
print(sum((1, 2, 3, 4, 5, 6, 7)))
""")
def test_sum_iterator(self):
self.assertCodeExecution("""
i = iter([1, 2])
print(sum(i))
print(sum(i))
""")
def test_sum_mix_floats_and_ints(self):
self.assertCodeExecution("""
print(sum([1, 1.414, 2, 3.14159]))
""")
class BuiltinSumFunctionTests(BuiltinFunctionTestCase, TranspileTestCase):
functions = ["sum"]
not_implemented = [
'test_bytearray',
'test_frozenzet',
]
| from .. utils import TranspileTestCase, BuiltinFunctionTestCase
class SumTests(TranspileTestCase):
def test_sum_list(self):
self.assertCodeExecution("""
print(sum([1, 2, 3, 4, 5, 6, 7]))
""")
def test_sum_tuple(self):
self.assertCodeExecution("""
print(sum((1, 2, 3, 4, 5, 6, 7)))
""")
def test_sum_iterator(self):
self.assertCodeExecution("""
i = iter([1, 2])
print(sum(i))
print(sum(i))
""")
def test_sum_mix_floats_and_ints(self):
self.assertCodeExecution("""
print(sum([1, 1.414, 2, 3.14159]))
""")
class BuiltinSumFunctionTests(BuiltinFunctionTestCase, TranspileTestCase):
functions = ["sum"]
not_implemented = [
'test_frozenzet',
]
| Fix unexpected success on sum(bytearray()) | Fix unexpected success on sum(bytearray())
| Python | bsd-3-clause | cflee/voc,cflee/voc,freakboy3742/voc,freakboy3742/voc | from .. utils import TranspileTestCase, BuiltinFunctionTestCase
class SumTests(TranspileTestCase):
def test_sum_list(self):
self.assertCodeExecution("""
print(sum([1, 2, 3, 4, 5, 6, 7]))
""")
def test_sum_tuple(self):
self.assertCodeExecution("""
print(sum((1, 2, 3, 4, 5, 6, 7)))
""")
def test_sum_iterator(self):
self.assertCodeExecution("""
i = iter([1, 2])
print(sum(i))
print(sum(i))
""")
def test_sum_mix_floats_and_ints(self):
self.assertCodeExecution("""
print(sum([1, 1.414, 2, 3.14159]))
""")
class BuiltinSumFunctionTests(BuiltinFunctionTestCase, TranspileTestCase):
functions = ["sum"]
not_implemented = [
- 'test_bytearray',
'test_frozenzet',
]
| Fix unexpected success on sum(bytearray()) | ## Code Before:
from .. utils import TranspileTestCase, BuiltinFunctionTestCase
class SumTests(TranspileTestCase):
def test_sum_list(self):
self.assertCodeExecution("""
print(sum([1, 2, 3, 4, 5, 6, 7]))
""")
def test_sum_tuple(self):
self.assertCodeExecution("""
print(sum((1, 2, 3, 4, 5, 6, 7)))
""")
def test_sum_iterator(self):
self.assertCodeExecution("""
i = iter([1, 2])
print(sum(i))
print(sum(i))
""")
def test_sum_mix_floats_and_ints(self):
self.assertCodeExecution("""
print(sum([1, 1.414, 2, 3.14159]))
""")
class BuiltinSumFunctionTests(BuiltinFunctionTestCase, TranspileTestCase):
functions = ["sum"]
not_implemented = [
'test_bytearray',
'test_frozenzet',
]
## Instruction:
Fix unexpected success on sum(bytearray())
## Code After:
from .. utils import TranspileTestCase, BuiltinFunctionTestCase
class SumTests(TranspileTestCase):
def test_sum_list(self):
self.assertCodeExecution("""
print(sum([1, 2, 3, 4, 5, 6, 7]))
""")
def test_sum_tuple(self):
self.assertCodeExecution("""
print(sum((1, 2, 3, 4, 5, 6, 7)))
""")
def test_sum_iterator(self):
self.assertCodeExecution("""
i = iter([1, 2])
print(sum(i))
print(sum(i))
""")
def test_sum_mix_floats_and_ints(self):
self.assertCodeExecution("""
print(sum([1, 1.414, 2, 3.14159]))
""")
class BuiltinSumFunctionTests(BuiltinFunctionTestCase, TranspileTestCase):
functions = ["sum"]
not_implemented = [
'test_frozenzet',
]
| from .. utils import TranspileTestCase, BuiltinFunctionTestCase
class SumTests(TranspileTestCase):
def test_sum_list(self):
self.assertCodeExecution("""
print(sum([1, 2, 3, 4, 5, 6, 7]))
""")
def test_sum_tuple(self):
self.assertCodeExecution("""
print(sum((1, 2, 3, 4, 5, 6, 7)))
""")
def test_sum_iterator(self):
self.assertCodeExecution("""
i = iter([1, 2])
print(sum(i))
print(sum(i))
""")
def test_sum_mix_floats_and_ints(self):
self.assertCodeExecution("""
print(sum([1, 1.414, 2, 3.14159]))
""")
class BuiltinSumFunctionTests(BuiltinFunctionTestCase, TranspileTestCase):
functions = ["sum"]
not_implemented = [
- 'test_bytearray',
'test_frozenzet',
] |
cd792dd6ab60b1976225c01d5071a925f0f185b7 | tests/test_linestyles2.py | tests/test_linestyles2.py |
from boomslang import Line, Plot
from ImageComparisonTestCase import ImageComparisonTestCase
import unittest
class LineStyles2Test(ImageComparisonTestCase, unittest.TestCase):
def __init__(self, testCaseName):
super(LineStyles2Test, self).__init__(testCaseName)
self.imageName = "linestyles2.png"
def constructImage(self):
plot = Plot()
for i in xrange(6):
line = Line()
line.xValues = xrange(5)
line.yValues = [(i+1) * x for x in line.xValues]
line.label = "Line %d" % (i + 1)
plot.add(line)
plot.addLineColor("red")
plot.addLineColor("blue")
plot.addLineColor("green")
plot.addMarker('')
plot.addMarker('x')
plot.hasLegend(columns=2)
plot.save(self.imageName)
ImageComparisonTestCase.register(LineStyles2Test)
if __name__ == "__main__":
test = LineStyles2Test()
test.constructImage()
|
from boomslang import Line, Plot
from ImageComparisonTestCase import ImageComparisonTestCase
import unittest
class LineStyles2Test(ImageComparisonTestCase, unittest.TestCase):
def __init__(self, testCaseName):
super(LineStyles2Test, self).__init__(testCaseName)
self.imageName = "linestyles2.png"
def constructImage(self):
plot = Plot()
for i in xrange(6):
line = Line()
line.xValues = xrange(5)
line.yValues = [(i+1) * x for x in line.xValues]
line.label = "Line %d" % (i + 1)
plot.add(line)
plot.addLineColor("red")
plot.addLineColor("blue")
plot.addLineColor("green")
plot.addMarker('')
plot.addMarker('x')
plot.hasLegend(columns=2)
plot.save(self.imageName)
ImageComparisonTestCase.register(LineStyles2Test)
if __name__ == "__main__":
test = LineStyles2Test("testImageComparison")
test.constructImage()
| Make linestyles2 test runnable (should probably fix this for other tests) | Make linestyles2 test runnable (should probably fix this for other tests)
| Python | bsd-3-clause | alexras/boomslang |
from boomslang import Line, Plot
from ImageComparisonTestCase import ImageComparisonTestCase
import unittest
class LineStyles2Test(ImageComparisonTestCase, unittest.TestCase):
def __init__(self, testCaseName):
super(LineStyles2Test, self).__init__(testCaseName)
self.imageName = "linestyles2.png"
def constructImage(self):
plot = Plot()
for i in xrange(6):
line = Line()
line.xValues = xrange(5)
line.yValues = [(i+1) * x for x in line.xValues]
line.label = "Line %d" % (i + 1)
plot.add(line)
plot.addLineColor("red")
plot.addLineColor("blue")
plot.addLineColor("green")
plot.addMarker('')
plot.addMarker('x')
plot.hasLegend(columns=2)
plot.save(self.imageName)
ImageComparisonTestCase.register(LineStyles2Test)
if __name__ == "__main__":
- test = LineStyles2Test()
+ test = LineStyles2Test("testImageComparison")
test.constructImage()
| Make linestyles2 test runnable (should probably fix this for other tests) | ## Code Before:
from boomslang import Line, Plot
from ImageComparisonTestCase import ImageComparisonTestCase
import unittest
class LineStyles2Test(ImageComparisonTestCase, unittest.TestCase):
def __init__(self, testCaseName):
super(LineStyles2Test, self).__init__(testCaseName)
self.imageName = "linestyles2.png"
def constructImage(self):
plot = Plot()
for i in xrange(6):
line = Line()
line.xValues = xrange(5)
line.yValues = [(i+1) * x for x in line.xValues]
line.label = "Line %d" % (i + 1)
plot.add(line)
plot.addLineColor("red")
plot.addLineColor("blue")
plot.addLineColor("green")
plot.addMarker('')
plot.addMarker('x')
plot.hasLegend(columns=2)
plot.save(self.imageName)
ImageComparisonTestCase.register(LineStyles2Test)
if __name__ == "__main__":
test = LineStyles2Test()
test.constructImage()
## Instruction:
Make linestyles2 test runnable (should probably fix this for other tests)
## Code After:
from boomslang import Line, Plot
from ImageComparisonTestCase import ImageComparisonTestCase
import unittest
class LineStyles2Test(ImageComparisonTestCase, unittest.TestCase):
def __init__(self, testCaseName):
super(LineStyles2Test, self).__init__(testCaseName)
self.imageName = "linestyles2.png"
def constructImage(self):
plot = Plot()
for i in xrange(6):
line = Line()
line.xValues = xrange(5)
line.yValues = [(i+1) * x for x in line.xValues]
line.label = "Line %d" % (i + 1)
plot.add(line)
plot.addLineColor("red")
plot.addLineColor("blue")
plot.addLineColor("green")
plot.addMarker('')
plot.addMarker('x')
plot.hasLegend(columns=2)
plot.save(self.imageName)
ImageComparisonTestCase.register(LineStyles2Test)
if __name__ == "__main__":
test = LineStyles2Test("testImageComparison")
test.constructImage()
|
from boomslang import Line, Plot
from ImageComparisonTestCase import ImageComparisonTestCase
import unittest
class LineStyles2Test(ImageComparisonTestCase, unittest.TestCase):
def __init__(self, testCaseName):
super(LineStyles2Test, self).__init__(testCaseName)
self.imageName = "linestyles2.png"
def constructImage(self):
plot = Plot()
for i in xrange(6):
line = Line()
line.xValues = xrange(5)
line.yValues = [(i+1) * x for x in line.xValues]
line.label = "Line %d" % (i + 1)
plot.add(line)
plot.addLineColor("red")
plot.addLineColor("blue")
plot.addLineColor("green")
plot.addMarker('')
plot.addMarker('x')
plot.hasLegend(columns=2)
plot.save(self.imageName)
ImageComparisonTestCase.register(LineStyles2Test)
if __name__ == "__main__":
- test = LineStyles2Test()
+ test = LineStyles2Test("testImageComparison")
test.constructImage() |
83a16ba4485f3e483adc20352cb0cef7c02f8ef2 | tests/test_config_schema.py | tests/test_config_schema.py | from __future__ import unicode_literals, division, absolute_import
import jsonschema
from flexget import config_schema
from flexget import plugin
from tests import FlexGetBase
class TestSchemaValidator(FlexGetBase):
def test_plugin_schemas_are_valid(self):
for p in plugin.plugins.values():
if p.schema is None:
continue
try:
config_schema.SchemaValidator.check_schema(p.schema)
except jsonschema.SchemaError as e:
assert False, 'plugin `%s` has an invalid schema. %s %s' % (
p.name, '/'.join(str(p) for p in e.path), e.message)
def test_resolves_local_refs(self):
schema = {'$ref': '/schema/plugin/accept_all'}
v = config_schema.SchemaValidator(schema)
# accept_all schema should be for type boolean
assert v.is_valid(True)
assert not v.is_valid(14)
def test_custom_format_checker(self):
schema = {'type': 'string', 'format': 'quality'}
v = config_schema.SchemaValidator(schema)
assert v.is_valid('720p')
assert not v.is_valid('aoeu')
| from __future__ import unicode_literals, division, absolute_import
import jsonschema
from flexget import config_schema
from tests import FlexGetBase
class TestSchemaValidator(FlexGetBase):
def test_registered_schemas_are_valid(self):
for path in config_schema.schema_paths:
schema = config_schema.resolve_ref(path)
try:
config_schema.SchemaValidator.check_schema(schema)
except jsonschema.SchemaError as e:
assert False, 'plugin `%s` has an invalid schema. %s %s' % (
path, '/'.join(str(p) for p in e.path), e.message)
def test_resolves_local_refs(self):
schema = {'$ref': '/schema/plugin/accept_all'}
v = config_schema.SchemaValidator(schema)
# accept_all schema should be for type boolean
assert v.is_valid(True)
assert not v.is_valid(14)
def test_custom_format_checker(self):
schema = {'type': 'string', 'format': 'quality'}
v = config_schema.SchemaValidator(schema)
assert v.is_valid('720p')
assert not v.is_valid('aoeu')
| Convert unit test to test all registered schemas instead of plugins directly. | Convert unit test to test all registered schemas instead of plugins directly.
| Python | mit | vfrc2/Flexget,poulpito/Flexget,jacobmetrick/Flexget,ibrahimkarahan/Flexget,Danfocus/Flexget,oxc/Flexget,ibrahimkarahan/Flexget,asm0dey/Flexget,qvazzler/Flexget,dsemi/Flexget,crawln45/Flexget,thalamus/Flexget,tsnoam/Flexget,patsissons/Flexget,tsnoam/Flexget,vfrc2/Flexget,Danfocus/Flexget,drwyrm/Flexget,v17al/Flexget,grrr2/Flexget,lildadou/Flexget,OmgOhnoes/Flexget,voriux/Flexget,crawln45/Flexget,ianstalk/Flexget,Danfocus/Flexget,spencerjanssen/Flexget,JorisDeRieck/Flexget,ratoaq2/Flexget,tobinjt/Flexget,thalamus/Flexget,ratoaq2/Flexget,gazpachoking/Flexget,qk4l/Flexget,grrr2/Flexget,lildadou/Flexget,tarzasai/Flexget,lildadou/Flexget,OmgOhnoes/Flexget,ZefQ/Flexget,antivirtel/Flexget,vfrc2/Flexget,Flexget/Flexget,qvazzler/Flexget,tobinjt/Flexget,patsissons/Flexget,xfouloux/Flexget,JorisDeRieck/Flexget,camon/Flexget,jawilson/Flexget,qk4l/Flexget,offbyone/Flexget,tarzasai/Flexget,poulpito/Flexget,sean797/Flexget,camon/Flexget,jacobmetrick/Flexget,Pretagonist/Flexget,tobinjt/Flexget,thalamus/Flexget,tsnoam/Flexget,tarzasai/Flexget,ratoaq2/Flexget,Pretagonist/Flexget,ianstalk/Flexget,ibrahimkarahan/Flexget,ZefQ/Flexget,gazpachoking/Flexget,grrr2/Flexget,Flexget/Flexget,malkavi/Flexget,Flexget/Flexget,spencerjanssen/Flexget,tvcsantos/Flexget,X-dark/Flexget,Flexget/Flexget,LynxyssCZ/Flexget,v17al/Flexget,asm0dey/Flexget,dsemi/Flexget,drwyrm/Flexget,tobinjt/Flexget,offbyone/Flexget,JorisDeRieck/Flexget,oxc/Flexget,cvium/Flexget,qk4l/Flexget,antivirtel/Flexget,LynxyssCZ/Flexget,malkavi/Flexget,cvium/Flexget,tvcsantos/Flexget,ianstalk/Flexget,poulpito/Flexget,drwyrm/Flexget,malkavi/Flexget,X-dark/Flexget,patsissons/Flexget,antivirtel/Flexget,LynxyssCZ/Flexget,offbyone/Flexget,JorisDeRieck/Flexget,jacobmetrick/Flexget,crawln45/Flexget,cvium/Flexget,jawilson/Flexget,jawilson/Flexget,oxc/Flexget,Danfocus/Flexget,xfouloux/Flexget,asm0dey/Flexget,crawln45/Flexget,spencerjanssen/Flexget,dsemi/Flexget,X-dark/Flexget,malkavi/Flexget,v17al/Flexget,ZefQ/Flexget,Pretagonist/Flexget,OmgOhnoes/Flexget,xfouloux/Flexget,jawilson/Flexget,LynxyssCZ/Flexget,sean797/Flexget,qvazzler/Flexget,voriux/Flexget,sean797/Flexget | from __future__ import unicode_literals, division, absolute_import
import jsonschema
from flexget import config_schema
- from flexget import plugin
from tests import FlexGetBase
class TestSchemaValidator(FlexGetBase):
- def test_plugin_schemas_are_valid(self):
+ def test_registered_schemas_are_valid(self):
+ for path in config_schema.schema_paths:
+ schema = config_schema.resolve_ref(path)
- for p in plugin.plugins.values():
- if p.schema is None:
- continue
try:
- config_schema.SchemaValidator.check_schema(p.schema)
+ config_schema.SchemaValidator.check_schema(schema)
except jsonschema.SchemaError as e:
assert False, 'plugin `%s` has an invalid schema. %s %s' % (
- p.name, '/'.join(str(p) for p in e.path), e.message)
+ path, '/'.join(str(p) for p in e.path), e.message)
def test_resolves_local_refs(self):
schema = {'$ref': '/schema/plugin/accept_all'}
v = config_schema.SchemaValidator(schema)
# accept_all schema should be for type boolean
assert v.is_valid(True)
assert not v.is_valid(14)
def test_custom_format_checker(self):
schema = {'type': 'string', 'format': 'quality'}
v = config_schema.SchemaValidator(schema)
assert v.is_valid('720p')
assert not v.is_valid('aoeu')
| Convert unit test to test all registered schemas instead of plugins directly. | ## Code Before:
from __future__ import unicode_literals, division, absolute_import
import jsonschema
from flexget import config_schema
from flexget import plugin
from tests import FlexGetBase
class TestSchemaValidator(FlexGetBase):
def test_plugin_schemas_are_valid(self):
for p in plugin.plugins.values():
if p.schema is None:
continue
try:
config_schema.SchemaValidator.check_schema(p.schema)
except jsonschema.SchemaError as e:
assert False, 'plugin `%s` has an invalid schema. %s %s' % (
p.name, '/'.join(str(p) for p in e.path), e.message)
def test_resolves_local_refs(self):
schema = {'$ref': '/schema/plugin/accept_all'}
v = config_schema.SchemaValidator(schema)
# accept_all schema should be for type boolean
assert v.is_valid(True)
assert not v.is_valid(14)
def test_custom_format_checker(self):
schema = {'type': 'string', 'format': 'quality'}
v = config_schema.SchemaValidator(schema)
assert v.is_valid('720p')
assert not v.is_valid('aoeu')
## Instruction:
Convert unit test to test all registered schemas instead of plugins directly.
## Code After:
from __future__ import unicode_literals, division, absolute_import
import jsonschema
from flexget import config_schema
from tests import FlexGetBase
class TestSchemaValidator(FlexGetBase):
def test_registered_schemas_are_valid(self):
for path in config_schema.schema_paths:
schema = config_schema.resolve_ref(path)
try:
config_schema.SchemaValidator.check_schema(schema)
except jsonschema.SchemaError as e:
assert False, 'plugin `%s` has an invalid schema. %s %s' % (
path, '/'.join(str(p) for p in e.path), e.message)
def test_resolves_local_refs(self):
schema = {'$ref': '/schema/plugin/accept_all'}
v = config_schema.SchemaValidator(schema)
# accept_all schema should be for type boolean
assert v.is_valid(True)
assert not v.is_valid(14)
def test_custom_format_checker(self):
schema = {'type': 'string', 'format': 'quality'}
v = config_schema.SchemaValidator(schema)
assert v.is_valid('720p')
assert not v.is_valid('aoeu')
| from __future__ import unicode_literals, division, absolute_import
import jsonschema
from flexget import config_schema
- from flexget import plugin
from tests import FlexGetBase
class TestSchemaValidator(FlexGetBase):
- def test_plugin_schemas_are_valid(self):
? ^^^ ^
+ def test_registered_schemas_are_valid(self):
? ^^ ^^^^^^
+ for path in config_schema.schema_paths:
+ schema = config_schema.resolve_ref(path)
- for p in plugin.plugins.values():
- if p.schema is None:
- continue
try:
- config_schema.SchemaValidator.check_schema(p.schema)
? --
+ config_schema.SchemaValidator.check_schema(schema)
except jsonschema.SchemaError as e:
assert False, 'plugin `%s` has an invalid schema. %s %s' % (
- p.name, '/'.join(str(p) for p in e.path), e.message)
? -- ^^
+ path, '/'.join(str(p) for p in e.path), e.message)
? ^^
def test_resolves_local_refs(self):
schema = {'$ref': '/schema/plugin/accept_all'}
v = config_schema.SchemaValidator(schema)
# accept_all schema should be for type boolean
assert v.is_valid(True)
assert not v.is_valid(14)
def test_custom_format_checker(self):
schema = {'type': 'string', 'format': 'quality'}
v = config_schema.SchemaValidator(schema)
assert v.is_valid('720p')
assert not v.is_valid('aoeu') |
9a988056944700d6188f6e7164e68dcd35c342d8 | databench/analysis.py | databench/analysis.py | """Analysis module for Databench."""
from flask import Blueprint, render_template
import databench.signals
LIST_ALL = []
class Analysis(object):
"""Databench's analysis class.
An optional :class:`databench.Signals` instance and :class:`flask.Blueprint`
can be dependency-injected, however that should not be necessary for
standard use cases.
Args:
name (str): Name of this analysis. If ``signals`` is not specified, this
also becomes the namespace for the Socket.IO connection and has
to match the frontend's :js:class:`Databench` ``name``.
import_name (str): Usually the file name ``__name__`` where this
analysis is instantiated.
signals (optional): Inject an instance of :class:`databench.Signals`.
blueprint (optional): Inject an instance of a :class:`flask.Blueprint`.
"""
def __init__(
self,
name,
import_name,
signals=None,
blueprint=None
):
LIST_ALL.append(self)
self.name = name
self.import_name = import_name
if not signals:
self.signals = databench.signals.Signals(name)
else:
self.signals = signals
if not blueprint:
self.blueprint = Blueprint(
name,
import_name,
template_folder='templates',
static_folder='static',
)
else:
self.blueprint = blueprint
self.show_in_index = True
@self.blueprint.route('/')
def render_index():
"""Renders the main analysis frontend template."""
return render_template(self.name+'.html')
| """Analysis module for Databench."""
from flask import Blueprint, render_template
import databench.signals
LIST_ALL = []
class Analysis(object):
"""Databench's analysis class.
An optional :class:`databench.Signals` instance and :class:`flask.Blueprint`
can be dependency-injected, however that should not be necessary for
standard use cases.
Args:
name (str): Name of this analysis. If ``signals`` is not specified, this
also becomes the namespace for the Socket.IO connection and has
to match the frontend's :js:class:`Databench` ``name``.
import_name (str): Usually the file name ``__name__`` where this
analysis is instantiated.
signals (optional): Inject an instance of :class:`databench.Signals`.
blueprint (optional): Inject an instance of a :class:`flask.Blueprint`.
"""
def __init__(
self,
name,
import_name,
signals=None,
blueprint=None
):
LIST_ALL.append(self)
self.show_in_index = True
self.name = name
self.import_name = import_name
if not signals:
self.signals = databench.signals.Signals(name)
else:
self.signals = signals
if not blueprint:
self.blueprint = Blueprint(
name,
import_name,
template_folder='templates',
static_folder='static',
)
else:
self.blueprint = blueprint
self.blueprint.add_url_rule('/', 'render_index', self.render_index)
def render_index(self):
"""Renders the main analysis frontend template."""
return render_template(self.name+'.html')
| Move the render_index() function out of the constructor and use add_url_rule() instead of the route() decorator to connect it to Flask. | Move the render_index() function out of the constructor and use add_url_rule() instead of the route() decorator to connect it to Flask.
| Python | mit | svenkreiss/databench,svenkreiss/databench,svenkreiss/databench,svenkreiss/databench | """Analysis module for Databench."""
from flask import Blueprint, render_template
import databench.signals
LIST_ALL = []
class Analysis(object):
"""Databench's analysis class.
An optional :class:`databench.Signals` instance and :class:`flask.Blueprint`
can be dependency-injected, however that should not be necessary for
standard use cases.
Args:
name (str): Name of this analysis. If ``signals`` is not specified, this
also becomes the namespace for the Socket.IO connection and has
to match the frontend's :js:class:`Databench` ``name``.
import_name (str): Usually the file name ``__name__`` where this
analysis is instantiated.
signals (optional): Inject an instance of :class:`databench.Signals`.
blueprint (optional): Inject an instance of a :class:`flask.Blueprint`.
"""
def __init__(
self,
name,
import_name,
signals=None,
blueprint=None
):
LIST_ALL.append(self)
+ self.show_in_index = True
+
self.name = name
self.import_name = import_name
if not signals:
self.signals = databench.signals.Signals(name)
else:
self.signals = signals
if not blueprint:
self.blueprint = Blueprint(
name,
import_name,
template_folder='templates',
static_folder='static',
)
else:
self.blueprint = blueprint
- self.show_in_index = True
+ self.blueprint.add_url_rule('/', 'render_index', self.render_index)
- @self.blueprint.route('/')
- def render_index():
+ def render_index(self):
- """Renders the main analysis frontend template."""
+ """Renders the main analysis frontend template."""
- return render_template(self.name+'.html')
+ return render_template(self.name+'.html')
| Move the render_index() function out of the constructor and use add_url_rule() instead of the route() decorator to connect it to Flask. | ## Code Before:
"""Analysis module for Databench."""
from flask import Blueprint, render_template
import databench.signals
LIST_ALL = []
class Analysis(object):
"""Databench's analysis class.
An optional :class:`databench.Signals` instance and :class:`flask.Blueprint`
can be dependency-injected, however that should not be necessary for
standard use cases.
Args:
name (str): Name of this analysis. If ``signals`` is not specified, this
also becomes the namespace for the Socket.IO connection and has
to match the frontend's :js:class:`Databench` ``name``.
import_name (str): Usually the file name ``__name__`` where this
analysis is instantiated.
signals (optional): Inject an instance of :class:`databench.Signals`.
blueprint (optional): Inject an instance of a :class:`flask.Blueprint`.
"""
def __init__(
self,
name,
import_name,
signals=None,
blueprint=None
):
LIST_ALL.append(self)
self.name = name
self.import_name = import_name
if not signals:
self.signals = databench.signals.Signals(name)
else:
self.signals = signals
if not blueprint:
self.blueprint = Blueprint(
name,
import_name,
template_folder='templates',
static_folder='static',
)
else:
self.blueprint = blueprint
self.show_in_index = True
@self.blueprint.route('/')
def render_index():
"""Renders the main analysis frontend template."""
return render_template(self.name+'.html')
## Instruction:
Move the render_index() function out of the constructor and use add_url_rule() instead of the route() decorator to connect it to Flask.
## Code After:
"""Analysis module for Databench."""
from flask import Blueprint, render_template
import databench.signals
LIST_ALL = []
class Analysis(object):
"""Databench's analysis class.
An optional :class:`databench.Signals` instance and :class:`flask.Blueprint`
can be dependency-injected, however that should not be necessary for
standard use cases.
Args:
name (str): Name of this analysis. If ``signals`` is not specified, this
also becomes the namespace for the Socket.IO connection and has
to match the frontend's :js:class:`Databench` ``name``.
import_name (str): Usually the file name ``__name__`` where this
analysis is instantiated.
signals (optional): Inject an instance of :class:`databench.Signals`.
blueprint (optional): Inject an instance of a :class:`flask.Blueprint`.
"""
def __init__(
self,
name,
import_name,
signals=None,
blueprint=None
):
LIST_ALL.append(self)
self.show_in_index = True
self.name = name
self.import_name = import_name
if not signals:
self.signals = databench.signals.Signals(name)
else:
self.signals = signals
if not blueprint:
self.blueprint = Blueprint(
name,
import_name,
template_folder='templates',
static_folder='static',
)
else:
self.blueprint = blueprint
self.blueprint.add_url_rule('/', 'render_index', self.render_index)
def render_index(self):
"""Renders the main analysis frontend template."""
return render_template(self.name+'.html')
| """Analysis module for Databench."""
from flask import Blueprint, render_template
import databench.signals
LIST_ALL = []
class Analysis(object):
"""Databench's analysis class.
An optional :class:`databench.Signals` instance and :class:`flask.Blueprint`
can be dependency-injected, however that should not be necessary for
standard use cases.
Args:
name (str): Name of this analysis. If ``signals`` is not specified, this
also becomes the namespace for the Socket.IO connection and has
to match the frontend's :js:class:`Databench` ``name``.
import_name (str): Usually the file name ``__name__`` where this
analysis is instantiated.
signals (optional): Inject an instance of :class:`databench.Signals`.
blueprint (optional): Inject an instance of a :class:`flask.Blueprint`.
"""
def __init__(
self,
name,
import_name,
signals=None,
blueprint=None
):
LIST_ALL.append(self)
+ self.show_in_index = True
+
self.name = name
self.import_name = import_name
if not signals:
self.signals = databench.signals.Signals(name)
else:
self.signals = signals
if not blueprint:
self.blueprint = Blueprint(
name,
import_name,
template_folder='templates',
static_folder='static',
)
else:
self.blueprint = blueprint
- self.show_in_index = True
+ self.blueprint.add_url_rule('/', 'render_index', self.render_index)
- @self.blueprint.route('/')
- def render_index():
? ----
+ def render_index(self):
? ++++
- """Renders the main analysis frontend template."""
? ----
+ """Renders the main analysis frontend template."""
- return render_template(self.name+'.html')
? ----
+ return render_template(self.name+'.html') |
04c8a36c5713e4279f8bf52fa45cdb03de721dbb | example/deploy.py | example/deploy.py | from pyinfra import inventory, state
from pyinfra_docker import deploy_docker
from pyinfra_etcd import deploy_etcd
from pyinfra_kubernetes import deploy_kubernetes_master, deploy_kubernetes_node
SUDO = True
FAIL_PERCENT = 0
def get_etcd_nodes():
return [
'http://{0}:2379'.format(
etcd_node.fact.network_devices[etcd_node.data.etcd_interface]
['ipv4']['address'],
)
for etcd_node in inventory.get_group('etcd_nodes')
]
# Install/configure etcd cluster
with state.limit('etcd_nodes'):
deploy_etcd()
# Install/configure the masters (apiserver, controller, scheduler)
with state.limit('kubernetes_masters'):
deploy_kubernetes_master(etcd_nodes=get_etcd_nodes())
# Install/configure the nodes
with state.limit('kubernetes_nodes'):
# Install Docker
deploy_docker()
# Install Kubernetes node components (kubelet, kube-proxy)
first_master = inventory.get_group('kubernetes_masters')[0]
deploy_kubernetes_node(
master_address='http://{0}'.format((
first_master
.fact.network_devices[first_master.data.network_interface]
['ipv4']['address']
)),
)
# deploy_docker(config={
# # Make Docker use the Vagrant provided interface which has it's own /24
# 'bip': '{{ host.fact.network_devices[host.data.network_interface].ipv4.address }}',
# })
| from pyinfra import inventory, state
from pyinfra_docker import deploy_docker
from pyinfra_etcd import deploy_etcd
from pyinfra_kubernetes import deploy_kubernetes_master, deploy_kubernetes_node
SUDO = True
FAIL_PERCENT = 0
def get_etcd_nodes():
return [
'http://{0}:2379'.format(
etcd_node.fact.network_devices[etcd_node.data.etcd_interface]
['ipv4']['address'],
)
for etcd_node in inventory.get_group('etcd_nodes')
]
# Install/configure etcd cluster
with state.limit('etcd_nodes'):
deploy_etcd()
# Install/configure the masters (apiserver, controller, scheduler)
with state.limit('kubernetes_masters'):
deploy_kubernetes_master(etcd_nodes=get_etcd_nodes())
# Install/configure the nodes
with state.limit('kubernetes_nodes'):
# Install Docker
deploy_docker(config={
# Make Docker use the Vagrant provided interface which has it's own /24
'bip': '{{ host.fact.network_devices[host.data.network_interface].ipv4.address }}',
})
# Install Kubernetes node components (kubelet, kube-proxy)
first_master = inventory.get_group('kubernetes_masters')[0]
deploy_kubernetes_node(
master_address='http://{0}'.format((
first_master
.fact.network_devices[first_master.data.network_interface]
['ipv4']['address']
)),
)
| Use Docker config pointing at the correct interface/subnect for networking. | Use Docker config pointing at the correct interface/subnect for networking.
| Python | mit | EDITD/pyinfra-kubernetes,EDITD/pyinfra-kubernetes | from pyinfra import inventory, state
from pyinfra_docker import deploy_docker
from pyinfra_etcd import deploy_etcd
from pyinfra_kubernetes import deploy_kubernetes_master, deploy_kubernetes_node
SUDO = True
FAIL_PERCENT = 0
def get_etcd_nodes():
return [
'http://{0}:2379'.format(
etcd_node.fact.network_devices[etcd_node.data.etcd_interface]
['ipv4']['address'],
)
for etcd_node in inventory.get_group('etcd_nodes')
]
# Install/configure etcd cluster
with state.limit('etcd_nodes'):
deploy_etcd()
# Install/configure the masters (apiserver, controller, scheduler)
with state.limit('kubernetes_masters'):
deploy_kubernetes_master(etcd_nodes=get_etcd_nodes())
# Install/configure the nodes
with state.limit('kubernetes_nodes'):
# Install Docker
- deploy_docker()
+ deploy_docker(config={
+ # Make Docker use the Vagrant provided interface which has it's own /24
+ 'bip': '{{ host.fact.network_devices[host.data.network_interface].ipv4.address }}',
+ })
# Install Kubernetes node components (kubelet, kube-proxy)
first_master = inventory.get_group('kubernetes_masters')[0]
deploy_kubernetes_node(
master_address='http://{0}'.format((
first_master
.fact.network_devices[first_master.data.network_interface]
['ipv4']['address']
)),
)
- # deploy_docker(config={
- # # Make Docker use the Vagrant provided interface which has it's own /24
- # 'bip': '{{ host.fact.network_devices[host.data.network_interface].ipv4.address }}',
- # })
- | Use Docker config pointing at the correct interface/subnect for networking. | ## Code Before:
from pyinfra import inventory, state
from pyinfra_docker import deploy_docker
from pyinfra_etcd import deploy_etcd
from pyinfra_kubernetes import deploy_kubernetes_master, deploy_kubernetes_node
SUDO = True
FAIL_PERCENT = 0
def get_etcd_nodes():
return [
'http://{0}:2379'.format(
etcd_node.fact.network_devices[etcd_node.data.etcd_interface]
['ipv4']['address'],
)
for etcd_node in inventory.get_group('etcd_nodes')
]
# Install/configure etcd cluster
with state.limit('etcd_nodes'):
deploy_etcd()
# Install/configure the masters (apiserver, controller, scheduler)
with state.limit('kubernetes_masters'):
deploy_kubernetes_master(etcd_nodes=get_etcd_nodes())
# Install/configure the nodes
with state.limit('kubernetes_nodes'):
# Install Docker
deploy_docker()
# Install Kubernetes node components (kubelet, kube-proxy)
first_master = inventory.get_group('kubernetes_masters')[0]
deploy_kubernetes_node(
master_address='http://{0}'.format((
first_master
.fact.network_devices[first_master.data.network_interface]
['ipv4']['address']
)),
)
# deploy_docker(config={
# # Make Docker use the Vagrant provided interface which has it's own /24
# 'bip': '{{ host.fact.network_devices[host.data.network_interface].ipv4.address }}',
# })
## Instruction:
Use Docker config pointing at the correct interface/subnect for networking.
## Code After:
from pyinfra import inventory, state
from pyinfra_docker import deploy_docker
from pyinfra_etcd import deploy_etcd
from pyinfra_kubernetes import deploy_kubernetes_master, deploy_kubernetes_node
SUDO = True
FAIL_PERCENT = 0
def get_etcd_nodes():
return [
'http://{0}:2379'.format(
etcd_node.fact.network_devices[etcd_node.data.etcd_interface]
['ipv4']['address'],
)
for etcd_node in inventory.get_group('etcd_nodes')
]
# Install/configure etcd cluster
with state.limit('etcd_nodes'):
deploy_etcd()
# Install/configure the masters (apiserver, controller, scheduler)
with state.limit('kubernetes_masters'):
deploy_kubernetes_master(etcd_nodes=get_etcd_nodes())
# Install/configure the nodes
with state.limit('kubernetes_nodes'):
# Install Docker
deploy_docker(config={
# Make Docker use the Vagrant provided interface which has it's own /24
'bip': '{{ host.fact.network_devices[host.data.network_interface].ipv4.address }}',
})
# Install Kubernetes node components (kubelet, kube-proxy)
first_master = inventory.get_group('kubernetes_masters')[0]
deploy_kubernetes_node(
master_address='http://{0}'.format((
first_master
.fact.network_devices[first_master.data.network_interface]
['ipv4']['address']
)),
)
| from pyinfra import inventory, state
from pyinfra_docker import deploy_docker
from pyinfra_etcd import deploy_etcd
from pyinfra_kubernetes import deploy_kubernetes_master, deploy_kubernetes_node
SUDO = True
FAIL_PERCENT = 0
def get_etcd_nodes():
return [
'http://{0}:2379'.format(
etcd_node.fact.network_devices[etcd_node.data.etcd_interface]
['ipv4']['address'],
)
for etcd_node in inventory.get_group('etcd_nodes')
]
# Install/configure etcd cluster
with state.limit('etcd_nodes'):
deploy_etcd()
# Install/configure the masters (apiserver, controller, scheduler)
with state.limit('kubernetes_masters'):
deploy_kubernetes_master(etcd_nodes=get_etcd_nodes())
# Install/configure the nodes
with state.limit('kubernetes_nodes'):
# Install Docker
- deploy_docker()
? ^
+ deploy_docker(config={
? ^^^^^^^^
+ # Make Docker use the Vagrant provided interface which has it's own /24
+ 'bip': '{{ host.fact.network_devices[host.data.network_interface].ipv4.address }}',
+ })
# Install Kubernetes node components (kubelet, kube-proxy)
first_master = inventory.get_group('kubernetes_masters')[0]
deploy_kubernetes_node(
master_address='http://{0}'.format((
first_master
.fact.network_devices[first_master.data.network_interface]
['ipv4']['address']
)),
)
-
- # deploy_docker(config={
- # # Make Docker use the Vagrant provided interface which has it's own /24
- # 'bip': '{{ host.fact.network_devices[host.data.network_interface].ipv4.address }}',
- # }) |
22ab7f94c3b8b04a50cd11e73b2963bddb0470a5 | poradnia/contrib/sites/migrations/0002_set_site_domain_and_name.py | poradnia/contrib/sites/migrations/0002_set_site_domain_and_name.py | from __future__ import unicode_literals
from django.conf import settings
from django.db import models, migrations
def update_site_forward(apps, schema_editor):
"""Set site domain and name."""
Site = apps.get_model("sites", "Site")
Site.objects.update_or_create(
id=settings.SITE_ID,
defaults={
"domain": "poradnia.informacjapubliczna.org.pl",
"name": "poradnia"
}
)
def update_site_backward(apps, schema_editor):
"""Revert site domain and name to default."""
Site = apps.get_model("sites", "Site")
Site.objects.update_or_create(
id=settings.SITE_ID,
defaults={
"domain": "example.com",
"name": "example.com"
}
)
class Migration(migrations.Migration):
dependencies = [
('sites', '0001_initial'),
]
operations = [
migrations.RunPython(update_site_forward, update_site_backward),
]
| from __future__ import unicode_literals
from django.conf import settings
from django.db import models, migrations
def update_site_forward(apps, schema_editor):
"""Set site domain and name."""
Site = apps.get_model("sites", "Site")
Site.objects.update_or_create(
id=settings.SITE_ID,
defaults={
"domain": "porady.siecobywatelska.pl",
"name": "poradnia"
}
)
def update_site_backward(apps, schema_editor):
"""Revert site domain and name to default."""
Site = apps.get_model("sites", "Site")
Site.objects.update_or_create(
id=settings.SITE_ID,
defaults={
"domain": "example.com",
"name": "example.com"
}
)
class Migration(migrations.Migration):
dependencies = [
('sites', '0001_initial'),
]
operations = [
migrations.RunPython(update_site_forward, update_site_backward),
]
| Fix migrations - drop old domain | Fix migrations - drop old domain
| Python | mit | rwakulszowa/poradnia,rwakulszowa/poradnia,watchdogpolska/poradnia.siecobywatelska.pl,watchdogpolska/poradnia,rwakulszowa/poradnia,watchdogpolska/poradnia,watchdogpolska/poradnia.siecobywatelska.pl,watchdogpolska/poradnia.siecobywatelska.pl,rwakulszowa/poradnia,watchdogpolska/poradnia,watchdogpolska/poradnia | from __future__ import unicode_literals
from django.conf import settings
from django.db import models, migrations
def update_site_forward(apps, schema_editor):
"""Set site domain and name."""
Site = apps.get_model("sites", "Site")
Site.objects.update_or_create(
id=settings.SITE_ID,
defaults={
- "domain": "poradnia.informacjapubliczna.org.pl",
+ "domain": "porady.siecobywatelska.pl",
"name": "poradnia"
}
)
def update_site_backward(apps, schema_editor):
"""Revert site domain and name to default."""
Site = apps.get_model("sites", "Site")
Site.objects.update_or_create(
id=settings.SITE_ID,
defaults={
"domain": "example.com",
"name": "example.com"
}
)
class Migration(migrations.Migration):
dependencies = [
('sites', '0001_initial'),
]
operations = [
migrations.RunPython(update_site_forward, update_site_backward),
]
| Fix migrations - drop old domain | ## Code Before:
from __future__ import unicode_literals
from django.conf import settings
from django.db import models, migrations
def update_site_forward(apps, schema_editor):
"""Set site domain and name."""
Site = apps.get_model("sites", "Site")
Site.objects.update_or_create(
id=settings.SITE_ID,
defaults={
"domain": "poradnia.informacjapubliczna.org.pl",
"name": "poradnia"
}
)
def update_site_backward(apps, schema_editor):
"""Revert site domain and name to default."""
Site = apps.get_model("sites", "Site")
Site.objects.update_or_create(
id=settings.SITE_ID,
defaults={
"domain": "example.com",
"name": "example.com"
}
)
class Migration(migrations.Migration):
dependencies = [
('sites', '0001_initial'),
]
operations = [
migrations.RunPython(update_site_forward, update_site_backward),
]
## Instruction:
Fix migrations - drop old domain
## Code After:
from __future__ import unicode_literals
from django.conf import settings
from django.db import models, migrations
def update_site_forward(apps, schema_editor):
"""Set site domain and name."""
Site = apps.get_model("sites", "Site")
Site.objects.update_or_create(
id=settings.SITE_ID,
defaults={
"domain": "porady.siecobywatelska.pl",
"name": "poradnia"
}
)
def update_site_backward(apps, schema_editor):
"""Revert site domain and name to default."""
Site = apps.get_model("sites", "Site")
Site.objects.update_or_create(
id=settings.SITE_ID,
defaults={
"domain": "example.com",
"name": "example.com"
}
)
class Migration(migrations.Migration):
dependencies = [
('sites', '0001_initial'),
]
operations = [
migrations.RunPython(update_site_forward, update_site_backward),
]
| from __future__ import unicode_literals
from django.conf import settings
from django.db import models, migrations
def update_site_forward(apps, schema_editor):
"""Set site domain and name."""
Site = apps.get_model("sites", "Site")
Site.objects.update_or_create(
id=settings.SITE_ID,
defaults={
- "domain": "poradnia.informacjapubliczna.org.pl",
+ "domain": "porady.siecobywatelska.pl",
"name": "poradnia"
}
)
def update_site_backward(apps, schema_editor):
"""Revert site domain and name to default."""
Site = apps.get_model("sites", "Site")
Site.objects.update_or_create(
id=settings.SITE_ID,
defaults={
"domain": "example.com",
"name": "example.com"
}
)
class Migration(migrations.Migration):
dependencies = [
('sites', '0001_initial'),
]
operations = [
migrations.RunPython(update_site_forward, update_site_backward),
] |
3d38af257f55a0252cb41408a404faa66b30d512 | pyconde/speakers/models.py | pyconde/speakers/models.py | from django.db import models
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
class Speaker(models.Model):
"""
The speaker model acts as user-abstraction for various session and proposal
related objects.
"""
user = models.OneToOneField(User, related_name='speaker_profile')
def __unicode__(self):
if self.user.first_name and self.user.last_name:
return u"{0} {1}".format(self.user.first_name, self.user.last_name)
return self.user.username
def get_absolute_url(self):
return reverse('account_profile', kwargs={'uid': self.user.id})
def create_speaker_profile(sender, instance, created, raw, **kwargs):
"""
Every user also is a potential speaker in the current implemention so we
also have to create a new speaker object for every newly created user
instance.
"""
if created:
Speaker(user=instance).save()
| from __future__ import unicode_literals
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
from django.db import models
from django.db.models.signals import post_save
from django.dispatch.dispatcher import receiver
class Speaker(models.Model):
"""
The speaker model acts as user-abstraction for various session and proposal
related objects.
"""
user = models.OneToOneField(User, related_name='speaker_profile')
def __unicode__(self):
if self.user.first_name and self.user.last_name:
return u"{0} {1}".format(self.user.first_name, self.user.last_name)
return self.user.username
def get_absolute_url(self):
return reverse('account_profile', kwargs={'uid': self.user.id})
@receiver(post_save, sender=User)
def create_speaker_profile(sender, instance, created, raw, **kwargs):
"""
Every user also is a potential speaker in the current implemention so we
also have to create a new speaker object for every newly created user
instance.
"""
if created:
Speaker(user=instance).save()
| Create a speaker profile for each user that is registered. | Create a speaker profile for each user that is registered.
| Python | bsd-3-clause | pysv/djep,EuroPython/djep,pysv/djep,EuroPython/djep,pysv/djep,EuroPython/djep,pysv/djep,EuroPython/djep,pysv/djep | - from django.db import models
+ from __future__ import unicode_literals
+
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
+ from django.db import models
+ from django.db.models.signals import post_save
+ from django.dispatch.dispatcher import receiver
class Speaker(models.Model):
"""
The speaker model acts as user-abstraction for various session and proposal
related objects.
"""
user = models.OneToOneField(User, related_name='speaker_profile')
def __unicode__(self):
if self.user.first_name and self.user.last_name:
return u"{0} {1}".format(self.user.first_name, self.user.last_name)
return self.user.username
def get_absolute_url(self):
return reverse('account_profile', kwargs={'uid': self.user.id})
+ @receiver(post_save, sender=User)
def create_speaker_profile(sender, instance, created, raw, **kwargs):
"""
Every user also is a potential speaker in the current implemention so we
also have to create a new speaker object for every newly created user
instance.
"""
if created:
Speaker(user=instance).save()
| Create a speaker profile for each user that is registered. | ## Code Before:
from django.db import models
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
class Speaker(models.Model):
"""
The speaker model acts as user-abstraction for various session and proposal
related objects.
"""
user = models.OneToOneField(User, related_name='speaker_profile')
def __unicode__(self):
if self.user.first_name and self.user.last_name:
return u"{0} {1}".format(self.user.first_name, self.user.last_name)
return self.user.username
def get_absolute_url(self):
return reverse('account_profile', kwargs={'uid': self.user.id})
def create_speaker_profile(sender, instance, created, raw, **kwargs):
"""
Every user also is a potential speaker in the current implemention so we
also have to create a new speaker object for every newly created user
instance.
"""
if created:
Speaker(user=instance).save()
## Instruction:
Create a speaker profile for each user that is registered.
## Code After:
from __future__ import unicode_literals
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
from django.db import models
from django.db.models.signals import post_save
from django.dispatch.dispatcher import receiver
class Speaker(models.Model):
"""
The speaker model acts as user-abstraction for various session and proposal
related objects.
"""
user = models.OneToOneField(User, related_name='speaker_profile')
def __unicode__(self):
if self.user.first_name and self.user.last_name:
return u"{0} {1}".format(self.user.first_name, self.user.last_name)
return self.user.username
def get_absolute_url(self):
return reverse('account_profile', kwargs={'uid': self.user.id})
@receiver(post_save, sender=User)
def create_speaker_profile(sender, instance, created, raw, **kwargs):
"""
Every user also is a potential speaker in the current implemention so we
also have to create a new speaker object for every newly created user
instance.
"""
if created:
Speaker(user=instance).save()
| - from django.db import models
+ from __future__ import unicode_literals
+
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
+ from django.db import models
+ from django.db.models.signals import post_save
+ from django.dispatch.dispatcher import receiver
class Speaker(models.Model):
"""
The speaker model acts as user-abstraction for various session and proposal
related objects.
"""
user = models.OneToOneField(User, related_name='speaker_profile')
def __unicode__(self):
if self.user.first_name and self.user.last_name:
return u"{0} {1}".format(self.user.first_name, self.user.last_name)
return self.user.username
def get_absolute_url(self):
return reverse('account_profile', kwargs={'uid': self.user.id})
+ @receiver(post_save, sender=User)
def create_speaker_profile(sender, instance, created, raw, **kwargs):
"""
Every user also is a potential speaker in the current implemention so we
also have to create a new speaker object for every newly created user
instance.
"""
if created:
Speaker(user=instance).save() |
6f75300037254f51f1512a271bf7850a4bc0a8f8 | djangospam/cookie/urls.py | djangospam/cookie/urls.py |
from django.conf.urls.defaults import patterns
urlpatterns = patterns('',
(r'^post$', 'djangospam.cookie.views.spammer_view'),) |
try:
from django.conf.urls import patterns
except ImportError:
from django.conf.urls.defaults import patterns
urlpatterns = patterns('',
(r'^post$', 'djangospam.cookie.views.spammer_view'),) | Add support for Django 1.4 and up | Add support for Django 1.4 and up
* Module django.conf.urls.defaults has been moved to django.conf.urls in
version 1.4.
Commit references issue #3.
| Python | bsd-2-clause | leandroarndt/djangospam,leandroarndt/djangospam |
+ try:
+ from django.conf.urls import patterns
+ except ImportError:
- from django.conf.urls.defaults import patterns
+ from django.conf.urls.defaults import patterns
urlpatterns = patterns('',
(r'^post$', 'djangospam.cookie.views.spammer_view'),) | Add support for Django 1.4 and up | ## Code Before:
from django.conf.urls.defaults import patterns
urlpatterns = patterns('',
(r'^post$', 'djangospam.cookie.views.spammer_view'),)
## Instruction:
Add support for Django 1.4 and up
## Code After:
try:
from django.conf.urls import patterns
except ImportError:
from django.conf.urls.defaults import patterns
urlpatterns = patterns('',
(r'^post$', 'djangospam.cookie.views.spammer_view'),) |
+ try:
+ from django.conf.urls import patterns
+ except ImportError:
- from django.conf.urls.defaults import patterns
+ from django.conf.urls.defaults import patterns
? ++++
urlpatterns = patterns('',
(r'^post$', 'djangospam.cookie.views.spammer_view'),) |
d292a81e95bd558f3902f88fa4d6d5641a4aa388 | tests/io/open_append.py | tests/io/open_append.py | import sys
try:
import _os as os
except ImportError:
import os
if not hasattr(os, "unlink"):
print("SKIP")
sys.exit()
try:
os.unlink("testfile")
except OSError:
pass
# Should create a file
f = open("testfile", "a")
f.write("foo")
f.close()
f = open("testfile")
print(f.read())
f.close()
f = open("testfile", "a")
f.write("bar")
f.close()
f = open("testfile")
print(f.read())
f.close()
| import sys
try:
import _os as os
except ImportError:
import os
if not hasattr(os, "unlink"):
print("SKIP")
sys.exit()
# cleanup in case testfile exists
try:
os.unlink("testfile")
except OSError:
pass
# Should create a file
f = open("testfile", "a")
f.write("foo")
f.close()
f = open("testfile")
print(f.read())
f.close()
f = open("testfile", "a")
f.write("bar")
f.close()
f = open("testfile")
print(f.read())
f.close()
# cleanup
try:
os.unlink("testfile")
except OSError:
pass
| Make io test cleanup after itself by removing 'testfile'. | tests: Make io test cleanup after itself by removing 'testfile'.
| Python | mit | tobbad/micropython,ahotam/micropython,adafruit/circuitpython,mhoffma/micropython,noahchense/micropython,adamkh/micropython,vitiral/micropython,orionrobots/micropython,adafruit/circuitpython,pozetroninc/micropython,lowRISC/micropython,ernesto-g/micropython,SHA2017-badge/micropython-esp32,ChuckM/micropython,misterdanb/micropython,henriknelson/micropython,cwyark/micropython,micropython/micropython-esp32,adafruit/micropython,dhylands/micropython,xyb/micropython,blmorris/micropython,dxxb/micropython,tobbad/micropython,pramasoul/micropython,xuxiaoxin/micropython,alex-robbins/micropython,selste/micropython,turbinenreiter/micropython,trezor/micropython,drrk/micropython,adafruit/circuitpython,stonegithubs/micropython,xyb/micropython,stonegithubs/micropython,infinnovation/micropython,cloudformdesign/micropython,mhoffma/micropython,turbinenreiter/micropython,tobbad/micropython,praemdonck/micropython,tralamazza/micropython,ahotam/micropython,oopy/micropython,xhat/micropython,chrisdearman/micropython,kerneltask/micropython,utopiaprince/micropython,skybird6672/micropython,firstval/micropython,dinau/micropython,lowRISC/micropython,blmorris/micropython,mhoffma/micropython,PappaPeppar/micropython,feilongfl/micropython,praemdonck/micropython,henriknelson/micropython,turbinenreiter/micropython,ahotam/micropython,PappaPeppar/micropython,Timmenem/micropython,pozetroninc/micropython,mianos/micropython,kerneltask/micropython,tralamazza/micropython,mianos/micropython,oopy/micropython,vitiral/micropython,ChuckM/micropython,dinau/micropython,mianos/micropython,supergis/micropython,infinnovation/micropython,ruffy91/micropython,EcmaXp/micropython,firstval/micropython,ganshun666/micropython,cwyark/micropython,MrSurly/micropython,alex-march/micropython,martinribelotta/micropython,deshipu/micropython,firstval/micropython,chrisdearman/micropython,pfalcon/micropython,neilh10/micropython,galenhz/micropython,ruffy91/micropython,feilongfl/micropython,omtinez/micropython,micropython/micropython-esp32,dmazzella/micropython,dxxb/micropython,noahchense/micropython,PappaPeppar/micropython,hosaka/micropython,xuxiaoxin/micropython,vriera/micropython,infinnovation/micropython,adafruit/micropython,vitiral/micropython,jlillest/micropython,torwag/micropython,henriknelson/micropython,dmazzella/micropython,alex-march/micropython,martinribelotta/micropython,torwag/micropython,firstval/micropython,Timmenem/micropython,ganshun666/micropython,SHA2017-badge/micropython-esp32,SHA2017-badge/micropython-esp32,puuu/micropython,mhoffma/micropython,turbinenreiter/micropython,noahwilliamsson/micropython,xuxiaoxin/micropython,pfalcon/micropython,orionrobots/micropython,redbear/micropython,blazewicz/micropython,bvernoux/micropython,hosaka/micropython,ryannathans/micropython,deshipu/micropython,emfcamp/micropython,trezor/micropython,pfalcon/micropython,dxxb/micropython,drrk/micropython,utopiaprince/micropython,danicampora/micropython,jmarcelino/pycom-micropython,praemdonck/micropython,ernesto-g/micropython,alex-robbins/micropython,rubencabrera/micropython,rubencabrera/micropython,ericsnowcurrently/micropython,puuu/micropython,hiway/micropython,ryannathans/micropython,galenhz/micropython,danicampora/micropython,redbear/micropython,SHA2017-badge/micropython-esp32,TDAbboud/micropython,dmazzella/micropython,ericsnowcurrently/micropython,cloudformdesign/micropython,deshipu/micropython,ganshun666/micropython,MrSurly/micropython,omtinez/micropython,jlillest/micropython,AriZuu/micropython,ernesto-g/micropython,rubencabrera/micropython,chrisdearman/micropython,vitiral/micropython,kerneltask/micropython,pfalcon/micropython,neilh10/micropython,selste/micropython,Peetz0r/micropython-esp32,mpalomer/micropython,selste/micropython,xhat/micropython,noahchense/micropython,EcmaXp/micropython,feilongfl/micropython,dhylands/micropython,drrk/micropython,ernesto-g/micropython,ahotam/micropython,EcmaXp/micropython,toolmacher/micropython,omtinez/micropython,drrk/micropython,adafruit/circuitpython,hiway/micropython,TDAbboud/micropython,blazewicz/micropython,torwag/micropython,xyb/micropython,ernesto-g/micropython,Timmenem/micropython,firstval/micropython,feilongfl/micropython,ryannathans/micropython,AriZuu/micropython,feilongfl/micropython,alex-robbins/micropython,EcmaXp/micropython,dinau/micropython,mpalomer/micropython,supergis/micropython,adafruit/micropython,jmarcelino/pycom-micropython,emfcamp/micropython,TDAbboud/micropython,vriera/micropython,xhat/micropython,xuxiaoxin/micropython,turbinenreiter/micropython,oopy/micropython,rubencabrera/micropython,swegener/micropython,oopy/micropython,orionrobots/micropython,tuc-osg/micropython,skybird6672/micropython,vriera/micropython,henriknelson/micropython,tobbad/micropython,drrk/micropython,puuu/micropython,adafruit/micropython,hiway/micropython,pramasoul/micropython,skybird6672/micropython,ericsnowcurrently/micropython,infinnovation/micropython,toolmacher/micropython,pramasoul/micropython,jlillest/micropython,martinribelotta/micropython,mhoffma/micropython,blmorris/micropython,EcmaXp/micropython,swegener/micropython,blmorris/micropython,MrSurly/micropython,AriZuu/micropython,MrSurly/micropython-esp32,jmarcelino/pycom-micropython,mpalomer/micropython,Peetz0r/micropython-esp32,danicampora/micropython,micropython/micropython-esp32,pfalcon/micropython,henriknelson/micropython,stonegithubs/micropython,adamkh/micropython,galenhz/micropython,stonegithubs/micropython,stonegithubs/micropython,HenrikSolver/micropython,adamkh/micropython,noahwilliamsson/micropython,praemdonck/micropython,cloudformdesign/micropython,adamkh/micropython,HenrikSolver/micropython,blmorris/micropython,neilh10/micropython,chrisdearman/micropython,neilh10/micropython,ganshun666/micropython,oopy/micropython,swegener/micropython,pramasoul/micropython,torwag/micropython,bvernoux/micropython,ganshun666/micropython,PappaPeppar/micropython,cloudformdesign/micropython,jlillest/micropython,mpalomer/micropython,cwyark/micropython,ChuckM/micropython,martinribelotta/micropython,emfcamp/micropython,dxxb/micropython,dxxb/micropython,mianos/micropython,misterdanb/micropython,utopiaprince/micropython,mpalomer/micropython,jlillest/micropython,Peetz0r/micropython-esp32,ChuckM/micropython,supergis/micropython,neilh10/micropython,tralamazza/micropython,swegener/micropython,noahwilliamsson/micropython,matthewelse/micropython,selste/micropython,matthewelse/micropython,blazewicz/micropython,dhylands/micropython,noahchense/micropython,trezor/micropython,rubencabrera/micropython,toolmacher/micropython,bvernoux/micropython,misterdanb/micropython,ruffy91/micropython,trezor/micropython,chrisdearman/micropython,infinnovation/micropython,dhylands/micropython,lowRISC/micropython,pozetroninc/micropython,adafruit/circuitpython,Peetz0r/micropython-esp32,ryannathans/micropython,mianos/micropython,vriera/micropython,lowRISC/micropython,puuu/micropython,matthewelse/micropython,jmarcelino/pycom-micropython,dinau/micropython,micropython/micropython-esp32,danicampora/micropython,Timmenem/micropython,matthewelse/micropython,ryannathans/micropython,galenhz/micropython,skybird6672/micropython,AriZuu/micropython,ericsnowcurrently/micropython,alex-march/micropython,hiway/micropython,dmazzella/micropython,hosaka/micropython,misterdanb/micropython,SHA2017-badge/micropython-esp32,pramasoul/micropython,MrSurly/micropython,ericsnowcurrently/micropython,xhat/micropython,hosaka/micropython,deshipu/micropython,pozetroninc/micropython,HenrikSolver/micropython,supergis/micropython,vitiral/micropython,blazewicz/micropython,redbear/micropython,TDAbboud/micropython,noahwilliamsson/micropython,redbear/micropython,torwag/micropython,alex-robbins/micropython,adafruit/micropython,utopiaprince/micropython,bvernoux/micropython,supergis/micropython,skybird6672/micropython,alex-march/micropython,kerneltask/micropython,hiway/micropython,dhylands/micropython,omtinez/micropython,MrSurly/micropython-esp32,lowRISC/micropython,redbear/micropython,misterdanb/micropython,MrSurly/micropython-esp32,alex-march/micropython,tuc-osg/micropython,adafruit/circuitpython,swegener/micropython,cwyark/micropython,danicampora/micropython,toolmacher/micropython,AriZuu/micropython,praemdonck/micropython,dinau/micropython,orionrobots/micropython,deshipu/micropython,micropython/micropython-esp32,tuc-osg/micropython,jmarcelino/pycom-micropython,blazewicz/micropython,TDAbboud/micropython,orionrobots/micropython,galenhz/micropython,puuu/micropython,matthewelse/micropython,martinribelotta/micropython,noahwilliamsson/micropython,adamkh/micropython,HenrikSolver/micropython,matthewelse/micropython,tobbad/micropython,HenrikSolver/micropython,omtinez/micropython,tuc-osg/micropython,PappaPeppar/micropython,emfcamp/micropython,kerneltask/micropython,MrSurly/micropython-esp32,bvernoux/micropython,ChuckM/micropython,MrSurly/micropython-esp32,alex-robbins/micropython,MrSurly/micropython,tralamazza/micropython,ahotam/micropython,hosaka/micropython,Peetz0r/micropython-esp32,ruffy91/micropython,xyb/micropython,cwyark/micropython,Timmenem/micropython,tuc-osg/micropython,xhat/micropython,pozetroninc/micropython,selste/micropython,vriera/micropython,emfcamp/micropython,xyb/micropython,trezor/micropython,utopiaprince/micropython,toolmacher/micropython,cloudformdesign/micropython,noahchense/micropython,xuxiaoxin/micropython,ruffy91/micropython | import sys
try:
import _os as os
except ImportError:
import os
if not hasattr(os, "unlink"):
print("SKIP")
sys.exit()
+ # cleanup in case testfile exists
try:
os.unlink("testfile")
except OSError:
pass
# Should create a file
f = open("testfile", "a")
f.write("foo")
f.close()
f = open("testfile")
print(f.read())
f.close()
f = open("testfile", "a")
f.write("bar")
f.close()
f = open("testfile")
print(f.read())
f.close()
+ # cleanup
+ try:
+ os.unlink("testfile")
+ except OSError:
+ pass
+ | Make io test cleanup after itself by removing 'testfile'. | ## Code Before:
import sys
try:
import _os as os
except ImportError:
import os
if not hasattr(os, "unlink"):
print("SKIP")
sys.exit()
try:
os.unlink("testfile")
except OSError:
pass
# Should create a file
f = open("testfile", "a")
f.write("foo")
f.close()
f = open("testfile")
print(f.read())
f.close()
f = open("testfile", "a")
f.write("bar")
f.close()
f = open("testfile")
print(f.read())
f.close()
## Instruction:
Make io test cleanup after itself by removing 'testfile'.
## Code After:
import sys
try:
import _os as os
except ImportError:
import os
if not hasattr(os, "unlink"):
print("SKIP")
sys.exit()
# cleanup in case testfile exists
try:
os.unlink("testfile")
except OSError:
pass
# Should create a file
f = open("testfile", "a")
f.write("foo")
f.close()
f = open("testfile")
print(f.read())
f.close()
f = open("testfile", "a")
f.write("bar")
f.close()
f = open("testfile")
print(f.read())
f.close()
# cleanup
try:
os.unlink("testfile")
except OSError:
pass
| import sys
try:
import _os as os
except ImportError:
import os
if not hasattr(os, "unlink"):
print("SKIP")
sys.exit()
+ # cleanup in case testfile exists
try:
os.unlink("testfile")
except OSError:
pass
# Should create a file
f = open("testfile", "a")
f.write("foo")
f.close()
f = open("testfile")
print(f.read())
f.close()
f = open("testfile", "a")
f.write("bar")
f.close()
f = open("testfile")
print(f.read())
f.close()
+
+ # cleanup
+ try:
+ os.unlink("testfile")
+ except OSError:
+ pass |
8dcda9a9dd5c7f106d5544bb185fa348157495fb | blimp_boards/accounts/serializers.py | blimp_boards/accounts/serializers.py | from rest_framework import serializers
from ..utils.fields import DomainNameField
from .fields import SignupDomainsField
from .models import Account
class ValidateSignupDomainsSerializer(serializers.Serializer):
"""
Serializer that handles signup domains validation endpoint.
"""
signup_domains = SignupDomainsField()
class AccountSerializer(serializers.ModelSerializer):
"""
Serializer for Accounts.
"""
class Meta:
model = Account
fields = ('id', 'name', 'slug', 'disqus_shortname', 'logo_color',
'date_created', 'date_modified')
class CheckSignupDomainSerializer(serializers.Serializer):
"""
Serializer to get account that has signup domain setup.
"""
signup_domain = DomainNameField()
def validate_signup_domain(self, attrs, source):
signup_domain = attrs[source]
data = {}
try:
account = Account.objects.get(
allow_signup=True, email_domains__domain_name=signup_domain)
data = AccountSerializer(account).data
except Account.DoesNotExist:
pass
return data
| from rest_framework import serializers
from ..utils.fields import DomainNameField
from .fields import SignupDomainsField
from .models import Account
class ValidateSignupDomainsSerializer(serializers.Serializer):
"""
Serializer that handles signup domains validation endpoint.
"""
signup_domains = SignupDomainsField()
class AccountSerializer(serializers.ModelSerializer):
"""
Serializer for Accounts.
"""
class Meta:
model = Account
read_only_fields = ('logo_color', )
fields = ('id', 'name', 'slug', 'disqus_shortname', 'logo_color',
'date_created', 'date_modified')
class CheckSignupDomainSerializer(serializers.Serializer):
"""
Serializer to get account that has signup domain setup.
"""
signup_domain = DomainNameField()
def validate_signup_domain(self, attrs, source):
signup_domain = attrs[source]
data = {}
try:
account = Account.objects.get(
allow_signup=True, email_domains__domain_name=signup_domain)
data = AccountSerializer(account).data
except Account.DoesNotExist:
pass
return data
| Set Account logo_color to be read only | Set Account logo_color to be read only | Python | agpl-3.0 | jessamynsmith/boards-backend,jessamynsmith/boards-backend,GetBlimp/boards-backend | from rest_framework import serializers
from ..utils.fields import DomainNameField
from .fields import SignupDomainsField
from .models import Account
class ValidateSignupDomainsSerializer(serializers.Serializer):
"""
Serializer that handles signup domains validation endpoint.
"""
signup_domains = SignupDomainsField()
class AccountSerializer(serializers.ModelSerializer):
"""
Serializer for Accounts.
"""
class Meta:
model = Account
+ read_only_fields = ('logo_color', )
fields = ('id', 'name', 'slug', 'disqus_shortname', 'logo_color',
'date_created', 'date_modified')
class CheckSignupDomainSerializer(serializers.Serializer):
"""
Serializer to get account that has signup domain setup.
"""
signup_domain = DomainNameField()
def validate_signup_domain(self, attrs, source):
signup_domain = attrs[source]
data = {}
try:
account = Account.objects.get(
allow_signup=True, email_domains__domain_name=signup_domain)
data = AccountSerializer(account).data
except Account.DoesNotExist:
pass
return data
| Set Account logo_color to be read only | ## Code Before:
from rest_framework import serializers
from ..utils.fields import DomainNameField
from .fields import SignupDomainsField
from .models import Account
class ValidateSignupDomainsSerializer(serializers.Serializer):
"""
Serializer that handles signup domains validation endpoint.
"""
signup_domains = SignupDomainsField()
class AccountSerializer(serializers.ModelSerializer):
"""
Serializer for Accounts.
"""
class Meta:
model = Account
fields = ('id', 'name', 'slug', 'disqus_shortname', 'logo_color',
'date_created', 'date_modified')
class CheckSignupDomainSerializer(serializers.Serializer):
"""
Serializer to get account that has signup domain setup.
"""
signup_domain = DomainNameField()
def validate_signup_domain(self, attrs, source):
signup_domain = attrs[source]
data = {}
try:
account = Account.objects.get(
allow_signup=True, email_domains__domain_name=signup_domain)
data = AccountSerializer(account).data
except Account.DoesNotExist:
pass
return data
## Instruction:
Set Account logo_color to be read only
## Code After:
from rest_framework import serializers
from ..utils.fields import DomainNameField
from .fields import SignupDomainsField
from .models import Account
class ValidateSignupDomainsSerializer(serializers.Serializer):
"""
Serializer that handles signup domains validation endpoint.
"""
signup_domains = SignupDomainsField()
class AccountSerializer(serializers.ModelSerializer):
"""
Serializer for Accounts.
"""
class Meta:
model = Account
read_only_fields = ('logo_color', )
fields = ('id', 'name', 'slug', 'disqus_shortname', 'logo_color',
'date_created', 'date_modified')
class CheckSignupDomainSerializer(serializers.Serializer):
"""
Serializer to get account that has signup domain setup.
"""
signup_domain = DomainNameField()
def validate_signup_domain(self, attrs, source):
signup_domain = attrs[source]
data = {}
try:
account = Account.objects.get(
allow_signup=True, email_domains__domain_name=signup_domain)
data = AccountSerializer(account).data
except Account.DoesNotExist:
pass
return data
| from rest_framework import serializers
from ..utils.fields import DomainNameField
from .fields import SignupDomainsField
from .models import Account
class ValidateSignupDomainsSerializer(serializers.Serializer):
"""
Serializer that handles signup domains validation endpoint.
"""
signup_domains = SignupDomainsField()
class AccountSerializer(serializers.ModelSerializer):
"""
Serializer for Accounts.
"""
class Meta:
model = Account
+ read_only_fields = ('logo_color', )
fields = ('id', 'name', 'slug', 'disqus_shortname', 'logo_color',
'date_created', 'date_modified')
class CheckSignupDomainSerializer(serializers.Serializer):
"""
Serializer to get account that has signup domain setup.
"""
signup_domain = DomainNameField()
def validate_signup_domain(self, attrs, source):
signup_domain = attrs[source]
data = {}
try:
account = Account.objects.get(
allow_signup=True, email_domains__domain_name=signup_domain)
data = AccountSerializer(account).data
except Account.DoesNotExist:
pass
return data |
8baff5cb627ed55f748123d536273c4a4e648d77 | obelisk-cardiograph.py | obelisk-cardiograph.py |
import zmq
def main():
""" main method """
serverip = '79.98.29.93'
serverport = '9092'
ctx = zmq.Context()
s = ctx.socket(zmq.SUB)
s.connect('tcp://' + serverip + ':' + serverport)
s.setsockopt(zmq.SUBSCRIBE, b'') # subscribe to everything
print("Entering main loop.")
while True:
reply = s.recv()
reply = reply[::-1] # obelisk sent little-endian
data = ':'.join(hex(x)[2:] for x in reply)
print(serverip, data)
# We never get here but clean up anyhow
s.close()
ctx.term()
if __name__ == "__main__":
main()
|
import zmq
def main():
""" main method """
servers = ['preacher.veox.pw:9092']
context = zmq.Context()
s = context.socket(zmq.SUB)
s.connect('tcp://' + servers[0])
s.setsockopt(zmq.SUBSCRIBE, b'') # subscribe to everything
print("Entering main loop.")
while True:
reply = s.recv()
reply = reply[::-1] # obelisk sent little-endian
data = ':'.join(hex(x)[2:] for x in reply)
print(servers[0], data)
# We never get here but clean up anyhow
s.close()
context.term()
if __name__ == "__main__":
main()
| Put servers in a list, use FQDNs if available, rename context var. | Put servers in a list, use FQDNs if available, rename context var.
| Python | agpl-3.0 | veox/obelisk-cardiograph |
import zmq
def main():
""" main method """
+ servers = ['preacher.veox.pw:9092']
- serverip = '79.98.29.93'
- serverport = '9092'
- ctx = zmq.Context()
+ context = zmq.Context()
- s = ctx.socket(zmq.SUB)
+ s = context.socket(zmq.SUB)
- s.connect('tcp://' + serverip + ':' + serverport)
+ s.connect('tcp://' + servers[0])
s.setsockopt(zmq.SUBSCRIBE, b'') # subscribe to everything
print("Entering main loop.")
while True:
reply = s.recv()
reply = reply[::-1] # obelisk sent little-endian
data = ':'.join(hex(x)[2:] for x in reply)
- print(serverip, data)
+ print(servers[0], data)
# We never get here but clean up anyhow
s.close()
- ctx.term()
+ context.term()
if __name__ == "__main__":
main()
| Put servers in a list, use FQDNs if available, rename context var. | ## Code Before:
import zmq
def main():
""" main method """
serverip = '79.98.29.93'
serverport = '9092'
ctx = zmq.Context()
s = ctx.socket(zmq.SUB)
s.connect('tcp://' + serverip + ':' + serverport)
s.setsockopt(zmq.SUBSCRIBE, b'') # subscribe to everything
print("Entering main loop.")
while True:
reply = s.recv()
reply = reply[::-1] # obelisk sent little-endian
data = ':'.join(hex(x)[2:] for x in reply)
print(serverip, data)
# We never get here but clean up anyhow
s.close()
ctx.term()
if __name__ == "__main__":
main()
## Instruction:
Put servers in a list, use FQDNs if available, rename context var.
## Code After:
import zmq
def main():
""" main method """
servers = ['preacher.veox.pw:9092']
context = zmq.Context()
s = context.socket(zmq.SUB)
s.connect('tcp://' + servers[0])
s.setsockopt(zmq.SUBSCRIBE, b'') # subscribe to everything
print("Entering main loop.")
while True:
reply = s.recv()
reply = reply[::-1] # obelisk sent little-endian
data = ':'.join(hex(x)[2:] for x in reply)
print(servers[0], data)
# We never get here but clean up anyhow
s.close()
context.term()
if __name__ == "__main__":
main()
|
import zmq
def main():
""" main method """
+ servers = ['preacher.veox.pw:9092']
- serverip = '79.98.29.93'
- serverport = '9092'
- ctx = zmq.Context()
+ context = zmq.Context()
? ++ + +
- s = ctx.socket(zmq.SUB)
+ s = context.socket(zmq.SUB)
? ++ + +
- s.connect('tcp://' + serverip + ':' + serverport)
+ s.connect('tcp://' + servers[0])
s.setsockopt(zmq.SUBSCRIBE, b'') # subscribe to everything
print("Entering main loop.")
while True:
reply = s.recv()
reply = reply[::-1] # obelisk sent little-endian
data = ':'.join(hex(x)[2:] for x in reply)
- print(serverip, data)
? ^^
+ print(servers[0], data)
? ^^^^
# We never get here but clean up anyhow
s.close()
- ctx.term()
+ context.term()
? ++ + +
if __name__ == "__main__":
main() |
4b03c2c39c90bd1563954df16f353348f20d7280 | setup.py | setup.py |
classifiers = """\
Development Status :: 3 - Alpha
Environment :: Win32 (MS Windows)
Intended Audience :: Developers
License :: OSI Approved :: BSD License
Operating System :: Microsoft :: MS-DOS
Programming Language :: Python
Topic :: Software Development :: Libraries
Topic :: System :: Shells
Topic :: Terminals
"""
from distutils.core import setup
doclines = __doc__.split('\n')
setup(
name='dosbox-screen',
version='0.0.1',
requires=['ctypes', 'colorama'],
description=doclines[0],
classifiers=[line for line in classifiers.split('\n') if line],
long_description=' '.join(doclines),
license="BSD",
#platform='win32',
author='Bjorn Pettersen',
author_email='bjorn@tkbe.org',
url='https://github.com/thebjorn/doscmd-screen',
download_url='https://github.com/thebjorn/doscmd-screen',
py_modules=['screen']
)
|
classifiers = """\
Development Status :: 3 - Alpha
Environment :: Win32 (MS Windows)
Intended Audience :: Developers
License :: OSI Approved :: BSD License
Operating System :: Microsoft :: MS-DOS
Programming Language :: Python
Topic :: Software Development :: Libraries
Topic :: System :: Shells
Topic :: Terminals
"""
from distutils.core import setup
doclines = __doc__.split('\n')
setup(
name='dosbox-screen',
version='0.0.3',
requires=['colorama'],
install_requires=['colorama'],
description=doclines[0],
classifiers=[line for line in classifiers.split('\n') if line],
long_description=' '.join(doclines),
license="BSD",
#platform='win32',
author='Bjorn Pettersen',
author_email='bjorn@tkbe.org',
url='https://github.com/thebjorn/doscmd-screen',
download_url='https://github.com/thebjorn/doscmd-screen',
py_modules=['screen']
)
| Add install_requires and remove ctypes from requirements. | Add install_requires and remove ctypes from requirements.
| Python | mit | thebjorn/doscmd-screen |
classifiers = """\
Development Status :: 3 - Alpha
Environment :: Win32 (MS Windows)
Intended Audience :: Developers
License :: OSI Approved :: BSD License
Operating System :: Microsoft :: MS-DOS
Programming Language :: Python
Topic :: Software Development :: Libraries
Topic :: System :: Shells
Topic :: Terminals
"""
from distutils.core import setup
doclines = __doc__.split('\n')
setup(
name='dosbox-screen',
- version='0.0.1',
+ version='0.0.3',
- requires=['ctypes', 'colorama'],
+ requires=['colorama'],
+ install_requires=['colorama'],
description=doclines[0],
classifiers=[line for line in classifiers.split('\n') if line],
long_description=' '.join(doclines),
license="BSD",
#platform='win32',
author='Bjorn Pettersen',
author_email='bjorn@tkbe.org',
url='https://github.com/thebjorn/doscmd-screen',
download_url='https://github.com/thebjorn/doscmd-screen',
py_modules=['screen']
)
| Add install_requires and remove ctypes from requirements. | ## Code Before:
classifiers = """\
Development Status :: 3 - Alpha
Environment :: Win32 (MS Windows)
Intended Audience :: Developers
License :: OSI Approved :: BSD License
Operating System :: Microsoft :: MS-DOS
Programming Language :: Python
Topic :: Software Development :: Libraries
Topic :: System :: Shells
Topic :: Terminals
"""
from distutils.core import setup
doclines = __doc__.split('\n')
setup(
name='dosbox-screen',
version='0.0.1',
requires=['ctypes', 'colorama'],
description=doclines[0],
classifiers=[line for line in classifiers.split('\n') if line],
long_description=' '.join(doclines),
license="BSD",
#platform='win32',
author='Bjorn Pettersen',
author_email='bjorn@tkbe.org',
url='https://github.com/thebjorn/doscmd-screen',
download_url='https://github.com/thebjorn/doscmd-screen',
py_modules=['screen']
)
## Instruction:
Add install_requires and remove ctypes from requirements.
## Code After:
classifiers = """\
Development Status :: 3 - Alpha
Environment :: Win32 (MS Windows)
Intended Audience :: Developers
License :: OSI Approved :: BSD License
Operating System :: Microsoft :: MS-DOS
Programming Language :: Python
Topic :: Software Development :: Libraries
Topic :: System :: Shells
Topic :: Terminals
"""
from distutils.core import setup
doclines = __doc__.split('\n')
setup(
name='dosbox-screen',
version='0.0.3',
requires=['colorama'],
install_requires=['colorama'],
description=doclines[0],
classifiers=[line for line in classifiers.split('\n') if line],
long_description=' '.join(doclines),
license="BSD",
#platform='win32',
author='Bjorn Pettersen',
author_email='bjorn@tkbe.org',
url='https://github.com/thebjorn/doscmd-screen',
download_url='https://github.com/thebjorn/doscmd-screen',
py_modules=['screen']
)
|
classifiers = """\
Development Status :: 3 - Alpha
Environment :: Win32 (MS Windows)
Intended Audience :: Developers
License :: OSI Approved :: BSD License
Operating System :: Microsoft :: MS-DOS
Programming Language :: Python
Topic :: Software Development :: Libraries
Topic :: System :: Shells
Topic :: Terminals
"""
from distutils.core import setup
doclines = __doc__.split('\n')
setup(
name='dosbox-screen',
- version='0.0.1',
? ^
+ version='0.0.3',
? ^
- requires=['ctypes', 'colorama'],
? ----------
+ requires=['colorama'],
+ install_requires=['colorama'],
description=doclines[0],
classifiers=[line for line in classifiers.split('\n') if line],
long_description=' '.join(doclines),
license="BSD",
#platform='win32',
author='Bjorn Pettersen',
author_email='bjorn@tkbe.org',
url='https://github.com/thebjorn/doscmd-screen',
download_url='https://github.com/thebjorn/doscmd-screen',
py_modules=['screen']
) |
afc18ff91bde4e6e6da554c7f9e520e5cac89fa2 | streams.py | streams.py | import praw
r = praw.Reddit(user_agent='nba_stream_parser')
submissions = r.get_subreddit('nbastreams').get_hot(limit=10)
for submission in submissions:
print(submission.selftext_html)
| from bs4 import BeautifulSoup
import html
import praw
r = praw.Reddit(user_agent='nba_stream_parser')
def get_streams_for_team(teams):
teams.append('Game Thread')
submissions = r.get_subreddit('nbastreams').get_hot(limit=20)
streams = []
for submission in submissions:
if all(team in submission.title for team in teams):
for comment in submission.comments:
soup = BeautifulSoup(
html.unescape(comment.body_html), 'html.parser')
if soup.find('a'):
streams.append(soup.find('a')['href'])
return streams
if __name__ == '__main__':
print(get_streams_for_team(['Spurs']))
| Add comment parser; get stream links for any (2) team(s) | Add comment parser; get stream links for any (2) team(s)
| Python | mit | kshvmdn/NBAScores,kshvmdn/nba.js,kshvmdn/nba-scores | + from bs4 import BeautifulSoup
+ import html
import praw
+
r = praw.Reddit(user_agent='nba_stream_parser')
- submissions = r.get_subreddit('nbastreams').get_hot(limit=10)
- for submission in submissions:
- print(submission.selftext_html)
+ def get_streams_for_team(teams):
+ teams.append('Game Thread')
+ submissions = r.get_subreddit('nbastreams').get_hot(limit=20)
+ streams = []
+ for submission in submissions:
+ if all(team in submission.title for team in teams):
+ for comment in submission.comments:
+ soup = BeautifulSoup(
+ html.unescape(comment.body_html), 'html.parser')
+ if soup.find('a'):
+ streams.append(soup.find('a')['href'])
+ return streams
+
+ if __name__ == '__main__':
+ print(get_streams_for_team(['Spurs']))
+ | Add comment parser; get stream links for any (2) team(s) | ## Code Before:
import praw
r = praw.Reddit(user_agent='nba_stream_parser')
submissions = r.get_subreddit('nbastreams').get_hot(limit=10)
for submission in submissions:
print(submission.selftext_html)
## Instruction:
Add comment parser; get stream links for any (2) team(s)
## Code After:
from bs4 import BeautifulSoup
import html
import praw
r = praw.Reddit(user_agent='nba_stream_parser')
def get_streams_for_team(teams):
teams.append('Game Thread')
submissions = r.get_subreddit('nbastreams').get_hot(limit=20)
streams = []
for submission in submissions:
if all(team in submission.title for team in teams):
for comment in submission.comments:
soup = BeautifulSoup(
html.unescape(comment.body_html), 'html.parser')
if soup.find('a'):
streams.append(soup.find('a')['href'])
return streams
if __name__ == '__main__':
print(get_streams_for_team(['Spurs']))
| + from bs4 import BeautifulSoup
+ import html
import praw
+
r = praw.Reddit(user_agent='nba_stream_parser')
+
+ def get_streams_for_team(teams):
+ teams.append('Game Thread')
- submissions = r.get_subreddit('nbastreams').get_hot(limit=10)
? ^
+ submissions = r.get_subreddit('nbastreams').get_hot(limit=20)
? ++++ ^
+ streams = []
- for submission in submissions:
+ for submission in submissions:
? ++++
- print(submission.selftext_html)
+ if all(team in submission.title for team in teams):
+ for comment in submission.comments:
+ soup = BeautifulSoup(
+ html.unescape(comment.body_html), 'html.parser')
+ if soup.find('a'):
+ streams.append(soup.find('a')['href'])
+ return streams
+
+ if __name__ == '__main__':
+ print(get_streams_for_team(['Spurs'])) |
3750bc289685fc243788ee3330676ef7e4387234 | apps/accounts/tests/test_user_landing.py | apps/accounts/tests/test_user_landing.py |
from django.core.urlresolvers import reverse
from django_webtest import WebTest
class KeycloakHeaderLandAtHome(WebTest):
def test_auto_login_on_landing(self):
headers = { 'KEYCLOAK_USERNAME' : 'user@0001.com' }
response = self.app.get(reverse('home'), headers=headers)
self.assertEqual(reverse('link-list'), response.location)
|
from django.core.urlresolvers import reverse
from django_webtest import WebTest
class KeycloakHeaderLandAtHome(WebTest):
def test_auto_login_on_landing(self):
headers = { 'KEYCLOAK_USERNAME' : 'user@0001.com' }
response = self.app.get(reverse('home'), headers=headers)
self.assertEqual('http://localhost:80/links', response.location)
| Test for landing login now asserts against the correct path. | Test for landing login now asserts against the correct path.
| Python | mit | dstl/lighthouse,dstl/lighthouse,dstl/lighthouse,dstl/lighthouse,dstl/lighthouse |
from django.core.urlresolvers import reverse
from django_webtest import WebTest
class KeycloakHeaderLandAtHome(WebTest):
def test_auto_login_on_landing(self):
headers = { 'KEYCLOAK_USERNAME' : 'user@0001.com' }
response = self.app.get(reverse('home'), headers=headers)
- self.assertEqual(reverse('link-list'), response.location)
+ self.assertEqual('http://localhost:80/links', response.location)
| Test for landing login now asserts against the correct path. | ## Code Before:
from django.core.urlresolvers import reverse
from django_webtest import WebTest
class KeycloakHeaderLandAtHome(WebTest):
def test_auto_login_on_landing(self):
headers = { 'KEYCLOAK_USERNAME' : 'user@0001.com' }
response = self.app.get(reverse('home'), headers=headers)
self.assertEqual(reverse('link-list'), response.location)
## Instruction:
Test for landing login now asserts against the correct path.
## Code After:
from django.core.urlresolvers import reverse
from django_webtest import WebTest
class KeycloakHeaderLandAtHome(WebTest):
def test_auto_login_on_landing(self):
headers = { 'KEYCLOAK_USERNAME' : 'user@0001.com' }
response = self.app.get(reverse('home'), headers=headers)
self.assertEqual('http://localhost:80/links', response.location)
|
from django.core.urlresolvers import reverse
from django_webtest import WebTest
class KeycloakHeaderLandAtHome(WebTest):
def test_auto_login_on_landing(self):
headers = { 'KEYCLOAK_USERNAME' : 'user@0001.com' }
response = self.app.get(reverse('home'), headers=headers)
- self.assertEqual(reverse('link-list'), response.location)
? ^^^^^ ^^^ --- - -
+ self.assertEqual('http://localhost:80/links', response.location)
? ^^^^^^^^^^^^^^^ ^^^^^
|
193831b6ee8b49674e32413e71819f2451bfc844 | situational/apps/quick_history/forms.py | situational/apps/quick_history/forms.py | from django import forms
from . import widgets
class HistoryDetailsForm(forms.Form):
CIRCUMSTANCE_CHOICES = [
("full_time", "Full time"),
("part_time", "Part time"),
("work_programme", "Work programme"),
("unemployed", "Unemployed"),
("sick", "Off sick"),
("training", "In full time training"),
("caring", "Caring full time for others"),
("none", "None of these"),
]
circumstances = forms.ChoiceField(
widget=forms.RadioSelect(),
choices=CIRCUMSTANCE_CHOICES
)
date = forms.DateField(
widget=widgets.MonthYearWidget(years=range(2000, 2016))
)
description = forms.CharField(required=False)
def clean(self):
cleaned_data = super(HistoryDetailsForm, self).clean()
return cleaned_data
| from django import forms
from . import widgets
class HistoryDetailsForm(forms.Form):
CIRCUMSTANCE_CHOICES = [
("full_time", "Full time"),
("part_time", "Part time"),
("unemployed", "Unemployed"),
("sick", "Off sick"),
("training", "In full time training"),
("caring", "Caring full time for others"),
("none", "None of these"),
]
circumstances = forms.ChoiceField(
widget=forms.RadioSelect(),
choices=CIRCUMSTANCE_CHOICES
)
date = forms.DateField(
widget=widgets.MonthYearWidget(years=range(2000, 2016))
)
description = forms.CharField(required=False)
def clean(self):
cleaned_data = super(HistoryDetailsForm, self).clean()
return cleaned_data
| Remove "work programme" option from quick history | Remove "work programme" option from quick history
| Python | bsd-3-clause | lm-tools/situational,lm-tools/sectors,lm-tools/situational,lm-tools/situational,lm-tools/situational,lm-tools/sectors,lm-tools/situational,lm-tools/sectors,lm-tools/sectors | from django import forms
from . import widgets
class HistoryDetailsForm(forms.Form):
CIRCUMSTANCE_CHOICES = [
("full_time", "Full time"),
("part_time", "Part time"),
- ("work_programme", "Work programme"),
("unemployed", "Unemployed"),
("sick", "Off sick"),
("training", "In full time training"),
("caring", "Caring full time for others"),
("none", "None of these"),
]
circumstances = forms.ChoiceField(
widget=forms.RadioSelect(),
choices=CIRCUMSTANCE_CHOICES
)
date = forms.DateField(
widget=widgets.MonthYearWidget(years=range(2000, 2016))
)
description = forms.CharField(required=False)
def clean(self):
cleaned_data = super(HistoryDetailsForm, self).clean()
return cleaned_data
| Remove "work programme" option from quick history | ## Code Before:
from django import forms
from . import widgets
class HistoryDetailsForm(forms.Form):
CIRCUMSTANCE_CHOICES = [
("full_time", "Full time"),
("part_time", "Part time"),
("work_programme", "Work programme"),
("unemployed", "Unemployed"),
("sick", "Off sick"),
("training", "In full time training"),
("caring", "Caring full time for others"),
("none", "None of these"),
]
circumstances = forms.ChoiceField(
widget=forms.RadioSelect(),
choices=CIRCUMSTANCE_CHOICES
)
date = forms.DateField(
widget=widgets.MonthYearWidget(years=range(2000, 2016))
)
description = forms.CharField(required=False)
def clean(self):
cleaned_data = super(HistoryDetailsForm, self).clean()
return cleaned_data
## Instruction:
Remove "work programme" option from quick history
## Code After:
from django import forms
from . import widgets
class HistoryDetailsForm(forms.Form):
CIRCUMSTANCE_CHOICES = [
("full_time", "Full time"),
("part_time", "Part time"),
("unemployed", "Unemployed"),
("sick", "Off sick"),
("training", "In full time training"),
("caring", "Caring full time for others"),
("none", "None of these"),
]
circumstances = forms.ChoiceField(
widget=forms.RadioSelect(),
choices=CIRCUMSTANCE_CHOICES
)
date = forms.DateField(
widget=widgets.MonthYearWidget(years=range(2000, 2016))
)
description = forms.CharField(required=False)
def clean(self):
cleaned_data = super(HistoryDetailsForm, self).clean()
return cleaned_data
| from django import forms
from . import widgets
class HistoryDetailsForm(forms.Form):
CIRCUMSTANCE_CHOICES = [
("full_time", "Full time"),
("part_time", "Part time"),
- ("work_programme", "Work programme"),
("unemployed", "Unemployed"),
("sick", "Off sick"),
("training", "In full time training"),
("caring", "Caring full time for others"),
("none", "None of these"),
]
circumstances = forms.ChoiceField(
widget=forms.RadioSelect(),
choices=CIRCUMSTANCE_CHOICES
)
date = forms.DateField(
widget=widgets.MonthYearWidget(years=range(2000, 2016))
)
description = forms.CharField(required=False)
def clean(self):
cleaned_data = super(HistoryDetailsForm, self).clean()
return cleaned_data |
f0371f68fc0ece594710ad9dbbdbfdab00a22e49 | migrations/003_add_capped_collections.py | migrations/003_add_capped_collections.py | import logging
log = logging.getLogger(__name__)
def up(db):
capped_collections = [
"fco_realtime_pay_legalisation_post",
"fco_realtime_pay_legalisation_drop_off",
"fco_realtime_pay_register_birth_abroad",
"fco_realtime_pay_register_death_abroad",
"fco_realtime_pay_foreign_marriage_certificates",
"fco_realtime_deposit_foreign_marriage",
"govuk_realtime",
"licensing_realtime",
]
for collection_name in capped_collections:
db.create_collection(name=collection_name, capped=True, size=5040)
log.info("created capped collection: %s" % collection_name)
| import logging
log = logging.getLogger(__name__)
def up(db):
capped_collections = [
"fco_pay_legalisation_post_realtime",
"fco_pay_legalisation_drop_off_realtime",
"fco_pay_register_birth_abroad_realtime",
"fco_pay_register_death_abroad_realtime",
"fco_pay_foreign_marriage_certificates_realtime",
"fco_deposit_foreign_marriage_realtime",
"govuk_realtime",
"licensing_realtime",
]
for collection_name in capped_collections:
db.create_collection(name=collection_name, capped=True, size=5040)
log.info("created capped collection: %s" % collection_name)
| Make realtim fco bucket names match format of others | Make realtim fco bucket names match format of others
| Python | mit | alphagov/backdrop,alphagov/backdrop,alphagov/backdrop | import logging
log = logging.getLogger(__name__)
def up(db):
capped_collections = [
- "fco_realtime_pay_legalisation_post",
+ "fco_pay_legalisation_post_realtime",
- "fco_realtime_pay_legalisation_drop_off",
+ "fco_pay_legalisation_drop_off_realtime",
- "fco_realtime_pay_register_birth_abroad",
+ "fco_pay_register_birth_abroad_realtime",
- "fco_realtime_pay_register_death_abroad",
+ "fco_pay_register_death_abroad_realtime",
- "fco_realtime_pay_foreign_marriage_certificates",
+ "fco_pay_foreign_marriage_certificates_realtime",
- "fco_realtime_deposit_foreign_marriage",
+ "fco_deposit_foreign_marriage_realtime",
"govuk_realtime",
"licensing_realtime",
]
for collection_name in capped_collections:
db.create_collection(name=collection_name, capped=True, size=5040)
log.info("created capped collection: %s" % collection_name)
| Make realtim fco bucket names match format of others | ## Code Before:
import logging
log = logging.getLogger(__name__)
def up(db):
capped_collections = [
"fco_realtime_pay_legalisation_post",
"fco_realtime_pay_legalisation_drop_off",
"fco_realtime_pay_register_birth_abroad",
"fco_realtime_pay_register_death_abroad",
"fco_realtime_pay_foreign_marriage_certificates",
"fco_realtime_deposit_foreign_marriage",
"govuk_realtime",
"licensing_realtime",
]
for collection_name in capped_collections:
db.create_collection(name=collection_name, capped=True, size=5040)
log.info("created capped collection: %s" % collection_name)
## Instruction:
Make realtim fco bucket names match format of others
## Code After:
import logging
log = logging.getLogger(__name__)
def up(db):
capped_collections = [
"fco_pay_legalisation_post_realtime",
"fco_pay_legalisation_drop_off_realtime",
"fco_pay_register_birth_abroad_realtime",
"fco_pay_register_death_abroad_realtime",
"fco_pay_foreign_marriage_certificates_realtime",
"fco_deposit_foreign_marriage_realtime",
"govuk_realtime",
"licensing_realtime",
]
for collection_name in capped_collections:
db.create_collection(name=collection_name, capped=True, size=5040)
log.info("created capped collection: %s" % collection_name)
| import logging
log = logging.getLogger(__name__)
def up(db):
capped_collections = [
- "fco_realtime_pay_legalisation_post",
? ---------
+ "fco_pay_legalisation_post_realtime",
? +++++++++
- "fco_realtime_pay_legalisation_drop_off",
? ---------
+ "fco_pay_legalisation_drop_off_realtime",
? +++++++++
- "fco_realtime_pay_register_birth_abroad",
? ---------
+ "fco_pay_register_birth_abroad_realtime",
? +++++++++
- "fco_realtime_pay_register_death_abroad",
? ---------
+ "fco_pay_register_death_abroad_realtime",
? +++++++++
- "fco_realtime_pay_foreign_marriage_certificates",
? ---------
+ "fco_pay_foreign_marriage_certificates_realtime",
? +++++++++
- "fco_realtime_deposit_foreign_marriage",
? ---------
+ "fco_deposit_foreign_marriage_realtime",
? +++++++++
"govuk_realtime",
"licensing_realtime",
]
for collection_name in capped_collections:
db.create_collection(name=collection_name, capped=True, size=5040)
log.info("created capped collection: %s" % collection_name) |
ecc3a9c90d20699c6f0bf18600cf9bd755b56d65 | rollbar/contrib/fastapi/utils.py | rollbar/contrib/fastapi/utils.py | import logging
log = logging.getLogger(__name__)
class FastAPIVersionError(Exception):
def __init__(self, version, reason=''):
err_msg = f'FastAPI {version}+ is required'
if reason:
err_msg += f' {reason}'
log.error(err_msg)
return super().__init__(err_msg)
| import functools
import logging
import fastapi
log = logging.getLogger(__name__)
class FastAPIVersionError(Exception):
def __init__(self, version, reason=''):
err_msg = f'FastAPI {version}+ is required'
if reason:
err_msg += f' {reason}'
log.error(err_msg)
return super().__init__(err_msg)
class fastapi_min_version:
def __init__(self, min_version):
self.min_version = min_version
def __call__(self, func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
if fastapi.__version__ < self.min_version:
raise FastAPIVersionError(
'0.41.0', reason=f'to use {func.__name__}() function'
)
return func(*args, **kwargs)
return wrapper
| Add decorator to check minimum required FastAPI version | Add decorator to check minimum required FastAPI version
| Python | mit | rollbar/pyrollbar | + import functools
import logging
+
+ import fastapi
log = logging.getLogger(__name__)
class FastAPIVersionError(Exception):
def __init__(self, version, reason=''):
err_msg = f'FastAPI {version}+ is required'
if reason:
err_msg += f' {reason}'
log.error(err_msg)
return super().__init__(err_msg)
+
+ class fastapi_min_version:
+ def __init__(self, min_version):
+ self.min_version = min_version
+
+ def __call__(self, func):
+ @functools.wraps(func)
+ def wrapper(*args, **kwargs):
+ if fastapi.__version__ < self.min_version:
+ raise FastAPIVersionError(
+ '0.41.0', reason=f'to use {func.__name__}() function'
+ )
+
+ return func(*args, **kwargs)
+
+ return wrapper
+ | Add decorator to check minimum required FastAPI version | ## Code Before:
import logging
log = logging.getLogger(__name__)
class FastAPIVersionError(Exception):
def __init__(self, version, reason=''):
err_msg = f'FastAPI {version}+ is required'
if reason:
err_msg += f' {reason}'
log.error(err_msg)
return super().__init__(err_msg)
## Instruction:
Add decorator to check minimum required FastAPI version
## Code After:
import functools
import logging
import fastapi
log = logging.getLogger(__name__)
class FastAPIVersionError(Exception):
def __init__(self, version, reason=''):
err_msg = f'FastAPI {version}+ is required'
if reason:
err_msg += f' {reason}'
log.error(err_msg)
return super().__init__(err_msg)
class fastapi_min_version:
def __init__(self, min_version):
self.min_version = min_version
def __call__(self, func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
if fastapi.__version__ < self.min_version:
raise FastAPIVersionError(
'0.41.0', reason=f'to use {func.__name__}() function'
)
return func(*args, **kwargs)
return wrapper
| + import functools
import logging
+
+ import fastapi
log = logging.getLogger(__name__)
class FastAPIVersionError(Exception):
def __init__(self, version, reason=''):
err_msg = f'FastAPI {version}+ is required'
if reason:
err_msg += f' {reason}'
log.error(err_msg)
return super().__init__(err_msg)
+
+
+ class fastapi_min_version:
+ def __init__(self, min_version):
+ self.min_version = min_version
+
+ def __call__(self, func):
+ @functools.wraps(func)
+ def wrapper(*args, **kwargs):
+ if fastapi.__version__ < self.min_version:
+ raise FastAPIVersionError(
+ '0.41.0', reason=f'to use {func.__name__}() function'
+ )
+
+ return func(*args, **kwargs)
+
+ return wrapper |
f3fb5bd0dbb3e19e58558af015aaee5ec120af71 | portal/template_helpers.py | portal/template_helpers.py | """ Module for helper functions used inside jinja2 templates """
# NB, each blueprint must individually load any functions defined below
# for them to appear in the namespace when invoked from respective blueprint
# See @<blueprint>.context_processor decorator for more info.
def split_string(s, delimiter=','):
return s.split(delimiter)
| """ Module for helper functions used inside jinja2 templates """
# NB, each blueprint must individually load any functions defined below
# for them to appear in the namespace when invoked from respective blueprint
# See @<blueprint>.context_processor decorator for more info.
def split_string(s, delimiter=','):
"""Given string (or tuple) return the delimited values"""
# If given a tuple, split already happened
if isinstance(s, (list, tuple)):
return s
return s.split(delimiter)
| Allow for list/tuples in config files when looking for comma delimited strings. | Allow for list/tuples in config files when looking for comma delimited
strings.
| Python | bsd-3-clause | uwcirg/true_nth_usa_portal,uwcirg/true_nth_usa_portal,uwcirg/true_nth_usa_portal,uwcirg/true_nth_usa_portal | """ Module for helper functions used inside jinja2 templates """
# NB, each blueprint must individually load any functions defined below
# for them to appear in the namespace when invoked from respective blueprint
# See @<blueprint>.context_processor decorator for more info.
def split_string(s, delimiter=','):
+ """Given string (or tuple) return the delimited values"""
+ # If given a tuple, split already happened
+ if isinstance(s, (list, tuple)):
+ return s
return s.split(delimiter)
| Allow for list/tuples in config files when looking for comma delimited strings. | ## Code Before:
""" Module for helper functions used inside jinja2 templates """
# NB, each blueprint must individually load any functions defined below
# for them to appear in the namespace when invoked from respective blueprint
# See @<blueprint>.context_processor decorator for more info.
def split_string(s, delimiter=','):
return s.split(delimiter)
## Instruction:
Allow for list/tuples in config files when looking for comma delimited strings.
## Code After:
""" Module for helper functions used inside jinja2 templates """
# NB, each blueprint must individually load any functions defined below
# for them to appear in the namespace when invoked from respective blueprint
# See @<blueprint>.context_processor decorator for more info.
def split_string(s, delimiter=','):
"""Given string (or tuple) return the delimited values"""
# If given a tuple, split already happened
if isinstance(s, (list, tuple)):
return s
return s.split(delimiter)
| """ Module for helper functions used inside jinja2 templates """
# NB, each blueprint must individually load any functions defined below
# for them to appear in the namespace when invoked from respective blueprint
# See @<blueprint>.context_processor decorator for more info.
def split_string(s, delimiter=','):
+ """Given string (or tuple) return the delimited values"""
+ # If given a tuple, split already happened
+ if isinstance(s, (list, tuple)):
+ return s
return s.split(delimiter) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.