Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Using the snippet: <|code_start|>
@pytest.fixture
def backend(request):
engine = get_sql_engine()
backend = _sql_backend(request, engine)
backend.register(Actor)
backend.register(Director)
backend.register(Movie)
backend.register(Food)
backend.init_schema()
backend.create_schema()
return backend
@pytest.fixture
<|code_end|>
, determine the next line of code. You have imports:
import pytest
from ..conftest import _sql_backend, get_sql_engine
from ..helpers.movie_data import Actor, Director, Food, Movie
and context (class names, function names, or code) available:
# Path: tests/conftest.py
# def _sql_backend(request, engine, **kwargs):
#
# meta = MetaData(engine)
# meta.reflect()
# meta.drop_all()
# # we enable foreign key checks for SQLITE
# if str(engine.url).startswith('sqlite://'):
# engine.connect().execute('pragma foreign_keys=ON')
#
# if not 'ondelete' in kwargs:
# kwargs['ondelete'] = 'CASCADE'
# backend = SqlBackend(engine=engine, **kwargs)
# backend.init_schema()
# backend.create_schema()
#
# def finalizer():
# backend.rollback()
# del backend.connection
# print("Dropping schema...")
# # we disable foreign key checks for SQLITE (as dropping tables with circular foreign keys won't work otherwise...)
# if str(engine.url).startswith('sqlite://'):
# engine.connect().execute('pragma foreign_keys=OFF')
# meta = MetaData(engine)
# meta.reflect()
# meta.drop_all()
# print("Done...")
#
# request.addfinalizer(finalizer)
#
# return backend
#
# def get_sql_engine():
# url = os.environ.get('BLITZDB_SQLALCHEMY_URL', memory_url)
# engine = create_engine(url, echo=False)
# # we make sure foreign keys are enforced...
# return engine
#
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Director(Document):
#
# """
# Warning: There is a circular foreign key relationship between
# Director and Movie, hence trying to save a pair of those objects
# that point to each other will yield an exception for e.g.
# the Postgres backend.
# """
#
# name = CharField(indexed = True)
# favorite_actor = ForeignKeyField('Actor')
# best_movie = ForeignKeyField('Movie',unique=True,backref = 'best_of_director')
#
# class Food(Document):
#
# name = CharField(indexed = True)
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | def empty_backend(request): |
Given the following code snippet before the placeholder: <|code_start|>
@pytest.fixture
def backend(request):
engine = get_sql_engine()
backend = _sql_backend(request, engine)
backend.register(Actor)
backend.register(Director)
backend.register(Movie)
backend.register(Food)
backend.init_schema()
backend.create_schema()
<|code_end|>
, predict the next line using imports from the current file:
import pytest
from ..conftest import _sql_backend, get_sql_engine
from ..helpers.movie_data import Actor, Director, Food, Movie
and context including class names, function names, and sometimes code from other files:
# Path: tests/conftest.py
# def _sql_backend(request, engine, **kwargs):
#
# meta = MetaData(engine)
# meta.reflect()
# meta.drop_all()
# # we enable foreign key checks for SQLITE
# if str(engine.url).startswith('sqlite://'):
# engine.connect().execute('pragma foreign_keys=ON')
#
# if not 'ondelete' in kwargs:
# kwargs['ondelete'] = 'CASCADE'
# backend = SqlBackend(engine=engine, **kwargs)
# backend.init_schema()
# backend.create_schema()
#
# def finalizer():
# backend.rollback()
# del backend.connection
# print("Dropping schema...")
# # we disable foreign key checks for SQLITE (as dropping tables with circular foreign keys won't work otherwise...)
# if str(engine.url).startswith('sqlite://'):
# engine.connect().execute('pragma foreign_keys=OFF')
# meta = MetaData(engine)
# meta.reflect()
# meta.drop_all()
# print("Done...")
#
# request.addfinalizer(finalizer)
#
# return backend
#
# def get_sql_engine():
# url = os.environ.get('BLITZDB_SQLALCHEMY_URL', memory_url)
# engine = create_engine(url, echo=False)
# # we make sure foreign keys are enforced...
# return engine
#
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Director(Document):
#
# """
# Warning: There is a circular foreign key relationship between
# Director and Movie, hence trying to save a pair of those objects
# that point to each other will yield an exception for e.g.
# the Postgres backend.
# """
#
# name = CharField(indexed = True)
# favorite_actor = ForeignKeyField('Actor')
# best_movie = ForeignKeyField('Movie',unique=True,backref = 'best_of_director')
#
# class Food(Document):
#
# name = CharField(indexed = True)
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | return backend |
Based on the snippet: <|code_start|>
@pytest.fixture
def backend(request):
engine = get_sql_engine()
backend = _sql_backend(request, engine)
backend.register(Actor)
backend.register(Director)
backend.register(Movie)
backend.register(Food)
backend.init_schema()
backend.create_schema()
return backend
<|code_end|>
, predict the immediate next line with the help of imports:
import pytest
from ..conftest import _sql_backend, get_sql_engine
from ..helpers.movie_data import Actor, Director, Food, Movie
and context (classes, functions, sometimes code) from other files:
# Path: tests/conftest.py
# def _sql_backend(request, engine, **kwargs):
#
# meta = MetaData(engine)
# meta.reflect()
# meta.drop_all()
# # we enable foreign key checks for SQLITE
# if str(engine.url).startswith('sqlite://'):
# engine.connect().execute('pragma foreign_keys=ON')
#
# if not 'ondelete' in kwargs:
# kwargs['ondelete'] = 'CASCADE'
# backend = SqlBackend(engine=engine, **kwargs)
# backend.init_schema()
# backend.create_schema()
#
# def finalizer():
# backend.rollback()
# del backend.connection
# print("Dropping schema...")
# # we disable foreign key checks for SQLITE (as dropping tables with circular foreign keys won't work otherwise...)
# if str(engine.url).startswith('sqlite://'):
# engine.connect().execute('pragma foreign_keys=OFF')
# meta = MetaData(engine)
# meta.reflect()
# meta.drop_all()
# print("Done...")
#
# request.addfinalizer(finalizer)
#
# return backend
#
# def get_sql_engine():
# url = os.environ.get('BLITZDB_SQLALCHEMY_URL', memory_url)
# engine = create_engine(url, echo=False)
# # we make sure foreign keys are enforced...
# return engine
#
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Director(Document):
#
# """
# Warning: There is a circular foreign key relationship between
# Director and Movie, hence trying to save a pair of those objects
# that point to each other will yield an exception for e.g.
# the Postgres backend.
# """
#
# name = CharField(indexed = True)
# favorite_actor = ForeignKeyField('Actor')
# best_movie = ForeignKeyField('Movie',unique=True,backref = 'best_of_director')
#
# class Food(Document):
#
# name = CharField(indexed = True)
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | @pytest.fixture |
Here is a snippet: <|code_start|>
def test_circular_reference(backend):
backend.init_schema()
backend.create_schema()
apocalypse_now = Movie({'title' : 'Apocalypse Now'})
francis_coppola = Director({'name' : 'Francis Coppola',
'best_movie' : apocalypse_now})
the_godfather = Movie({'title' : 'The Godfather',
'director' : francis_coppola})
robert_de_niro = Actor({'name' : 'Robert de Niro','movies' : []})
robert_de_niro.movies.append(the_godfather)
francis_coppola.favorite_actor = robert_de_niro
#this will yield an exception as we have a circular foreign key relationship
with pytest.raises(IntegrityError):
backend.save(robert_de_niro)
<|code_end|>
. Write the next line using the current file imports:
import pytest
from sqlalchemy.exc import IntegrityError
from ..helpers.movie_data import Actor, Director, Movie
and context from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Director(Document):
#
# """
# Warning: There is a circular foreign key relationship between
# Director and Movie, hence trying to save a pair of those objects
# that point to each other will yield an exception for e.g.
# the Postgres backend.
# """
#
# name = CharField(indexed = True)
# favorite_actor = ForeignKeyField('Actor')
# best_movie = ForeignKeyField('Movie',unique=True,backref = 'best_of_director')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
, which may include functions, classes, or code. Output only the next line. | del francis_coppola.favorite_actor |
Given the following code snippet before the placeholder: <|code_start|>
def test_circular_reference(backend):
backend.init_schema()
backend.create_schema()
apocalypse_now = Movie({'title' : 'Apocalypse Now'})
francis_coppola = Director({'name' : 'Francis Coppola',
'best_movie' : apocalypse_now})
the_godfather = Movie({'title' : 'The Godfather',
'director' : francis_coppola})
robert_de_niro = Actor({'name' : 'Robert de Niro','movies' : []})
robert_de_niro.movies.append(the_godfather)
francis_coppola.favorite_actor = robert_de_niro
#this will yield an exception as we have a circular foreign key relationship
<|code_end|>
, predict the next line using imports from the current file:
import pytest
from sqlalchemy.exc import IntegrityError
from ..helpers.movie_data import Actor, Director, Movie
and context including class names, function names, and sometimes code from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Director(Document):
#
# """
# Warning: There is a circular foreign key relationship between
# Director and Movie, hence trying to save a pair of those objects
# that point to each other will yield an exception for e.g.
# the Postgres backend.
# """
#
# name = CharField(indexed = True)
# favorite_actor = ForeignKeyField('Actor')
# best_movie = ForeignKeyField('Movie',unique=True,backref = 'best_of_director')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | with pytest.raises(IntegrityError): |
Predict the next line for this snippet: <|code_start|>
backend.init_schema()
backend.create_schema()
francis_coppola = Director({'name' : 'Francis Coppola'})
stanley_kubrick = Director({'name' : 'Stanley Kubrick'})
robert_de_niro = Actor({'name' : 'Robert de Niro','movies' : []})
harrison_ford = Actor({'name' : 'Harrison Ford'})
brian_de_palma = Director({'name' : 'Brian de Palma'})
al_pacino = Actor({'name' : 'Al Pacino','movies' : []})
scarface = Movie({'title' : 'Scarface','director' : brian_de_palma})
the_godfather = Movie({'title' : 'The Godfather',
'director' : francis_coppola})
space_odyssey = Movie({'title' : '2001 - A space odyssey',
'director' : stanley_kubrick})
clockwork_orange = Movie({'title' : 'A Clockwork Orange',
'director' : stanley_kubrick})
robert_de_niro.movies.append(the_godfather)
al_pacino.movies.append(the_godfather)
al_pacino.movies.append(scarface)
stanley_kubrick.favorite_actor = al_pacino
apocalypse_now = Movie({'title' : 'Apocalypse Now'})
star_wars_v = Movie({'title' : 'Star Wars V: The Empire Strikes Back'})
<|code_end|>
with the help of current file imports:
import pytest
from sqlalchemy.exc import IntegrityError
from ..helpers.movie_data import Actor, Director, Movie
and context from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Director(Document):
#
# """
# Warning: There is a circular foreign key relationship between
# Director and Movie, hence trying to save a pair of those objects
# that point to each other will yield an exception for e.g.
# the Postgres backend.
# """
#
# name = CharField(indexed = True)
# favorite_actor = ForeignKeyField('Actor')
# best_movie = ForeignKeyField('Movie',unique=True,backref = 'best_of_director')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
, which may contain function names, class names, or code. Output only the next line. | harrison_ford.movies = [star_wars_v] |
Given the following code snippet before the placeholder: <|code_start|>from __future__ import absolute_import
def test_basic_sorting(backend):
backend.filter(Actor, {}).delete()
backend.save(Actor({'birth_year': 1983}))
backend.save(Actor({'birth_year': 1983}))
backend.save(Actor({'birth_year': 1984}))
backend.save(Actor({'birth_year': 1984}))
backend.save(Actor({'birth_year': 1984}))
backend.save(Actor({'birth_year': 1985}))
backend.save(Actor({'birth_year': 1980}))
backend.save(Actor({'birth_year': 1990}))
backend.save(Actor({'birth_year': 2000}))
backend.save(Actor({'birth_year': 2000}))
backend.save(Actor({'birth_year': 1900}))
backend.save(Actor({'birth_year': 1843}))
backend.save(Actor({'birth_year': 2014}))
<|code_end|>
, predict the next line using imports from the current file:
from blitzdb.backends.sql import Backend as SqlBackend
from .helpers.movie_data import Actor
and context including class names, function names, and sometimes code from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
. Output only the next line. | backend.commit() |
Predict the next line after this snippet: <|code_start|>from __future__ import absolute_import
def test_nested_value(backend):
actor = Actor({'name' : 'Robert de Niro'})
movie = Movie({'best_actor' : actor,'title' : 'The Godfather'})
backend.save(actor)
actor.movies = [movie]
backend.save(actor)
backend.commit()
backend.save(movie)
backend.commit()
recovered_actor = backend.get(Actor,{'pk' : actor.pk})
assert recovered_actor == actor
assert movie in recovered_actor.movies
assert recovered_actor.movies[0] == movie
assert 'best_actor' in recovered_actor.movies[0]
<|code_end|>
using the current file's imports:
from .helpers.movie_data import Actor, Movie
and any relevant context from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | assert recovered_actor.movies[0].best_actor == recovered_actor |
Given the following code snippet before the placeholder: <|code_start|>from __future__ import absolute_import
def test_nested_value(backend):
actor = Actor({'name' : 'Robert de Niro'})
movie = Movie({'best_actor' : actor,'title' : 'The Godfather'})
backend.save(actor)
actor.movies = [movie]
<|code_end|>
, predict the next line using imports from the current file:
from .helpers.movie_data import Actor, Movie
and context including class names, function names, and sometimes code from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | backend.save(actor) |
Predict the next line after this snippet: <|code_start|>
actor = Actor({'name': 'Robert de Niro', 'age': 54, 'movies': [Movie({'name': 'The Godfather', 'year': 1987, 'rating': 'AAA'})]})
no_autoload_mongodb_backend.save(actor)
no_autoload_mongodb_backend.commit()
assert len(no_autoload_mongodb_backend.filter(Actor, {'name': 'Robert de Niro'})) == 1
recovered_actor = no_autoload_mongodb_backend.get(Actor, {'name': 'Robert de Niro'})
assert recovered_actor.movies[0]._lazy == True
assert recovered_actor.movies[0].lazy_attributes == {'year': 1987, 'pk': actor.movies[0].pk}
with pytest.raises(AttributeError):
recovered_actor.movies[0].rating
assert recovered_actor.movies[0].year == 1987
recovered_actor.movies[0].load_if_lazy()
assert recovered_actor.movies[0].rating == 'AAA'
def test_eager_property(no_autoload_mongodb_backend):
no_autoload_mongodb_backend.register(Movie,overwrite = True)
actor = Actor({'name': 'Robert de Niro', 'age': 54, 'movies': [Movie({'name': 'The Godfather', 'year': 1987, 'rating': 'AAA'})]})
no_autoload_mongodb_backend.save(actor)
<|code_end|>
using the current file's imports:
import pytest
from .helpers.movie_data import Actor, Movie
and any relevant context from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | no_autoload_mongodb_backend.commit() |
Next line prediction: <|code_start|>from __future__ import absolute_import
def test_update_by_list(no_autoload_mongodb_backend):
no_autoload_mongodb_backend.register(Movie,overwrite = True)
actor = Actor({'name': 'Robert de Niro', 'age': 54, 'movies': [Movie({'name': 'The Godfather', 'year': 1987, 'rating': 'AAA'})]})
no_autoload_mongodb_backend.save(actor)
no_autoload_mongodb_backend.commit()
assert len(no_autoload_mongodb_backend.filter(Actor, {'name': 'Robert de Niro'})) == 1
recovered_actor = no_autoload_mongodb_backend.get(Actor, {'name': 'Robert de Niro'})
<|code_end|>
. Use current file imports:
(import pytest
from .helpers.movie_data import Actor, Movie)
and context including class names, function names, or small code snippets from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | assert recovered_actor.movies[0]._lazy == True |
Given snippet: <|code_start|>from __future__ import absolute_import
def test_nonunique_file_backend_index(file_backend):
file_backend.create_index(Actor, fields={'yob': 1})
actor1 = Actor({'yob': 1})
file_backend.save(actor1)
actor2 = Actor({'yob': 1})
file_backend.save(actor2)
file_backend.commit()
assert actor1.pk != actor2.pk
def test_unique_file_backend_index(file_backend):
file_backend.create_index(Actor, fields={'num_films': 1}, unique=True)
actor1 = Actor({'num_films': 1})
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pytest
from blitzdb.backends.file import NonUnique
from ..helpers.movie_data import Actor
and context:
# Path: blitzdb/backends/file/index.py
# class NonUnique(BaseException):
# """Index uniqueness constraint violated"""
# pass
#
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
which might include code, classes, or functions. Output only the next line. | file_backend.save(actor1) |
Next line prediction: <|code_start|>from __future__ import absolute_import
def test_basic_storage(backend):
#the dots will get encoded and should be decoded when loading the data...
movie = Movie({"foo.bar.baz" : "bar"})
with backend.transaction():
<|code_end|>
. Use current file imports:
(from .helpers.movie_data import Movie)
and context including class names, function names, or small code snippets from other files:
# Path: tests/helpers/movie_data.py
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | backend.save(movie) |
Predict the next line for this snippet: <|code_start|>from __future__ import absolute_import
def test_basic_delete(backend, small_test_data):
backend.filter(Actor, {}).delete()
backend.commit()
assert len(backend.filter(Actor, {})) == 0
def test_basic_storage(backend, small_test_data):
(movies, actors, directors) = small_test_data
assert len(backend.filter(Movie, {})) == len(movies)
assert len(backend.filter(Actor, {})) == len(actors)
def test_delete(backend):
actor = Actor({'foo' : 'bar'})
<|code_end|>
with the help of current file imports:
import pytest
from .helpers.movie_data import Actor, Movie
and context from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
, which may contain function names, class names, or code. Output only the next line. | backend.save(actor) |
Next line prediction: <|code_start|>from __future__ import absolute_import
def test_basic_delete(backend, small_test_data):
backend.filter(Actor, {}).delete()
backend.commit()
assert len(backend.filter(Actor, {})) == 0
<|code_end|>
. Use current file imports:
(import pytest
from .helpers.movie_data import Actor, Movie)
and context including class names, function names, or small code snippets from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | def test_basic_storage(backend, small_test_data): |
Given the code snippet: <|code_start|>
with pytest.raises(BaseException):
backend.filter(Actor, {'$in' : Movie.cast})
def test_non_indexed_delete(backend, small_test_data):
(movies, actors, directors) = small_test_data
for movie in movies:
if movie.get('director'):
director = movie.director
for directed_movie in backend.filter(Movie,{'director' : director}):
backend.update(directed_movie,unset_fields = ['director'])
backend.commit()
backend.delete(director)
backend.commit()
directors = backend.filter(Director,{})
for director in directors:
assert len(backend.filter(Movie,{'director' : director})) == 0
def test_default_backend(backend, small_test_data):
movies = backend.filter(Movie, {})
old_len = len(movies)
movie = movies[0]
movie.delete()
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from .helpers.movie_data import Actor, Director, Movie
and context (functions, classes, or occasionally code) from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Director(Document):
#
# """
# Warning: There is a circular foreign key relationship between
# Director and Movie, hence trying to save a pair of those objects
# that point to each other will yield an exception for e.g.
# the Postgres backend.
# """
#
# name = CharField(indexed = True)
# favorite_actor = ForeignKeyField('Actor')
# best_movie = ForeignKeyField('Movie',unique=True,backref = 'best_of_director')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | backend.commit() |
Predict the next line after this snippet: <|code_start|> backend.save(leonardo_di_caprio)
backend.save(david_hasselhoff)
backend.save(charlie_chaplin)
backend.commit()
assert len(backend.filter(Actor, {})) == 4
for op, results in (('$gt', [david_hasselhoff]), ('$gte', [david_hasselhoff]), ('$lt', [charlie_chaplin]), ('$lte', [charlie_chaplin])):
query = {
'$and':
[
{'gross_income_m': {op: 1.0}},
{'is_funny': True}
]
}
assert len(backend.filter(Actor, query)) == len(results)
assert results in backend.filter(Actor, query)
for op, results in (('$gt', [david_hasselhoff, charlie_chaplin, marlon_brando]), ('$gte', [marlon_brando, david_hasselhoff, charlie_chaplin]), ('$lt', [charlie_chaplin]), ('$lte', [charlie_chaplin])):
query = {
'$and':
[
{'$or': [
{'gross_income_m': {op: 1.0}},
{'birth_year': {'$lt': 1900}},
]},
<|code_end|>
using the current file's imports:
import pytest
from .helpers.movie_data import Actor, Director, Movie
and any relevant context from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Director(Document):
#
# """
# Warning: There is a circular foreign key relationship between
# Director and Movie, hence trying to save a pair of those objects
# that point to each other will yield an exception for e.g.
# the Postgres backend.
# """
#
# name = CharField(indexed = True)
# favorite_actor = ForeignKeyField('Actor')
# best_movie = ForeignKeyField('Movie',unique=True,backref = 'best_of_director')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | {'$or': [ |
Continue the code snippet: <|code_start|> backend.save(actor)
backend.commit()
assert actor.foo == 'bar'
assert backend.get(Actor,{'pk' : actor.pk}).foo == 'bar'
del actor.foo
with pytest.raises(AttributeError):
actor.foo
with pytest.raises(KeyError):
actor['foo']
backend.save(actor)
backend.commit()
with pytest.raises(AttributeError):
backend.get(Actor,{'pk' : actor.pk}).foo
def test_negative_indexing(backend, small_test_data):
(movies, actors, directors) = small_test_data
actors = backend.filter(Actor, {})
assert actors[-1] == actors[len(actors) - 1]
assert actors[-10:-1] == actors[len(actors) - 10:len(actors) - 1]
<|code_end|>
. Use current file imports:
import pytest
from .helpers.movie_data import Actor, Director, Movie
and context (classes, functions, or code) from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Director(Document):
#
# """
# Warning: There is a circular foreign key relationship between
# Director and Movie, hence trying to save a pair of those objects
# that point to each other will yield an exception for e.g.
# the Postgres backend.
# """
#
# name = CharField(indexed = True)
# favorite_actor = ForeignKeyField('Actor')
# best_movie = ForeignKeyField('Movie',unique=True,backref = 'best_of_director')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | assert actors[-len(actors):-1] == actors[0:len(actors) - 1] |
Predict the next line after this snippet: <|code_start|>
def test_implicit_transaction(backend):
backend.init_schema()
backend.create_schema()
al_pacino = Actor({'name' : 'Al Pacino','best_genre' : 'action'})
#this will be automatically committed
backend.save(al_pacino)
assert backend.current_transaction is None
assert backend._conn is None
def test_explicit_transaction(backend):
backend.init_schema()
backend.create_schema()
al_pacino = Actor({'name' : 'Al Pacino','best_genre' : 'action'})
#here we explicitly begin a transaction
transaction = backend.begin()
backend.save(al_pacino)
#now the transaction object should be equal to the one we had before
<|code_end|>
using the current file's imports:
from ..helpers.movie_data import Actor
and any relevant context from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
. Output only the next line. | assert backend.current_transaction == transaction |
Predict the next line for this snippet: <|code_start|> harrison_ford = Actor({'name' : 'Harrison Ford'})
andreas_dewes = Actor({'name' : 'Andreas Dewes'})
brian_de_palma = Director({'name' : 'Brian de Palma'})
al_pacino = Actor({'name' : 'Al Pacino','movies' : [],'salary' : {'amount' : 100000000,'currency' : u'€'}})
scarface = Movie({'title' : 'Scarface','director' : brian_de_palma})
the_godfather = Movie({'title' : 'The Godfather',
'director' : francis_coppola})
space_odyssey = Movie({'title' : '2001 - A space odyssey',
'director' : stanley_kubrick})
clockwork_orange = Movie({'title' : 'A Clockwork Orange',
'director' : stanley_kubrick})
robert_de_niro.movies.append(the_godfather)
al_pacino.movies.append(the_godfather)
al_pacino.movies.append(scarface)
apocalypse_now = Movie({'title' : 'Apocalypse Now'})
star_wars_v = Movie({'title' : 'Star Wars V: The Empire Strikes Back'})
harrison_ford.movies = [star_wars_v]
backend.save(robert_de_niro)
backend.save(al_pacino)
backend.save(francis_coppola)
backend.save(andreas_dewes)
backend.save(stanley_kubrick)
<|code_end|>
with the help of current file imports:
from ..helpers.movie_data import Actor, Director, Movie
import sqlite3
and context from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Director(Document):
#
# """
# Warning: There is a circular foreign key relationship between
# Director and Movie, hence trying to save a pair of those objects
# that point to each other will yield an exception for e.g.
# the Postgres backend.
# """
#
# name = CharField(indexed = True)
# favorite_actor = ForeignKeyField('Actor')
# best_movie = ForeignKeyField('Movie',unique=True,backref = 'best_of_director')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
, which may contain function names, class names, or code. Output only the next line. | backend.save(brian_de_palma) |
Given the following code snippet before the placeholder: <|code_start|> stanley_kubrick = Director({'name' : 'Stanley Kubrick'})
robert_de_niro = Actor({'name' : 'Robert de Niro','movies' : []})
harrison_ford = Actor({'name' : 'Harrison Ford'})
andreas_dewes = Actor({'name' : 'Andreas Dewes'})
brian_de_palma = Director({'name' : 'Brian de Palma'})
al_pacino = Actor({'name' : 'Al Pacino','movies' : [],'salary' : {'amount' : 100000000,'currency' : u'€'}})
scarface = Movie({'title' : 'Scarface','director' : brian_de_palma})
the_godfather = Movie({'title' : 'The Godfather',
'director' : francis_coppola})
space_odyssey = Movie({'title' : '2001 - A space odyssey',
'director' : stanley_kubrick})
clockwork_orange = Movie({'title' : 'A Clockwork Orange',
'director' : stanley_kubrick})
robert_de_niro.movies.append(the_godfather)
al_pacino.movies.append(the_godfather)
al_pacino.movies.append(scarface)
apocalypse_now = Movie({'title' : 'Apocalypse Now'})
star_wars_v = Movie({'title' : 'Star Wars V: The Empire Strikes Back'})
harrison_ford.movies = [star_wars_v]
backend.save(robert_de_niro)
backend.save(al_pacino)
backend.save(francis_coppola)
<|code_end|>
, predict the next line using imports from the current file:
from ..helpers.movie_data import Actor, Director, Movie
import sqlite3
and context including class names, function names, and sometimes code from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Director(Document):
#
# """
# Warning: There is a circular foreign key relationship between
# Director and Movie, hence trying to save a pair of those objects
# that point to each other will yield an exception for e.g.
# the Postgres backend.
# """
#
# name = CharField(indexed = True)
# favorite_actor = ForeignKeyField('Actor')
# best_movie = ForeignKeyField('Movie',unique=True,backref = 'best_of_director')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | backend.save(andreas_dewes) |
Based on the snippet: <|code_start|> al_pacino.movies.append(the_godfather)
al_pacino.movies.append(scarface)
apocalypse_now = Movie({'title' : 'Apocalypse Now'})
star_wars_v = Movie({'title' : 'Star Wars V: The Empire Strikes Back'})
harrison_ford.movies = [star_wars_v]
backend.save(robert_de_niro)
backend.save(al_pacino)
backend.save(francis_coppola)
backend.save(andreas_dewes)
backend.save(stanley_kubrick)
backend.save(brian_de_palma)
backend.save(harrison_ford)
backend.update(the_godfather,{'best_actor' : al_pacino})
backend.update(scarface,{'best_actor' : al_pacino})
backend.update(stanley_kubrick,{'favorite_actor' : al_pacino})
backend.update(francis_coppola,{'favorite_actor' : robert_de_niro})
backend.save(the_godfather)
backend.save(clockwork_orange)
backend.save(space_odyssey)
backend.save(scarface)
backend.commit()
def test_one_to_many_include(backend):
<|code_end|>
, predict the immediate next line with the help of imports:
from ..helpers.movie_data import Actor, Director, Movie
import sqlite3
and context (classes, functions, sometimes code) from other files:
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
#
# class Director(Document):
#
# """
# Warning: There is a circular foreign key relationship between
# Director and Movie, hence trying to save a pair of those objects
# that point to each other will yield an exception for e.g.
# the Postgres backend.
# """
#
# name = CharField(indexed = True)
# favorite_actor = ForeignKeyField('Actor')
# best_movie = ForeignKeyField('Movie',unique=True,backref = 'best_of_director')
#
# class Movie(Document):
#
# title = CharField(nullable = True,indexed = True)
# director = ForeignKeyField(related = 'Director',nullable = True,backref = 'movies')
# cast = ManyToManyField(related = 'Actor')
# year = IntegerField(indexed = True)
# best_actor = ForeignKeyField('Actor',backref = 'best_movies')
#
# class Meta(Document.Meta):
#
# dbref_includes = ['title','year']
. Output only the next line. | if str(backend.engine.url).startswith('sqlite://'): |
Given snippet: <|code_start|>
if test_mongo:
def test_regex(mongodb_backend):
# DB setup
backend = mongodb_backend
backend.filter(Actor, {}).delete()
marlon_brando = Actor({'name': 'Marlon Brando', 'gross_income_m': 1.453, 'appearances': 78, 'is_funny': False, 'birth_year': 1924})
leonardo_di_caprio = Actor({'name': 'Leonardo di Caprio', 'gross_income_m': 12.453, 'appearances': 34, 'is_funny': 'it depends', 'birth_year': 1974})
david_hasselhoff = Actor({'name': 'David Hasselhoff', 'gross_income_m': 12.453, 'appearances': 173, 'is_funny': True, 'birth_year': 1952})
charlie_chaplin = Actor({'name': 'Charlie Chaplin', 'gross_income_m': 0.371, 'appearances': 473, 'is_funny': True, 'birth_year': 1889})
backend.save(marlon_brando)
backend.save(leonardo_di_caprio)
backend.save(david_hasselhoff)
backend.save(charlie_chaplin)
backend.commit()
assert len(backend.filter(Actor, {})) == 4
# DB setup
# Test with normal conditions
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from ..conftest import test_mongo
from ..helpers.movie_data import Actor
and context:
# Path: tests/conftest.py
# def _mongodb_backend(config, autoload_embedded=True):
# def temporary_path(request):
# def mongodb_backend(request):
# def small_mongodb_test_data(request, mongodb_backend):
# def get_sql_engine():
# def _sql_backend(request, engine, **kwargs):
# def finalizer():
# def sql_backend(request):
# def small_sql_test_data(request, sql_backend):
# def backend(request, temporary_path):
# def no_autoload_backend(request, temporary_path):
# def no_autoload_mongodb_backend(request, temporary_path):
# def transactional_backend(request, temporary_path):
# def large_test_data(request, backend):
# def small_test_data(request, backend):
# def large_transactional_test_data(request, transactional_backend):
# def small_transactional_test_data(request, transactional_backend):
# def _backend(request, temporary_path, autoload_embedded=True):
# def _init_indexes(backend):
# def _file_backend(request, temporary_path, config, autoload_embedded=True):
# def file_backend(request, temporary_path):
#
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
which might include code, classes, or functions. Output only the next line. | query = {'name': {'$regex': 'Mar.*do'}} |
Predict the next line for this snippet: <|code_start|>
if test_mongo:
def test_regex(mongodb_backend):
# DB setup
backend = mongodb_backend
backend.filter(Actor, {}).delete()
marlon_brando = Actor({'name': 'Marlon Brando', 'gross_income_m': 1.453, 'appearances': 78, 'is_funny': False, 'birth_year': 1924})
leonardo_di_caprio = Actor({'name': 'Leonardo di Caprio', 'gross_income_m': 12.453, 'appearances': 34, 'is_funny': 'it depends', 'birth_year': 1974})
david_hasselhoff = Actor({'name': 'David Hasselhoff', 'gross_income_m': 12.453, 'appearances': 173, 'is_funny': True, 'birth_year': 1952})
charlie_chaplin = Actor({'name': 'Charlie Chaplin', 'gross_income_m': 0.371, 'appearances': 473, 'is_funny': True, 'birth_year': 1889})
backend.save(marlon_brando)
backend.save(leonardo_di_caprio)
backend.save(david_hasselhoff)
backend.save(charlie_chaplin)
<|code_end|>
with the help of current file imports:
from ..conftest import test_mongo
from ..helpers.movie_data import Actor
and context from other files:
# Path: tests/conftest.py
# def _mongodb_backend(config, autoload_embedded=True):
# def temporary_path(request):
# def mongodb_backend(request):
# def small_mongodb_test_data(request, mongodb_backend):
# def get_sql_engine():
# def _sql_backend(request, engine, **kwargs):
# def finalizer():
# def sql_backend(request):
# def small_sql_test_data(request, sql_backend):
# def backend(request, temporary_path):
# def no_autoload_backend(request, temporary_path):
# def no_autoload_mongodb_backend(request, temporary_path):
# def transactional_backend(request, temporary_path):
# def large_test_data(request, backend):
# def small_test_data(request, backend):
# def large_transactional_test_data(request, transactional_backend):
# def small_transactional_test_data(request, transactional_backend):
# def _backend(request, temporary_path, autoload_embedded=True):
# def _init_indexes(backend):
# def _file_backend(request, temporary_path, config, autoload_embedded=True):
# def file_backend(request, temporary_path):
#
# Path: tests/helpers/movie_data.py
# class Actor(Document):
#
# name = CharField(indexed = True)
# gross_income_m = FloatField(indexed = True)
# salary_amount = FloatField(indexed = True,key = 'salary.amount')
# salary_currency = CharField(indexed = True,key = 'salary.currency')
# appearances = IntegerField(indexed = True)
# birth_year = IntegerField(indexed = True)
# favorite_food = ManyToManyField('Food')
# is_funny = BooleanField(indexed = True)
# movies = ManyToManyField('Movie',backref = 'actors')
, which may contain function names, class names, or code. Output only the next line. | backend.commit() |
Given snippet: <|code_start|>
class EmailAddressFactory(factory.Factory):
value = factory.Sequence("test-{0}@example.com".format)
class Meta:
model = str
inline_args = ("value",)
class SurveyFactory(factory.DjangoModelFactory):
num_expected = 5
class Meta:
model = Survey
class TokenFactory(factory.Factory):
seed = 12345
prime_identifier = 5
is_admin = False
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import factory
from django.utils import timezone
from disparity.apps.salary.utils import (
generate_survey_token,
SURVEY_TOKEN_MAX_AGE,
)
from disparity.apps.salary.models import (
Survey,
)
and context:
# Path: disparity/apps/salary/utils.py
# def generate_survey_token(seed, prime_identifier, is_admin, survey_id):
# return signing.dumps({
# 'seed': seed,
# 'prime_identifier': prime_identifier,
# 'is_admin': is_admin,
# 'survey_id': str(survey_id),
# 'expires_at': str(timezone.now() + timezone.timedelta(seconds=SURVEY_TOKEN_MAX_AGE)),
# }, salt=SURVEY_TOKEN_SALT)
#
# SURVEY_TOKEN_MAX_AGE = 60 * 60 * 24 * 7 # 7 days
#
# Path: disparity/apps/salary/models.py
# class Survey(models.Model):
# uuid = uuidfield.UUIDField(auto=True, version=4, hyphenate=True)
# created_at = models.DateTimeField(default=timezone.now)
# updated_at = models.DateTimeField(auto_now=True)
#
# # This field stores the running total of all of the collected salaries
# # while salaries are being collected, and the average salary if collection
# # has completed.
# total = models.BigIntegerField(default=get_default_total)
# # The tracker field stores a VERY large number that is used to enforce one
# # response per participant. Each link sent to a participant has a large
# # prime number embedded in it. Each time a response is entered, the
# # `tracker` number is multiplied by that number. This way, we can know if
# # someone has already responded by checking to see if the tracker number is
# # divisible by the prime that was assigned to them.
# _tracker = models.CharField(default='1', max_length=10000, null=True)
#
# num_collected = models.PositiveIntegerField(default=0, null=True)
# num_expected = models.PositiveIntegerField(null=True)
#
# @property
# def tracker(self):
# if self._tracker is None:
# return None
# return long(self._tracker)
#
# @tracker.setter
# def tracker(self, value):
# if value is None:
# self._tracker = None
# else:
# self._tracker = str(value)
#
# def has_key_been_recorded(self, key):
# if self.tracker is None:
# return None
# return self.tracker % key == 0
#
# def record_salary(self, salary, key):
# if self.has_key_been_recorded(key):
# raise ValueError("This key has already recorded a salary")
# self.tracker *= key
# self.total += salary
# self.num_collected += 1
# self.save()
#
# @property
# def is_open(self):
# return self.tracker is not None
#
# @property
# def is_finalized(self):
# return not self.is_open
#
# @property
# def is_finalizable(self):
# return self.num_collected >= 4
#
# def finalize(self, seed):
# if not self.is_finalizable:
# raise ValueError("Survey must have at least 4 responses to be finalized")
# total = self.total - seed
# self.total = total / self.num_collected
# self.num_collected = None
# self.num_expected = None
# self.tracker = None
# self.save()
which might include code, classes, or functions. Output only the next line. | survey_id = 'survey-id' |
Predict the next line after this snippet: <|code_start|>
class EmailAddressFactory(factory.Factory):
value = factory.Sequence("test-{0}@example.com".format)
class Meta:
<|code_end|>
using the current file's imports:
import factory
from django.utils import timezone
from disparity.apps.salary.utils import (
generate_survey_token,
SURVEY_TOKEN_MAX_AGE,
)
from disparity.apps.salary.models import (
Survey,
)
and any relevant context from other files:
# Path: disparity/apps/salary/utils.py
# def generate_survey_token(seed, prime_identifier, is_admin, survey_id):
# return signing.dumps({
# 'seed': seed,
# 'prime_identifier': prime_identifier,
# 'is_admin': is_admin,
# 'survey_id': str(survey_id),
# 'expires_at': str(timezone.now() + timezone.timedelta(seconds=SURVEY_TOKEN_MAX_AGE)),
# }, salt=SURVEY_TOKEN_SALT)
#
# SURVEY_TOKEN_MAX_AGE = 60 * 60 * 24 * 7 # 7 days
#
# Path: disparity/apps/salary/models.py
# class Survey(models.Model):
# uuid = uuidfield.UUIDField(auto=True, version=4, hyphenate=True)
# created_at = models.DateTimeField(default=timezone.now)
# updated_at = models.DateTimeField(auto_now=True)
#
# # This field stores the running total of all of the collected salaries
# # while salaries are being collected, and the average salary if collection
# # has completed.
# total = models.BigIntegerField(default=get_default_total)
# # The tracker field stores a VERY large number that is used to enforce one
# # response per participant. Each link sent to a participant has a large
# # prime number embedded in it. Each time a response is entered, the
# # `tracker` number is multiplied by that number. This way, we can know if
# # someone has already responded by checking to see if the tracker number is
# # divisible by the prime that was assigned to them.
# _tracker = models.CharField(default='1', max_length=10000, null=True)
#
# num_collected = models.PositiveIntegerField(default=0, null=True)
# num_expected = models.PositiveIntegerField(null=True)
#
# @property
# def tracker(self):
# if self._tracker is None:
# return None
# return long(self._tracker)
#
# @tracker.setter
# def tracker(self, value):
# if value is None:
# self._tracker = None
# else:
# self._tracker = str(value)
#
# def has_key_been_recorded(self, key):
# if self.tracker is None:
# return None
# return self.tracker % key == 0
#
# def record_salary(self, salary, key):
# if self.has_key_been_recorded(key):
# raise ValueError("This key has already recorded a salary")
# self.tracker *= key
# self.total += salary
# self.num_collected += 1
# self.save()
#
# @property
# def is_open(self):
# return self.tracker is not None
#
# @property
# def is_finalized(self):
# return not self.is_open
#
# @property
# def is_finalizable(self):
# return self.num_collected >= 4
#
# def finalize(self, seed):
# if not self.is_finalizable:
# raise ValueError("Survey must have at least 4 responses to be finalized")
# total = self.total - seed
# self.total = total / self.num_collected
# self.num_collected = None
# self.num_expected = None
# self.tracker = None
# self.save()
. Output only the next line. | model = str |
Next line prediction: <|code_start|>
def test_survey_creation_page(webtest_client, factories):
url = reverse('survey-create')
response = webtest_client.get(url)
<|code_end|>
. Use current file imports:
(from django.core.urlresolvers import reverse
from disparity.apps.salary.utils import (
unsign_survey_token,
))
and context including class names, function names, or small code snippets from other files:
# Path: disparity/apps/salary/utils.py
# def unsign_survey_token(token):
# data = signing.loads(
# token, salt=SURVEY_TOKEN_SALT, max_age=SURVEY_TOKEN_MAX_AGE,
# )
# expires_at_str = data.pop('expires_at')
# data['expires_at'] = parser.parse(expires_at_str)
# return data
. Output only the next line. | assert response.status_code == 200 |
Here is a snippet: <|code_start|>
@pytest.mark.django_db
def test_sending_survey_creation_email(factories):
assert len(mail.outbox) == 0
all_emails=factories.EmailAddressFactory.create_batch(5)
token = factories.TokenFactory(
prime_identifier=5,
survey_id='some-id',
)
detail_url = reverse('survey-detail', kwargs={'token': token})
send_survey_creation_email(
email='test@example.com',
all_emails=all_emails,
token=token,
)
<|code_end|>
. Write the next line using the current file imports:
import pytest
from django.core import mail
from django.core.urlresolvers import reverse
from disparity.apps.salary.emails import (
send_survey_creation_email,
)
and context from other files:
# Path: disparity/apps/salary/emails.py
# class SurveyCreationEmail(mixins.BuildAbsoluteURIMixin, DisparityEmail):
# def __init__(self, email, all_emails, token):
# def get_context_data(self, **kwargs):
, which may include functions, classes, or code. Output only the next line. | assert len(mail.outbox) == 1 |
Given the code snippet: <|code_start|>
def test_token_round_trip():
data_in = {
'seed': 12345,
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from disparity.apps.salary.utils import (
generate_survey_token,
unsign_survey_token,
)
and context (functions, classes, or occasionally code) from other files:
# Path: disparity/apps/salary/utils.py
# def generate_survey_token(seed, prime_identifier, is_admin, survey_id):
# return signing.dumps({
# 'seed': seed,
# 'prime_identifier': prime_identifier,
# 'is_admin': is_admin,
# 'survey_id': str(survey_id),
# 'expires_at': str(timezone.now() + timezone.timedelta(seconds=SURVEY_TOKEN_MAX_AGE)),
# }, salt=SURVEY_TOKEN_SALT)
#
# def unsign_survey_token(token):
# data = signing.loads(
# token, salt=SURVEY_TOKEN_SALT, max_age=SURVEY_TOKEN_MAX_AGE,
# )
# expires_at_str = data.pop('expires_at')
# data['expires_at'] = parser.parse(expires_at_str)
# return data
. Output only the next line. | 'is_admin': True, |
Based on the snippet: <|code_start|>
def test_token_round_trip():
data_in = {
'seed': 12345,
'is_admin': True,
'prime_identifier': 5,
'survey_id': 'some-id',
<|code_end|>
, predict the immediate next line with the help of imports:
import pytest
from disparity.apps.salary.utils import (
generate_survey_token,
unsign_survey_token,
)
and context (classes, functions, sometimes code) from other files:
# Path: disparity/apps/salary/utils.py
# def generate_survey_token(seed, prime_identifier, is_admin, survey_id):
# return signing.dumps({
# 'seed': seed,
# 'prime_identifier': prime_identifier,
# 'is_admin': is_admin,
# 'survey_id': str(survey_id),
# 'expires_at': str(timezone.now() + timezone.timedelta(seconds=SURVEY_TOKEN_MAX_AGE)),
# }, salt=SURVEY_TOKEN_SALT)
#
# def unsign_survey_token(token):
# data = signing.loads(
# token, salt=SURVEY_TOKEN_SALT, max_age=SURVEY_TOKEN_MAX_AGE,
# )
# expires_at_str = data.pop('expires_at')
# data['expires_at'] = parser.parse(expires_at_str)
# return data
. Output only the next line. | } |
Based on the snippet: <|code_start|> assert 'participant_emails' in form.errors
assert any(
['Too few' in err for err in form.errors['participant_emails']]
), form.errors['participant_emails']
def test_valid_participant_emails_are_parsed():
data = {
'owner_email': 'owner@example.com',
'owner_salary': 12345,
'participant_emails': (
'test-1@example.com,'
'test-2@example.com,'
'test-3@example.com,'
'test-4@example.com,'
),
}
form = SurveyCreateForm(data=data)
assert form.is_valid(), form.errors
expected = set((
'test-1@example.com',
'test-2@example.com',
'test-3@example.com',
'test-4@example.com',
))
assert not expected.symmetric_difference(form.cleaned_data['participant_emails'])
def test_duplicate_participant_email_is_error():
<|code_end|>
, predict the immediate next line with the help of imports:
from disparity.apps.salary.forms import (
SurveyCreateForm,
)
and context (classes, functions, sometimes code) from other files:
# Path: disparity/apps/salary/forms.py
# class SurveyCreateForm(forms.Form):
# owner_email = forms.EmailField(
# label='Your Email Address', help_text=(
# "Your email address will only be used to email you a special link "
# "that allows you to see the survey results and administer the "
# "survey."
# ),
# )
# owner_salary = forms.IntegerField(
# label='Your Salary', help_text=(
# "Your salary information in whole dollars is not directly stored in "
# "the database. (e.g. $50,000)"
# ),
# )
# participant_emails = forms.CharField(
# help_text=(
# "Comma delimited list of email addresses. Newlines and spaces will "
# "be stripped."
# ),
# widget=forms.Textarea,
# )
#
# def clean_participant_emails(self):
# unparsed_emails = self.cleaned_data['participant_emails']
# emails = [
# email.strip() for email in unparsed_emails.split(',') if email.strip()
# ]
# validator = EmailValidator()
# for email in emails:
# try:
# validator(email)
# except forms.ValidationError:
# self.add_error(
# 'participant_emails',
# "{0} is not a valid email address".format(email),
# )
# if len(emails) < 4:
# self.add_error(
# 'participant_emails',
# "Too few email addresses",
# )
# duplicates = [
# email for email, count in collections.Counter(emails).items() if count > 1
# ]
# if duplicates:
# self.add_error(
# 'participant_emails',
# "The email address(es) {0} appear more than once".format(duplicates),
# )
#
# owner_email = self.cleaned_data['owner_email']
# if owner_email in emails:
# self.add_error(
# 'participant_emails',
# "The survey owner email cannot be in the participant list"
# )
#
# return emails
. Output only the next line. | data = { |
Next line prediction: <|code_start|>
class SurveyCreationEmail(mixins.BuildAbsoluteURIMixin, DisparityEmail):
template_name = 'salary/mail/survey_created.html'
subject = 'Salary Survey Created'
def __init__(self, email, all_emails, token):
self.to = email
self.all_emails = all_emails
self.token = token
def get_context_data(self, **kwargs):
context = super(SurveyCreationEmail, self).get_context_data(**kwargs)
context.update({
'token': self.token,
<|code_end|>
. Use current file imports:
(from emailtools import mixins
from django.core.urlresolvers import reverse
from disparity.apps.core.emails import DisparityEmail
from disparity.apps.salary.utils import (
unsign_survey_token,
))
and context including class names, function names, or small code snippets from other files:
# Path: disparity/apps/core/emails.py
# class DisparityEmail(MarkdownEmail):
# from_email = settings.DEFAULT_FROM_EMAIL
#
# def get_subject(self):
# return "[Are We Being Underpaid] {0}".format(self.subject)
#
# Path: disparity/apps/salary/utils.py
# def unsign_survey_token(token):
# data = signing.loads(
# token, salt=SURVEY_TOKEN_SALT, max_age=SURVEY_TOKEN_MAX_AGE,
# )
# expires_at_str = data.pop('expires_at')
# data['expires_at'] = parser.parse(expires_at_str)
# return data
. Output only the next line. | 'all_emails': self.all_emails, |
Predict the next line for this snippet: <|code_start|>
class SurveyCreationEmail(mixins.BuildAbsoluteURIMixin, DisparityEmail):
template_name = 'salary/mail/survey_created.html'
subject = 'Salary Survey Created'
def __init__(self, email, all_emails, token):
self.to = email
self.all_emails = all_emails
self.token = token
def get_context_data(self, **kwargs):
context = super(SurveyCreationEmail, self).get_context_data(**kwargs)
context.update({
'token': self.token,
'all_emails': self.all_emails,
'survey_url': self.build_absolute_uri(
<|code_end|>
with the help of current file imports:
from emailtools import mixins
from django.core.urlresolvers import reverse
from disparity.apps.core.emails import DisparityEmail
from disparity.apps.salary.utils import (
unsign_survey_token,
)
and context from other files:
# Path: disparity/apps/core/emails.py
# class DisparityEmail(MarkdownEmail):
# from_email = settings.DEFAULT_FROM_EMAIL
#
# def get_subject(self):
# return "[Are We Being Underpaid] {0}".format(self.subject)
#
# Path: disparity/apps/salary/utils.py
# def unsign_survey_token(token):
# data = signing.loads(
# token, salt=SURVEY_TOKEN_SALT, max_age=SURVEY_TOKEN_MAX_AGE,
# )
# expires_at_str = data.pop('expires_at')
# data['expires_at'] = parser.parse(expires_at_str)
# return data
, which may contain function names, class names, or code. Output only the next line. | reverse('survey-detail', kwargs={'token': self.token}) |
Here is a snippet: <|code_start|>
def test_tracker_getting(factories):
survey = factories.SurveyFactory()
survey.tracker = 12345L
assert survey._tracker == '12345'
assert survey.tracker == 12345L
def test_tracker_setting_with_huge_number(factories, models):
huge_number = reduce(operator.mul, PRIMES)
survey = factories.SurveyFactory()
survey.tracker = huge_number
survey.save()
updated_survey = models.Survey.objects.get(pk=survey.pk)
assert updated_survey.tracker == huge_number
def test_setting_and_getting_null(factories):
<|code_end|>
. Write the next line using the current file imports:
import operator
from disparity.apps.salary.utils import (
PRIMES,
)
and context from other files:
# Path: disparity/apps/salary/utils.py
# SURVEY_TOKEN_SALT = 'salary:survey'
# SURVEY_TOKEN_MAX_AGE = 60 * 60 * 24 * 7 # 7 days
# def get_survey_unique_primes(*emails):
# def generate_survey_token(seed, prime_identifier, is_admin, survey_id):
# def unsign_survey_token(token):
, which may include functions, classes, or code. Output only the next line. | survey = factories.SurveyFactory() |
Next line prediction: <|code_start|>
def stop(self):
#self.server.stop()
pass
def __enter__(self):
self.start()
return self
def __exit__(self, type, value, traceback):
self.stop()
def projectData(self):
data={
'fullproject': self.regieinterface.projectRaw(),
'fileTree': self.regieinterface.hplayer.files()
}
return data
def watcher(self):
def onchange(e):
self.regieinterface.log('project updated ! pushing it...')
self.regieinterface.reload()
self.sendBuffer.put( ('data', self.projectData()) )
<|code_end|>
. Use current file imports:
(from .base import BaseInterface
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
from flask import Flask, render_template, session, request, send_from_directory
from flask_socketio import SocketIO, emit, join_room, leave_room, close_room, rooms, disconnect
from werkzeug.utils import secure_filename
from ..engine.network import get_allip, get_hostname
from zeroconf import ServiceInfo, Zeroconf
import eventlet
import threading, os, time, queue
import logging, sys, json
import socket)
and context including class names, function names, or small code snippets from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
. Output only the next line. | handler = PatternMatchingEventHandler("*/project.json", None, False, True) |
Using the snippet: <|code_start|> self.log("PLAYSEQ")
try:
# self.log('PLAYSEQ', seqIndex, sceneIndex, boxes)
orderz = []
boxes = [b for b in self._project["project"][0][sceneIndex]["allMedias"] if b["y"] == seqIndex]
for b in boxes:
peerName = self._project["pool"][ b["x"] ]["name"]
# MEDIA
order = { 'peer': peerName, 'synchro': True}
if b["media"] in ['stop', 'pause', 'unfade'] :
order["event"] = b["media"]
elif b["media"] == '...':
order["event"] = 'continue'
elif b["media"].startswith('fade'):
order["event"] = 'fade'
order["data"] = b["media"].split('fade ')[1]
else:
order["event"] = 'playthen'
order["data"] = [ self._project["project"][0][sceneIndex]["name"] + '/' + b["media"] ]
# ON MEDIA END
if 'onend' in b:
if b['onend'] == 'next':
order["data"].append( {'event': 'do-playseq', 'data': [sceneIndex, seqIndex+1] } )
elif b['onend'] == 'prev':
order["data"].append( {'event': 'do-playseq', 'data': [sceneIndex, seqIndex-1] } )
elif b['onend'] == 'replay':
<|code_end|>
, determine the next line of code. You have imports:
from .base import BaseInterface
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
from flask import Flask, render_template, session, request, send_from_directory
from flask_socketio import SocketIO, emit, join_room, leave_room, close_room, rooms, disconnect
from werkzeug.utils import secure_filename
from ..engine.network import get_allip, get_hostname
from zeroconf import ServiceInfo, Zeroconf
import eventlet
import threading, os, time, queue
import logging, sys, json
import socket
and context (class names, function names, or code) available:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
. Output only the next line. | order["data"].append( {'event': 'do-playseq', 'data': [sceneIndex, seqIndex] } ) |
Next line prediction: <|code_start|> def index():
# self.regieinterface.log('requesting index')
return send_from_directory(www_path, 'index.html')
@app.route('/<path:path>')
def send_static(path):
# self.regieinterface.log('requesting '+path)
return send_from_directory(www_path, path)
#
# FLASK Routing API
#
# @app.route('/<path:path>')
# def send_static(path):
# # self.regieinterface.log('requesting '+path)
# return send_from_directory(www_path, path)
#
# SOCKETIO Routing
#
self.sendBuffer = queue.Queue()
def background_thread():
while True:
try:
task = self.sendBuffer.get_nowait()
if len(task) > 1: socketio.emit(task[0], task[1])
else: socketio.emit(task[0], None)
<|code_end|>
. Use current file imports:
(from .base import BaseInterface
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
from flask import Flask, render_template, session, request, send_from_directory
from flask_socketio import SocketIO, emit, join_room, leave_room, close_room, rooms, disconnect
from werkzeug.utils import secure_filename
from ..engine.network import get_allip, get_hostname
from zeroconf import ServiceInfo, Zeroconf
import eventlet
import threading, os, time, queue
import logging, sys, json
import socket)
and context including class names, function names, or small code snippets from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
. Output only the next line. | self.sendBuffer.task_done() |
Given the code snippet: <|code_start|>
# PLAYER
player = hplayer.addplayer('mpv', 'gadagne')
# Interfaces
player.addInterface('osc', 4000, 4001)
player.addInterface('http', 8080)
# player.addInterface('gpio', [16,19,20,21,26])
# GADAGNE logic
defaultFile = 'media0.mp4'
push1File = 'media1.mp4'
push2File = 'media2.mp4'
push3File = 'media3.mp4'
# Loop default file
player.on('end', lambda: player.play(defaultFile))
# HTTP + GPIO events
player.on(['push1', 'gpio20'], lambda: player.play(push1File))
player.on(['push2', 'gpio21'], lambda: player.play(push2File))
player.on(['push3', 'gpio26'], lambda: player.play(push3File))
<|code_end|>
, generate the next line using the imports in this file:
from core.engine import hplayer
and context (functions, classes, or occasionally code) from other files:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
. Output only the next line. | fails = 5 |
Using the snippet: <|code_start|>
class ZyreNode ():
def __init__(self, interface, netiface=None):
self.interface = interface
# Peers book
self.book = {}
self.topics = []
# Publisher
self.pub_cache = {}
<|code_end|>
, determine the next line of code. You have imports:
from .base import BaseInterface
from time import sleep
from pyre import Pyre
from pyre import zhelper
import zmq
and context (class names, function names, or code) available:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
. Output only the next line. | self.publisher = Zsock.new_xpub(("tcp://*:*").encode()) |
Predict the next line for this snippet: <|code_start|>
# SERIAL receiver THREAD
def listen(self):
retryCount = 0
while self.isRunning():
# find port
if not self.port:
retryCount += 1
if self.maxRetry == 0 or retryCount <= self.maxRetry:
for dev in list_ports.grep(self.filter):
self.port = dev.device
break
if self.port: continue
self.log("no device found.. retrying")
for i in range(10):
time.sleep(0.5)
if not self.isRunning():
return
# connect to serial
elif not self.serial:
try:
# Reset
self.serial = serial.Serial(self.port) # dummy connection to receive all the watchdog gibberish (unplug + replug) and properly reset the arduino
with self.serial:
self.serial.setDTR(False) # reset flag
time.sleep(1)
<|code_end|>
with the help of current file imports:
from .base import BaseInterface
from serial.tools import list_ports
import time
import serial
and context from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
, which may contain function names, class names, or code. Output only the next line. | self.serial.flushInput() |
Using the snippet: <|code_start|> self.log("connected to", self.port, "!")
self.emit('ready')
self.clear()
except:
self.log("connection failed on", self.port)
self.port = None
# read / write
else:
try:
data = self.serial.readline()[:-2].decode("utf-8") #the last bit gets rid of the new-line chars
if data:
self.emit(data)
# self.serial.write( ("2 1 "+data+"\n").encode() )
say = None
if self._hardClear:
say = '¤0'
self._hardClear = False
for i,l in enumerate(self._buffer):
if l['dirty']:
if not say: say = '¤'
else: say += '£'
say += str(i+1)
say += l['txt'].ljust(26, ' ')
l['dirty'] = False
if say:
# self.log(say.encode())
<|code_end|>
, determine the next line of code. You have imports:
from .base import BaseInterface
from core.engine import network
from serial.tools import list_ports
from threading import Timer
import time, os
import serial
and context (class names, function names, or code) available:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
. Output only the next line. | say += '¤' |
Predict the next line for this snippet: <|code_start|> try:
data = self.serial.readline()[:-2].decode("utf-8") #the last bit gets rid of the new-line chars
if data:
self.emit(data)
# self.serial.write( ("2 1 "+data+"\n").encode() )
say = None
if self._hardClear:
say = '¤0'
self._hardClear = False
for i,l in enumerate(self._buffer):
if l['dirty']:
if not say: say = '¤'
else: say += '£'
say += str(i+1)
say += l['txt'].ljust(26, ' ')
l['dirty'] = False
if say:
# self.log(say.encode())
say += '¤'
self.serial.write( (say).encode() )
# self.log(say)
time.sleep(0.1)
self.refresh()
except serial.SerialException:
self.log("broken link..")
<|code_end|>
with the help of current file imports:
from .base import BaseInterface
from core.engine import network
from serial.tools import list_ports
from threading import Timer
import time, os
import serial
and context from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
, which may contain function names, class names, or code. Output only the next line. | self.serial = None |
Next line prediction: <|code_start|> if old.startswith(basepath):
check = True
if not check: return
check = True
for basepath in self.http2interface.hplayer.files.root_paths:
if new.startswith(basepath):
check = True
if not check: return
if not os.path.exists(old): return
os.rename(old, new)
fileslist_message()
@socketio.on('connect', namespace='/test')
def test_connect():
pass
@socketio.on('disconnect', namespace='/test')
def test_disconnect():
print('Client disconnected', request.sid)
# prepare sub-thread
self.server_thread = threading.Thread(target=lambda:socketio.run(app, host='0.0.0.0', port=port))
self.server_thread.daemon = True
<|code_end|>
. Use current file imports:
(from .base import BaseInterface
from flask import Flask, render_template, session, request, send_from_directory, send_file, redirect, url_for
from flask_socketio import SocketIO, emit, join_room, leave_room, close_room, rooms, disconnect
from werkzeug.utils import secure_filename
from PIL import Image
from ..engine.network import get_allip, get_hostname
from zeroconf import ServiceInfo, Zeroconf
import socketio
import eventlet
import threading, os, time
import queue
import socket)
and context including class names, function names, or small code snippets from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
. Output only the next line. | def start(self): |
Based on the snippet: <|code_start|> if message:
for e in message:
e = e.replace('/..', '')
for basepath in self.http2interface.hplayer.files.root_paths:
if e.startswith(basepath):
os.remove(e)
fileslist_message()
@socketio.on('filerename')
def filerename_message(old, new):
old = old.replace('/..', '')
new = new.replace('/..', '')
self.http2interface.log('file rename', old, new)
check = False
for basepath in self.http2interface.hplayer.files.root_paths:
if old.startswith(basepath):
check = True
if not check: return
check = True
for basepath in self.http2interface.hplayer.files.root_paths:
if new.startswith(basepath):
check = True
if not check: return
if not os.path.exists(old): return
os.rename(old, new)
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import BaseInterface
from flask import Flask, render_template, session, request, send_from_directory, send_file, redirect, url_for
from flask_socketio import SocketIO, emit, join_room, leave_room, close_room, rooms, disconnect
from werkzeug.utils import secure_filename
from PIL import Image
from ..engine.network import get_allip, get_hostname
from zeroconf import ServiceInfo, Zeroconf
import socketio
import eventlet
import threading, os, time
import queue
import socket
and context (classes, functions, sometimes code) from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
. Output only the next line. | fileslist_message() |
Using the snippet: <|code_start|> )
zeroconf.register_service(info)
# Start server
self.log( "web interface on port", self._port)
with ThreadedHTTPServer(self, self._port) as server:
self.stopped.wait()
# Unregister ZeroConf
if zero_enable:
zeroconf.unregister_service(info)
zeroconf.close()
# SEND socketio message to clients
def send(self, event, message):
self.emit('do-socketio', event, message)
#
# Threaded HTTP Server
#
class ThreadedHTTPServer(object):
def __init__(self, http2interface, port):
self.http2interface = http2interface
interface_path = os.path.dirname(os.path.realpath(__file__))
www_path = os.path.join(interface_path, 'http2')
<|code_end|>
, determine the next line of code. You have imports:
from .base import BaseInterface
from flask import Flask, render_template, session, request, send_from_directory, send_file, redirect, url_for
from flask_socketio import SocketIO, emit, join_room, leave_room, close_room, rooms, disconnect
from werkzeug.utils import secure_filename
from PIL import Image
from ..engine.network import get_allip, get_hostname
from zeroconf import ServiceInfo, Zeroconf
import socketio
import eventlet
import threading, os, time
import queue
import socket
and context (class names, function names, or code) available:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
. Output only the next line. | app = Flask(__name__, template_folder=www_path) |
Predict the next line after this snippet: <|code_start|>from __future__ import print_function
class OmxPlayer(BasePlayer):
def __init__(self, hplayer, name):
<|code_end|>
using the current file's imports:
from termcolor import colored
from omxplayer.player import OMXPlayer
from .base import BasePlayer
import socket, threading, subprocess, os, json, select
import time
and any relevant context from other files:
# Path: core/players/base.py
# class BasePlayer(Module):
#
# def __init__(self, hplayer, name):
# super().__init__(hplayer, name, 'magenta')
#
# self._running = threading.Event()
# self._running.set()
#
# self.doLog = {
# 'recv': False,
# 'cmds': False
# }
#
#
# self.logQuietEvents.append('status') # Do not log status events
#
# self._validExt = []
#
# self._events = {}
# self._overlays = {}
#
# self._status = {
# 'isReady': False,
# 'isPlaying': False,
# 'isPaused': False,
# 'media': None,
# 'time': 0,
# 'duration': 0,
# 'speed': 1.0
# }
#
#
# def addOverlay(self, olay, args=[]):
# OverlayClass = overlays.getOverlay(olay)
# self._overlays[olay] = OverlayClass()
# return self._overlays[olay]
#
# def getOverlay(self, name):
# if name in self._overlays.keys():
# return self._overlays[name]
# return None
#
#
# # CHECK EXT
# def validExt(self, filename):
# # self.log('testing', filename, 'against', self._validExt)
# if os.path.basename(filename).startswith('.'):
# return False
# if '*' in self._validExt:
# return True
# if filename.lower().split('.')[-1] in self._validExt:
# return True
# return False
#
#
# #
# # Player STATUS
# #
#
# # Status SET
# def update(self, key, value):
# self._status[key] = value
# self.emit('status', key, value)
#
# # SET/GET is running
# def isRunning(self, state=None):
# # SET (optionnal)
# if state is not None:
# self._running.set() if state else self._running.clear()
# # GET
# for olay in self._overlays.values():
# if not olay.isRunning():
# return False
# return self._running.is_set()
#
# # STATUS Set/Get
# def status(self, entry=None):
# s = self._status.copy()
# if entry:
# return s[entry]
# return s
#
# def isPlaying(self):
# return self._status['isPlaying'] or self._status['isPaused']
#
# def isPaused(self):
# return self._status['isPaused']
#
# def position(self):
# return self._status['time']
#
# #
# # Player CONTROLS
# #
#
# # START
# def start(self):
# for olay in self._overlays.values():
# olay.start()
# self.isRunning(True)
# self._start()
#
# # QUIT
# def quit(self):
# for olay in self._overlays.values():
# olay.quit()
# self._quit()
# self.isRunning(False)
#
#
# # Play Media
# def play(self, media):
# self._play(media)
# self.update('isPaused', False)
# self.update('media', media)
# self.update('time', 0)
#
# # STOP Playback
# def stop(self):
# self._stop()
# self.update('isPaused', False)
# self.update('media', None)
# self.update('time', 0)
#
# # PAUSE Playback
# def pause(self):
# self.update('isPaused', True)
# self._pause()
#
# # RESUME Playback
# def resume(self):
# self.update('isPaused', False)
# self._resume()
#
# # SEEK to position
# def seekTo(self, milli):
# self._seekTo(milli)
#
# # SKIP time
# def skip(self, milli):
# self._skip(milli)
#
# # SET speed
# def speed(self, s):
# if s != self._status['speed']:
# self.update('speed', s)
# self._speed(s)
#
# #
# # Player INTERNAL actions: Methods to overwrite !
# #
#
# def _start(self):
# self.log("start")
#
# def _quit(self):
# self.log("quit")
#
# def _play(self, path):
# self.log("play", path)
# self.emit('playing', path)
#
# def _stop(self):
# self.log("stop")
# self.emit('stopped')
#
# def _pause(self):
# self.log("pause")
# self.emit('paused')
#
# def _resume(self):
# self.log("resume")
# self.emit('resumed')
#
# def _seekTo(self, milli):
# self.log("seek to", milli)
# self.emit('seekedto', milli)
#
# def _skip(self, milli):
# self.log("skip", milli)
# self.emit('skipped', milli)
#
# def _applyVolume(self, volume):
# self.log("volume set to", volume)
#
# def _applyPan(self, pan):
# self.log("pan set to", pan)
#
# def _applyFlip(self, flip):
# self.log("screen flip", flip)
#
# def _applyOneLoop(self, oneloop):
# self.log("one loop", oneloop)
. Output only the next line. | super().__init__(hplayer, name) |
Here is a snippet: <|code_start|>
class BtserialInterface (BaseInterface):
def __init__(self, hplayer, _device):
super().__init__(hplayer, "BTSERIAL")
self.device_name = _device
self.device_addr = None
self.isConnected = False
self.sock = None
def connect(self):
if self.isConnected:
return True
try:
self.sock = bluetooth.BluetoothSocket( bluetooth.RFCOMM )
self.sock.connect((self.device_addr, 1))
self.sock.settimeout(0.5)
self.isConnected = True
self.log("connected to ", self.device_name)
self.send("Yo Rasta?")
return True
except:
e = sys.exc_info()[0]
self.log('Error while connecting to ', self.device_name, ':', e)
self.isConnected = False
return False
def send(self, topic, data=''):
if self.isConnected:
<|code_end|>
. Write the next line using the current file imports:
from .base import BaseInterface
from time import sleep
import socket, bluetooth, sys
and context from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
, which may include functions, classes, or code. Output only the next line. | try: |
Predict the next line after this snippet: <|code_start|>
# PLAYER
player = hplayer.addplayer('mpv', 'looper')
# INTERFACES
player.addInterface('keyboard').asIRremote()
def playloop():
print("No Media... Retrying")
sleep(1)
<|code_end|>
using the current file's imports:
from time import sleep
from core.engine import hplayer
and any relevant context from other files:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
. Output only the next line. | player.play('*') |
Predict the next line for this snippet: <|code_start|>player.on(['KEY_KP0-down'], lambda ev: set_activedir(0))
player.on(['KEY_KP1-down'], lambda ev: set_activedir(1))
player.on(['KEY_KP2-down'], lambda ev: set_activedir(2))
player.on(['KEY_KP3-down'], lambda ev: set_activedir(3))
player.on(['KEY_KP4-down'], lambda ev: set_activedir(4))
player.on(['KEY_KP5-down'], lambda ev: set_activedir(5))
player.on(['KEY_KP6-down'], lambda ev: set_activedir(6))
player.on(['KEY_KP7-down'], lambda ev: set_activedir(7))
player.on(['KEY_KP8-down'], lambda ev: set_activedir(8))
player.on(['KEY_KP9-down'], lambda ev: set_activedir(9))
player.on(['KEY_KPDOT-down'], lambda ev: sel_lastdir())
player.on(['KEY_KPENTER-down'], lambda ev: broadcast('/stop'))
player.on(['KEY_KPPLUS-down', 'KEY_KPPLUS-hold'], vol_inc)
player.on(['KEY_KPMINUS-down', 'KEY_KPMINUS-hold'], vol_dec)
# Bind HTTP remotes + Keyboard
player.on(['btn1', 'KEY_NUMLOCK-down'], lambda ev: play_activedir(0))
player.on(['btn2', 'KEY_KPSLASH-down'], lambda ev: play_activedir(1))
player.on(['btn3', 'KEY_KPASTERISK-down'], lambda ev: play_activedir(2))
player.on(['btn4', 'KEY_BACKSPACE-down'], lambda ev: play_activedir(3))
player.on(['inc'], remote_inc)
player.on(['dec'], remote_dec)
player.on(['push'], switch_mode)
# OSC synctest request from ESP remotes
def syncTest(arg, **kwargs):
if remote_mode:
#SCENE
<|code_end|>
with the help of current file imports:
from core.engine import hplayer
from core.engine import network
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
from threading import Timer
from time import sleep
import os, types, platform
import subprocess
and context from other files:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
, which may contain function names, class names, or code. Output only the next line. | display = available_dir[active_dir].replace("scene ", "S.")[:5].ljust(5) + " " |
Here is a snippet: <|code_start|># FIX early boot ETH0 error
def restartEth0():
print('switch OFF eth0')
subprocess.run(['ip', 'link', 'set', 'eth0', 'down'])
sleep(15)
print('switch ON eth0')
subprocess.run(['ip', 'link', 'set', 'eth0', 'up'])
# Timer(5, restartEth0).start()
# Remote modes
remote_mode = True
def switch_mode(**kwargs):
global remote_mode
remote_mode = not remote_mode
def remote_inc(**kwargs):
if remote_mode: next_dir()
else: vol_inc()
def remote_dec(**kwargs):
if remote_mode: prev_dir()
else: vol_dec()
# BROADCAST to other Pi's
def broadcast(path, *args):
if path.startswith('/play'):
player.getInterface('zyre').node.broadcast(path, list(args), 434)
<|code_end|>
. Write the next line using the current file imports:
from core.engine import hplayer
from core.engine import network
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
from threading import Timer
from time import sleep
import os, types, platform
import subprocess
and context from other files:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
, which may include functions, classes, or code. Output only the next line. | else: |
Here is a snippet: <|code_start|>
class FileManager(Module):
def __init__(self, hplayer):
super().__init__(hplayer, 'Files', 'yellow')
self.hplayer = hplayer
self.root_paths = []
self.unified_dir = []
self.active_dir = 0
self.active_list = []
self.refreshTimer = None
self.pathObservers = []
<|code_end|>
. Write the next line using the current file imports:
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
from threading import Timer
from collections import OrderedDict
from ..module import Module
import os
import re
import pathlib
and context from other files:
# Path: core/module.py
# class Module(EventEmitterX):
# def __init__(self, parent, name, color):
# super().__init__(wildcard=True, delimiter=".")
# self.name = name.replace(" ", "_")
# self.nameP = colored(('['+self.name+']').ljust(10, ' ')+' ', color)
# self.parent = parent
# self.logQuietEvents = [] # list of not-logged events '*' for full quiet
#
# def log(self, *argv):
# safe_print(self.nameP, *argv)
# sys.stdout.flush()
#
# # Emit extended
# def emit(self, event, *args):
# fullEvent = self.name.lower() + '.' + event
# if not '*' in self.logQuietEvents and not event in self.logQuietEvents:
# self.log('-', event, *args )
#
# super().emit(event, *args)
# self.parent.emit(fullEvent, *args)
, which may include functions, classes, or code. Output only the next line. | self.logQuietEvents.append('file-changed') |
Next line prediction: <|code_start|> LTC += '00'+'0000'
HLP += '__'+'____'
#secs units / user bits field 3 / secs tens
LTC += ble(secs_units,4) + '0000' + ble(secs_tens,3)
HLP += '---{u}____--{t}'.format(u=secs_units, t=secs_tens)
# bit 27 flag / user bits field 4
LTC += '0' + '0000'
HLP += '_' + '____'
#mins units / user bits field 5 / mins tens
LTC += ble(mins_units,4) + '0000' + ble(mins_tens,3)
HLP += '---{u}____--{t}'.format(u=mins_units, t=mins_tens)
# bit 43 flag / user bits field 6
LTC += '0' + '0000'
HLP += '_' + '____'
#hrs units / user bits field 7 / hrs tens
LTC += ble(hrs_units,4) + '0000' + ble(hrs_tens,2)
HLP += '---{u}____--{t}'.format(u=hrs_units, t=hrs_tens)
# bit 58 clock flag / bit 59 flag / user bits field 8
LTC += '0' + '0' + '0000'
HLP += '_' + '_' + '____'
# sync word
LTC += '0011111111111101'
HLP += '################'
<|code_end|>
. Use current file imports:
(from .base import BaseInterface
from timecode import Timecode
import mido)
and context including class names, function names, or small code snippets from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
. Output only the next line. | if as_string: |
Continue the code snippet: <|code_start|>
class BaseInterface(ABC, Module):
def __init__(self, hplayer, name="INTERFACE", color="blue"):
super().__init__(hplayer, name, color)
self.hplayer = hplayer
# stopping flag
self.stopped = threading.Event()
self.stopped.set()
# Listen thread
self.recvThread = threading.Thread(target=self.listen)
# Receiver THREAD (ABSTRACT)
<|code_end|>
. Use current file imports:
from ..module import Module
from time import sleep
from abc import ABC, abstractmethod
import threading
and context (classes, functions, or code) from other files:
# Path: core/module.py
# class Module(EventEmitterX):
# def __init__(self, parent, name, color):
# super().__init__(wildcard=True, delimiter=".")
# self.name = name.replace(" ", "_")
# self.nameP = colored(('['+self.name+']').ljust(10, ' ')+' ', color)
# self.parent = parent
# self.logQuietEvents = [] # list of not-logged events '*' for full quiet
#
# def log(self, *argv):
# safe_print(self.nameP, *argv)
# sys.stdout.flush()
#
# # Emit extended
# def emit(self, event, *args):
# fullEvent = self.name.lower() + '.' + event
# if not '*' in self.logQuietEvents and not event in self.logQuietEvents:
# self.log('-', event, *args )
#
# super().emit(event, *args)
# self.parent.emit(fullEvent, *args)
. Output only the next line. | @abstractmethod |
Next line prediction: <|code_start|> player.getInterface('osc').send(playerName, 'auto', loop, screen, playing, media)
def fullSyncTest():
if not regie_ip:
player.getInterface('osc').hostOut = network.get_broadcast()
player.getInterface('osc').send(playerName, 'initinfo', network.get_ip())
def setIpRegie(args):
global regie_ip
regie_ip = args[0]
player.getInterface('osc').hostOut = regie_ip
def fadeColor(args=None):
if is_RPi:
if args and len(args) == 3:
player.getOverlay('rpifade').set(args[0]/255.0, args[1]/255.0, args[2]/255.0, 1.0)
elif args and len(args) == 4:
player.getOverlay('rpifade').set(args[0]/255.0, args[1]/255.0, args[2]/255.0, args[3]/255.0)
else:
player.getOverlay('rpifade').set(1.0, 1.0, 1.0, 1.0)
def unfadeColor():
if is_RPi:
player.getOverlay('rpifade').set(alpha=0.0)
def playmovie(args=None):
player.play( args[0] ) if args else player.play()
player.on(['/synctest'], syncTest)
<|code_end|>
. Use current file imports:
(from core.engine import hplayer
from core.engine import network
import os, platform)
and context including class names, function names, or small code snippets from other files:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
. Output only the next line. | player.on(['/fullsynctest'], fullSyncTest) |
Next line prediction: <|code_start|>
# Overlay
if is_RPi:
player.addOverlay('rpifade')
# OSC events
def syncTest():
loop = "loop" if player.status()['loop'] else "unloop"
screen = "screen" if not player.status()['flip'] else "screenflip"
playing = "playmovie" if player.isPlaying() else "stopmovie"
media = player.status()['media']
if media:
media = os.path.basename(media)
if not regie_ip:
player.getInterface('osc').hostOut = network.get_broadcast()
player.getInterface('osc').send(playerName, 'auto', loop, screen, playing, media)
def fullSyncTest():
if not regie_ip:
player.getInterface('osc').hostOut = network.get_broadcast()
player.getInterface('osc').send(playerName, 'initinfo', network.get_ip())
def setIpRegie(args):
global regie_ip
regie_ip = args[0]
player.getInterface('osc').hostOut = regie_ip
def fadeColor(args=None):
if is_RPi:
if args and len(args) == 3:
<|code_end|>
. Use current file imports:
(from core.engine import hplayer
from core.engine import network
import os, platform)
and context including class names, function names, or small code snippets from other files:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
. Output only the next line. | player.getOverlay('rpifade').set(args[0]/255.0, args[1]/255.0, args[2]/255.0, 1.0) |
Based on the snippet: <|code_start|> def send(self, topic, data=None, QOS=1):
self.client.publish(topic, payload=data, qos=QOS, retain=False)
if self.isConnected:
self.log("send", topic, data)
else:
self.log("not connected.. can't send", topic, data)
# MQTT loop
def listen(self):
self.log("starting MQTT client")
self.client = mqtt.Client(client_id="", clean_session=True, userdata=None)
self.client.on_connect = self.on_connect
self.client.on_disconnect = self.on_disconnect
self.client.on_message = self.on_message
while True:
try:
self.client.connect(self.broker, port=1883, keepalive=30)
break
except:
self.log("Can't connect to broker at ", self.broker, ", retrying...")
for i in range(10):
sleep(0.5)
if not self.isRunning():
return
self.client.loop_start()
self.stopped.wait()
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import BaseInterface
from time import sleep
import paho.mqtt.client as mqtt
and context (classes, functions, sometimes code) from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
. Output only the next line. | self.client.loop_stop(force=True) |
Here is a snippet: <|code_start|>
###
### ADAFRUIT NFC PN532
### https://github.com/adafruit/Adafruit_Python_PN532
###
class NfcInterface (BaseInterface):
state = {}
def __init__(self, hplayer, timeout=1000, divider=5):
self.log('timeout:', timeout ,'ms')
self.log('divider:', divider ,'ms')
# Interface settings
super(NfcInterface, self).__init__(hplayer, "NFC")
# Timeout
self.timeout = timeout
self.timeout_divider = divider
self.timeout_internal = self.timeout*1.0 / self.timeout_divider
<|code_end|>
. Write the next line using the current file imports:
from .base import BaseInterface
from time import sleep
import binascii
import sys
import Adafruit_PN532 as PN532
and context from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
, which may include functions, classes, or code. Output only the next line. | if self.timeout_internal < 0.02: |
Given snippet: <|code_start|>
class TickerInterface (BaseInterface):
def __init__(self, hplayer, bpm, event='tick'):
super().__init__(hplayer, "Ticker")
self._bpm = bpm
self._event = event
self._count = 0
# receiver THREAD
def listen(self):
self.log("starting Ticker")
while self.isRunning():
sleep(60/self._bpm)
self._count += 1
self.emit(self._event, self._count)
# BPM set
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import BaseInterface
from time import sleep
and context:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
which might include code, classes, or functions. Output only the next line. | def setBPM(self, bpm): |
Given snippet: <|code_start|>
# Broadcast Order on OSC to other Pi's
def broadcast(path, *args):
if path.startswith('/play'):
player.getInterface('zyre').node.broadcast(path, list(args), 434) ## WARNING LATENCY !! (1WATT 434ms)
else:
player.getInterface('zyre').node.broadcast(path, list(args))
# player.getInterface('osc').hostOut = network.get_broadcast('wlan0')
# player.getInterface('osc').sendBurst(path, *args)
def play_activedir(index):
broadcast('/playlist', current_dir(), index)
broadcast('/scene', available_dir[active_dir])
def play_lastdir(index):
sel_lastdir()
play_activedir(index)
def play_firstdir(index):
sel_firstdir()
play_activedir(index)
def current_dir():
return os.path.join(base_path, available_dir[active_dir])
def next_dir():
new_dir = active_dir+1
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from core.engine import hplayer
from core.engine import network
import os, types, platform
and context:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
which might include code, classes, or functions. Output only the next line. | if new_dir >= len(available_dir): new_dir=0 |
Given snippet: <|code_start|> if new_dir < 0: new_dir=len(available_dir)-1
set_activedir(new_dir)
def sel_lastdir():
set_activedir(len(available_dir)-1)
def sel_firstdir():
set_activedir(0)
def set_activedir(index):
if index >= 0 and index < len(available_dir):
global active_dir, active_dir_length
active_dir = index
active_dir_length = len(player.buildList(current_dir()))
broadcast('/scene', available_dir[active_dir])
def change_scene(dir):
if isinstance(dir, list):
dir = dir[0]
if dir in available_dir:
global active_dir
active_dir = available_dir.index(dir)
# DO NOT RE-BROADCAST !!
# Sub folders
if is_RPi: base_path = '/mnt/usb'
else: base_path = '/home/mgr/Videos'
available_dir = [d for d in next(os.walk(base_path))[1] if not d.startswith('.')]
available_dir.sort()
active_dir_length = 0
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from core.engine import hplayer
from core.engine import network
import os, types, platform
and context:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
which might include code, classes, or functions. Output only the next line. | if len(available_dir) == 0: available_dir.insert(0,'') |
Using the snippet: <|code_start|>else: base_path = '/home/mgr/Videos'
available_dir = [d for d in next(os.walk(base_path))[1] if not d.startswith('.')]
available_dir.sort()
active_dir = 0
active_dir_length = 0
if len(available_dir) == 0: available_dir.insert(0,'')
set_activedir(0)
def play_media(target_dir):
if target_dir < len(available_dir):
target_path = os.path.join(base_path, available_dir[target_dir])
available_files = [f for f in next(os.walk(target_path))[2] if not f.startswith('.')]
available_files.sort()
for f in available_files:
if f.startswith(str(args[1])):
set_activedir(target_dir)
player.play( available_files.index(f) )
def play_activedir(index):
#available_files = [f for f in next(os.walk(current_dir()))[2] if not f.startswith('.')]
#media = available_files[index]
broadcast('/playmedia', active_dir, index)
def current_dir():
return os.path.join(base_path, available_dir[active_dir])
def next_dir():
new_dir = active_dir+1
if new_dir >= len(available_dir): new_dir=0
<|code_end|>
, determine the next line of code. You have imports:
from core.engine import hplayer
from core.engine import network
import os, types, platform
and context (class names, function names, or code) available:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
. Output only the next line. | set_activedir(new_dir) |
Using the snippet: <|code_start|>playerName = network.get_hostname()
# PLAYER
player = hplayer.addplayer('mpv', 'chalon')
player.loop(1)
# player.doLog['events'] = True
# Interfaces
player.addInterface('zyre', 'wlan0')
player.addInterface('http2', 8080)
player.addInterface('http', 8037)
player.addInterface('keyboard')
is_RPi = platform.machine().startswith('armv')
if is_RPi:
player.addInterface('keypad')
# BROADCAST to other Pi's
def broadcast(path, *args):
if path.startswith('/play'):
player.getInterface('zyre').node.broadcast(path, list(args), 434) ## WARNING LATENCY !! (1WATT 434ms)
else:
player.getInterface('zyre').node.broadcast(path, list(args))
# DIRECTORY / FILE
if is_RPi: base_path = '/mnt/usb'
else: base_path = '/home/mgr/Videos'
available_dir = [d for d in next(os.walk(base_path))[1] if not d.startswith('.')]
<|code_end|>
, determine the next line of code. You have imports:
from core.engine import hplayer
from core.engine import network
import os, types, platform
and context (class names, function names, or code) available:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
. Output only the next line. | available_dir.sort() |
Using the snippet: <|code_start|> def handler(func):
if self.isRunning():
# oscServer.add_method(path, argsTypes, oscdump)
oscServer.add_method(path, argsTypes, func)
return func
return handler
@osc("/burst")
def burst(path, args, types):
if len(args) < 2: return
mac = args.pop(0)
stamp = args.pop(0)
if not mac in self.burstMem or self.burstMem[mac] != stamp:
self.burstMem[mac] = stamp
path = args.pop(0)
types = types[2:]
# print("relaying bursted frame", path, args, types)
target = liblo.Address("osc.udp://127.0.0.1:"+str(self._portIn))
liblo.send(target, path, *args)
@osc(None, None)
def fallback(path, args, types, src):
self.emit(path[1:], *args)
# Advertize on ZeroConf
zeroconf = Zeroconf()
info = ServiceInfo(
"_osc._udp.local.",
"OSC input._"+get_hostname()+"._osc._udp.local.",
addresses=[socket.inet_aton(ip) for ip in get_allip()],
<|code_end|>
, determine the next line of code. You have imports:
from .base import BaseInterface
from core.engine import network
from sys import getsizeof
from ..engine.network import get_allip, get_hostname
from zeroconf import ServiceInfo, Zeroconf
import liblo
import random, time
import socket
and context (class names, function names, or code) available:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
. Output only the next line. | port=self._portIn, |
Using the snippet: <|code_start|>
except liblo.ServerError as e:
self.log( "OSC Error:", e)
self.stopped.set()
# OSC trigger decorator
def osc(path, argsTypes=None):
def handler(func):
if self.isRunning():
# oscServer.add_method(path, argsTypes, oscdump)
oscServer.add_method(path, argsTypes, func)
return func
return handler
@osc("/burst")
def burst(path, args, types):
if len(args) < 2: return
mac = args.pop(0)
stamp = args.pop(0)
if not mac in self.burstMem or self.burstMem[mac] != stamp:
self.burstMem[mac] = stamp
path = args.pop(0)
types = types[2:]
# print("relaying bursted frame", path, args, types)
target = liblo.Address("osc.udp://127.0.0.1:"+str(self._portIn))
liblo.send(target, path, *args)
@osc(None, None)
def fallback(path, args, types, src):
<|code_end|>
, determine the next line of code. You have imports:
from .base import BaseInterface
from core.engine import network
from sys import getsizeof
from ..engine.network import get_allip, get_hostname
from zeroconf import ServiceInfo, Zeroconf
import liblo
import random, time
import socket
and context (class names, function names, or code) available:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
. Output only the next line. | self.emit(path[1:], *args) |
Continue the code snippet: <|code_start|> def handler(func):
if self.isRunning():
# oscServer.add_method(path, argsTypes, oscdump)
oscServer.add_method(path, argsTypes, func)
return func
return handler
@osc("/burst")
def burst(path, args, types):
if len(args) < 2: return
mac = args.pop(0)
stamp = args.pop(0)
if not mac in self.burstMem or self.burstMem[mac] != stamp:
self.burstMem[mac] = stamp
path = args.pop(0)
types = types[2:]
# print("relaying bursted frame", path, args, types)
target = liblo.Address("osc.udp://127.0.0.1:"+str(self._portIn))
liblo.send(target, path, *args)
@osc(None, None)
def fallback(path, args, types, src):
self.emit(path[1:], *args)
# Advertize on ZeroConf
zeroconf = Zeroconf()
info = ServiceInfo(
"_osc._udp.local.",
"OSC input._"+get_hostname()+"._osc._udp.local.",
addresses=[socket.inet_aton(ip) for ip in get_allip()],
<|code_end|>
. Use current file imports:
from .base import BaseInterface
from core.engine import network
from sys import getsizeof
from ..engine.network import get_allip, get_hostname
from zeroconf import ServiceInfo, Zeroconf
import liblo
import random, time
import socket
and context (classes, functions, or code) from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
. Output only the next line. | port=self._portIn, |
Given snippet: <|code_start|>
current_milli_time = lambda: int(round(time.time() * 1000))
def oscdump(path, args, types):
print("OSC Received:", path, args)
class OscInterface (BaseInterface):
def __init__(self, hplayer, in_port, out_port=0):
super(OscInterface, self).__init__(hplayer, "OSC")
self._portIn = in_port
self._portOut = out_port if out_port > 0 else in_port
self.hostOut = network.get_broadcast()
self.burstCounter = random.randint(1,10000)
self.ethMac = network.get_ethmac()
self.burstMem = {}
# OSC sender
def send(self, path, *args):
target = liblo.Address("osc.udp://"+self.hostOut+":"+str(self._portOut))
liblo.send(target, path, *args)
# self.log("sent OSC", path, args ," to ","osc.udp://"+self.hostOut+":"+str(self._portOut))
# OSC send BURST using stamp
def sendBurst(self, path, *args):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import BaseInterface
from core.engine import network
from sys import getsizeof
from ..engine.network import get_allip, get_hostname
from zeroconf import ServiceInfo, Zeroconf
import liblo
import random, time
import socket
and context:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
which might include code, classes, or functions. Output only the next line. | self.burstCounter += 1 |
Predict the next line after this snippet: <|code_start|>
if not isinstance(pinz, list):
pinz = [pinz]
for pin in pinz:
# Can't set if already an INPUT
if pin in self._pinsIN:
self.log("GPIO", pin, "is already set as INPUT only... can't set it!")
return
# Create pin if it does not exists yet
if pin not in self._pinsOUT:
self._pinsOUT.append(pin)
GPIO.setup(pin, GPIO.OUT)
if (str(state).lower() == 'on' or str(state).lower() == 'up'): state=True
if (str(state).lower() == 'off' or str(state).lower() == 'down'): state=False
GPIO.output(pin, state)
self._state[pin] = GPIO.input(pin)
# GPIO get
def get(self, pin):
# PIN never used, set as input (but without watcher)
if pin not in self._pinsIN and pin not in self._pinsOUT:
if self._pupdown == 'PUP':
GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
elif self._pupdown == 'PDOWN':
GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
<|code_end|>
using the current file's imports:
from .base import BaseInterface
import RPi.GPIO as GPIO
and any relevant context from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
. Output only the next line. | else: |
Based on the snippet: <|code_start|> player.getInterface('zyre').node.broadcast('/play', list(media), 200)
print('doPLay: master.. broadcast')
else:
print('doPLay: slave.. do nothing')
else:
player.mute(True)
time.sleep(0.1)
player.play(media)
time.sleep(0.05)
player.mute(False)
# PLAY with super debounce (ATTENTION: compatible avec 1 appel seulement)
superLastTime = 0
def superDebounce(media, timeout=1000):
global superLastTime
if (int(round(time.time() * 1000)) - superLastTime) > timeout:
doPlay(media)
superLastTime = int(round(time.time() * 1000))
print("PLAU")
# DEFAULT File
player.on(['player-ready', 'end-playlist'], lambda: doPlay("0_*.*"))
# HTTP + GPIO events
player.on(['push1', 'gpio21-on'], lambda: doPlay("1_*.*"))
player.on(['push2', 'gpio20-on'], lambda: doPlay("2_*.*"))
player.on(['push3', 'gpio16-on'], lambda: doPlay("3_*.*"))
# GPIO on+off
<|code_end|>
, predict the immediate next line with the help of imports:
from core.engine import hplayer, network
import time
import tempfile
and context (classes, functions, sometimes code) from other files:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
. Output only the next line. | player.on(['turn1', 'gpio26'], lambda state: superDebounce("1_*.*", 1000)) |
Based on the snippet: <|code_start|> print("import error: zeroconf is missing")
zero_enable = False
class HttpInterface (BaseInterface):
def __init__(self, hplayer, port):
super().__init__(hplayer, "HTTP")
self._port = port
# HTTP receiver THREAD
def listen(self):
# Advertize on ZeroConf
if zero_enable:
zeroconf = Zeroconf()
info = ServiceInfo(
"_api-http._tcp.local.",
"HPlayer2._"+get_hostname()+"._api-http._tcp.local.",
addresses=[socket.inet_aton(ip) for ip in get_allip()],
port=self._port,
properties={},
server=get_hostname()+".local.",
)
zeroconf.register_service(info)
# Start server
self.log( "listening on port", self._port)
with ThreadedHTTPServer(self._port, BasicHTTPServerHandler(self)) as server:
self.stopped.wait()
# Unregister ZeroConf
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import BaseInterface
from ..engine.network import get_allip, get_hostname
from http.server import BaseHTTPRequestHandler, HTTPServer
from zeroconf import ServiceInfo, Zeroconf
import threading
import socket
import pprint
and context (classes, functions, sometimes code) from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
. Output only the next line. | if zero_enable: |
Continue the code snippet: <|code_start|> class CustomHandler(BaseHTTPRequestHandler, object):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.httpinterface = httpinterface
def _set_headers(self):
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
def do_GET(self):
self._set_headers()
args = self.path.split('/')
args.pop(0)
if len(args) == 0 or args[0] == '':
self.wfile.write( ("<html><body><h1>Hello World!</h1><p>HPlayer2 API endpoint</p></body></html>").encode() )
return
command = args.pop(0)
# Pre-Format arguments
#
if command == 'loop':
doLoop = 2
if len(args) > 0:
if args[0] == 'all' or args[0] == 2:
doLoop = 2
elif args[0] == 'one' or args[0] == 1:
<|code_end|>
. Use current file imports:
from .base import BaseInterface
from ..engine.network import get_allip, get_hostname
from http.server import BaseHTTPRequestHandler, HTTPServer
from zeroconf import ServiceInfo, Zeroconf
import threading
import socket
import pprint
and context (classes, functions, or code) from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
. Output only the next line. | doLoop = 1 |
Predict the next line for this snippet: <|code_start|>
try:
zero_enable = True
except:
print("import error: zeroconf is missing")
<|code_end|>
with the help of current file imports:
from .base import BaseInterface
from ..engine.network import get_allip, get_hostname
from http.server import BaseHTTPRequestHandler, HTTPServer
from zeroconf import ServiceInfo, Zeroconf
import threading
import socket
import pprint
and context from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
#
# Path: core/engine/network.py
# def get_allip():
# ip = []
# ifaces = ni.interfaces()
# for iface in ifaces:
# if iface.startswith("e"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# else:
# for iface in ifaces:
# if iface.startswith("w"):
# try:
# ip.append(ni.ifaddresses(iface)[AF_INET][0]['addr'])
# except:
# pass
# return ip
#
# def get_hostname():
# import socket
# return socket.gethostname()
, which may contain function names, class names, or code. Output only the next line. | zero_enable = False |
Using the snippet: <|code_start|>
# PLAYER
player = hplayer.addplayer('mpv', 'audioscope')
player.loop(1)
player.log['events'] = True
# Interfaces
<|code_end|>
, determine the next line of code. You have imports:
from core.engine import hplayer
from core.engine import network
and context (class names, function names, or code) available:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
. Output only the next line. | player.addInterface('osc', 1222, 3737) |
Based on the snippet: <|code_start|> def __init__(self):
super(RpifadeOverlay, self).__init__()
self.name = "RPI Fade"
self.nameP = colored(self.name,'cyan')
self.workit = False
# Queue processor
def receive(self):
texture = rpiopengles.colortexture()
print(self.nameP, "texture created")
while self.isRunning():
if not self.queue.empty():
goalFader = self.queue.get()
self.workit = True
while self.workit:
# print (self.currentFader)
self.workit = False
self.currentFader['red'] += self._diff( goalFader['red'], self.currentFader['red'])
self.currentFader['green'] += self._diff( goalFader['green'], self.currentFader['green'])
self.currentFader['blue'] += self._diff( goalFader['blue'], self.currentFader['blue'])
self.currentFader['alpha'] += self._diff( goalFader['alpha'], self.currentFader['alpha'])
print(self.currentFader)
texture.draw( red=self.currentFader['red'],
green=self.currentFader['green'],
<|code_end|>
, predict the immediate next line with the help of imports:
from termcolor import colored
from time import sleep
from .base import BaseOverlay
from .rpiopengles import rpiopengles
import copy
import queue
and context (classes, functions, sometimes code) from other files:
# Path: core/overlays/base.py
# class BaseOverlay(object):
#
# def __init__(self):
#
# self.name = "OVERLAY"
# self.nameP = colored(self.name,'cyan')
#
# # running flag
# self.running = threading.Event()
#
# # Receive thread
# self.recvThread = threading.Thread(target=self.receive)
#
# # receiver THREAD (dummy)
# def receive(self):
# while self.isRunning():
# sleep(1000)
# return
#
# # Stop
# def start(self):
# self.running.set()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.isRunning(False)
# self.recvThread.join()
# print(self.nameP, "stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.running.set() if state else self.running.clear()
# return self.running.is_set()
#
# Path: core/overlays/rpiopengles/rpiopengles.py
# EGL_DEFAULT_DISPLAY = 0
# EGL_NO_CONTEXT = 0
# EGL_NO_DISPLAY = 0
# EGL_NO_SURFACE = 0
# DISPMANX_PROTECTION_NONE = 0
# def eglints(L):
# def eglfloats(L):
# def check(e):
# def __init__(self,depthbuffer=False):
# def __init__(self):
# def draw(self, red=0.0, green=0.0, blue=0.0, alpha=0.0):
# def check(self):
# class EGL(object):
# class colortexture():
. Output only the next line. | blue=self.currentFader['blue'], |
Using the snippet: <|code_start|>from __future__ import print_function
class RpifadeOverlay (BaseOverlay):
queue = queue.Queue()
nextFader = {'red': 0.0, 'green': 0.0, 'blue': 0.0, 'alpha': 0.0}
currentFader = copy.deepcopy(nextFader)
def __init__(self):
super(RpifadeOverlay, self).__init__()
self.name = "RPI Fade"
self.nameP = colored(self.name,'cyan')
self.workit = False
# Queue processor
def receive(self):
texture = rpiopengles.colortexture()
print(self.nameP, "texture created")
while self.isRunning():
if not self.queue.empty():
goalFader = self.queue.get()
<|code_end|>
, determine the next line of code. You have imports:
from termcolor import colored
from time import sleep
from .base import BaseOverlay
from .rpiopengles import rpiopengles
import copy
import queue
and context (class names, function names, or code) available:
# Path: core/overlays/base.py
# class BaseOverlay(object):
#
# def __init__(self):
#
# self.name = "OVERLAY"
# self.nameP = colored(self.name,'cyan')
#
# # running flag
# self.running = threading.Event()
#
# # Receive thread
# self.recvThread = threading.Thread(target=self.receive)
#
# # receiver THREAD (dummy)
# def receive(self):
# while self.isRunning():
# sleep(1000)
# return
#
# # Stop
# def start(self):
# self.running.set()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.isRunning(False)
# self.recvThread.join()
# print(self.nameP, "stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.running.set() if state else self.running.clear()
# return self.running.is_set()
#
# Path: core/overlays/rpiopengles/rpiopengles.py
# EGL_DEFAULT_DISPLAY = 0
# EGL_NO_CONTEXT = 0
# EGL_NO_DISPLAY = 0
# EGL_NO_SURFACE = 0
# DISPMANX_PROTECTION_NONE = 0
# def eglints(L):
# def eglfloats(L):
# def check(e):
# def __init__(self,depthbuffer=False):
# def __init__(self):
# def draw(self, red=0.0, green=0.0, blue=0.0, alpha=0.0):
# def check(self):
# class EGL(object):
# class colortexture():
. Output only the next line. | self.workit = True |
Predict the next line after this snippet: <|code_start|>
# NAME
playerName = network.get_hostname()
# PLAYER
player = hplayer.addplayer('mpv', 'kxkm')
# INTERFACES
player.addInterface('http2', 8080)
player.addInterface('osc', 1222, 3737)
<|code_end|>
using the current file's imports:
from core.engine import hplayer
from core.engine import network
import os, platform
and any relevant context from other files:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
. Output only the next line. | player.addInterface('keyboard') |
Predict the next line for this snippet: <|code_start|>
def fullSyncTest():
if not regie_ip:
player.getInterface('osc').hostOut = network.get_broadcast()
player.getInterface('osc').send(playerName, 'initinfo', network.get_ip())
def setIpRegie(args):
global regie_ip
regie_ip = args[0]
player.getInterface('osc').hostOut = regie_ip
def fadeColor(args=None):
if is_RPi:
if args and len(args) == 3:
player.getOverlay('rpifade').set(args[0]/255.0, args[1]/255.0, args[2]/255.0, 1.0)
elif args and len(args) == 4:
player.getOverlay('rpifade').set(args[0]/255.0, args[1]/255.0, args[2]/255.0, args[3]/255.0)
else:
player.getOverlay('rpifade').set(1.0, 1.0, 1.0, 1.0)
def unfadeColor():
if is_RPi:
player.getOverlay('rpifade').set(alpha=0.0)
def playmovie(args=None):
player.play( args[0] ) if args else player.play()
player.on(['/synctest'], syncTest)
player.on(['/fullsynctest'], fullSyncTest)
<|code_end|>
with the help of current file imports:
from core.engine import hplayer
from core.engine import network
import os, platform
and context from other files:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
, which may contain function names, class names, or code. Output only the next line. | player.on(['/ipregie'], setIpRegie) |
Predict the next line after this snippet: <|code_start|>
class Playlist(Module):
_playlist = []
_index = 0
_lastran = -1
def __init__(self, hplayer):
super().__init__(hplayer, 'Playlist', 'yellow')
<|code_end|>
using the current file's imports:
from ..module import Module
from random import randrange
import os
import re
and any relevant context from other files:
# Path: core/module.py
# class Module(EventEmitterX):
# def __init__(self, parent, name, color):
# super().__init__(wildcard=True, delimiter=".")
# self.name = name.replace(" ", "_")
# self.nameP = colored(('['+self.name+']').ljust(10, ' ')+' ', color)
# self.parent = parent
# self.logQuietEvents = [] # list of not-logged events '*' for full quiet
#
# def log(self, *argv):
# safe_print(self.nameP, *argv)
# sys.stdout.flush()
#
# # Emit extended
# def emit(self, event, *args):
# fullEvent = self.name.lower() + '.' + event
# if not '*' in self.logQuietEvents and not event in self.logQuietEvents:
# self.log('-', event, *args )
#
# super().emit(event, *args)
# self.parent.emit(fullEvent, *args)
. Output only the next line. | self.hplayer = hplayer |
Given the following code snippet before the placeholder: <|code_start|>
remote_ip = "3.0.0.255"
# PLAYER
player = hplayer.addplayer('mpv', 'ciconia')
player.loop(0)
# Interfaces
player.addInterface('osc', 4000, 4001)
player.addInterface('http', 8037)
player.addInterface('http2', 8080)
<|code_end|>
, predict the next line using imports from the current file:
from core.engine import hplayer
from core.engine import network
import os
and context including class names, function names, and sometimes code from other files:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
. Output only the next line. | player.addInterface('keypad') |
Predict the next line after this snippet: <|code_start|>
millis = lambda: int(round(time.time() * 1000))
class KeyboardInterface (BaseInterface):
def __init__(self, hplayer):
# Interface settings
super(KeyboardInterface, self).__init__(hplayer, "Keyboard")
# keyboard connection watchdog
event_handler = FileSystemEventHandler()
event_handler.on_created = self.bind
event_handler.on_deleted = self.unbind
self.observer = Observer()
self.observer.schedule(event_handler, '/dev/input/', recursive=False)
self.observer.start()
self.remote = None
self.holdDebounce = 5
self.bind(self.detect())
# Find Keyboard
<|code_end|>
using the current file's imports:
from .base import BaseInterface
from evdev import InputDevice, categorize, ecodes
from watchdog.observers import Observer # python3-watchdog ?
from watchdog.events import FileSystemEventHandler
import sys, subprocess
import time
and any relevant context from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
. Output only the next line. | def detect(self): |
Predict the next line after this snippet: <|code_start|>
# EXTRA TMP UPLOAD
tempfile.tempdir = '/data/var/tmp'
# PLAYER
player = hplayer.addplayer('mpv', network.get_hostname())
player.doLog['events'] = True
player.doLog['cmds'] = True
# Interfaces
player.addInterface('http', 8080)
player.addInterface('http2', 80)
player.addInterface('serial', "^CP2102")
# SERIAL USB
player.on(['RELOOP'], lambda: player.play("loop*.*"))
# PATH
hplayer.setBasePath(["/mnt/usb"])
hplayer.persistentSettings("/data/hplayer2-flipper.cfg")
# DISABLE automations
def disableAuto(settings):
<|code_end|>
using the current file's imports:
from core.engine import hplayer, network
import tempfile
and any relevant context from other files:
# Path: core/engine/hplayer.py
# def signal_handler(signal, frame):
# def __init__(self, basepath=None, settingspath=None):
# def log(self, *argv):
# def isRPi():
# def name():
# def addPlayer(self, ptype, name):
# def vol(ev, value, settings):
# def pan(ev, value, settings):
# def flip(ev, value, settings):
# def loop(ev, value, settings=None):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def player(self, name):
# def players(self):
# def activePlayer(self):
# def statusPlayers(self):
# def addSampler(self, ptype, name, poly=4):
# def emitStatus(ev, *args):
# def reset(ev, *args):
# def sampler(self, name):
# def samplers(self):
# def statusSamplers(self):
# def addInterface(self, iface, *argv):
# def interface(self, name):
# def interfaces(self):
# def running(self):
# def run(self):
# def autoBind(self, module):
# def hardreset(ev, *args):
# def doaudioout(ev, *args):
# def play(ev, *args):
# def playonce(ev, *args):
# def playloop(ev, *args):
# def load(ev, *args):
# def playindex(ev, *args):
# def playindex(ev, *args):
# def add(ev, *args):
# def remove(ev, *args):
# def clear(ev, *args):
# def next(ev, *args):
# def prev(ev, *args):
# def doplay(ev, *args):
# def stop(ev, *args):
# def pause(ev, *args):
# def resume(ev, *args):
# def seek(ev, *args):
# def skip(ev, *args):
# def doplayseq(ev, *args):
# def loop(ev, *args):
# def unloop(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def volume(ev, *args):
# def mute(ev, *args):
# def unmute(ev, *args):
# def pan(ev, *args):
# def audiomode(ev, *args):
# def audiomode(ev, *args):
# def flip(ev, *args):
# def fade(ev, *args):
# def unfade(ev, *args):
# def unflip(ev, *args):
# def autoplay(ev, *args):
# class HPlayer2(EventEmitterX):
#
# Path: core/engine/network.py
# def get_ip(iface=None):
# def get_allip():
# def get_broadcast(iface=None):
# def get_hostname():
# def get_ethmac():
# def get_essid(iface):
# def get_rssi(iface):
. Output only the next line. | player.loop(False) |
Given the following code snippet before the placeholder: <|code_start|>
def recv(self):
if not self.sock:
return
self.LT2 = int(time.time()*PRECISION)
self.ST = int(Zmsg.recv(self.sock).popstr().decode())
self.sock = None
self.RTT = self.LT2 - self.LT1
self.CS = self.ST - (self.RTT/2) - self.LT1
#
# CLIENT Actor to perform Clock Shift measurment with a remote peer
#
class TimeClient():
def __init__(self, ip, port):
self.client_ip = ip
self.url = ("tcp://"+self.client_ip+":"+port).encode()
self.clockshift = 0
self._actor_fn = zactor_fn(self.actor_fn) # ctypes function reference must live as long as the actor.
self.done = True
self.start()
def start(self):
if not self.done:
self.stop()
self.actor = Zactor(self._actor_fn, create_string_buffer(b"Sync request"))
self.done = False
<|code_end|>
, predict the next line using imports from the current file:
from .base import BaseInterface
from zyre import Zyre, ZyreEvent
from czmq import *
from time import sleep
from threading import Timer, Lock
from ctypes import string_at
from sys import getsizeof
from binascii import hexlify
import time, random
import json
and context including class names, function names, and sometimes code from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
. Output only the next line. | self._refresh = Timer(120, self.start) |
Based on the snippet: <|code_start|>
class KeypadInterface (BaseInterface):
buttons = ( (LCD.SELECT, 'Select', (1,1,1)),
(LCD.LEFT, 'Left' , (1,0,0)),
(LCD.UP, 'Up' , (0,0,1)),
(LCD.DOWN, 'Down' , (0,1,0)),
(LCD.RIGHT, 'Right' , (1,0,1)) )
display = ["", ""]
def __init__(self, hplayer):
super(KeypadInterface, self).__init__(hplayer, "KEYPAD")
try:
self.lcd = LCD.Adafruit_CharLCDPlate()
self.lcd.set_color(0, 0, 0)
except:
self.log("LCD Keypad not found ...")
self.lcd = None
def update(self):
lines = ["", ""]
# Line 1 : MEDIA
if not self.hplayer.statusPlayers()[0]['media']: lines[0] = '-stop-'
else: lines[0] = os.path.basename(self.hplayer.statusPlayers()[0]['media'])[:-4]
lines[0] = lines[0].ljust(16, ' ')[:16]
# Line 2 : VOLUME / TIME
lines[1] = 'VOLUME: '+str(self.hplayer.settings()['volume'])
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import BaseInterface
from time import sleep
import Adafruit_CharLCD as LCD
import os
and context (classes, functions, sometimes code) from other files:
# Path: core/interfaces/base.py
# class BaseInterface(ABC, Module):
#
# def __init__(self, hplayer, name="INTERFACE", color="blue"):
# super().__init__(hplayer, name, color)
# self.hplayer = hplayer
#
# # stopping flag
# self.stopped = threading.Event()
# self.stopped.set()
#
# # Listen thread
# self.recvThread = threading.Thread(target=self.listen)
#
#
# # Receiver THREAD (ABSTRACT)
# @abstractmethod
# def listen(self):
# self.stopped.wait()
#
# # Start
# def start(self):
# self.stopped.clear()
# self.recvThread.start()
# return self
#
# # Stop
# def quit(self):
# self.log("stopping...")
# self.stopped.set()
# self.recvThread.join()
# self.log("stopped")
#
# # is Running
# def isRunning(self, state=None):
# if state is not None:
# self.stopped.clear() if state else self.stopped.set()
# return not self.stopped.is_set()
. Output only the next line. | if self.hplayer.statusPlayers()[0]['time'] is not None: |
Next line prediction: <|code_start|> for key in self._settings:
self.emit('do-'+key, self._settings[key], self.export())
self.emit('updated', self.export())
self.emit('loaded', self.export())
self.log('settings loaded:', self._settings)
except:
self.log('ERROR loading settings file', self._settingspath)
def export(self):
return self._settings.copy()
def get(self, key):
if key in self._settings:
return self._settings[key]
return None
def set(self, key, val):
if self._settings[key] != val:
self._settings[key] = val
self.emit('do-'+key, val, self.export())
self.emit('updated', self.export())
self.save()
def save(self):
if self._settingspath:
with open(self._settingspath, 'w') as fd:
<|code_end|>
. Use current file imports:
(from ..module import Module
import json
import os)
and context including class names, function names, or small code snippets from other files:
# Path: core/module.py
# class Module(EventEmitterX):
# def __init__(self, parent, name, color):
# super().__init__(wildcard=True, delimiter=".")
# self.name = name.replace(" ", "_")
# self.nameP = colored(('['+self.name+']').ljust(10, ' ')+' ', color)
# self.parent = parent
# self.logQuietEvents = [] # list of not-logged events '*' for full quiet
#
# def log(self, *argv):
# safe_print(self.nameP, *argv)
# sys.stdout.flush()
#
# # Emit extended
# def emit(self, event, *args):
# fullEvent = self.name.lower() + '.' + event
# if not '*' in self.logQuietEvents and not event in self.logQuietEvents:
# self.log('-', event, *args )
#
# super().emit(event, *args)
# self.parent.emit(fullEvent, *args)
. Output only the next line. | json.dump(self._settings, fd, indent=4) |
Using the snippet: <|code_start|>parsable = parsable.Parsable()
OTHER_DECODE = '_OTHER'
TRUTHY = ['1', '1.0', 'True', 'true', 't']
FALSEY = ['0', '0.0', 'False', 'false', 'f']
BOOLEAN_SYMBOLS = {
key: value
for keys, value in [(TRUTHY, True), (FALSEY, False)]
for key in keys
}
EXAMPLE_VALUES = {
'booleans': False,
'counts': 0,
'reals': 0.0,
}
EXAMPLE_CATEGORICAL_ENCODER = {
'name': 'day-of-week',
'model': 'dd',
'symbols': {
'Monday': 0,
'Tuesday': 1,
'Wednesday': 2,
'Friday': 4,
},
}
<|code_end|>
, determine the next line of code. You have imports:
import os
import shutil
import parsable
import loom.util
import loom.schema
import loom.schema_pb2
import loom.cFormat
import loom.documented
from itertools import cycle
from itertools import izip
from contextlib2 import ExitStack
from collections import defaultdict
from distributions.dbg.models import dpd
from distributions.fileutil import tempdir
from distributions.io.stream import json_dump
from distributions.io.stream import json_load
from distributions.io.stream import open_compressed
from distributions.io.stream import protobuf_stream_load
from loom.util import csv_reader
from loom.util import csv_writer
from loom.util import LoomError
and context (class names, function names, or code) available:
# Path: loom/util.py
# @contextlib.contextmanager
# def csv_reader(filename):
# with open_compressed(filename, 'rb') as f:
# yield csv.reader(f)
#
# Path: loom/util.py
# @contextlib.contextmanager
# def csv_writer(filename):
# with open_compressed(filename, 'wb') as f:
# yield csv.writer(f)
#
# Path: loom/util.py
# class LoomError(Exception):
# pass
. Output only the next line. | @parsable.command |
Using the snippet: <|code_start|># notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# - Neither the name of Salesforce.com nor the names of its contributors
# may be used to endorse or promote products derived from this
# software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
OTHER_DECODE = '_OTHER'
TRUTHY = ['1', '1.0', 'True', 'true', 't']
FALSEY = ['0', '0.0', 'False', 'false', 'f']
BOOLEAN_SYMBOLS = {
key: value
for keys, value in [(TRUTHY, True), (FALSEY, False)]
for key in keys
}
<|code_end|>
, determine the next line of code. You have imports:
import os
import shutil
import parsable
import loom.util
import loom.schema
import loom.schema_pb2
import loom.cFormat
import loom.documented
from itertools import cycle
from itertools import izip
from contextlib2 import ExitStack
from collections import defaultdict
from distributions.dbg.models import dpd
from distributions.fileutil import tempdir
from distributions.io.stream import json_dump
from distributions.io.stream import json_load
from distributions.io.stream import open_compressed
from distributions.io.stream import protobuf_stream_load
from loom.util import csv_reader
from loom.util import csv_writer
from loom.util import LoomError
and context (class names, function names, or code) available:
# Path: loom/util.py
# @contextlib.contextmanager
# def csv_reader(filename):
# with open_compressed(filename, 'rb') as f:
# yield csv.reader(f)
#
# Path: loom/util.py
# @contextlib.contextmanager
# def csv_writer(filename):
# with open_compressed(filename, 'wb') as f:
# yield csv.writer(f)
#
# Path: loom/util.py
# class LoomError(Exception):
# pass
. Output only the next line. | EXAMPLE_VALUES = { |
Given the code snippet: <|code_start|># may be used to endorse or promote products derived from this
# software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
OTHER_DECODE = '_OTHER'
TRUTHY = ['1', '1.0', 'True', 'true', 't']
FALSEY = ['0', '0.0', 'False', 'false', 'f']
BOOLEAN_SYMBOLS = {
key: value
for keys, value in [(TRUTHY, True), (FALSEY, False)]
for key in keys
}
EXAMPLE_VALUES = {
'booleans': False,
'counts': 0,
<|code_end|>
, generate the next line using the imports in this file:
import os
import shutil
import parsable
import loom.util
import loom.schema
import loom.schema_pb2
import loom.cFormat
import loom.documented
from itertools import cycle
from itertools import izip
from contextlib2 import ExitStack
from collections import defaultdict
from distributions.dbg.models import dpd
from distributions.fileutil import tempdir
from distributions.io.stream import json_dump
from distributions.io.stream import json_load
from distributions.io.stream import open_compressed
from distributions.io.stream import protobuf_stream_load
from loom.util import csv_reader
from loom.util import csv_writer
from loom.util import LoomError
and context (functions, classes, or occasionally code) from other files:
# Path: loom/util.py
# @contextlib.contextmanager
# def csv_reader(filename):
# with open_compressed(filename, 'rb') as f:
# yield csv.reader(f)
#
# Path: loom/util.py
# @contextlib.contextmanager
# def csv_writer(filename):
# with open_compressed(filename, 'wb') as f:
# yield csv.writer(f)
#
# Path: loom/util.py
# class LoomError(Exception):
# pass
. Output only the next line. | 'reals': 0.0, |
Predict the next line for this snippet: <|code_start|># may be used to endorse or promote products derived from this
# software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
LOOM_TEST_COST = int(os.environ.get('LOOM_TEST_COST', 100))
FEATURE_TYPES = loom.schema.MODELS.keys()
FEATURE_TYPES += ['mixed']
COST = {
'gp': 10,
'mixed': 10,
}
# work around bug https://github.com/priorknowledge/loom/issues/55
LOOM_DEBUG_MIX = int(os.environ.get('LOOM_DEBUG_MIX', 0))
<|code_end|>
with the help of current file imports:
import os
import loom
import loom.config
import loom.consensus
import loom.generate
import loom.transforms
import loom.format
import loom.runner
import loom.store
import parsable
from distributions.io.stream import json_dump
from distributions.io.stream import json_load
from distributions.io.stream import open_compressed
from distributions.io.stream import protobuf_stream_dump
from loom.util import cp_ns
from loom.util import mkdir_p
from loom.util import parallel_map
from loom.util import rm_rf
and context from other files:
# Path: loom/util.py
# def cp_ns(source, destin):
# 'like cp -ns, link destin to source if destin does not exist'
# if not os.path.exists(destin):
# assert os.path.exists(source), source
# dirname = os.path.dirname(destin)
# if dirname:
# mkdir_p(dirname)
# try:
# os.symlink(source, destin)
# except OSError as e:
# if not os.path.exists(destin):
# raise e
#
# Path: loom/util.py
# def mkdir_p(dirname):
# 'like mkdir -p'
# if not os.path.exists(dirname):
# try:
# os.makedirs(dirname)
# except OSError as e:
# if not os.path.exists(dirname):
# raise e
#
# Path: loom/util.py
# def parallel_map(fun, args):
# if not isinstance(args, list):
# args = list(args)
# is_daemon = multiprocessing.current_process().daemon
# if THREADS == 1 or len(args) < 2 or is_daemon:
# print 'Running {} in this thread'.format(fun.__name__)
# return map(fun, args)
# else:
# print 'Running {} in {:d} threads'.format(fun.__name__, THREADS)
# pool = multiprocessing.Pool(THREADS)
# fun_args = [(fun, arg) for arg in args]
# return pool.map(print_trace, fun_args, chunksize=1)
#
# Path: loom/util.py
# def rm_rf(path):
# 'like rm -rf'
# if os.path.exists(path):
# if os.path.isdir(path):
# shutil.rmtree(path)
# else:
# os.remove(path)
, which may contain function names, class names, or code. Output only the next line. | def get_cell_count(config): |
Based on the snippet: <|code_start|>
def get_cell_count(config):
return config['row_count'] * config['feature_count'] * config['density']
def get_cost(config):
return get_cell_count(config) * COST.get(config['feature_type'], 1)
CONFIG_VALUES = [
{
'feature_type': feature_type,
'row_count': row_count,
'feature_count': feature_count,
'density': density,
}
for feature_type in FEATURE_TYPES
for row_count in [10 ** r for r in [1, 2, 3, 4, 5, 6]]
for feature_count in [10 ** c for c in [1, 2, 3, 4]]
for density in [0.05, 0.5]
if density * row_count > 1
]
CONFIGS = {
'{feature_type}-{row_count}-{feature_count}-{density}'.format(**c): c
for c in CONFIG_VALUES
if get_cost(c) <= 10 ** 7
}
TEST_CONFIGS = [
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import loom
import loom.config
import loom.consensus
import loom.generate
import loom.transforms
import loom.format
import loom.runner
import loom.store
import parsable
from distributions.io.stream import json_dump
from distributions.io.stream import json_load
from distributions.io.stream import open_compressed
from distributions.io.stream import protobuf_stream_dump
from loom.util import cp_ns
from loom.util import mkdir_p
from loom.util import parallel_map
from loom.util import rm_rf
and context (classes, functions, sometimes code) from other files:
# Path: loom/util.py
# def cp_ns(source, destin):
# 'like cp -ns, link destin to source if destin does not exist'
# if not os.path.exists(destin):
# assert os.path.exists(source), source
# dirname = os.path.dirname(destin)
# if dirname:
# mkdir_p(dirname)
# try:
# os.symlink(source, destin)
# except OSError as e:
# if not os.path.exists(destin):
# raise e
#
# Path: loom/util.py
# def mkdir_p(dirname):
# 'like mkdir -p'
# if not os.path.exists(dirname):
# try:
# os.makedirs(dirname)
# except OSError as e:
# if not os.path.exists(dirname):
# raise e
#
# Path: loom/util.py
# def parallel_map(fun, args):
# if not isinstance(args, list):
# args = list(args)
# is_daemon = multiprocessing.current_process().daemon
# if THREADS == 1 or len(args) < 2 or is_daemon:
# print 'Running {} in this thread'.format(fun.__name__)
# return map(fun, args)
# else:
# print 'Running {} in {:d} threads'.format(fun.__name__, THREADS)
# pool = multiprocessing.Pool(THREADS)
# fun_args = [(fun, arg) for arg in args]
# return pool.map(print_trace, fun_args, chunksize=1)
#
# Path: loom/util.py
# def rm_rf(path):
# 'like rm -rf'
# if os.path.exists(path):
# if os.path.isdir(path):
# shutil.rmtree(path)
# else:
# os.remove(path)
. Output only the next line. | name |
Given the following code snippet before the placeholder: <|code_start|># USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
LOOM_TEST_COST = int(os.environ.get('LOOM_TEST_COST', 100))
FEATURE_TYPES = loom.schema.MODELS.keys()
FEATURE_TYPES += ['mixed']
COST = {
'gp': 10,
'mixed': 10,
}
# work around bug https://github.com/priorknowledge/loom/issues/55
LOOM_DEBUG_MIX = int(os.environ.get('LOOM_DEBUG_MIX', 0))
def get_cell_count(config):
return config['row_count'] * config['feature_count'] * config['density']
def get_cost(config):
return get_cell_count(config) * COST.get(config['feature_type'], 1)
CONFIG_VALUES = [
{
'feature_type': feature_type,
'row_count': row_count,
'feature_count': feature_count,
<|code_end|>
, predict the next line using imports from the current file:
import os
import loom
import loom.config
import loom.consensus
import loom.generate
import loom.transforms
import loom.format
import loom.runner
import loom.store
import parsable
from distributions.io.stream import json_dump
from distributions.io.stream import json_load
from distributions.io.stream import open_compressed
from distributions.io.stream import protobuf_stream_dump
from loom.util import cp_ns
from loom.util import mkdir_p
from loom.util import parallel_map
from loom.util import rm_rf
and context including class names, function names, and sometimes code from other files:
# Path: loom/util.py
# def cp_ns(source, destin):
# 'like cp -ns, link destin to source if destin does not exist'
# if not os.path.exists(destin):
# assert os.path.exists(source), source
# dirname = os.path.dirname(destin)
# if dirname:
# mkdir_p(dirname)
# try:
# os.symlink(source, destin)
# except OSError as e:
# if not os.path.exists(destin):
# raise e
#
# Path: loom/util.py
# def mkdir_p(dirname):
# 'like mkdir -p'
# if not os.path.exists(dirname):
# try:
# os.makedirs(dirname)
# except OSError as e:
# if not os.path.exists(dirname):
# raise e
#
# Path: loom/util.py
# def parallel_map(fun, args):
# if not isinstance(args, list):
# args = list(args)
# is_daemon = multiprocessing.current_process().daemon
# if THREADS == 1 or len(args) < 2 or is_daemon:
# print 'Running {} in this thread'.format(fun.__name__)
# return map(fun, args)
# else:
# print 'Running {} in {:d} threads'.format(fun.__name__, THREADS)
# pool = multiprocessing.Pool(THREADS)
# fun_args = [(fun, arg) for arg in args]
# return pool.map(print_trace, fun_args, chunksize=1)
#
# Path: loom/util.py
# def rm_rf(path):
# 'like rm -rf'
# if os.path.exists(path):
# if os.path.isdir(path):
# shutil.rmtree(path)
# else:
# os.remove(path)
. Output only the next line. | 'density': density, |
Predict the next line after this snippet: <|code_start|># USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
def get_paths(name, operation):
inputs = loom.store.get_paths(name)
results = loom.store.get_paths(os.path.join(name, 'benchmark', operation))
return inputs, results
def checkpoint_files(path, suffix=''):
path = os.path.abspath(str(path))
assert os.path.exists(path), path
return {
'model' + suffix: os.path.join(path, 'model.pb.gz'),
'groups' + suffix: os.path.join(path, 'groups'),
'assign' + suffix: os.path.join(path, 'assign.pbs.gz'),
'checkpoint' + suffix: os.path.join(path, 'checkpoint.pb.gz'),
}
parsable.command(loom.runner.profilers)
@parsable.command
def generate(
feature_type='mixed',
row_count=10000,
feature_count=100,
<|code_end|>
using the current file's imports:
import os
import shutil
import glob
import parsable
import loom.store
import loom.config
import loom.runner
import loom.generate
import loom.format
import loom.datasets
import loom.schema_pb2
import loom.query
import loom.preql
from distributions.io.stream import (
open_compressed,
json_load,
protobuf_stream_load,
)
from loom.util import chdir, mkdir_p, rm_rf
and any relevant context from other files:
# Path: loom/util.py
# @contextlib.contextmanager
# def chdir(wd):
# oldwd = os.getcwd()
# try:
# os.chdir(wd)
# yield wd
# finally:
# os.chdir(oldwd)
#
# def mkdir_p(dirname):
# 'like mkdir -p'
# if not os.path.exists(dirname):
# try:
# os.makedirs(dirname)
# except OSError as e:
# if not os.path.exists(dirname):
# raise e
#
# def rm_rf(path):
# 'like rm -rf'
# if os.path.exists(path):
# if os.path.isdir(path):
# shutil.rmtree(path)
# else:
# os.remove(path)
. Output only the next line. | density=0.5, |
Here is a snippet: <|code_start|># LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
def get_paths(name, operation):
inputs = loom.store.get_paths(name)
results = loom.store.get_paths(os.path.join(name, 'benchmark', operation))
return inputs, results
def checkpoint_files(path, suffix=''):
path = os.path.abspath(str(path))
assert os.path.exists(path), path
return {
'model' + suffix: os.path.join(path, 'model.pb.gz'),
'groups' + suffix: os.path.join(path, 'groups'),
'assign' + suffix: os.path.join(path, 'assign.pbs.gz'),
'checkpoint' + suffix: os.path.join(path, 'checkpoint.pb.gz'),
}
<|code_end|>
. Write the next line using the current file imports:
import os
import shutil
import glob
import parsable
import loom.store
import loom.config
import loom.runner
import loom.generate
import loom.format
import loom.datasets
import loom.schema_pb2
import loom.query
import loom.preql
from distributions.io.stream import (
open_compressed,
json_load,
protobuf_stream_load,
)
from loom.util import chdir, mkdir_p, rm_rf
and context from other files:
# Path: loom/util.py
# @contextlib.contextmanager
# def chdir(wd):
# oldwd = os.getcwd()
# try:
# os.chdir(wd)
# yield wd
# finally:
# os.chdir(oldwd)
#
# def mkdir_p(dirname):
# 'like mkdir -p'
# if not os.path.exists(dirname):
# try:
# os.makedirs(dirname)
# except OSError as e:
# if not os.path.exists(dirname):
# raise e
#
# def rm_rf(path):
# 'like rm -rf'
# if os.path.exists(path):
# if os.path.isdir(path):
# shutil.rmtree(path)
# else:
# os.remove(path)
, which may include functions, classes, or code. Output only the next line. | parsable.command(loom.runner.profilers) |
Next line prediction: <|code_start|># software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
def get_paths(name, operation):
inputs = loom.store.get_paths(name)
results = loom.store.get_paths(os.path.join(name, 'benchmark', operation))
return inputs, results
def checkpoint_files(path, suffix=''):
path = os.path.abspath(str(path))
assert os.path.exists(path), path
return {
'model' + suffix: os.path.join(path, 'model.pb.gz'),
'groups' + suffix: os.path.join(path, 'groups'),
'assign' + suffix: os.path.join(path, 'assign.pbs.gz'),
<|code_end|>
. Use current file imports:
(import os
import shutil
import glob
import parsable
import loom.store
import loom.config
import loom.runner
import loom.generate
import loom.format
import loom.datasets
import loom.schema_pb2
import loom.query
import loom.preql
from distributions.io.stream import (
open_compressed,
json_load,
protobuf_stream_load,
)
from loom.util import chdir, mkdir_p, rm_rf)
and context including class names, function names, or small code snippets from other files:
# Path: loom/util.py
# @contextlib.contextmanager
# def chdir(wd):
# oldwd = os.getcwd()
# try:
# os.chdir(wd)
# yield wd
# finally:
# os.chdir(oldwd)
#
# def mkdir_p(dirname):
# 'like mkdir -p'
# if not os.path.exists(dirname):
# try:
# os.makedirs(dirname)
# except OSError as e:
# if not os.path.exists(dirname):
# raise e
#
# def rm_rf(path):
# 'like rm -rf'
# if os.path.exists(path):
# if os.path.isdir(path):
# shutil.rmtree(path)
# else:
# os.remove(path)
. Output only the next line. | 'checkpoint' + suffix: os.path.join(path, 'checkpoint.pb.gz'), |
Predict the next line for this snippet: <|code_start|># INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
EXAMPLE_VALUES = {
'boolean': ['0', '1', 'true', 'false'],
'categorical': ['Monday', 'June'],
'unbounded_categorical': ['CRM', '90210'],
'count': ['0', '1', '2', '3', '4'],
'real': ['-100.0', '1e-4'],
'sparse_real': ['0', '0', '0', '0', '123456.78', '0', '0', '0'],
'date': ['2014-03-31', '10pm, August 1, 1979'],
'text': ['This is a text feature.', 'Hello World!'],
'tags': ['', 'big_data machine_learning platform'],
}
for fluent_type, values in EXAMPLE_VALUES.items():
EXAMPLE_VALUES['optional_{}'.format(fluent_type)] = [''] + values
EXAMPLE_VALUES['id'] = ['any unique string can serve as an id']
FLUENT_TO_BASIC = {
'boolean': 'bb',
'categorical': 'dd',
'unbounded_categorical': 'dpd',
'count': 'gp',
'real': 'nich',
<|code_end|>
with the help of current file imports:
import os
import re
import datetime
import dateutil.parser
import loom.util
import loom.documented
import parsable
from itertools import izip
from collections import Counter
from contextlib2 import ExitStack
from distributions.io.stream import json_dump
from distributions.io.stream import json_load
from loom.util import cp_ns
from loom.util import LOG
from loom.util import parallel_map
from loom.util import pickle_dump
from loom.util import pickle_load
from loom.format import load_encoder
from loom.format import load_decoder
and context from other files:
# Path: loom/util.py
# def cp_ns(source, destin):
# 'like cp -ns, link destin to source if destin does not exist'
# if not os.path.exists(destin):
# assert os.path.exists(source), source
# dirname = os.path.dirname(destin)
# if dirname:
# mkdir_p(dirname)
# try:
# os.symlink(source, destin)
# except OSError as e:
# if not os.path.exists(destin):
# raise e
#
# Path: loom/util.py
# def LOG(message):
# if VERBOSITY:
# sys.stdout.write('{}\n'.format(message))
# sys.stdout.flush()
#
# Path: loom/util.py
# def parallel_map(fun, args):
# if not isinstance(args, list):
# args = list(args)
# is_daemon = multiprocessing.current_process().daemon
# if THREADS == 1 or len(args) < 2 or is_daemon:
# print 'Running {} in this thread'.format(fun.__name__)
# return map(fun, args)
# else:
# print 'Running {} in {:d} threads'.format(fun.__name__, THREADS)
# pool = multiprocessing.Pool(THREADS)
# fun_args = [(fun, arg) for arg in args]
# return pool.map(print_trace, fun_args, chunksize=1)
#
# Path: loom/util.py
# def pickle_dump(data, filename):
# with open_compressed(filename, 'wb') as f:
# pickle.dump(data, f)
#
# Path: loom/util.py
# def pickle_load(filename):
# with open_compressed(filename, 'rb') as f:
# return pickle.load(f)
#
# Path: loom/format.py
# def load_encoder(encoder):
# model = encoder['model']
# if 'symbols' in encoder:
# encode = encoder['symbols'].__getitem__
# elif model == 'bb':
# encode = BOOLEAN_SYMBOLS.__getitem__
# else:
# encode = loom.schema.MODELS[model].Value
# return encode
#
# Path: loom/format.py
# def load_decoder(encoder):
# model = encoder['model']
# if 'symbols' in encoder:
# decoder = {value: key for key, value in encoder['symbols'].iteritems()}
# decode = decoder.__getitem__
# elif model == 'bb':
# decode = ('0', '1').__getitem__
# else:
# decode = str
# return decode
, which may contain function names, class names, or code. Output only the next line. | } |
Given the following code snippet before the placeholder: <|code_start|># THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
EXAMPLE_VALUES = {
'boolean': ['0', '1', 'true', 'false'],
'categorical': ['Monday', 'June'],
'unbounded_categorical': ['CRM', '90210'],
'count': ['0', '1', '2', '3', '4'],
'real': ['-100.0', '1e-4'],
'sparse_real': ['0', '0', '0', '0', '123456.78', '0', '0', '0'],
'date': ['2014-03-31', '10pm, August 1, 1979'],
'text': ['This is a text feature.', 'Hello World!'],
'tags': ['', 'big_data machine_learning platform'],
}
for fluent_type, values in EXAMPLE_VALUES.items():
EXAMPLE_VALUES['optional_{}'.format(fluent_type)] = [''] + values
EXAMPLE_VALUES['id'] = ['any unique string can serve as an id']
FLUENT_TO_BASIC = {
<|code_end|>
, predict the next line using imports from the current file:
import os
import re
import datetime
import dateutil.parser
import loom.util
import loom.documented
import parsable
from itertools import izip
from collections import Counter
from contextlib2 import ExitStack
from distributions.io.stream import json_dump
from distributions.io.stream import json_load
from loom.util import cp_ns
from loom.util import LOG
from loom.util import parallel_map
from loom.util import pickle_dump
from loom.util import pickle_load
from loom.format import load_encoder
from loom.format import load_decoder
and context including class names, function names, and sometimes code from other files:
# Path: loom/util.py
# def cp_ns(source, destin):
# 'like cp -ns, link destin to source if destin does not exist'
# if not os.path.exists(destin):
# assert os.path.exists(source), source
# dirname = os.path.dirname(destin)
# if dirname:
# mkdir_p(dirname)
# try:
# os.symlink(source, destin)
# except OSError as e:
# if not os.path.exists(destin):
# raise e
#
# Path: loom/util.py
# def LOG(message):
# if VERBOSITY:
# sys.stdout.write('{}\n'.format(message))
# sys.stdout.flush()
#
# Path: loom/util.py
# def parallel_map(fun, args):
# if not isinstance(args, list):
# args = list(args)
# is_daemon = multiprocessing.current_process().daemon
# if THREADS == 1 or len(args) < 2 or is_daemon:
# print 'Running {} in this thread'.format(fun.__name__)
# return map(fun, args)
# else:
# print 'Running {} in {:d} threads'.format(fun.__name__, THREADS)
# pool = multiprocessing.Pool(THREADS)
# fun_args = [(fun, arg) for arg in args]
# return pool.map(print_trace, fun_args, chunksize=1)
#
# Path: loom/util.py
# def pickle_dump(data, filename):
# with open_compressed(filename, 'wb') as f:
# pickle.dump(data, f)
#
# Path: loom/util.py
# def pickle_load(filename):
# with open_compressed(filename, 'rb') as f:
# return pickle.load(f)
#
# Path: loom/format.py
# def load_encoder(encoder):
# model = encoder['model']
# if 'symbols' in encoder:
# encode = encoder['symbols'].__getitem__
# elif model == 'bb':
# encode = BOOLEAN_SYMBOLS.__getitem__
# else:
# encode = loom.schema.MODELS[model].Value
# return encode
#
# Path: loom/format.py
# def load_decoder(encoder):
# model = encoder['model']
# if 'symbols' in encoder:
# decoder = {value: key for key, value in encoder['symbols'].iteritems()}
# decode = decoder.__getitem__
# elif model == 'bb':
# decode = ('0', '1').__getitem__
# else:
# decode = str
# return decode
. Output only the next line. | 'boolean': 'bb', |
Given the code snippet: <|code_start|># notice, this list of conditions and the following disclaimer.
# - Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# - Neither the name of Salesforce.com nor the names of its contributors
# may be used to endorse or promote products derived from this
# software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
EXAMPLE_VALUES = {
'boolean': ['0', '1', 'true', 'false'],
'categorical': ['Monday', 'June'],
'unbounded_categorical': ['CRM', '90210'],
'count': ['0', '1', '2', '3', '4'],
'real': ['-100.0', '1e-4'],
'sparse_real': ['0', '0', '0', '0', '123456.78', '0', '0', '0'],
'date': ['2014-03-31', '10pm, August 1, 1979'],
<|code_end|>
, generate the next line using the imports in this file:
import os
import re
import datetime
import dateutil.parser
import loom.util
import loom.documented
import parsable
from itertools import izip
from collections import Counter
from contextlib2 import ExitStack
from distributions.io.stream import json_dump
from distributions.io.stream import json_load
from loom.util import cp_ns
from loom.util import LOG
from loom.util import parallel_map
from loom.util import pickle_dump
from loom.util import pickle_load
from loom.format import load_encoder
from loom.format import load_decoder
and context (functions, classes, or occasionally code) from other files:
# Path: loom/util.py
# def cp_ns(source, destin):
# 'like cp -ns, link destin to source if destin does not exist'
# if not os.path.exists(destin):
# assert os.path.exists(source), source
# dirname = os.path.dirname(destin)
# if dirname:
# mkdir_p(dirname)
# try:
# os.symlink(source, destin)
# except OSError as e:
# if not os.path.exists(destin):
# raise e
#
# Path: loom/util.py
# def LOG(message):
# if VERBOSITY:
# sys.stdout.write('{}\n'.format(message))
# sys.stdout.flush()
#
# Path: loom/util.py
# def parallel_map(fun, args):
# if not isinstance(args, list):
# args = list(args)
# is_daemon = multiprocessing.current_process().daemon
# if THREADS == 1 or len(args) < 2 or is_daemon:
# print 'Running {} in this thread'.format(fun.__name__)
# return map(fun, args)
# else:
# print 'Running {} in {:d} threads'.format(fun.__name__, THREADS)
# pool = multiprocessing.Pool(THREADS)
# fun_args = [(fun, arg) for arg in args]
# return pool.map(print_trace, fun_args, chunksize=1)
#
# Path: loom/util.py
# def pickle_dump(data, filename):
# with open_compressed(filename, 'wb') as f:
# pickle.dump(data, f)
#
# Path: loom/util.py
# def pickle_load(filename):
# with open_compressed(filename, 'rb') as f:
# return pickle.load(f)
#
# Path: loom/format.py
# def load_encoder(encoder):
# model = encoder['model']
# if 'symbols' in encoder:
# encode = encoder['symbols'].__getitem__
# elif model == 'bb':
# encode = BOOLEAN_SYMBOLS.__getitem__
# else:
# encode = loom.schema.MODELS[model].Value
# return encode
#
# Path: loom/format.py
# def load_decoder(encoder):
# model = encoder['model']
# if 'symbols' in encoder:
# decoder = {value: key for key, value in encoder['symbols'].iteritems()}
# decode = decoder.__getitem__
# elif model == 'bb':
# decode = ('0', '1').__getitem__
# else:
# decode = str
# return decode
. Output only the next line. | 'text': ['This is a text feature.', 'Hello World!'], |
Given the code snippet: <|code_start|># "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
EXAMPLE_VALUES = {
'boolean': ['0', '1', 'true', 'false'],
'categorical': ['Monday', 'June'],
'unbounded_categorical': ['CRM', '90210'],
'count': ['0', '1', '2', '3', '4'],
'real': ['-100.0', '1e-4'],
'sparse_real': ['0', '0', '0', '0', '123456.78', '0', '0', '0'],
'date': ['2014-03-31', '10pm, August 1, 1979'],
'text': ['This is a text feature.', 'Hello World!'],
'tags': ['', 'big_data machine_learning platform'],
}
for fluent_type, values in EXAMPLE_VALUES.items():
EXAMPLE_VALUES['optional_{}'.format(fluent_type)] = [''] + values
EXAMPLE_VALUES['id'] = ['any unique string can serve as an id']
FLUENT_TO_BASIC = {
'boolean': 'bb',
<|code_end|>
, generate the next line using the imports in this file:
import os
import re
import datetime
import dateutil.parser
import loom.util
import loom.documented
import parsable
from itertools import izip
from collections import Counter
from contextlib2 import ExitStack
from distributions.io.stream import json_dump
from distributions.io.stream import json_load
from loom.util import cp_ns
from loom.util import LOG
from loom.util import parallel_map
from loom.util import pickle_dump
from loom.util import pickle_load
from loom.format import load_encoder
from loom.format import load_decoder
and context (functions, classes, or occasionally code) from other files:
# Path: loom/util.py
# def cp_ns(source, destin):
# 'like cp -ns, link destin to source if destin does not exist'
# if not os.path.exists(destin):
# assert os.path.exists(source), source
# dirname = os.path.dirname(destin)
# if dirname:
# mkdir_p(dirname)
# try:
# os.symlink(source, destin)
# except OSError as e:
# if not os.path.exists(destin):
# raise e
#
# Path: loom/util.py
# def LOG(message):
# if VERBOSITY:
# sys.stdout.write('{}\n'.format(message))
# sys.stdout.flush()
#
# Path: loom/util.py
# def parallel_map(fun, args):
# if not isinstance(args, list):
# args = list(args)
# is_daemon = multiprocessing.current_process().daemon
# if THREADS == 1 or len(args) < 2 or is_daemon:
# print 'Running {} in this thread'.format(fun.__name__)
# return map(fun, args)
# else:
# print 'Running {} in {:d} threads'.format(fun.__name__, THREADS)
# pool = multiprocessing.Pool(THREADS)
# fun_args = [(fun, arg) for arg in args]
# return pool.map(print_trace, fun_args, chunksize=1)
#
# Path: loom/util.py
# def pickle_dump(data, filename):
# with open_compressed(filename, 'wb') as f:
# pickle.dump(data, f)
#
# Path: loom/util.py
# def pickle_load(filename):
# with open_compressed(filename, 'rb') as f:
# return pickle.load(f)
#
# Path: loom/format.py
# def load_encoder(encoder):
# model = encoder['model']
# if 'symbols' in encoder:
# encode = encoder['symbols'].__getitem__
# elif model == 'bb':
# encode = BOOLEAN_SYMBOLS.__getitem__
# else:
# encode = loom.schema.MODELS[model].Value
# return encode
#
# Path: loom/format.py
# def load_decoder(encoder):
# model = encoder['model']
# if 'symbols' in encoder:
# decoder = {value: key for key, value in encoder['symbols'].iteritems()}
# decode = decoder.__getitem__
# elif model == 'bb':
# decode = ('0', '1').__getitem__
# else:
# decode = str
# return decode
. Output only the next line. | 'categorical': 'dd', |
Given the code snippet: <|code_start|># THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
EXAMPLE_VALUES = {
'boolean': ['0', '1', 'true', 'false'],
'categorical': ['Monday', 'June'],
'unbounded_categorical': ['CRM', '90210'],
'count': ['0', '1', '2', '3', '4'],
'real': ['-100.0', '1e-4'],
'sparse_real': ['0', '0', '0', '0', '123456.78', '0', '0', '0'],
'date': ['2014-03-31', '10pm, August 1, 1979'],
'text': ['This is a text feature.', 'Hello World!'],
'tags': ['', 'big_data machine_learning platform'],
}
for fluent_type, values in EXAMPLE_VALUES.items():
EXAMPLE_VALUES['optional_{}'.format(fluent_type)] = [''] + values
EXAMPLE_VALUES['id'] = ['any unique string can serve as an id']
FLUENT_TO_BASIC = {
<|code_end|>
, generate the next line using the imports in this file:
import os
import re
import datetime
import dateutil.parser
import loom.util
import loom.documented
import parsable
from itertools import izip
from collections import Counter
from contextlib2 import ExitStack
from distributions.io.stream import json_dump
from distributions.io.stream import json_load
from loom.util import cp_ns
from loom.util import LOG
from loom.util import parallel_map
from loom.util import pickle_dump
from loom.util import pickle_load
from loom.format import load_encoder
from loom.format import load_decoder
and context (functions, classes, or occasionally code) from other files:
# Path: loom/util.py
# def cp_ns(source, destin):
# 'like cp -ns, link destin to source if destin does not exist'
# if not os.path.exists(destin):
# assert os.path.exists(source), source
# dirname = os.path.dirname(destin)
# if dirname:
# mkdir_p(dirname)
# try:
# os.symlink(source, destin)
# except OSError as e:
# if not os.path.exists(destin):
# raise e
#
# Path: loom/util.py
# def LOG(message):
# if VERBOSITY:
# sys.stdout.write('{}\n'.format(message))
# sys.stdout.flush()
#
# Path: loom/util.py
# def parallel_map(fun, args):
# if not isinstance(args, list):
# args = list(args)
# is_daemon = multiprocessing.current_process().daemon
# if THREADS == 1 or len(args) < 2 or is_daemon:
# print 'Running {} in this thread'.format(fun.__name__)
# return map(fun, args)
# else:
# print 'Running {} in {:d} threads'.format(fun.__name__, THREADS)
# pool = multiprocessing.Pool(THREADS)
# fun_args = [(fun, arg) for arg in args]
# return pool.map(print_trace, fun_args, chunksize=1)
#
# Path: loom/util.py
# def pickle_dump(data, filename):
# with open_compressed(filename, 'wb') as f:
# pickle.dump(data, f)
#
# Path: loom/util.py
# def pickle_load(filename):
# with open_compressed(filename, 'rb') as f:
# return pickle.load(f)
#
# Path: loom/format.py
# def load_encoder(encoder):
# model = encoder['model']
# if 'symbols' in encoder:
# encode = encoder['symbols'].__getitem__
# elif model == 'bb':
# encode = BOOLEAN_SYMBOLS.__getitem__
# else:
# encode = loom.schema.MODELS[model].Value
# return encode
#
# Path: loom/format.py
# def load_decoder(encoder):
# model = encoder['model']
# if 'symbols' in encoder:
# decoder = {value: key for key, value in encoder['symbols'].iteritems()}
# decode = decoder.__getitem__
# elif model == 'bb':
# decode = ('0', '1').__getitem__
# else:
# decode = str
# return decode
. Output only the next line. | 'boolean': 'bb', |
Given the following code snippet before the placeholder: <|code_start|>#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
parsable = parsable.Parsable()
EXAMPLE_VALUES = {
'boolean': ['0', '1', 'true', 'false'],
'categorical': ['Monday', 'June'],
'unbounded_categorical': ['CRM', '90210'],
'count': ['0', '1', '2', '3', '4'],
'real': ['-100.0', '1e-4'],
'sparse_real': ['0', '0', '0', '0', '123456.78', '0', '0', '0'],
'date': ['2014-03-31', '10pm, August 1, 1979'],
'text': ['This is a text feature.', 'Hello World!'],
'tags': ['', 'big_data machine_learning platform'],
}
for fluent_type, values in EXAMPLE_VALUES.items():
EXAMPLE_VALUES['optional_{}'.format(fluent_type)] = [''] + values
EXAMPLE_VALUES['id'] = ['any unique string can serve as an id']
<|code_end|>
, predict the next line using imports from the current file:
import os
import re
import datetime
import dateutil.parser
import loom.util
import loom.documented
import parsable
from itertools import izip
from collections import Counter
from contextlib2 import ExitStack
from distributions.io.stream import json_dump
from distributions.io.stream import json_load
from loom.util import cp_ns
from loom.util import LOG
from loom.util import parallel_map
from loom.util import pickle_dump
from loom.util import pickle_load
from loom.format import load_encoder
from loom.format import load_decoder
and context including class names, function names, and sometimes code from other files:
# Path: loom/util.py
# def cp_ns(source, destin):
# 'like cp -ns, link destin to source if destin does not exist'
# if not os.path.exists(destin):
# assert os.path.exists(source), source
# dirname = os.path.dirname(destin)
# if dirname:
# mkdir_p(dirname)
# try:
# os.symlink(source, destin)
# except OSError as e:
# if not os.path.exists(destin):
# raise e
#
# Path: loom/util.py
# def LOG(message):
# if VERBOSITY:
# sys.stdout.write('{}\n'.format(message))
# sys.stdout.flush()
#
# Path: loom/util.py
# def parallel_map(fun, args):
# if not isinstance(args, list):
# args = list(args)
# is_daemon = multiprocessing.current_process().daemon
# if THREADS == 1 or len(args) < 2 or is_daemon:
# print 'Running {} in this thread'.format(fun.__name__)
# return map(fun, args)
# else:
# print 'Running {} in {:d} threads'.format(fun.__name__, THREADS)
# pool = multiprocessing.Pool(THREADS)
# fun_args = [(fun, arg) for arg in args]
# return pool.map(print_trace, fun_args, chunksize=1)
#
# Path: loom/util.py
# def pickle_dump(data, filename):
# with open_compressed(filename, 'wb') as f:
# pickle.dump(data, f)
#
# Path: loom/util.py
# def pickle_load(filename):
# with open_compressed(filename, 'rb') as f:
# return pickle.load(f)
#
# Path: loom/format.py
# def load_encoder(encoder):
# model = encoder['model']
# if 'symbols' in encoder:
# encode = encoder['symbols'].__getitem__
# elif model == 'bb':
# encode = BOOLEAN_SYMBOLS.__getitem__
# else:
# encode = loom.schema.MODELS[model].Value
# return encode
#
# Path: loom/format.py
# def load_decoder(encoder):
# model = encoder['model']
# if 'symbols' in encoder:
# decoder = {value: key for key, value in encoder['symbols'].iteritems()}
# decode = decoder.__getitem__
# elif model == 'bb':
# decode = ('0', '1').__getitem__
# else:
# decode = str
# return decode
. Output only the next line. | FLUENT_TO_BASIC = { |
Next line prediction: <|code_start|># - Neither the name of Salesforce.com nor the names of its contributors
# may be used to endorse or promote products derived from this
# software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@for_each_dataset
def test_cat(name, **paths):
_test_cat(name, paths)
def _test_cat(name, paths):
for key, filename in loom.store.iter_paths(name, paths):
if os.path.isdir(filename) and not filename.startswith('test'):
for f in os.listdir(filename):
_test_cat('{}.{}'.format(name, key), os.path.join(filename, f))
else:
print '==== {} ===='.format(key)
<|code_end|>
. Use current file imports:
(import os
import loom.util
from loom.test.util import for_each_dataset)
and context including class names, function names, or small code snippets from other files:
# Path: loom/test/util.py
# def for_each_dataset(fun):
# @functools.wraps(fun)
# def test_one(dataset):
# paths = loom.store.get_paths(dataset, sample_count=2)
# for key, path in loom.store.iter_paths(dataset, paths):
# if not os.path.exists(path):
# raise ValueError(
# 'missing {} at {},\n first `python -m loom.datasets test`'
# .format(key, path))
# kwargs = {'name': dataset}
# kwargs.update(paths['query'])
# kwargs.update(paths['consensus'])
# kwargs.update(paths['samples'][0])
# kwargs.update(paths['ingest'])
# kwargs.update(paths)
# fun(**kwargs)
#
# @functools.wraps(fun)
# def test_all():
# for dataset in loom.datasets.TEST_CONFIGS:
# yield test_one, dataset
#
# return test_all
. Output only the next line. | loom.util.cat(filename) |
Predict the next line after this snippet: <|code_start|>def test_csv_short_row_error(**kwargs):
modify = lambda data: data + [data[1][:1]]
_test_modify_csv(modify, **kwargs)
@for_each_dataset
@raises(LoomError)
def test_csv_long_row_error(**kwargs):
modify = lambda data: data + [data[1] + data[1]]
_test_modify_csv(modify, **kwargs)
def _test_modify_schema(modify, name, schema, rows_csv, **unused):
with tempdir(cleanup_on_error=CLEANUP_ON_ERROR) as store:
with mock.patch('loom.store.STORE', new=store):
modified_schema = os.path.join(store, 'schema.json')
data = json_load(schema)
data = modify(data)
json_dump(data, modified_schema)
loom.tasks.ingest(name, modified_schema, rows_csv, debug=True)
@for_each_dataset
def test_schema_ok(**kwargs):
modify = lambda data: data
_test_modify_schema(modify, **kwargs)
@for_each_dataset
@raises(LoomError)
<|code_end|>
using the current file's imports:
import os
import csv
import mock
import numpy.random
import loom.store
import loom.format
import loom.datasets
import loom.tasks
from nose.tools import raises
from distributions.io.stream import open_compressed, json_load, json_dump
from loom.util import LoomError, tempdir
from loom.test.util import for_each_dataset, CLEANUP_ON_ERROR
and any relevant context from other files:
# Path: loom/util.py
# class LoomError(Exception):
# pass
#
# @contextlib.contextmanager
# def tempdir(cleanup_on_error=True):
# oldwd = os.getcwd()
# wd = tempfile.mkdtemp()
# try:
# os.chdir(wd)
# yield wd
# cleanup_on_error = True
# finally:
# os.chdir(oldwd)
# if cleanup_on_error:
# shutil.rmtree(wd)
#
# Path: loom/test/util.py
# def for_each_dataset(fun):
# @functools.wraps(fun)
# def test_one(dataset):
# paths = loom.store.get_paths(dataset, sample_count=2)
# for key, path in loom.store.iter_paths(dataset, paths):
# if not os.path.exists(path):
# raise ValueError(
# 'missing {} at {},\n first `python -m loom.datasets test`'
# .format(key, path))
# kwargs = {'name': dataset}
# kwargs.update(paths['query'])
# kwargs.update(paths['consensus'])
# kwargs.update(paths['samples'][0])
# kwargs.update(paths['ingest'])
# kwargs.update(paths)
# fun(**kwargs)
#
# @functools.wraps(fun)
# def test_all():
# for dataset in loom.datasets.TEST_CONFIGS:
# yield test_one, dataset
#
# return test_all
#
# CLEANUP_ON_ERROR = int(os.environ.get('CLEANUP_ON_ERROR', 1))
. Output only the next line. | def test_schema_empty_error(**kwargs): |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.