Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Predict the next line for this snippet: <|code_start|> open_mock = mock_open()
with patch("builtins.open", open_mock):
srt.return_value = ""
caption = Caption(
{
"url": "url1",
"name": {"simpleText": "name1"},
"languageCode": "en",
"vssId": ".en"
}
)
caption.download("title", filename_prefix="1 ")
assert (
open_mock.call_args_list[0][0][0].split(os.path.sep)[-1]
== "1 title (en).srt"
)
@mock.patch("pytube.captions.Caption.generate_srt_captions")
def test_download_with_output_path(srt):
open_mock = mock_open()
captions.target_directory = MagicMock(return_value="/target")
with patch("builtins.open", open_mock):
srt.return_value = ""
caption = Caption(
{
"url": "url1",
"name": {"simpleText": "name1"},
"languageCode": "en",
"vssId": ".en"
<|code_end|>
with the help of current file imports:
import os
import pytest
from unittest import mock
from unittest.mock import MagicMock, mock_open, patch
from pytube import Caption, CaptionQuery, captions
and context from other files:
# Path: pytube/captions.py
# class Caption:
# def __init__(self, caption_track: Dict):
# def xml_captions(self) -> str:
# def generate_srt_captions(self) -> str:
# def float_to_srt_time_format(d: float) -> str:
# def xml_caption_to_srt(self, xml_captions: str) -> str:
# def download(
# self,
# title: str,
# srt: bool = True,
# output_path: Optional[str] = None,
# filename_prefix: Optional[str] = None,
# ) -> str:
# def __repr__(self):
#
# Path: pytube/query.py
# class CaptionQuery(Mapping):
# """Interface for querying the available captions."""
#
# def __init__(self, captions: List[Caption]):
# """Construct a :class:`Caption <Caption>`.
#
# param list captions:
# list of :class:`Caption <Caption>` instances.
#
# """
# self.lang_code_index = {c.code: c for c in captions}
#
# @deprecated(
# "This object can be treated as a dictionary, i.e. captions['en']"
# )
# def get_by_language_code(
# self, lang_code: str
# ) -> Optional[Caption]: # pragma: no cover
# """Get the :class:`Caption <Caption>` for a given ``lang_code``.
#
# :param str lang_code:
# The code that identifies the caption language.
# :rtype: :class:`Caption <Caption>` or None
# :returns:
# The :class:`Caption <Caption>` matching the given ``lang_code`` or
# None if it does not exist.
# """
# return self.lang_code_index.get(lang_code)
#
# @deprecated("This object can be treated as a dictionary")
# def all(self) -> List[Caption]: # pragma: no cover
# """Get all the results represented by this query as a list.
#
# :rtype: list
#
# """
# return list(self.lang_code_index.values())
#
# def __getitem__(self, i: str):
# return self.lang_code_index[i]
#
# def __len__(self) -> int:
# return len(self.lang_code_index)
#
# def __iter__(self):
# return iter(self.lang_code_index.values())
#
# def __repr__(self) -> str:
# return f"{self.lang_code_index}"
, which may contain function names, class names, or code. Output only the next line. | } |
Given the code snippet: <|code_start|> captions.target_directory = MagicMock(return_value="/target")
with patch("builtins.open", open_mock):
srt.return_value = ""
caption = Caption(
{
"url": "url1",
"name": {"simpleText": "name1"},
"languageCode": "en",
"vssId": ".en"
}
)
file_path = caption.download("title", output_path="blah")
assert file_path == os.path.join("/target","title (en).srt")
captions.target_directory.assert_called_with("blah")
@mock.patch("pytube.captions.Caption.xml_captions")
def test_download_xml_and_trim_extension(xml):
open_mock = mock_open()
with patch("builtins.open", open_mock):
xml.return_value = ""
caption = Caption(
{
"url": "url1",
"name": {"simpleText": "name1"},
"languageCode": "en",
"vssId": ".en"
}
)
caption.download("title.xml", srt=False)
<|code_end|>
, generate the next line using the imports in this file:
import os
import pytest
from unittest import mock
from unittest.mock import MagicMock, mock_open, patch
from pytube import Caption, CaptionQuery, captions
and context (functions, classes, or occasionally code) from other files:
# Path: pytube/captions.py
# class Caption:
# def __init__(self, caption_track: Dict):
# def xml_captions(self) -> str:
# def generate_srt_captions(self) -> str:
# def float_to_srt_time_format(d: float) -> str:
# def xml_caption_to_srt(self, xml_captions: str) -> str:
# def download(
# self,
# title: str,
# srt: bool = True,
# output_path: Optional[str] = None,
# filename_prefix: Optional[str] = None,
# ) -> str:
# def __repr__(self):
#
# Path: pytube/query.py
# class CaptionQuery(Mapping):
# """Interface for querying the available captions."""
#
# def __init__(self, captions: List[Caption]):
# """Construct a :class:`Caption <Caption>`.
#
# param list captions:
# list of :class:`Caption <Caption>` instances.
#
# """
# self.lang_code_index = {c.code: c for c in captions}
#
# @deprecated(
# "This object can be treated as a dictionary, i.e. captions['en']"
# )
# def get_by_language_code(
# self, lang_code: str
# ) -> Optional[Caption]: # pragma: no cover
# """Get the :class:`Caption <Caption>` for a given ``lang_code``.
#
# :param str lang_code:
# The code that identifies the caption language.
# :rtype: :class:`Caption <Caption>` or None
# :returns:
# The :class:`Caption <Caption>` matching the given ``lang_code`` or
# None if it does not exist.
# """
# return self.lang_code_index.get(lang_code)
#
# @deprecated("This object can be treated as a dictionary")
# def all(self) -> List[Caption]: # pragma: no cover
# """Get all the results represented by this query as a list.
#
# :rtype: list
#
# """
# return list(self.lang_code_index.values())
#
# def __getitem__(self, i: str):
# return self.lang_code_index[i]
#
# def __len__(self) -> int:
# return len(self.lang_code_index)
#
# def __iter__(self):
# return iter(self.lang_code_index.values())
#
# def __repr__(self) -> str:
# return f"{self.lang_code_index}"
. Output only the next line. | assert ( |
Using the snippet: <|code_start|> srt.return_value = ""
caption = Caption(
{
"url": "url1",
"name": {"simpleText": "name1"},
"languageCode": "en",
"vssId": ".en"
}
)
caption.download("title")
assert (
open_mock.call_args_list[0][0][0].split(os.path.sep)[-1] == "title (en).srt"
)
@mock.patch("pytube.captions.Caption.generate_srt_captions")
def test_download_with_prefix(srt):
open_mock = mock_open()
with patch("builtins.open", open_mock):
srt.return_value = ""
caption = Caption(
{
"url": "url1",
"name": {"simpleText": "name1"},
"languageCode": "en",
"vssId": ".en"
}
)
caption.download("title", filename_prefix="1 ")
assert (
<|code_end|>
, determine the next line of code. You have imports:
import os
import pytest
from unittest import mock
from unittest.mock import MagicMock, mock_open, patch
from pytube import Caption, CaptionQuery, captions
and context (class names, function names, or code) available:
# Path: pytube/captions.py
# class Caption:
# def __init__(self, caption_track: Dict):
# def xml_captions(self) -> str:
# def generate_srt_captions(self) -> str:
# def float_to_srt_time_format(d: float) -> str:
# def xml_caption_to_srt(self, xml_captions: str) -> str:
# def download(
# self,
# title: str,
# srt: bool = True,
# output_path: Optional[str] = None,
# filename_prefix: Optional[str] = None,
# ) -> str:
# def __repr__(self):
#
# Path: pytube/query.py
# class CaptionQuery(Mapping):
# """Interface for querying the available captions."""
#
# def __init__(self, captions: List[Caption]):
# """Construct a :class:`Caption <Caption>`.
#
# param list captions:
# list of :class:`Caption <Caption>` instances.
#
# """
# self.lang_code_index = {c.code: c for c in captions}
#
# @deprecated(
# "This object can be treated as a dictionary, i.e. captions['en']"
# )
# def get_by_language_code(
# self, lang_code: str
# ) -> Optional[Caption]: # pragma: no cover
# """Get the :class:`Caption <Caption>` for a given ``lang_code``.
#
# :param str lang_code:
# The code that identifies the caption language.
# :rtype: :class:`Caption <Caption>` or None
# :returns:
# The :class:`Caption <Caption>` matching the given ``lang_code`` or
# None if it does not exist.
# """
# return self.lang_code_index.get(lang_code)
#
# @deprecated("This object can be treated as a dictionary")
# def all(self) -> List[Caption]: # pragma: no cover
# """Get all the results represented by this query as a list.
#
# :rtype: list
#
# """
# return list(self.lang_code_index.values())
#
# def __getitem__(self, i: str):
# return self.lang_code_index[i]
#
# def __len__(self) -> int:
# return len(self.lang_code_index)
#
# def __iter__(self):
# return iter(self.lang_code_index.values())
#
# def __repr__(self) -> str:
# return f"{self.lang_code_index}"
. Output only the next line. | open_mock.call_args_list[0][0][0].split(os.path.sep)[-1] |
Given the code snippet: <|code_start|>
def test_map_functions():
with pytest.raises(RegexMatchError):
cipher.map_functions("asdf")
def test_get_initial_function_name_with_no_match_should_error():
with pytest.raises(RegexMatchError):
cipher.get_initial_function_name("asdf")
def test_get_transform_object_with_no_match_should_error():
with pytest.raises(RegexMatchError):
cipher.get_transform_object("asdf", var="lt")
def test_reverse():
reversed_array = cipher.reverse([1, 2, 3, 4], None)
assert reversed_array == [4, 3, 2, 1]
def test_splice():
assert cipher.splice([1, 2, 3, 4], 2) == [3, 4]
assert cipher.splice([1, 2, 3, 4], 1) == [2, 3, 4]
def test_throttling_reverse():
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from pytube import cipher
from pytube.exceptions import RegexMatchError
and context (functions, classes, or occasionally code) from other files:
# Path: pytube/cipher.py
# class Cipher:
# def __init__(self, js: str):
# def calculate_n(self, initial_n: list):
# def get_signature(self, ciphered_signature: str) -> str:
# def parse_function(self, js_func: str) -> Tuple[str, int]:
# def get_initial_function_name(js: str) -> str:
# def get_transform_plan(js: str) -> List[str]:
# def get_transform_object(js: str, var: str) -> List[str]:
# def get_transform_map(js: str, var: str) -> Dict:
# def get_throttling_function_name(js: str) -> str:
# def get_throttling_function_code(js: str) -> str:
# def get_throttling_function_array(js: str) -> List[Any]:
# def get_throttling_plan(js: str):
# def reverse(arr: List, _: Optional[Any]):
# def splice(arr: List, b: int):
# def swap(arr: List, b: int):
# def throttling_reverse(arr: list):
# def throttling_push(d: list, e: Any):
# def throttling_mod_func(d: list, e: int):
# def throttling_unshift(d: list, e: int):
# def throttling_cipher_function(d: list, e: str):
# def throttling_nested_splice(d: list, e: int):
# def throttling_prepend(d: list, e: int):
# def throttling_swap(d: list, e: int):
# def js_splice(arr: list, start: int, delete_count=None, *items):
# def map_functions(js_func: str) -> Callable:
#
# Path: pytube/exceptions.py
# class RegexMatchError(ExtractError):
# """Regex pattern did not return any matches."""
#
# def __init__(self, caller: str, pattern: Union[str, Pattern]):
# """
# :param str caller:
# Calling function
# :param str pattern:
# Pattern that failed to match
# """
# super().__init__(f"{caller}: could not find match for {pattern}")
# self.caller = caller
# self.pattern = pattern
. Output only the next line. | a = [1, 2, 3, 4] |
Using the snippet: <|code_start|>
def test_throttling_prepend():
a = [1, 2, 3, 4]
cipher.throttling_prepend(a, 1)
assert a == [4, 1, 2, 3]
a = [1, 2, 3, 4]
cipher.throttling_prepend(a, 2)
assert a == [3, 4, 1, 2]
def test_throttling_swap():
a = [1, 2, 3, 4]
cipher.throttling_swap(a, 3)
assert a == [4, 2, 3, 1]
def test_js_splice():
mapping = {
}
for args, result in mapping.items():
a = [1, 2, 3, 4]
assert cipher.js_splice(a, *args) == result
def test_get_throttling_function_name(base_js):
# Values expected as of 2022/02/04:
raw_var = r'var Apa=[hha]'
assert raw_var in base_js
<|code_end|>
, determine the next line of code. You have imports:
import pytest
from pytube import cipher
from pytube.exceptions import RegexMatchError
and context (class names, function names, or code) available:
# Path: pytube/cipher.py
# class Cipher:
# def __init__(self, js: str):
# def calculate_n(self, initial_n: list):
# def get_signature(self, ciphered_signature: str) -> str:
# def parse_function(self, js_func: str) -> Tuple[str, int]:
# def get_initial_function_name(js: str) -> str:
# def get_transform_plan(js: str) -> List[str]:
# def get_transform_object(js: str, var: str) -> List[str]:
# def get_transform_map(js: str, var: str) -> Dict:
# def get_throttling_function_name(js: str) -> str:
# def get_throttling_function_code(js: str) -> str:
# def get_throttling_function_array(js: str) -> List[Any]:
# def get_throttling_plan(js: str):
# def reverse(arr: List, _: Optional[Any]):
# def splice(arr: List, b: int):
# def swap(arr: List, b: int):
# def throttling_reverse(arr: list):
# def throttling_push(d: list, e: Any):
# def throttling_mod_func(d: list, e: int):
# def throttling_unshift(d: list, e: int):
# def throttling_cipher_function(d: list, e: str):
# def throttling_nested_splice(d: list, e: int):
# def throttling_prepend(d: list, e: int):
# def throttling_swap(d: list, e: int):
# def js_splice(arr: list, start: int, delete_count=None, *items):
# def map_functions(js_func: str) -> Callable:
#
# Path: pytube/exceptions.py
# class RegexMatchError(ExtractError):
# """Regex pattern did not return any matches."""
#
# def __init__(self, caller: str, pattern: Union[str, Pattern]):
# """
# :param str caller:
# Calling function
# :param str pattern:
# Pattern that failed to match
# """
# super().__init__(f"{caller}: could not find match for {pattern}")
# self.caller = caller
# self.pattern = pattern
. Output only the next line. | raw_code = r'a.url="";a.C&&(b=a.get("n"))&&(b=Apa[0](b),a.set("n",b),'\ |
Predict the next line for this snippet: <|code_start|> PreferencesDialog.setWindowModality(QtCore.Qt.WindowModal)
PreferencesDialog.resize(719, 528)
self.verticalLayout_5 = QtWidgets.QVBoxLayout(PreferencesDialog)
self.verticalLayout_5.setObjectName("verticalLayout_5")
self.tabsPreferences = QtWidgets.QTabWidget(PreferencesDialog)
self.tabsPreferences.setTabPosition(QtWidgets.QTabWidget.North)
self.tabsPreferences.setObjectName("tabsPreferences")
self.tabSearch = QtWidgets.QWidget()
self.tabSearch.setLayoutDirection(QtCore.Qt.LeftToRight)
self.tabSearch.setObjectName("tabSearch")
self.horizontalLayout_3 = QtWidgets.QVBoxLayout(self.tabSearch)
self.horizontalLayout_3.setObjectName("horizontalLayout_3")
self.groupBoxSearchLanguages = QtWidgets.QGroupBox(self.tabSearch)
self.groupBoxSearchLanguages.setObjectName("groupBoxSearchLanguages")
self.verticalLayout_6 = QtWidgets.QVBoxLayout(self.groupBoxSearchLanguages)
self.verticalLayout_6.setObjectName("verticalLayout_6")
self.scrollAreaSearch = QtWidgets.QScrollArea(self.groupBoxSearchLanguages)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.MinimumExpanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.scrollAreaSearch.sizePolicy().hasHeightForWidth())
self.scrollAreaSearch.setSizePolicy(sizePolicy)
self.scrollAreaSearch.setMinimumSize(QtCore.QSize(0, 150))
self.scrollAreaSearch.setWidgetResizable(True)
self.scrollAreaSearch.setObjectName("scrollAreaSearch")
self.scrollAreaWidgetSearch = QtWidgets.QWidget()
self.scrollAreaWidgetSearch.setGeometry(QtCore.QRect(0, 0, 655, 372))
self.scrollAreaWidgetSearch.setObjectName("scrollAreaWidgetSearch")
self.vbox_B = QtWidgets.QVBoxLayout(self.scrollAreaWidgetSearch)
self.vbox_B.setObjectName("vbox_B")
<|code_end|>
with the help of current file imports:
from PyQt5 import QtCore, QtGui, QtWidgets
from subdownloader.client.gui.views.language import InterfaceLanguageComboBox, LanguageComboBox
from subdownloader.client.gui.views.provider import ProviderComboBox
and context from other files:
# Path: subdownloader/client/gui/views/language.py
# class InterfaceLanguageComboBox(AbstractLanguageComboBox):
# def legal_languages(self):
# return [Language.from_locale(locale) for locale in i18n_get_supported_locales()]
#
# class LanguageComboBox(AbstractLanguageComboBox):
# def legal_languages(self):
# return [l for l in legal_languages()]
#
# Path: subdownloader/client/gui/views/provider.py
# class ProviderComboBox(QComboBox):
# selected_provider_state_changed = pyqtSignal(_Optional)
#
# def __init__(self, parent):
# QComboBox.__init__(self, parent)
# self._model = ProviderModel()
# self._current_provider_state = None
#
# self.setup_ui()
#
# def set_general_text(self, general_text):
# self._model.set_general_text(general_text)
#
# def set_general_visible(self, general_visible):
# self._model.set_general_visible(general_visible)
#
# def set_filter_enable(self, filter_enable):
# self._model.set_filter_enable(filter_enable)
#
# def set_state(self, state):
# current_index = self.currentIndex()
# self._model.set_state(state)
# if current_index >= self._model.rowCount():
# current_index = self._model.rowCount() - 1
# self.setCurrentIndex(current_index)
#
# def set_selected_provider(self, provider):
# index = self._model.index_of_provider(provider)
# if index is not None:
# self.setCurrentIndex(index)
#
# def get_selected_provider_state(self):
# return self._current_provider_state
#
# def setup_ui(self):
# self.setModel(self._model)
#
# self.setIconSize(QSize(16, 16))
#
# self.setCurrentIndex(0)
# self._current_provider_state = self._model.provider_state_at_index(self.currentIndex())
#
# self.currentIndexChanged.connect(self.onCurrentIndexChanged)
#
# @pyqtSlot(int)
# def onCurrentIndexChanged(self, index):
# self._current_provider_state = self._model.provider_state_at_index(index)
# self.selected_provider_state_changed.emit(_Optional(self._current_provider_state))
, which may contain function names, class names, or code. Output only the next line. | self.scrollAreaWidgetLayoutSearch = QtWidgets.QGridLayout() |
Next line prediction: <|code_start|> self.verticalLayout_5.setObjectName("verticalLayout_5")
self.tabsPreferences = QtWidgets.QTabWidget(PreferencesDialog)
self.tabsPreferences.setTabPosition(QtWidgets.QTabWidget.North)
self.tabsPreferences.setObjectName("tabsPreferences")
self.tabSearch = QtWidgets.QWidget()
self.tabSearch.setLayoutDirection(QtCore.Qt.LeftToRight)
self.tabSearch.setObjectName("tabSearch")
self.horizontalLayout_3 = QtWidgets.QVBoxLayout(self.tabSearch)
self.horizontalLayout_3.setObjectName("horizontalLayout_3")
self.groupBoxSearchLanguages = QtWidgets.QGroupBox(self.tabSearch)
self.groupBoxSearchLanguages.setObjectName("groupBoxSearchLanguages")
self.verticalLayout_6 = QtWidgets.QVBoxLayout(self.groupBoxSearchLanguages)
self.verticalLayout_6.setObjectName("verticalLayout_6")
self.scrollAreaSearch = QtWidgets.QScrollArea(self.groupBoxSearchLanguages)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.MinimumExpanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.scrollAreaSearch.sizePolicy().hasHeightForWidth())
self.scrollAreaSearch.setSizePolicy(sizePolicy)
self.scrollAreaSearch.setMinimumSize(QtCore.QSize(0, 150))
self.scrollAreaSearch.setWidgetResizable(True)
self.scrollAreaSearch.setObjectName("scrollAreaSearch")
self.scrollAreaWidgetSearch = QtWidgets.QWidget()
self.scrollAreaWidgetSearch.setGeometry(QtCore.QRect(0, 0, 655, 372))
self.scrollAreaWidgetSearch.setObjectName("scrollAreaWidgetSearch")
self.vbox_B = QtWidgets.QVBoxLayout(self.scrollAreaWidgetSearch)
self.vbox_B.setObjectName("vbox_B")
self.scrollAreaWidgetLayoutSearch = QtWidgets.QGridLayout()
self.scrollAreaWidgetLayoutSearch.setObjectName("scrollAreaWidgetLayoutSearch")
self.vbox_B.addLayout(self.scrollAreaWidgetLayoutSearch)
<|code_end|>
. Use current file imports:
(from PyQt5 import QtCore, QtGui, QtWidgets
from subdownloader.client.gui.views.language import InterfaceLanguageComboBox, LanguageComboBox
from subdownloader.client.gui.views.provider import ProviderComboBox)
and context including class names, function names, or small code snippets from other files:
# Path: subdownloader/client/gui/views/language.py
# class InterfaceLanguageComboBox(AbstractLanguageComboBox):
# def legal_languages(self):
# return [Language.from_locale(locale) for locale in i18n_get_supported_locales()]
#
# class LanguageComboBox(AbstractLanguageComboBox):
# def legal_languages(self):
# return [l for l in legal_languages()]
#
# Path: subdownloader/client/gui/views/provider.py
# class ProviderComboBox(QComboBox):
# selected_provider_state_changed = pyqtSignal(_Optional)
#
# def __init__(self, parent):
# QComboBox.__init__(self, parent)
# self._model = ProviderModel()
# self._current_provider_state = None
#
# self.setup_ui()
#
# def set_general_text(self, general_text):
# self._model.set_general_text(general_text)
#
# def set_general_visible(self, general_visible):
# self._model.set_general_visible(general_visible)
#
# def set_filter_enable(self, filter_enable):
# self._model.set_filter_enable(filter_enable)
#
# def set_state(self, state):
# current_index = self.currentIndex()
# self._model.set_state(state)
# if current_index >= self._model.rowCount():
# current_index = self._model.rowCount() - 1
# self.setCurrentIndex(current_index)
#
# def set_selected_provider(self, provider):
# index = self._model.index_of_provider(provider)
# if index is not None:
# self.setCurrentIndex(index)
#
# def get_selected_provider_state(self):
# return self._current_provider_state
#
# def setup_ui(self):
# self.setModel(self._model)
#
# self.setIconSize(QSize(16, 16))
#
# self.setCurrentIndex(0)
# self._current_provider_state = self._model.provider_state_at_index(self.currentIndex())
#
# self.currentIndexChanged.connect(self.onCurrentIndexChanged)
#
# @pyqtSlot(int)
# def onCurrentIndexChanged(self, index):
# self._current_provider_state = self._model.provider_state_at_index(index)
# self.selected_provider_state_changed.emit(_Optional(self._current_provider_state))
. Output only the next line. | self.scrollAreaSearch.setWidget(self.scrollAreaWidgetSearch) |
Predict the next line for this snippet: <|code_start|> self.optionSubFnSame = QtWidgets.QRadioButton(self.groupBoxSubFn)
self.optionSubFnSame.setChecked(True)
self.optionSubFnSame.setObjectName("optionSubFnSame")
self.verticalLayout_2.addWidget(self.optionSubFnSame)
self.optionSubFnSameLang = QtWidgets.QRadioButton(self.groupBoxSubFn)
self.optionSubFnSameLang.setChecked(False)
self.optionSubFnSameLang.setObjectName("optionSubFnSameLang")
self.verticalLayout_2.addWidget(self.optionSubFnSameLang)
self.optionSubFnSameLangUploader = QtWidgets.QRadioButton(self.groupBoxSubFn)
self.optionSubFnSameLangUploader.setChecked(False)
self.optionSubFnSameLangUploader.setObjectName("optionSubFnSameLangUploader")
self.verticalLayout_2.addWidget(self.optionSubFnSameLangUploader)
self.optionSubFnOnline = QtWidgets.QRadioButton(self.groupBoxSubFn)
self.optionSubFnOnline.setObjectName("optionSubFnOnline")
self.verticalLayout_2.addWidget(self.optionSubFnOnline)
self.verticalLayout.addWidget(self.groupBoxSubFn)
self.tabsPreferences.addTab(self.tabDownload, "")
self.tabUpload = QtWidgets.QWidget()
self.tabUpload.setObjectName("tabUpload")
self.verticalLayout_7 = QtWidgets.QVBoxLayout(self.tabUpload)
self.verticalLayout_7.setObjectName("verticalLayout_7")
self.uploadFrame = QtWidgets.QFrame(self.tabUpload)
self.uploadFrame.setObjectName("uploadFrame")
self.formLayout_2 = QtWidgets.QFormLayout(self.uploadFrame)
self.formLayout_2.setObjectName("formLayout_2")
self.textUlDefaultLanguage = QtWidgets.QLabel(self.uploadFrame)
self.textUlDefaultLanguage.setMinimumSize(QtCore.QSize(339, 0))
self.textUlDefaultLanguage.setObjectName("textUlDefaultLanguage")
self.formLayout_2.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.textUlDefaultLanguage)
self.optionUlDefaultLanguage = LanguageComboBox(self.uploadFrame)
<|code_end|>
with the help of current file imports:
from PyQt5 import QtCore, QtGui, QtWidgets
from subdownloader.client.gui.views.language import InterfaceLanguageComboBox, LanguageComboBox
from subdownloader.client.gui.views.provider import ProviderComboBox
and context from other files:
# Path: subdownloader/client/gui/views/language.py
# class InterfaceLanguageComboBox(AbstractLanguageComboBox):
# def legal_languages(self):
# return [Language.from_locale(locale) for locale in i18n_get_supported_locales()]
#
# class LanguageComboBox(AbstractLanguageComboBox):
# def legal_languages(self):
# return [l for l in legal_languages()]
#
# Path: subdownloader/client/gui/views/provider.py
# class ProviderComboBox(QComboBox):
# selected_provider_state_changed = pyqtSignal(_Optional)
#
# def __init__(self, parent):
# QComboBox.__init__(self, parent)
# self._model = ProviderModel()
# self._current_provider_state = None
#
# self.setup_ui()
#
# def set_general_text(self, general_text):
# self._model.set_general_text(general_text)
#
# def set_general_visible(self, general_visible):
# self._model.set_general_visible(general_visible)
#
# def set_filter_enable(self, filter_enable):
# self._model.set_filter_enable(filter_enable)
#
# def set_state(self, state):
# current_index = self.currentIndex()
# self._model.set_state(state)
# if current_index >= self._model.rowCount():
# current_index = self._model.rowCount() - 1
# self.setCurrentIndex(current_index)
#
# def set_selected_provider(self, provider):
# index = self._model.index_of_provider(provider)
# if index is not None:
# self.setCurrentIndex(index)
#
# def get_selected_provider_state(self):
# return self._current_provider_state
#
# def setup_ui(self):
# self.setModel(self._model)
#
# self.setIconSize(QSize(16, 16))
#
# self.setCurrentIndex(0)
# self._current_provider_state = self._model.provider_state_at_index(self.currentIndex())
#
# self.currentIndexChanged.connect(self.onCurrentIndexChanged)
#
# @pyqtSlot(int)
# def onCurrentIndexChanged(self, index):
# self._current_provider_state = self._model.provider_state_at_index(index)
# self.selected_provider_state_changed.emit(_Optional(self._current_provider_state))
, which may contain function names, class names, or code. Output only the next line. | sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed) |
Predict the next line for this snippet: <|code_start|># -*- coding: utf-8 -*-
# Copyright (c) 2019 SubDownloader Developers - See COPYING - GPLv3
class ImdbSearchModel(QAbstractTableModel):
NB_COLS = 2
COL_IMDB_ID = 0
<|code_end|>
with the help of current file imports:
from subdownloader.provider.imdb import ImdbMovieMatch
from typing import Optional, Sequence
from PyQt5.QtCore import QModelIndex, QObject, Qt, QAbstractTableModel
and context from other files:
# Path: subdownloader/provider/imdb.py
# class ImdbMovieMatch:
# def __init__(self, imdb_id: str, title: str, year: Optional[int]):
# self.imdb_id = imdb_id
# self.title = title
# self.year = year
#
# @property
# def url(self) -> str:
# return 'https://www.imdb.com/title/{}'.format(self.imdb_id)
#
# @property
# def title_year(self) -> str:
# return '{}{}'.format(self.title, ' ({})'.format(self.year) if self.year is not None else '')
#
# def serialize(self) -> str:
# year_str = '' if self.year is None else str(self.year)
# return '{},{},{}'.format(self.imdb_id, year_str, self.title)
#
# @classmethod
# def deserialize(cls, data: str) -> Optional['ImdbMovieMatch']:
# try:
# [imdb_id, year_str, title] = data.split(',', 2)
# year = int(year_str.strip()) if year_str else None
# return cls(imdb_id.strip(), title.strip(), year)
# except ValueError:
# return None
, which may contain function names, class names, or code. Output only the next line. | COL_NAME = 1 |
Based on the snippet: <|code_start|>
def __init__(self, parent):
QComboBox.__init__(self, parent)
self._model = ProviderModel()
self._current_provider_state = None
self.setup_ui()
def set_general_text(self, general_text):
self._model.set_general_text(general_text)
def set_general_visible(self, general_visible):
self._model.set_general_visible(general_visible)
def set_filter_enable(self, filter_enable):
self._model.set_filter_enable(filter_enable)
def set_state(self, state):
current_index = self.currentIndex()
self._model.set_state(state)
if current_index >= self._model.rowCount():
current_index = self._model.rowCount() - 1
self.setCurrentIndex(current_index)
def set_selected_provider(self, provider):
index = self._model.index_of_provider(provider)
if index is not None:
self.setCurrentIndex(index)
def get_selected_provider_state(self):
<|code_end|>
, predict the immediate next line with the help of imports:
import logging
from subdownloader.client.gui.models.provider import ProviderModel
from PyQt5.QtCore import pyqtSignal, pyqtSlot, QSize
from PyQt5.QtWidgets import QComboBox
and context (classes, functions, sometimes code) from other files:
# Path: subdownloader/client/gui/models/provider.py
# class ProviderModel(QAbstractListModel):
# def __init__(self, general_text_visible=True, general_text=None):
# QAbstractListModel.__init__(self)
# self._state = None
# self._filter_enable = True
# self._general_visible = general_text_visible
# self._callback = ProviderStateModelCallback(self)
# if general_text is None:
# general_text = 'GENERAL_TEXT'
# self._general_text = general_text
#
# def underlying_data_changed(self):
# self.dataChanged.emit(self.index(0), self.index(self.rowCount(QModelIndex())))
#
# def set_general_visible(self, general_visible):
# if self._general_visible == general_visible:
# return
#
# if general_visible:
# self.beginInsertRows(QModelIndex(), 0, 0)
# self._general_visible = general_visible
# self.endInsertRows()
# else:
# self.beginRemoveRows(QModelIndex(), 0, 0)
# self._general_visible = general_visible
# self.endRemoveRows()
#
# def set_filter_enable(self, filter_enable):
# if self._filter_enable != filter_enable:
# self.beginResetModel()
# self._filter_enable = filter_enable
# self.endResetModel()
#
# def set_general_text(self, general_text):
# self._general_text = general_text
# if self._general_visible:
# index = self.index(0)
# self.dataChanged.emit(index, index)
#
# def set_state(self, state):
# dx = 1 if self._general_visible else 0
# if self._state:
# self._state.remove_callback(self._callback)
# self.beginRemoveRows(QModelIndex(), dx, dx + self.rowCount(QModelIndex()))
# self._state = None
# self.endRemoveRows()
#
# if state is None:
# return
#
# self._state = state
# self._state.providers.add_callback(self._callback)
# self.beginInsertRows(QModelIndex(), dx, dx + self.rowCount(QModelIndex()))
# self.endInsertRows()
#
# def provider_state_at_index(self, index):
# if self._general_visible:
# if index == 0:
# return None
# index -= 1
#
# if self._state is None:
# return None
# if self._filter_enable:
# return self._state.providers.get(index)
# else:
# return self._state.providers.all_states[index]
#
# def data(self, index, role=None):
# if not index.isValid():
# return None
# provider_state = self.provider_state_at_index(index.row())
#
# if provider_state is None:
# if role == Qt.FontRole:
# font = QFont()
# font.setItalic(True)
# return font
# elif role == Qt.DisplayRole:
# return self._general_text
# else:
# if role == Qt.UserRole:
# return provider_state
# elif role == Qt.DecorationRole:
# path = provider_state.provider.get_icon()
# if path:
# return QIcon(path)
# else:
# return None
# elif role == Qt.TextColorRole:
# if not provider_state.getEnabled():
# color = QColor(Qt.lightGray)
# return color
# elif role == Qt.DisplayRole:
# return provider_state.provider.get_name()
#
# return None
#
# def index(self, row, column=0, parent=QModelIndex()):
# if row < 0 or column < 0:
# return QModelIndex()
#
# if row == 0:
# return self.createIndex(row, column, None)
#
# if self._state is None:
# return QModelIndex()
#
# if row > self._state.providers.get_number_providers():
# return QModelIndex()
#
# if not parent.isValid():
# return self.createIndex(row, column, None)
#
# return QModelIndex()
#
# def index_of_provider(self, provider):
# if self._state is None:
# return None
# if self._filter_enable:
# providers = list(ps.provider for ps in self._state.providers.get_providers())
# else:
# providers = list(ps.provider for ps in self._state.providers.all_states)
# if self._general_visible:
# providers.insert(0, None)
# try:
# return providers.index(provider)
# except ValueError:
# return None
#
# def headerData(self, *args, **kwargs):
# return None
#
# def rowCount(self, parent=None, *args, **kwargs):
# if self._state is None:
# return 1 if self._general_visible else 0
#
# if parent is None or not parent.isValid():
# if self._filter_enable:
# nb = self._state.providers.get_number_providers()
# else:
# nb = len(self._state.providers.all_states)
# if self._general_visible:
# nb += 1
# return nb
# return 0
. Output only the next line. | return self._current_provider_state |
Given the following code snippet before the placeholder: <|code_start|> @classmethod
def local_search(cls, provider):
try:
module_name = 'subdownloader.provider.{provider}'.format(provider=provider)
log.debug('Attempting to import "{}"...'.format(module_name))
provider_module = importlib.import_module(module_name)
log.debug('... OK')
except ImportError:
log.debug('... FAILED')
raise NoProviderException('Unknown provider "{}"'.format(provider))
try:
log.debug('Attempting to get "providers" from module...')
provider_classes = provider_module.providers
log.debug('... OK')
except AttributeError:
log.debug('... FAILED')
raise NoProviderException('"{}" must provide a "providers" attribute'.format(provider))
log.debug('Checking provider types:')
for provider_class in provider_classes:
log.debug('- {}:'.format(provider_class))
if not issubclass(provider_class, SubtitleProvider):
log.debug('... FAILED: not a SubtitleProvider')
raise NoProviderException('Provider must subclass SubtitleProvider')
log.debug('... OK')
return provider_classes
@classmethod
def list(cls):
providers = []
provider_path = Path(__file__).parent
<|code_end|>
, predict the next line using imports from the current file:
import importlib
import logging
from pathlib import Path
from subdownloader.provider.provider import SubtitleProvider
and context including class names, function names, and sometimes code from other files:
# Path: subdownloader/provider/provider.py
# class SubtitleProvider(object):
# """
# Represents an abstract SubtitleProvider..
# """
# # FIXME: add documentation
#
# def __init__(self):
# pass
#
# def __del__(self):
# try:
# self.disconnect()
# except ProviderConnectionError:
# log.debug('Disconnect failed during destructor', exc_info=sys.exc_info())
#
# def get_settings(self):
# raise NotImplementedError()
#
# def set_settings(self, settings):
# raise NotImplementedError()
#
# def connect(self):
# raise NotImplementedError()
#
# def disconnect(self):
# raise NotImplementedError()
#
# def connected(self):
# raise NotImplementedError()
#
# def login(self):
# raise NotImplementedError()
#
# def logout(self):
# raise NotImplementedError()
#
# def logged_in(self):
# raise NotImplementedError()
#
# def search_videos(self, videos, callback, language=None):
# raise NotImplementedError()
#
# def query_text(self, query):
# raise NotImplementedError()
#
# def upload_subtitles(self, local_movie):
# raise NotImplementedError()
#
# def ping(self):
# raise NotImplementedError()
#
# def provider_info(self):
# raise NotImplementedError()
#
# # @classmethod
# # def supports_mode(cls, method):
# # raise NotImplementedError()
#
# @classmethod
# def get_name(cls):
# raise NotImplementedError()
#
# @classmethod
# def get_short_name(cls):
# raise NotImplementedError()
#
# @classmethod
# def get_icon(cls):
# raise NotImplementedError()
. Output only the next line. | for file in provider_path.iterdir(): |
Given snippet: <|code_start|># -*- coding: utf-8 -*-
# Copyright (c) 2019 SubDownloader Developers - See COPYING - GPLv3
try:
def langdetect_detect(*args):
try:
return detect(*args)
except LangDetectException:
return UnknownLanguage.create_generic()
except ImportError:
def langdetect_detect(*args):
return UnknownLanguage.create_generic()
log = logging.getLogger("subdownloader.languages.language")
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import itertools
import logging
from langdetect import detect
from langdetect.lang_detect_exception import LangDetectException
from subdownloader.util import asciify
and context:
# Path: subdownloader/util.py
# def asciify(data):
# """
# Limit the byte data string to only ascii characters and convert it to a string.
# Non-representable characters are dropped.
# :param data: byte data string to convert to ascii
# :return: string
# """
# return ''.join(map(chr, filter(lambda x : x < 128, data)))
which might include code, classes, or functions. Output only the next line. | class NotALanguageException(ValueError): |
Here is a snippet: <|code_start|>
def sort(self, column, reverse=False):
def vs_getitem(vs, column):
if column == UploadDataCollection.COL_VIDEO:
return vs.video
else: # column == UploadDataCollection.COL_SUBTITLE:
return vs.subtitle
data = self._local_movie.get_data()
l = [(i, vs) for (i, vs) in enumerate(data) if vs_getitem(vs, column)]
index_upl = sorted(l, key=lambda d: vs_getitem(d[1], column).get_filename(), reverse=reverse)
data = [d for i, d in index_upl]
none_keys = set(range(len(data))) - set(i for i, d in index_upl)
data += [data[i] for i in none_keys]
self._local_movie.set_data(data)
def insert_count(self, row, count):
data = self._local_movie.get_data()
data = data[:row] + [VideoSubtitle() for _ in range(count)] + data[row:]
self._local_movie.set_data(data)
def remove_count(self, row, count):
data = self._local_movie.get_data()
data = data[:row] + data[(row + count):]
self._local_movie.set_data(data)
def remove_rows(self, rows):
data = self._local_movie.get_data()
new_rows = set(range(len(self))) - set(rows)
<|code_end|>
. Write the next line using the current file imports:
import logging
from subdownloader.movie import LocalMovie, VideoSubtitle
from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot, QAbstractTableModel, QModelIndex
and context from other files:
# Path: subdownloader/movie.py
# class LocalMovie(object):
# def __init__(self):
# self._movie_name = None
# self._imdb_id = None
# self._language = UnknownLanguage.create_generic()
# self._release_name = None
# self._comments = None
# self._author = None
#
# self._hearing_impaired = None
# self._high_definition = None
# self._foreign_only = None
# self._automatic_translation = None
#
# self._data = []
#
# def add_video_subtitle(self, video, subtitle):
# self._data.append(VideoSubtitle(video, subtitle))
#
# def check(self):
# video_paths = set()
# subtitle_paths = set()
# for data in self._data:
# if not data.check():
# return False
# vfp = str(data.video.get_filepath().resolve())
# if vfp in video_paths:
# return False
# video_paths.add(vfp)
#
# sfp = str(data.subtitle.get_filepath().resolve())
# if sfp in subtitle_paths:
# return False
# if self._language.is_generic():
# return False
# return True
#
# def get_data(self):
# return self._data
#
# def set_data(self, data):
# self._data = data
#
# def iter_video_subtitles(self):
# for d in self._data:
# yield d.video, d.subtitle
#
# def set_movie_name(self, movie_name):
# self._movie_name = movie_name
#
# def get_movie_name(self):
# return self._movie_name
#
# def set_imdb_id(self, imdb_id):
# self._imdb_id = imdb_id
#
# def get_imdb_id(self):
# return self._imdb_id
#
# def set_language(self, language):
# self._language = language
#
# def get_language(self):
# return self._language
#
# def set_release_name(self, release_name):
# self._release_name = release_name
#
# def get_release_name(self):
# return self._release_name
#
# def set_comments(self, comments):
# self._comments = comments
#
# def get_comments(self):
# return self._comments
#
# def set_author(self, author):
# self._author = author
#
# def get_author(self):
# return self._author
#
# def set_hearing_impaired(self, hearing_impaired):
# self._hearing_impaired = hearing_impaired
#
# def is_hearing_impaired(self):
# return self._hearing_impaired
#
# def set_high_definition(self, high_definition):
# self._high_definition = high_definition
#
# def is_high_definition(self):
# return self._high_definition
#
# def set_foreign_only(self, foreign_only):
# self._foreign_only = foreign_only
#
# def is_foreign_only(self):
# return self._foreign_only
#
# def set_automatic_translation(self, automatic_translation):
# self._automatic_translation = automatic_translation
#
# def is_automatic_translation(self):
# return self._automatic_translation
#
# class VideoSubtitle(object):
# def __init__(self, video=None, subtitle=None):
# self.video = video
# self.subtitle = subtitle
#
# def check(self):
# if not self.video or not self.video.exists():
# return False
# if not self.subtitle or not self.subtitle.exists():
# return False
# return True
, which may include functions, classes, or code. Output only the next line. | data = [data[row] for row in new_rows] |
Here is a snippet: <|code_start|> index_upl = sorted(l, key=lambda d: vs_getitem(d[1], column).get_filename(), reverse=reverse)
data = [d for i, d in index_upl]
none_keys = set(range(len(data))) - set(i for i, d in index_upl)
data += [data[i] for i in none_keys]
self._local_movie.set_data(data)
def insert_count(self, row, count):
data = self._local_movie.get_data()
data = data[:row] + [VideoSubtitle() for _ in range(count)] + data[row:]
self._local_movie.set_data(data)
def remove_count(self, row, count):
data = self._local_movie.get_data()
data = data[:row] + data[(row + count):]
self._local_movie.set_data(data)
def remove_rows(self, rows):
data = self._local_movie.get_data()
new_rows = set(range(len(self))) - set(rows)
data = [data[row] for row in new_rows]
self._local_movie.set_data(data)
def move_row(self, row_from, row_to):
data = self._local_movie.get_data()
data_row = [data[row_from]]
data = data[:row_from] + data[row_from+1:]
data = data[:row_to] + data_row + data[row_to:]
self._local_movie.set_data(data)
def is_valid(self):
<|code_end|>
. Write the next line using the current file imports:
import logging
from subdownloader.movie import LocalMovie, VideoSubtitle
from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot, QAbstractTableModel, QModelIndex
and context from other files:
# Path: subdownloader/movie.py
# class LocalMovie(object):
# def __init__(self):
# self._movie_name = None
# self._imdb_id = None
# self._language = UnknownLanguage.create_generic()
# self._release_name = None
# self._comments = None
# self._author = None
#
# self._hearing_impaired = None
# self._high_definition = None
# self._foreign_only = None
# self._automatic_translation = None
#
# self._data = []
#
# def add_video_subtitle(self, video, subtitle):
# self._data.append(VideoSubtitle(video, subtitle))
#
# def check(self):
# video_paths = set()
# subtitle_paths = set()
# for data in self._data:
# if not data.check():
# return False
# vfp = str(data.video.get_filepath().resolve())
# if vfp in video_paths:
# return False
# video_paths.add(vfp)
#
# sfp = str(data.subtitle.get_filepath().resolve())
# if sfp in subtitle_paths:
# return False
# if self._language.is_generic():
# return False
# return True
#
# def get_data(self):
# return self._data
#
# def set_data(self, data):
# self._data = data
#
# def iter_video_subtitles(self):
# for d in self._data:
# yield d.video, d.subtitle
#
# def set_movie_name(self, movie_name):
# self._movie_name = movie_name
#
# def get_movie_name(self):
# return self._movie_name
#
# def set_imdb_id(self, imdb_id):
# self._imdb_id = imdb_id
#
# def get_imdb_id(self):
# return self._imdb_id
#
# def set_language(self, language):
# self._language = language
#
# def get_language(self):
# return self._language
#
# def set_release_name(self, release_name):
# self._release_name = release_name
#
# def get_release_name(self):
# return self._release_name
#
# def set_comments(self, comments):
# self._comments = comments
#
# def get_comments(self):
# return self._comments
#
# def set_author(self, author):
# self._author = author
#
# def get_author(self):
# return self._author
#
# def set_hearing_impaired(self, hearing_impaired):
# self._hearing_impaired = hearing_impaired
#
# def is_hearing_impaired(self):
# return self._hearing_impaired
#
# def set_high_definition(self, high_definition):
# self._high_definition = high_definition
#
# def is_high_definition(self):
# return self._high_definition
#
# def set_foreign_only(self, foreign_only):
# self._foreign_only = foreign_only
#
# def is_foreign_only(self):
# return self._foreign_only
#
# def set_automatic_translation(self, automatic_translation):
# self._automatic_translation = automatic_translation
#
# def is_automatic_translation(self):
# return self._automatic_translation
#
# class VideoSubtitle(object):
# def __init__(self, video=None, subtitle=None):
# self.video = video
# self.subtitle = subtitle
#
# def check(self):
# if not self.video or not self.video.exists():
# return False
# if not self.subtitle or not self.subtitle.exists():
# return False
# return True
, which may include functions, classes, or code. Output only the next line. | data = self._local_movie.get_data() |
Given snippet: <|code_start|> self.label_filterBy.setFont(font)
self.label_filterBy.setObjectName("label_filterBy")
self.layoutTopVideos.addWidget(self.label_filterBy)
self.filterLanguageForVideo = LanguageComboBox(self.pageSearchResult)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.filterLanguageForVideo.sizePolicy().hasHeightForWidth())
self.filterLanguageForVideo.setSizePolicy(sizePolicy)
self.filterLanguageForVideo.setMinimumSize(QtCore.QSize(100, 0))
self.filterLanguageForVideo.setObjectName("filterLanguageForVideo")
self.layoutTopVideos.addWidget(self.filterLanguageForVideo)
self.layoutTopVideos.setStretch(3, 1)
self.verticalLayout_12.addLayout(self.layoutTopVideos)
self.videoView = QtWidgets.QTreeView(self.pageSearchResult)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.videoView.sizePolicy().hasHeightForWidth())
self.videoView.setSizePolicy(sizePolicy)
self.videoView.setObjectName("videoView")
self.verticalLayout_12.addWidget(self.videoView)
self.layoutBottomVideos = QtWidgets.QHBoxLayout()
self.layoutBottomVideos.setContentsMargins(-1, -1, -1, 0)
self.layoutBottomVideos.setObjectName("layoutBottomVideos")
self.buttonIMDB = QtWidgets.QPushButton(self.pageSearchResult)
self.buttonIMDB.setEnabled(False)
icon3 = QtGui.QIcon()
icon3.addPixmap(QtGui.QPixmap(":/images/info.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.buttonIMDB.setIcon(icon3)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from PyQt5 import QtCore, QtGui, QtWidgets
from subdownloader.client.gui.views.language import LanguageComboBox
and context:
# Path: subdownloader/client/gui/views/language.py
# class LanguageComboBox(AbstractLanguageComboBox):
# def legal_languages(self):
# return [l for l in legal_languages()]
which might include code, classes, or functions. Output only the next line. | self.buttonIMDB.setIconSize(QtCore.QSize(32, 16)) |
Predict the next line after this snippet: <|code_start|># -*- coding: utf-8 -*-
# Copyright (c) 2019 SubDownloader Developers - See COPYING - GPLv3
log = logging.getLogger('subdownloader.client.callback')
class ClientCallback(ProgressCallback):
def __init__(self, minimum=None, maximum=None):
ProgressCallback.__init__(self, minimum=minimum, maximum=maximum)
self._block = False
self._label_text = ''
self._title_text = ''
self._updated_text = ''
self._finished_text = ''
<|code_end|>
using the current file's imports:
import logging
from subdownloader.callback import ProgressCallback
and any relevant context from other files:
# Path: subdownloader/callback.py
# class ProgressCallback(object):
# """
# This class allows calling function to be informed of eventual progress.
# Subclasses should only override the on_*** function members.
# """
# def __init__(self, minimum=None, maximum=None):
# """
# Create a a new ProgressCallback object.
# :param minimum: minimum value of the range (None if no percentage is required)
# :param maximum: maximum value of the range (None if no percentage is required)
# """
# log.debug('init: min={min}, max={max}'.format(min=minimum, max=maximum))
# self._min = minimum
# self._max = maximum
#
# self._canceled = False
# self._finished = False
#
# def range_initialized(self):
# """
# Check whether a range is set.
# """
# return None not in self.get_range()
#
# def set_range(self, minimum, maximum):
# """
# Set a range.
# The range is passed unchanged to the rangeChanged member function.
# :param minimum: minimum value of the range (None if no percentage is required)
# :param maximum: maximum value of the range (None if no percentage is required)
# """
# self._min = minimum
# self._max = maximum
# self.on_rangeChange(minimum, maximum)
#
# def get_range(self):
# """
# Returns the minimum and maximum
# :return: A tuple with the minimum and maximum
# """
# return self._min, self._max
#
# def get_child_progress(self, parent_min, parent_max):
# """
# Create a new child ProgressCallback.
# Minimum and maximum values of the child are mapped to parent_min and parent_max of this parent ProgressCallback.
# :param parent_min: minimum value of the child is mapped to parent_min of this parent ProgressCallback
# :param parent_max: maximum value of the child is mapped to parent_max of this parent ProgressCallback
# :return: instance of SubProgressCallback
# """
# return SubProgressCallback(parent=self, parent_min=parent_min, parent_max=parent_max)
#
# def update(self, value, *args, **kwargs):
# """
# Call this function to inform that an update is available.
# This function does NOT call finish when value == maximum.
# :param value: The current index/position of the action. (Should be, but must not be, in the range [min, max])
# :param args: extra positional arguments to pass on
# :param kwargs: extra keyword arguments to pass on
# """
# log.debug('update(value={value}, args={args}, kwargs={kwargs})'.format(value=value, args=args, kwargs=kwargs))
# self.on_update(value, *args, **kwargs)
#
# def finish(self, *args, **kwargs):
# """
# Call this function to inform that the operation is finished.
# :param args: extra positional arguments to pass on
# :param kwargs: extra keyword arguments to pass on
# """
# log.debug('finish(args={args}, kwargs={kwargs})'.format(args=args, kwargs=kwargs))
# self._finished = True
# self.on_finish(*args, **kwargs)
#
# def cancel(self):
# """
# Call this function to inform that the operation has been cancelled.
# """
# log.debug('cancel()')
# self._canceled = True
# self.on_cancel()
#
# def on_rangeChange(self, minimum, maximum):
# """
# Override this function if a custom action is required upon range change.
# :param minimum: New minimum value
# :param maximum: New maximum value
# """
# pass
#
# def on_update(self, value, *args, **kwargs):
# """
# Override this function if a custom update action is required.
# :param value: The current index/position of the action. (Should be, but must not be, in the range [min, max])
# :param args: extra positional arguments to pass on
# :param kwargs: extra keyword arguments to pass on
# """
# pass
#
# def on_finish(self, *args, **kwargs):
# """
# Override this function if a custom finish action is required.
# :param args: extra positional arguments to pass on
# :param kwargs: extra keyword arguments to pass on
# """
# pass
#
# def on_cancel(self):
# """
# Override this function if a custom cancel action is required
# """
# pass
#
# def canceled(self):
# """
# Return true when the progress has been canceled.
# :return: Boolean value
# """
# return self._canceled
#
# def finished(self):
# """
# Return true when the progress has been finished.
# :return: Boolean value
# """
# return self._finished
. Output only the next line. | self._cancellable = True |
Continue the code snippet: <|code_start|># -*- coding: utf-8 -*-
# Copyright (c) 2019 SubDownloader Developers - See COPYING - GPLv3
class VideoSubtitle(object):
def __init__(self, video=None, subtitle=None):
self.video = video
self.subtitle = subtitle
def check(self):
if not self.video or not self.video.exists():
return False
if not self.subtitle or not self.subtitle.exists():
return False
return True
class LocalMovie(object):
def __init__(self):
self._movie_name = None
self._imdb_id = None
self._language = UnknownLanguage.create_generic()
self._release_name = None
self._comments = None
self._author = None
<|code_end|>
. Use current file imports:
from subdownloader.identification import MovieMatch
from subdownloader.languages.language import UnknownLanguage
from subdownloader.subtitle2 import SubtitleFileCollection
from subdownloader.identification import Identities
and context (classes, functions, or code) from other files:
# Path: subdownloader/identification.py
# class MovieMatch(Enum):
# Equal = True
# NonEqual = False
# Unknown = None
#
# def __and__(self, other):
# if type(self) != type(other):
# return MovieMatch.Unknown
#
# sv = self.value
# ov = other.value
#
# if sv == MovieMatch.NonEqual or ov == MovieMatch.NonEqual:
# return MovieMatch.NonEqual
#
# if sv == MovieMatch.Equal or ov == MovieMatch.Equal:
# return MovieMatch.Equal
#
# return MovieMatch.Unknown
#
# Path: subdownloader/languages/language.py
# class UnknownLanguage(Language):
# def __init__(self, code):
# Language.__init__(self, 0)
# self._code = code
#
# # FIXME: better name for & check generic logic
#
# @classmethod
# def create_generic(cls):
# """
# Return a UnknownLanguage instance..
# :return: UnknownLanguage instance.
# """
# return cls('unknown') # NO internationalization!
#
# def name(self):
# """
# Return readable name of Language. Contains info about the unknown Language.
# :return: Readable name as string
# """
# return _(self._code)
#
# def generic_name(self):
# """
# Return readable name of Language. Contains no info about the unknown Language.
# :return: Readable name as string
# """
# return Language.name(self)
#
# def is_generic(self):
# return self._code == 'unknown' # NO internationalization!
#
# def __eq__(self, other):
# """
# Tests if other has the same type of this and the same unknown language code.
# :return: True if other is of the same type and has the same unknown language code
# """
# if not Language.__eq__(self, other):
# return False
# return self._code == other._code
#
# def __hash__(self):
# """
# Return hash of this object.
# :return: hash integer
# """
# return hash((self._id, self._code))
#
# def __repr__(self):
# """
# Return representation of this instance
# :return: string representation of self
# """
# return '<UnknownLanguage:code={code}>'.format(code=self._code)
#
# Path: subdownloader/subtitle2.py
# class SubtitleFileCollection(object):
# def __init__(self, parent):
# self._parent = parent
# self._networks = []
# self._candidates = []
#
# def get_parent(self):
# return self._parent
#
# def get_subtitle_networks(self):
# return self._networks
#
# def add_subtitle(self, subtitle, priority=False):
# for network in self._networks:
# if network.equals_subtitle_file(subtitle):
# network.add_subtitle(subtitle, priority=priority)
# return
# for candidate in self._candidates:
# if candidate.equals_subtitle_file(subtitle):
# network = SubtitleFileNetwork(parent=self, subtitle_file=subtitle)
# network.add_subtitle(candidate.get_subtitles()[0])
# if priority:
# self._networks.insert(0, network)
# else:
# self._networks.append(network)
# self._candidates.remove(candidate)
# return
# network = SubtitleFileNetwork(parent=self, subtitle_file=subtitle)
# if priority:
# self._networks.insert(0, network)
# else:
# self._networks.append(network)
#
# def add_candidates(self, subtitles):
# for subtitle in subtitles:
# for candidate in self._candidates:
# if candidate.equals_subtitle_file(subtitle):
# candidate.add_subtitle(subtitle, reparent=False)
# break
# new_candidate = SubtitleFileNetwork(parent=self, subtitle_file=subtitle, reparent=False)
# self._candidates.append(new_candidate)
#
# def iter_local_subtitles(self):
# for network in self._networks:
# for subtitle in network.iter_local_subtitles():
# yield subtitle
#
# def get_nb_subtitles(self):
# return sum(len(network) for network in self._networks)
#
# def __len__(self):
# return len(self._networks)
#
# def __getitem__(self, item):
# return self._networks[item]
. Output only the next line. | self._hearing_impaired = None |
Predict the next line after this snippet: <|code_start|> subtitle_paths = set()
for data in self._data:
if not data.check():
return False
vfp = str(data.video.get_filepath().resolve())
if vfp in video_paths:
return False
video_paths.add(vfp)
sfp = str(data.subtitle.get_filepath().resolve())
if sfp in subtitle_paths:
return False
if self._language.is_generic():
return False
return True
def get_data(self):
return self._data
def set_data(self, data):
self._data = data
def iter_video_subtitles(self):
for d in self._data:
yield d.video, d.subtitle
def set_movie_name(self, movie_name):
self._movie_name = movie_name
def get_movie_name(self):
<|code_end|>
using the current file's imports:
from subdownloader.identification import MovieMatch
from subdownloader.languages.language import UnknownLanguage
from subdownloader.subtitle2 import SubtitleFileCollection
from subdownloader.identification import Identities
and any relevant context from other files:
# Path: subdownloader/identification.py
# class MovieMatch(Enum):
# Equal = True
# NonEqual = False
# Unknown = None
#
# def __and__(self, other):
# if type(self) != type(other):
# return MovieMatch.Unknown
#
# sv = self.value
# ov = other.value
#
# if sv == MovieMatch.NonEqual or ov == MovieMatch.NonEqual:
# return MovieMatch.NonEqual
#
# if sv == MovieMatch.Equal or ov == MovieMatch.Equal:
# return MovieMatch.Equal
#
# return MovieMatch.Unknown
#
# Path: subdownloader/languages/language.py
# class UnknownLanguage(Language):
# def __init__(self, code):
# Language.__init__(self, 0)
# self._code = code
#
# # FIXME: better name for & check generic logic
#
# @classmethod
# def create_generic(cls):
# """
# Return a UnknownLanguage instance..
# :return: UnknownLanguage instance.
# """
# return cls('unknown') # NO internationalization!
#
# def name(self):
# """
# Return readable name of Language. Contains info about the unknown Language.
# :return: Readable name as string
# """
# return _(self._code)
#
# def generic_name(self):
# """
# Return readable name of Language. Contains no info about the unknown Language.
# :return: Readable name as string
# """
# return Language.name(self)
#
# def is_generic(self):
# return self._code == 'unknown' # NO internationalization!
#
# def __eq__(self, other):
# """
# Tests if other has the same type of this and the same unknown language code.
# :return: True if other is of the same type and has the same unknown language code
# """
# if not Language.__eq__(self, other):
# return False
# return self._code == other._code
#
# def __hash__(self):
# """
# Return hash of this object.
# :return: hash integer
# """
# return hash((self._id, self._code))
#
# def __repr__(self):
# """
# Return representation of this instance
# :return: string representation of self
# """
# return '<UnknownLanguage:code={code}>'.format(code=self._code)
#
# Path: subdownloader/subtitle2.py
# class SubtitleFileCollection(object):
# def __init__(self, parent):
# self._parent = parent
# self._networks = []
# self._candidates = []
#
# def get_parent(self):
# return self._parent
#
# def get_subtitle_networks(self):
# return self._networks
#
# def add_subtitle(self, subtitle, priority=False):
# for network in self._networks:
# if network.equals_subtitle_file(subtitle):
# network.add_subtitle(subtitle, priority=priority)
# return
# for candidate in self._candidates:
# if candidate.equals_subtitle_file(subtitle):
# network = SubtitleFileNetwork(parent=self, subtitle_file=subtitle)
# network.add_subtitle(candidate.get_subtitles()[0])
# if priority:
# self._networks.insert(0, network)
# else:
# self._networks.append(network)
# self._candidates.remove(candidate)
# return
# network = SubtitleFileNetwork(parent=self, subtitle_file=subtitle)
# if priority:
# self._networks.insert(0, network)
# else:
# self._networks.append(network)
#
# def add_candidates(self, subtitles):
# for subtitle in subtitles:
# for candidate in self._candidates:
# if candidate.equals_subtitle_file(subtitle):
# candidate.add_subtitle(subtitle, reparent=False)
# break
# new_candidate = SubtitleFileNetwork(parent=self, subtitle_file=subtitle, reparent=False)
# self._candidates.append(new_candidate)
#
# def iter_local_subtitles(self):
# for network in self._networks:
# for subtitle in network.iter_local_subtitles():
# yield subtitle
#
# def get_nb_subtitles(self):
# return sum(len(network) for network in self._networks)
#
# def __len__(self):
# return len(self._networks)
#
# def __getitem__(self, item):
# return self._networks[item]
. Output only the next line. | return self._movie_name |
Here is a snippet: <|code_start|> identity.merge(movie.get_identities())
return identity
def movies(self):
return self._movies
def get_subtitles(self):
return self._subtitles
def search_more_subtitles(self):
found_new = False
for movie, query in zip(self._movies, self._queries):
new_subs = query.search_more_subtitles(movie)
for new_sub in new_subs:
self._subtitles.add_subtitle(new_sub)
if new_subs:
found_new = True
return found_new
class RemoteMovieCollection(object):
def __init__(self):
self._movie_networks = []
def add_movie(self, movie, query):
m_identities = movie.get_identities()
for movie_network in self._movie_networks:
match_identity = m_identities.matches_identity(movie_network.get_identities())
if match_identity == MovieMatch.Equal:
movie_network.add_movie(movie, query)
<|code_end|>
. Write the next line using the current file imports:
from subdownloader.identification import MovieMatch
from subdownloader.languages.language import UnknownLanguage
from subdownloader.subtitle2 import SubtitleFileCollection
from subdownloader.identification import Identities
and context from other files:
# Path: subdownloader/identification.py
# class MovieMatch(Enum):
# Equal = True
# NonEqual = False
# Unknown = None
#
# def __and__(self, other):
# if type(self) != type(other):
# return MovieMatch.Unknown
#
# sv = self.value
# ov = other.value
#
# if sv == MovieMatch.NonEqual or ov == MovieMatch.NonEqual:
# return MovieMatch.NonEqual
#
# if sv == MovieMatch.Equal or ov == MovieMatch.Equal:
# return MovieMatch.Equal
#
# return MovieMatch.Unknown
#
# Path: subdownloader/languages/language.py
# class UnknownLanguage(Language):
# def __init__(self, code):
# Language.__init__(self, 0)
# self._code = code
#
# # FIXME: better name for & check generic logic
#
# @classmethod
# def create_generic(cls):
# """
# Return a UnknownLanguage instance..
# :return: UnknownLanguage instance.
# """
# return cls('unknown') # NO internationalization!
#
# def name(self):
# """
# Return readable name of Language. Contains info about the unknown Language.
# :return: Readable name as string
# """
# return _(self._code)
#
# def generic_name(self):
# """
# Return readable name of Language. Contains no info about the unknown Language.
# :return: Readable name as string
# """
# return Language.name(self)
#
# def is_generic(self):
# return self._code == 'unknown' # NO internationalization!
#
# def __eq__(self, other):
# """
# Tests if other has the same type of this and the same unknown language code.
# :return: True if other is of the same type and has the same unknown language code
# """
# if not Language.__eq__(self, other):
# return False
# return self._code == other._code
#
# def __hash__(self):
# """
# Return hash of this object.
# :return: hash integer
# """
# return hash((self._id, self._code))
#
# def __repr__(self):
# """
# Return representation of this instance
# :return: string representation of self
# """
# return '<UnknownLanguage:code={code}>'.format(code=self._code)
#
# Path: subdownloader/subtitle2.py
# class SubtitleFileCollection(object):
# def __init__(self, parent):
# self._parent = parent
# self._networks = []
# self._candidates = []
#
# def get_parent(self):
# return self._parent
#
# def get_subtitle_networks(self):
# return self._networks
#
# def add_subtitle(self, subtitle, priority=False):
# for network in self._networks:
# if network.equals_subtitle_file(subtitle):
# network.add_subtitle(subtitle, priority=priority)
# return
# for candidate in self._candidates:
# if candidate.equals_subtitle_file(subtitle):
# network = SubtitleFileNetwork(parent=self, subtitle_file=subtitle)
# network.add_subtitle(candidate.get_subtitles()[0])
# if priority:
# self._networks.insert(0, network)
# else:
# self._networks.append(network)
# self._candidates.remove(candidate)
# return
# network = SubtitleFileNetwork(parent=self, subtitle_file=subtitle)
# if priority:
# self._networks.insert(0, network)
# else:
# self._networks.append(network)
#
# def add_candidates(self, subtitles):
# for subtitle in subtitles:
# for candidate in self._candidates:
# if candidate.equals_subtitle_file(subtitle):
# candidate.add_subtitle(subtitle, reparent=False)
# break
# new_candidate = SubtitleFileNetwork(parent=self, subtitle_file=subtitle, reparent=False)
# self._candidates.append(new_candidate)
#
# def iter_local_subtitles(self):
# for network in self._networks:
# for subtitle in network.iter_local_subtitles():
# yield subtitle
#
# def get_nb_subtitles(self):
# return sum(len(network) for network in self._networks)
#
# def __len__(self):
# return len(self._networks)
#
# def __getitem__(self, item):
# return self._networks[item]
, which may include functions, classes, or code. Output only the next line. | else: |
Using the snippet: <|code_start|># -*- coding: utf-8 -*-
# Copyright (c) 2019 SubDownloader Developers - See COPYING - GPLv3
log = logging.getLogger('subdownloader.client.gui.models.provider')
class ProviderStateModelCallback(ProviderStateCallback):
def __init__(self, provider_model):
ProviderStateCallback.__init__(self)
self._provider_model = provider_model
def __getattribute__(self, item):
if item.startswith('on_'):
item = '_func'
return object.__getattribute__(self, item)
def _func(self, *args, **kwargs):
self._provider_model.underlying_data_changed()
class ProviderModel(QAbstractListModel):
<|code_end|>
, determine the next line of code. You have imports:
import logging
from subdownloader.client.state import ProviderStateCallback
from PyQt5.QtCore import QAbstractListModel, QModelIndex, Qt
from PyQt5.QtGui import QColor, QFont, QIcon
and context (class names, function names, or code) available:
# Path: subdownloader/client/state.py
# class ProviderStateCallback(object):
#
# class Stage(Enum):
# Started = 'started'
# Busy = 'busy'
# Finished = 'finished'
#
# def __init__(self):
# pass
#
# def on_connect(self, stage):
# pass
#
# def on_disconnect(self, stage):
# pass
#
# def on_login(self, stage):
# pass
#
# def on_logout(self, stage):
# pass
#
# def on_change(self):
# pass
. Output only the next line. | def __init__(self, general_text_visible=True, general_text=None): |
Predict the next line for this snippet: <|code_start|> def __del__(self):
self.status_progress.close()
del self.status_progress
def set_block(self, block):
self._block = block
def set_title_text(self, title_text):
self._title_text = title_text
def set_label_text(self, label_text):
self._label_text = label_text
def set_updated_text(self, updated_text):
self._updated_text = updated_text
def set_finished_text(self, finished_label):
self._finished_text = finished_label
def set_cancellable(self, cancellable):
if not self._cancellable and cancellable:
log.warning('ProgressCallbackWidget.set_cancellable({cancellable}): invalid operation'.format(
cancellable=cancellable))
if cancellable:
if not self._cancellable:
self.status_progress.setCancelButton(QPushButton(_('Cancel')))
else:
self.status_progress.setCancelButton(None)
self._cancellable = cancellable
<|code_end|>
with the help of current file imports:
import logging
from subdownloader.client.callback import ClientCallback
from PyQt5.QtCore import QCoreApplication, Qt
from PyQt5.QtWidgets import QPushButton, QProgressDialog
and context from other files:
# Path: subdownloader/client/callback.py
# class ClientCallback(ProgressCallback):
# def __init__(self, minimum=None, maximum=None):
# ProgressCallback.__init__(self, minimum=minimum, maximum=maximum)
#
# self._block = False
#
# self._label_text = ''
# self._title_text = ''
# self._updated_text = ''
# self._finished_text = ''
# self._cancellable = True
#
# def set_block(self, block):
# self._block = block
#
# def set_title_text(self, title_text):
# self._title_text = title_text
#
# def set_label_text(self, label_text):
# self._label_text = label_text
#
# def set_updated_text(self, updated_text):
# self._updated_text = updated_text
#
# def set_finished_text(self, finished_label):
# self._finished_text = finished_label
#
# def set_cancellable(self, cancellable):
# self._cancellable = cancellable
#
# def show(self):
# log.debug('show()')
# self.on_show()
#
# def on_show(self):
# pass
, which may contain function names, class names, or code. Output only the next line. | def on_show(self): |
Given snippet: <|code_start|># -*- coding: utf-8 -*-
# Copyright (c) 2019 SubDownloader Developers - See COPYING - GPLv3
class ImdbListView(QTableView):
def __init__(self, parent=None):
QTableView.__init__(self, parent)
self._imdb_model = ImdbSearchModel()
self.setup_ui()
def setup_ui(self):
self.setModel(self._imdb_model)
self.setSelectionMode(QTableView.SingleSelection)
self.setSelectionBehavior(QTableView.SelectRows)
self.setGridStyle(Qt.DotLine)
self.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from typing import Optional, Sequence
from subdownloader.client.gui.models.imdbSearchModel import ImdbSearchModel
from subdownloader.provider.imdb import ImdbMovieMatch
from PyQt5.QtCore import pyqtSignal, pyqtSlot, Qt
from PyQt5.QtWidgets import QHeaderView, QTableView
and context:
# Path: subdownloader/client/gui/models/imdbSearchModel.py
# class ImdbSearchModel(QAbstractTableModel):
# NB_COLS = 2
# COL_IMDB_ID = 0
# COL_NAME = 1
#
# def __init__(self, parent: QObject=None):
# QAbstractTableModel.__init__(self, parent)
# self._imdb_data = []
# self._headers = None
#
# def set_imdb_data(self, imdb_data: Sequence[ImdbMovieMatch]) -> None:
# self.beginResetModel()
# self._imdb_data = list(imdb_data)
# self.endResetModel()
#
# def rowCount(self, parent: QModelIndex=None) -> int:
# return len(self._imdb_data)
#
# def columnCount(self, parent: QModelIndex=None) -> int:
# return self.NB_COLS
#
# def data(self, index: QModelIndex, role=None) -> Optional[str]:
# row, col = index.row(), index.column()
# if role == Qt.DisplayRole:
# imdb = self._imdb_data[row]
# if col == self.COL_IMDB_ID:
# return imdb.imdb_id
# else: # if col == self.COL_NAME:
# return imdb.title_year
#
# return None
#
# def get_imdb_at_row(self, row: int) -> ImdbMovieMatch:
# return self._imdb_data[row]
#
# def sort(self, column: int, order=Qt.AscendingOrder) -> None:
# reverse = order is Qt.DescendingOrder
# self.beginResetModel()
# if column == self.COL_IMDB_ID:
# def key(identity):
# return identity.get_imdb_identity().get_imdb_id()
# else:
# def key(identity):
# return identity.video_identity.get_name().lower()
# self._imdb_data = sorted(self._imdb_data, key=key,
# reverse=reverse)
# self.endResetModel()
#
# def headerData(self, section: int, orientation: int, role=None) -> Optional[str]:
# if role == Qt.DisplayRole:
# if orientation == Qt.Horizontal:
# if section == self.COL_IMDB_ID:
# return _('Id')
# else:
# return _('Name')
# else:
# return None
#
# Path: subdownloader/provider/imdb.py
# class ImdbMovieMatch:
# def __init__(self, imdb_id: str, title: str, year: Optional[int]):
# self.imdb_id = imdb_id
# self.title = title
# self.year = year
#
# @property
# def url(self) -> str:
# return 'https://www.imdb.com/title/{}'.format(self.imdb_id)
#
# @property
# def title_year(self) -> str:
# return '{}{}'.format(self.title, ' ({})'.format(self.year) if self.year is not None else '')
#
# def serialize(self) -> str:
# year_str = '' if self.year is None else str(self.year)
# return '{},{},{}'.format(self.imdb_id, year_str, self.title)
#
# @classmethod
# def deserialize(cls, data: str) -> Optional['ImdbMovieMatch']:
# try:
# [imdb_id, year_str, title] = data.split(',', 2)
# year = int(year_str.strip()) if year_str else None
# return cls(imdb_id.strip(), title.strip(), year)
# except ValueError:
# return None
which might include code, classes, or functions. Output only the next line. | self.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch) |
Continue the code snippet: <|code_start|># -*- coding: utf-8 -*-
# Form implementation generated from reading ui file '/home/maarten/programming/subdownloader_old/scripts/gui/ui/imdbSearch.ui'
#
# Created by: PyQt5 UI code generator 5.13.0
#
# WARNING! All changes made in this file will be lost!
class Ui_IMDBSearchDialog(object):
def setupUi(self, IMDBSearchDialog):
IMDBSearchDialog.setObjectName("IMDBSearchDialog")
IMDBSearchDialog.setWindowModality(QtCore.Qt.ApplicationModal)
IMDBSearchDialog.setModal(True)
self._2 = QtWidgets.QVBoxLayout(IMDBSearchDialog)
self._2.setObjectName("_2")
self.label = QtWidgets.QLabel(IMDBSearchDialog)
self.label.setObjectName("label")
self._2.addWidget(self.label)
self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.movieSearch = QtWidgets.QLineEdit(IMDBSearchDialog)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
<|code_end|>
. Use current file imports:
from PyQt5 import QtCore, QtGui, QtWidgets
from subdownloader.client.gui.views.imdb import ImdbListView
from subdownloader.client.gui.views.provider import ProviderComboBox
and context (classes, functions, or code) from other files:
# Path: subdownloader/client/gui/views/imdb.py
# class ImdbListView(QTableView):
# def __init__(self, parent=None):
# QTableView.__init__(self, parent)
# self._imdb_model = ImdbSearchModel()
# self.setup_ui()
#
# def setup_ui(self):
# self.setModel(self._imdb_model)
#
# self.setSelectionMode(QTableView.SingleSelection)
# self.setSelectionBehavior(QTableView.SelectRows)
# self.setGridStyle(Qt.DotLine)
#
# self.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)
# self.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
# self.horizontalHeader().sectionClicked.connect(self.on_header_clicked)
# self.verticalHeader().hide()
#
# self.selectionModel().selectionChanged.connect(self.imdb_selection_changed)
#
# self.retranslate()
#
# def retranslate(self):
# self._imdb_model.headerDataChanged.emit(Qt.Horizontal, 0, ImdbSearchModel.NB_COLS - 1)
#
# def set_imdb_data(self, imdb_data: Sequence[ImdbMovieMatch]):
# self._imdb_model.set_imdb_data(imdb_data)
#
# @pyqtSlot(int)
# def on_header_clicked(self, section: int) -> None:
# self._imdb_model.sort(section)
#
# imdb_selection_changed = pyqtSignal()
#
# def get_selected_imdb(self) -> Optional[ImdbMovieMatch]:
# selection = self.selectionModel().selection()
#
# if not selection.count():
# return None
#
# selection_range = selection.first()
# return self._imdb_model.get_imdb_at_row(selection_range.top())
#
# Path: subdownloader/client/gui/views/provider.py
# class ProviderComboBox(QComboBox):
# selected_provider_state_changed = pyqtSignal(_Optional)
#
# def __init__(self, parent):
# QComboBox.__init__(self, parent)
# self._model = ProviderModel()
# self._current_provider_state = None
#
# self.setup_ui()
#
# def set_general_text(self, general_text):
# self._model.set_general_text(general_text)
#
# def set_general_visible(self, general_visible):
# self._model.set_general_visible(general_visible)
#
# def set_filter_enable(self, filter_enable):
# self._model.set_filter_enable(filter_enable)
#
# def set_state(self, state):
# current_index = self.currentIndex()
# self._model.set_state(state)
# if current_index >= self._model.rowCount():
# current_index = self._model.rowCount() - 1
# self.setCurrentIndex(current_index)
#
# def set_selected_provider(self, provider):
# index = self._model.index_of_provider(provider)
# if index is not None:
# self.setCurrentIndex(index)
#
# def get_selected_provider_state(self):
# return self._current_provider_state
#
# def setup_ui(self):
# self.setModel(self._model)
#
# self.setIconSize(QSize(16, 16))
#
# self.setCurrentIndex(0)
# self._current_provider_state = self._model.provider_state_at_index(self.currentIndex())
#
# self.currentIndexChanged.connect(self.onCurrentIndexChanged)
#
# @pyqtSlot(int)
# def onCurrentIndexChanged(self, index):
# self._current_provider_state = self._model.provider_state_at_index(index)
# self.selected_provider_state_changed.emit(_Optional(self._current_provider_state))
. Output only the next line. | sizePolicy.setHorizontalStretch(0) |
Given the code snippet: <|code_start|># -*- coding: utf-8 -*-
# Form implementation generated from reading ui file '/home/maarten/programming/subdownloader_old/scripts/gui/ui/imdbSearch.ui'
#
# Created by: PyQt5 UI code generator 5.13.0
#
# WARNING! All changes made in this file will be lost!
class Ui_IMDBSearchDialog(object):
def setupUi(self, IMDBSearchDialog):
IMDBSearchDialog.setObjectName("IMDBSearchDialog")
IMDBSearchDialog.setWindowModality(QtCore.Qt.ApplicationModal)
IMDBSearchDialog.setModal(True)
<|code_end|>
, generate the next line using the imports in this file:
from PyQt5 import QtCore, QtGui, QtWidgets
from subdownloader.client.gui.views.imdb import ImdbListView
from subdownloader.client.gui.views.provider import ProviderComboBox
and context (functions, classes, or occasionally code) from other files:
# Path: subdownloader/client/gui/views/imdb.py
# class ImdbListView(QTableView):
# def __init__(self, parent=None):
# QTableView.__init__(self, parent)
# self._imdb_model = ImdbSearchModel()
# self.setup_ui()
#
# def setup_ui(self):
# self.setModel(self._imdb_model)
#
# self.setSelectionMode(QTableView.SingleSelection)
# self.setSelectionBehavior(QTableView.SelectRows)
# self.setGridStyle(Qt.DotLine)
#
# self.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)
# self.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
# self.horizontalHeader().sectionClicked.connect(self.on_header_clicked)
# self.verticalHeader().hide()
#
# self.selectionModel().selectionChanged.connect(self.imdb_selection_changed)
#
# self.retranslate()
#
# def retranslate(self):
# self._imdb_model.headerDataChanged.emit(Qt.Horizontal, 0, ImdbSearchModel.NB_COLS - 1)
#
# def set_imdb_data(self, imdb_data: Sequence[ImdbMovieMatch]):
# self._imdb_model.set_imdb_data(imdb_data)
#
# @pyqtSlot(int)
# def on_header_clicked(self, section: int) -> None:
# self._imdb_model.sort(section)
#
# imdb_selection_changed = pyqtSignal()
#
# def get_selected_imdb(self) -> Optional[ImdbMovieMatch]:
# selection = self.selectionModel().selection()
#
# if not selection.count():
# return None
#
# selection_range = selection.first()
# return self._imdb_model.get_imdb_at_row(selection_range.top())
#
# Path: subdownloader/client/gui/views/provider.py
# class ProviderComboBox(QComboBox):
# selected_provider_state_changed = pyqtSignal(_Optional)
#
# def __init__(self, parent):
# QComboBox.__init__(self, parent)
# self._model = ProviderModel()
# self._current_provider_state = None
#
# self.setup_ui()
#
# def set_general_text(self, general_text):
# self._model.set_general_text(general_text)
#
# def set_general_visible(self, general_visible):
# self._model.set_general_visible(general_visible)
#
# def set_filter_enable(self, filter_enable):
# self._model.set_filter_enable(filter_enable)
#
# def set_state(self, state):
# current_index = self.currentIndex()
# self._model.set_state(state)
# if current_index >= self._model.rowCount():
# current_index = self._model.rowCount() - 1
# self.setCurrentIndex(current_index)
#
# def set_selected_provider(self, provider):
# index = self._model.index_of_provider(provider)
# if index is not None:
# self.setCurrentIndex(index)
#
# def get_selected_provider_state(self):
# return self._current_provider_state
#
# def setup_ui(self):
# self.setModel(self._model)
#
# self.setIconSize(QSize(16, 16))
#
# self.setCurrentIndex(0)
# self._current_provider_state = self._model.provider_state_at_index(self.currentIndex())
#
# self.currentIndexChanged.connect(self.onCurrentIndexChanged)
#
# @pyqtSlot(int)
# def onCurrentIndexChanged(self, index):
# self._current_provider_state = self._model.provider_state_at_index(index)
# self.selected_provider_state_changed.emit(_Optional(self._current_provider_state))
. Output only the next line. | self._2 = QtWidgets.QVBoxLayout(IMDBSearchDialog) |
Predict the next line after this snippet: <|code_start|># -*- coding: utf-8 -*-
# Copyright (c) 2019 SubDownloader Developers - See COPYING - GPLv3
log = logging.getLogger('subdownloader.client.gui.models.language')
class LanguageModel(QAbstractListModel):
def __init__(self, unknown_text, unknown_visible, languages):
QAbstractListModel.__init__(self)
self._unknown_visible = unknown_visible
self._unknown_text = unknown_text
<|code_end|>
using the current file's imports:
import logging
from subdownloader.languages.language import UnknownLanguage
from PyQt5.QtCore import QAbstractListModel, QModelIndex, QSize, Qt
from PyQt5.QtGui import QFont, QIcon
and any relevant context from other files:
# Path: subdownloader/languages/language.py
# class UnknownLanguage(Language):
# def __init__(self, code):
# Language.__init__(self, 0)
# self._code = code
#
# # FIXME: better name for & check generic logic
#
# @classmethod
# def create_generic(cls):
# """
# Return a UnknownLanguage instance..
# :return: UnknownLanguage instance.
# """
# return cls('unknown') # NO internationalization!
#
# def name(self):
# """
# Return readable name of Language. Contains info about the unknown Language.
# :return: Readable name as string
# """
# return _(self._code)
#
# def generic_name(self):
# """
# Return readable name of Language. Contains no info about the unknown Language.
# :return: Readable name as string
# """
# return Language.name(self)
#
# def is_generic(self):
# return self._code == 'unknown' # NO internationalization!
#
# def __eq__(self, other):
# """
# Tests if other has the same type of this and the same unknown language code.
# :return: True if other is of the same type and has the same unknown language code
# """
# if not Language.__eq__(self, other):
# return False
# return self._code == other._code
#
# def __hash__(self):
# """
# Return hash of this object.
# :return: hash integer
# """
# return hash((self._id, self._code))
#
# def __repr__(self):
# """
# Return representation of this instance
# :return: string representation of self
# """
# return '<UnknownLanguage:code={code}>'.format(code=self._code)
. Output only the next line. | self._languages = languages |
Based on the snippet: <|code_start|>################################################################################
# Copyright (C) 2015 Jaakko Luttinen
#
# This file is licensed under the MIT License.
################################################################################
class Add(Deterministic):
r"""
Node for computing sums of Gaussian nodes: :math:`X+Y+Z`.
Examples
--------
>>> import numpy as np
>>> from bayespy import nodes
>>> X = nodes.Gaussian(np.zeros(2), np.identity(2), plates=(3,))
>>> Y = nodes.Gaussian(np.ones(2), np.identity(2))
>>> Z = nodes.Add(X, Y)
>>> print("Mean:\n", Z.get_moments()[0])
Mean:
[[1. 1.]]
>>> print("Second moment:\n", Z.get_moments()[1])
<|code_end|>
, predict the immediate next line with the help of imports:
import numpy as np
import functools
from .deterministic import Deterministic
from .gaussian import Gaussian, GaussianMoments
from bayespy.utils import linalg
and context (classes, functions, sometimes code) from other files:
# Path: bayespy/inference/vmp/nodes/deterministic.py
# class Deterministic(Node):
# """
# Base class for deterministic nodes.
#
# Sub-classes must implement:
# 1. For implementing the deterministic function:
# _compute_moments(self, *u)
# 2. One of the following options:
# a) Simple methods:
# _compute_message_to_parent(self, index, m, *u)
# b) More control with:
# _compute_message_and_mask_to_parent(self, index, m, *u)
#
# Sub-classes may need to re-implement:
# 1. If they manipulate plates:
# _compute_weights_to_parent(index, mask)
# _compute_plates_to_parent(self, index, plates)
# _compute_plates_from_parent(self, index, plates)
#
#
# """
#
# def __init__(self, *args, **kwargs):
# super().__init__(*args, plates=None, notify_parents=False, **kwargs)
#
# def _get_id_list(self):
# """
# Returns the stochastic ID list.
#
# This method is used to check that same stochastic nodes are not direct
# parents of a node several times. It is only valid if there are
# intermediate stochastic nodes.
#
# To put it another way: each ID corresponds to one factor q(..) in the
# posterior approximation. Different IDs mean different factors, thus they
# mean independence. The parents must have independent factors.
#
# Stochastic nodes should return their unique ID. Deterministic nodes
# should return the IDs of their parents. Constant nodes should return
# empty list of IDs.
# """
# id_list = []
# for parent in self.parents:
# id_list = id_list + parent._get_id_list()
# return id_list
#
# def get_moments(self):
# u_parents = self._message_from_parents()
# return self._compute_moments(*u_parents)
#
# def _compute_message_and_mask_to_parent(self, index, m_children, *u_parents):
# # The following methods should be implemented by sub-classes.
# m = self._compute_message_to_parent(index, m_children, *u_parents)
# mask = self._compute_weights_to_parent(index, self.mask) != 0
# return (m, mask)
#
# def _get_message_and_mask_to_parent(self, index, u_parent=None):
# u_parents = self._message_from_parents(exclude=index)
# u_parents[index] = u_parent
# if u_parent is not None:
# u_self = self._compute_moments(*u_parents)
# else:
# u_self = None
# m_children = self._message_from_children(u_self=u_self)
# return self._compute_message_and_mask_to_parent(index,
# m_children,
# *u_parents)
#
#
# def _compute_moments(self, *u_parents):
# """
# Compute the moments given the moments of the parents.
# """
# raise NotImplementedError()
#
#
# def _compute_message_to_parent(self, index, m_children, *u_parents):
# """
# Compute the message to a parent.
# """
# raise NotImplementedError()
#
#
# def _add_child(self, child, index):
# """
# Add a child node.
#
# Only child nodes that are stochastic (or have stochastic children
# recursively) are counted as children because deterministic nodes without
# stochastic children do not have any messages to send so the parents do
# not need to know about the deterministic node.
#
# A deterministic node does not notify its parents when created, but if it
# gets a stochastic child node, then notify parents. This method is called
# only if a stochastic child (recursively) node is added, thus there is at
# least one stochastic node below this deterministic node.
#
# Parameters
# ----------
# child : node
# index : int
# The parent index of this node for the child node.
# The child node recognizes its parents by their index
# number.
# """
# super()._add_child(child, index)
# # Now that this deterministic node has non-deterministic children,
# # notify parents
# for (ind,parent) in enumerate(self.parents):
# parent._add_child(self, ind)
#
# def _remove_child(self, child, index):
# """
# Remove a child node.
#
# Only child nodes that are stochastic (or have stochastic children
# recursively) are counted as children because deterministic nodes without
# stochastic children do not have any messages to send so the parents do
# not need to know about the deterministic node.
#
# So, if the deterministic node does not have any stochastic children left
# after removal, remove it from its parents.
# """
# super()._remove_child(child, index)
# # Check whether there are any children left. If not, remove from parents
# if len(self.children) == 0:
# for (ind, parent) in enumerate(self.parents):
# parent._remove_child(self, ind)
#
# def lower_bound_contribution(self, gradient=False, **kwargs):
# # Deterministic functions are delta distributions so the lower bound
# # contribuion is zero.
# return 0
#
#
# def random(self):
# samples = [parent.random() for parent in self.parents]
# return self._compute_function(*samples)
. Output only the next line. | Second moment: |
Next line prediction: <|code_start|>
class Command(BaseCommand):
help = ("Fills a cache with the json and image data for open spaces "
"in all campuses")
def handle(self, *args, **kwargs):
if not hasattr(settings, 'SS_LOCATIONS'):
raise("Error running load_open_now_cache - you need "
"to define your locations")
for location in settings.SS_LOCATIONS:
image_ids = []
spaces = fetch_open_now_for_campus(location,
use_cache=False,
fill_cache=True)
for space in spaces:
if len(space["images"]) > 0:
image_ids.append("%i" % space["images"][0]["id"])
if len(image_ids):
get_multi_image(None,
",".join(image_ids),
True,
thumb_width=150,
<|code_end|>
. Use current file imports:
(from django.core.management.base import BaseCommand
from django.conf import settings
from spacescout_web.views.home import fetch_open_now_for_campus
from spacescout_web.views.image import get_multi_image)
and context including class names, function names, or small code snippets from other files:
# Path: spacescout_web/views/home.py
# def fetch_open_now_for_campus(
# request, campus, use_cache=True,
# fill_cache=False, cache_period=FIVE_MINUTE_CACHE):
# if campus is None:
# # Default to zooming in on the UW Seattle campus
# center_latitude = '47.655003'
# center_longitude = '-122.306864'
# zoom_level = '15'
# distance = '500'
#
# else:
# location = settings.SS_LOCATIONS[campus]
# center_latitude = location['CENTER_LATITUDE']
# center_longitude = location['CENTER_LONGITUDE']
# zoom_level = location['ZOOM_LEVEL']
#
# if 'DISTANCE' in location:
# distance = location['DISTANCE']
# else:
# distance = '500'
#
# # SPOT-1832. Making the distance far enough that center of campus to
# # furthest spot from the center can be found
# distance = 1000
# consumer = oauth2.Consumer(
# key=settings.SS_WEB_OAUTH_KEY,
# secret=settings.SS_WEB_OAUTH_SECRET)
# client = oauth2.Client(consumer)
#
# chain = SearchFilterChain(request)
# search_url_args = []
# search_url_args = chain.url_args(request)
# search_url_args.append({'center_latitude': center_latitude})
# search_url_args.append({'center_longitude': center_longitude})
# search_url_args.append({'open_now': '1'})
# search_url_args.append({'distance': distance})
# search_url_args.append({'limit': '0'})
#
# return get_space_json(
# client, search_url_args, use_cache,
# fill_cache, cache_period)
#
# Path: spacescout_web/views/image.py
# def get_multi_image(
# spot_id, image_ids, constrain, thumb_width=None,
# thumb_height=None, fill_cache=False):
# if constrain is True:
# constraint = []
# if thumb_width:
# constraint.append("width:%s" % thumb_width)
# if thumb_height:
# constraint.append("height:%s" % thumb_height)
# url = "{0}/api/v1/multi_image/{2}/thumb/constrain/{3}".format(
# settings.SS_WEB_SERVER_HOST,
# spot_id, image_ids,
# ','.join(constraint))
# else:
# url = "{0}/api/v1/multi_image/{2}/thumb/{3}x{4}".format(
# settings.SS_WEB_SERVER_HOST,
# spot_id, image_ids,
# thumb_width, thumb_height)
#
# image_cache_key = "spot_multi_image_%s" % hashlib.sha224(url).hexdigest()
# offsets_cache_key = "spot_multi_image_offsets_%s" % (
# hashlib.sha224(url).hexdigest())
#
# if fill_cache:
# client = get_client()
# resp, content = client.request(url, 'GET')
# cache.set(image_cache_key, content)
# cache.set(offsets_cache_key, resp['sprite-offsets'])
#
# cached_image = cache.get(image_cache_key)
# cached_offsets = cache.get(offsets_cache_key)
#
# if not cached_offsets or not cached_image:
# return None, None
#
# return {
# 'Content-Type': 'image/jpeg',
# 'Sprite-Offsets': cached_offsets
# }, cached_image
. Output only the next line. | fill_cache=True) |
Predict the next line for this snippet: <|code_start|>
class Command(BaseCommand):
help = ("Fills a cache with the json and image data for open spaces "
"in all campuses")
<|code_end|>
with the help of current file imports:
from django.core.management.base import BaseCommand
from django.conf import settings
from spacescout_web.views.home import fetch_open_now_for_campus
from spacescout_web.views.image import get_multi_image
and context from other files:
# Path: spacescout_web/views/home.py
# def fetch_open_now_for_campus(
# request, campus, use_cache=True,
# fill_cache=False, cache_period=FIVE_MINUTE_CACHE):
# if campus is None:
# # Default to zooming in on the UW Seattle campus
# center_latitude = '47.655003'
# center_longitude = '-122.306864'
# zoom_level = '15'
# distance = '500'
#
# else:
# location = settings.SS_LOCATIONS[campus]
# center_latitude = location['CENTER_LATITUDE']
# center_longitude = location['CENTER_LONGITUDE']
# zoom_level = location['ZOOM_LEVEL']
#
# if 'DISTANCE' in location:
# distance = location['DISTANCE']
# else:
# distance = '500'
#
# # SPOT-1832. Making the distance far enough that center of campus to
# # furthest spot from the center can be found
# distance = 1000
# consumer = oauth2.Consumer(
# key=settings.SS_WEB_OAUTH_KEY,
# secret=settings.SS_WEB_OAUTH_SECRET)
# client = oauth2.Client(consumer)
#
# chain = SearchFilterChain(request)
# search_url_args = []
# search_url_args = chain.url_args(request)
# search_url_args.append({'center_latitude': center_latitude})
# search_url_args.append({'center_longitude': center_longitude})
# search_url_args.append({'open_now': '1'})
# search_url_args.append({'distance': distance})
# search_url_args.append({'limit': '0'})
#
# return get_space_json(
# client, search_url_args, use_cache,
# fill_cache, cache_period)
#
# Path: spacescout_web/views/image.py
# def get_multi_image(
# spot_id, image_ids, constrain, thumb_width=None,
# thumb_height=None, fill_cache=False):
# if constrain is True:
# constraint = []
# if thumb_width:
# constraint.append("width:%s" % thumb_width)
# if thumb_height:
# constraint.append("height:%s" % thumb_height)
# url = "{0}/api/v1/multi_image/{2}/thumb/constrain/{3}".format(
# settings.SS_WEB_SERVER_HOST,
# spot_id, image_ids,
# ','.join(constraint))
# else:
# url = "{0}/api/v1/multi_image/{2}/thumb/{3}x{4}".format(
# settings.SS_WEB_SERVER_HOST,
# spot_id, image_ids,
# thumb_width, thumb_height)
#
# image_cache_key = "spot_multi_image_%s" % hashlib.sha224(url).hexdigest()
# offsets_cache_key = "spot_multi_image_offsets_%s" % (
# hashlib.sha224(url).hexdigest())
#
# if fill_cache:
# client = get_client()
# resp, content = client.request(url, 'GET')
# cache.set(image_cache_key, content)
# cache.set(offsets_cache_key, resp['sprite-offsets'])
#
# cached_image = cache.get(image_cache_key)
# cached_offsets = cache.get(offsets_cache_key)
#
# if not cached_offsets or not cached_image:
# return None, None
#
# return {
# 'Content-Type': 'image/jpeg',
# 'Sprite-Offsets': cached_offsets
# }, cached_image
, which may contain function names, class names, or code. Output only the next line. | def handle(self, *args, **kwargs): |
Using the snippet: <|code_start|>
def getElementList(self, regex):
compiledRE = re.compile(regex)
exElementList = []
for str in (compiledRE.findall(self.fileText)):
elementText, startIndex, endIndex = self.extractElementText(str)
elementObj = self.getElementObject(elementText, regex)
exElementList.append(ExElement(elementObj, startIndex, endIndex))
return exElementList
# TODO: Handle variables
# Unwrap classes from list
def getIncludeClasses(self):
compiledIncludeRE = re.compile(SMCONSTS.DECLARE_INCLUDE_REGEX)
compiledResourceRE = re.compile(SMCONSTS.DECLARE_RESOURCE_REGEX)
declareClassList = []
declareClassName = ""
for match in (compiledIncludeRE.findall(self.fileText)):
#print(match)
declareClassText = match
cleanInclude = re.sub(r'^\s*include \[?(.+)\]?\s*$', r'\1', declareClassText)
#print("Clean include: %s" % cleanInclude)
class_name = r'(?:Class\[)?\'?\:{0,2}([\w\d\:\-_\$]+)\'?\]?'
classRE = re.compile(class_name)
if ',' in cleanInclude:
classes = cleanInclude.split(',')
for c in classes:
for m in classRE.findall(c):
# Find a variable value in text
<|code_end|>
, determine the next line of code. You have imports:
import re
import SourceModel.SM_CaseStmt
import SourceModel.SM_Class
import SourceModel.SM_Constants as SMCONSTS
import SourceModel.SM_Define
import SourceModel.SM_Define
import SourceModel.SM_Element
import SourceModel.SM_Exec
import SourceModel.SM_FileResource
import SourceModel.SM_IfStmt
import SourceModel.SM_IncludeResource
import SourceModel.SM_LCOM
import SourceModel.SM_Node
import SourceModel.SM_PackageResource
import SourceModel.SM_ServiceResource
import SourceModel.SM_User
from SmellDetector import Utilities
and context (class names, function names, or code) available:
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | if m.startswith('$'): |
Next line prediction: <|code_start|>
class TestHieSmells(TestCase):
def test_detectBroHierarchy(self):
folderName = "/Users/Tushar/Documents/Research/PuppetQuality/Repos/vagrant-baseline/puppet/"
outFileName = "tmp/brokenHieTest.txt"
outFile = open(outFileName, 'w')
#fileObj = SourceModel.SM_File.SM_File("/Users/Tushar/Documents/Research/PuppetQuality/Repos/vagrant-baseline/puppet/modules/vendors/mongodb/manifests/repo/apt.pp")
HieSmellDectector.detectBroHierarchy(folderName, outFile)
#fileObj.getClassHierarchyInfo()
outFile.close()
<|code_end|>
. Use current file imports:
(from unittest import TestCase
from SmellDetector import HieSmellDectector)
and context including class names, function names, or small code snippets from other files:
# Path: SmellDetector/HieSmellDectector.py
# def detectSmells(folder, outputFile):
# def detectBrokenHie(folder, outputFile):
# def detectBroHierarchy(folder, outputFile):
# def getModulesFolder(folder):
# def collectClassNames(folder):
. Output only the next line. | outFileRead = open(outFileName, 'r') |
Next line prediction: <|code_start|>
def detectSmells(folder, outputFile):
detectBrokenHie(folder, outputFile)
def detectBrokenHie(folder, outputFile):
modulesFolder = getModulesFolder(folder)
if modulesFolder:
for dir in os.listdir(modulesFolder):
if os.path.isdir(os.path.join(modulesFolder, dir)):
detectBroHierarchy(os.path.join(modulesFolder, dir), outputFile)
def detectBroHierarchy(folder, outputFile):
<|code_end|>
. Use current file imports:
(import os
import SourceModel.SM_File
from SmellDetector import Constants as CONSTS, Utilities)
and context including class names, function names, or small code snippets from other files:
# Path: SmellDetector/Constants.py
# REPO_ROOT = "/Users/user/Desktop/puppetAnalysis"
# AGGREGATOR_FILE = "AggregatedOutput.csv"
# CSV_HEADER = "Repo_name,PuppetFileCount,ClassCount,DefineCount,FileResourceCount,PackageResourceCount,\
# ServiceResourceCount,ExecCount,LOC,MultifacetedAbs,UnnecessaryAbs,ImperativeAbs,MissingAbs,\
# InsufficientMod,UnstructuredMod,TightlyCoupledMod,DuplicateAbs,MissingDep,BrokenHie,HairballStr,\
# DeficientEnc,WeakendMod\n"
# PUPPETEER_OUT_FILE = "Puppeteer_output.txt"
# PUPPET_FILE_COUNT = "Puppet file count: "
# TOTAL_CLASS_DECLS = "Total class declarations: "
# TOTAL_DEFINE_DECLS = "Total define declarations: "
# TOTAL_FILE_RES_DECLS = "Total file declarations: "
# TOTAL_PACKAGE_RES_DECLS = "Total package declarations: "
# TOTAL_SERVICE_RES_DECLS = "Total service declarations: "
# TOTAL_EXEC_DECLS = "Total exec declarations: "
# TOTAL_LOC = "Total LOC: "
# DEBUG_ON = False
# SMELL_MUL_ABS_1 = "Multifaceted Abstraction - Form 1"
# SMELL_MUL_ABS_2 = "Multifaceted Abstraction - Form 2"
# SMELL_UNN_ABS = "Unnecessary Abstraction"
# SMELL_IMP_ABS = "Imperative Abstraction"
# SMELL_MIS_ABS = "Missing Abstraction"
# SMELL_INS_MOD_1 = "Insufficient Modularization - Form 1"
# SMELL_INS_MOD_2 = "Insufficient Modularization - Form 2"
# SMELL_INS_MOD_3 = "Insufficient Modularization - Form 3"
# SMELL_UNS_MOD_1 = "Unstructured Module - Form 1"
# SMELL_UNS_MOD_2 = "Unstructured Module - Form 2"
# SMELL_UNS_MOD_3 = "Unstructured Module - Form 3"
# SMELL_TC_MOD = "Tightly-coupled Module"
# SMELL_DUP_ABS = "Duplicate Abstraction"
# SMELL_BRO_HIE = "Broken Hierarchy"
# SMELL_MIS_DEP = "Missing Dependency"
# SMELL_HAI_STR = "Hairball Structure"
# SMELL_DEF_ENC = "Deficient Encapsulation"
# SMELL_WEA_MOD = "Weakend Modularity"
# FILE_RES = " File "
# SERVICE_RES = " Service "
# PACKAGE_RES = " Package "
# CLASS_RES = " Class "
# DEFINE_RES = " Define "
# MODULE_RES = " Module "
# REPO_RES = " Repo "
# NODES_RES = " Node "
# REPO_MANIFEST = " Manifest(Repo) "
# MODULE_MANIFEST = " Manifest(Module) "
# OTHERFILES = " Others "
# MODULES = "modules"
# MANIFESTS = "manifests"
# LCOM_THRESHOLD = 0.7
# SIZE_THRESHOLD_UNNABS = 2
# LOC_THRESHOLD_UNNABS = 3
# IMPABS_THRESHOLD = 0.2
# IMPABS_MAXEXECCOUNT = 2
# MISABS_MAX_NON_ABS_COUNT = 2
# MAX_CLASS_LOC_THRESHOLD = 40
# MAX_DEFINE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD
# MAX_MODULE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD * 2
# MAX_NESTING_DEPTH = 3
# MAX_MANIFESTS_PUPPET_FILES = 5
# MAX_ALLOWED_NONSTANDARD_FILES = 3
# MAX_GRAPH_DEGREE_THRESHOLD = 0.5
# MODULARITY_THRESHOLD = 1.0
#
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | classNames, superClassNames = collectClassNames(folder) |
Continue the code snippet: <|code_start|>
class TestModSmells(TestCase):
def test_detectDefEnc(self):
fileName = "/Users/Tushar/Documents/Research/PuppetQuality/Repos/percona-xtradb-cluster-tutorial/manifests/master_slave.pp"
outFileName = "tmp/DefEncTest.txt"
fileObj = SourceModel.SM_File.SM_File(fileName)
<|code_end|>
. Use current file imports:
from unittest import TestCase
from SmellDetector import EncSmellDectector
import SourceModel.SM_File
and context (classes, functions, or code) from other files:
# Path: SmellDetector/EncSmellDectector.py
# def detectSmells(folder, outputFile):
# def detectDeficientEnc(folder, outputFile):
# def detectDefEnc(fileObj, outputFile):
. Output only the next line. | outFile = open(outFileName, 'w') |
Based on the snippet: <|code_start|> if modulesFolder:
for dir in os.listdir(modulesFolder):
detectUnsModForm3(os.path.join(modulesFolder, dir), outputFile)
def detectUnsModForm3(folder, outputFile):
counter = 0
if os.path.isdir(folder):
for dir in os.listdir(folder):
if not (dir == "files" or dir == "manifests" or dir == "templates" or dir == "lib" or dir == "tests" or
dir == "spec" or dir.__contains__("readme") or dir.__contains__("README") or
dir.__contains__("license") or dir.__contains__("LICENSE") or dir.__contains__("metadata")):
counter += 1
if counter > CONSTS.MAX_ALLOWED_NONSTANDARD_FILES:
Utilities.reportSmell(outputFile, folder, CONSTS.SMELL_UNS_MOD_3, CONSTS.OTHERFILES)
def detectTCMod(fileObj, outputFile):
if not (fileObj.fileName.__contains__("param") or fileObj.fileName.__contains__("init") or fileObj.fileName.__contains__("site")):
if len(fileObj.getHardCodedStatments()) > 1:
Utilities.reportSmell(outputFile, fileObj.fileName, CONSTS.SMELL_TC_MOD, CONSTS.FILE_RES)
def getGraph(folder):
graph = Graph.Graph.Graph()
addGraphNodes(folder, graph)
#graph.printGraph()
addGraphEdges(folder, graph)
return graph
def addGraphNodes(folder, graph):
addGraphNodesFromModules(folder, graph)
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import Graph.GR_Constants as GRCONSTS
import Graph.Graph
import Graph.GraphNode
import Graph.Resource
import SmellDetector.Constants as CONSTS
import SourceModel.SM_File
from SmellDetector import FileOperations, Utilities
and context (classes, functions, sometimes code) from other files:
# Path: SmellDetector/FileOperations.py
# def countPuppetFiles(folder):
#
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | addGraphNodesFromRestPuppetFiles(folder, graph) |
Given the following code snippet before the placeholder: <|code_start|>
def detectSmells(folder, outputFile):
detectInsufficientMod(folder, outputFile)
detectUnstructuredMod(folder, outputFile)
detectTightlyCoupledMod(folder, outputFile)
detectHairballStrAndWeakendMod(folder, outputFile)
def detectInsufficientMod(folder, outputFile):
detectInsufficientModForm1(folder, outputFile)
detectInsufficientModForm2(folder, outputFile)
detectInsufficientModForm3(folder, outputFile)
def detectUnstructuredMod(folder, outputFile):
detectUnstructuredModForm1(folder, outputFile)
detectUnstructuredModForm2(folder, outputFile)
detectUnstructuredModForm3(folder, outputFile)
def detectTightlyCoupledMod(folder, outputFile):
for root, dirs, files in os.walk(folder):
for file in files:
if file.endswith(".pp") and not os.path.islink(os.path.join(root, file)):
fileObj = SourceModel.SM_File.SM_File(os.path.join(root, file))
detectTCMod(fileObj, outputFile)
def detectHairballStrAndWeakendMod(folder, outputFile):
graph = getGraph(folder)
detectHaiStr(graph, folder, outputFile) #Excessive avg dependency
<|code_end|>
, predict the next line using imports from the current file:
import os
import Graph.GR_Constants as GRCONSTS
import Graph.Graph
import Graph.GraphNode
import Graph.Resource
import SmellDetector.Constants as CONSTS
import SourceModel.SM_File
from SmellDetector import FileOperations, Utilities
and context including class names, function names, and sometimes code from other files:
# Path: SmellDetector/FileOperations.py
# def countPuppetFiles(folder):
#
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | detectWeakendMod(graph, folder, outputFile) #modularity ratio |
Based on the snippet: <|code_start|>
def myPrint(msg):
if(CONSTS.DEBUG_ON):
print(msg)
def reportSmell(outputFile, fileName, smellName, reason):
outputFile.write(smellName + " at " + reason + " in file " + fileName + "\n")
myPrint(smellName + " at " + reason + " in file " + fileName + "\n")
def intersection(list1, list2):
return list(set(list1) & set(list2))
def summation(list1, list2):
<|code_end|>
, predict the immediate next line with the help of imports:
from SmellDetector import Constants as CONSTS
and context (classes, functions, sometimes code) from other files:
# Path: SmellDetector/Constants.py
# REPO_ROOT = "/Users/user/Desktop/puppetAnalysis"
# AGGREGATOR_FILE = "AggregatedOutput.csv"
# CSV_HEADER = "Repo_name,PuppetFileCount,ClassCount,DefineCount,FileResourceCount,PackageResourceCount,\
# ServiceResourceCount,ExecCount,LOC,MultifacetedAbs,UnnecessaryAbs,ImperativeAbs,MissingAbs,\
# InsufficientMod,UnstructuredMod,TightlyCoupledMod,DuplicateAbs,MissingDep,BrokenHie,HairballStr,\
# DeficientEnc,WeakendMod\n"
# PUPPETEER_OUT_FILE = "Puppeteer_output.txt"
# PUPPET_FILE_COUNT = "Puppet file count: "
# TOTAL_CLASS_DECLS = "Total class declarations: "
# TOTAL_DEFINE_DECLS = "Total define declarations: "
# TOTAL_FILE_RES_DECLS = "Total file declarations: "
# TOTAL_PACKAGE_RES_DECLS = "Total package declarations: "
# TOTAL_SERVICE_RES_DECLS = "Total service declarations: "
# TOTAL_EXEC_DECLS = "Total exec declarations: "
# TOTAL_LOC = "Total LOC: "
# DEBUG_ON = False
# SMELL_MUL_ABS_1 = "Multifaceted Abstraction - Form 1"
# SMELL_MUL_ABS_2 = "Multifaceted Abstraction - Form 2"
# SMELL_UNN_ABS = "Unnecessary Abstraction"
# SMELL_IMP_ABS = "Imperative Abstraction"
# SMELL_MIS_ABS = "Missing Abstraction"
# SMELL_INS_MOD_1 = "Insufficient Modularization - Form 1"
# SMELL_INS_MOD_2 = "Insufficient Modularization - Form 2"
# SMELL_INS_MOD_3 = "Insufficient Modularization - Form 3"
# SMELL_UNS_MOD_1 = "Unstructured Module - Form 1"
# SMELL_UNS_MOD_2 = "Unstructured Module - Form 2"
# SMELL_UNS_MOD_3 = "Unstructured Module - Form 3"
# SMELL_TC_MOD = "Tightly-coupled Module"
# SMELL_DUP_ABS = "Duplicate Abstraction"
# SMELL_BRO_HIE = "Broken Hierarchy"
# SMELL_MIS_DEP = "Missing Dependency"
# SMELL_HAI_STR = "Hairball Structure"
# SMELL_DEF_ENC = "Deficient Encapsulation"
# SMELL_WEA_MOD = "Weakend Modularity"
# FILE_RES = " File "
# SERVICE_RES = " Service "
# PACKAGE_RES = " Package "
# CLASS_RES = " Class "
# DEFINE_RES = " Define "
# MODULE_RES = " Module "
# REPO_RES = " Repo "
# NODES_RES = " Node "
# REPO_MANIFEST = " Manifest(Repo) "
# MODULE_MANIFEST = " Manifest(Module) "
# OTHERFILES = " Others "
# MODULES = "modules"
# MANIFESTS = "manifests"
# LCOM_THRESHOLD = 0.7
# SIZE_THRESHOLD_UNNABS = 2
# LOC_THRESHOLD_UNNABS = 3
# IMPABS_THRESHOLD = 0.2
# IMPABS_MAXEXECCOUNT = 2
# MISABS_MAX_NON_ABS_COUNT = 2
# MAX_CLASS_LOC_THRESHOLD = 40
# MAX_DEFINE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD
# MAX_MODULE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD * 2
# MAX_NESTING_DEPTH = 3
# MAX_MANIFESTS_PUPPET_FILES = 5
# MAX_ALLOWED_NONSTANDARD_FILES = 3
# MAX_GRAPH_DEGREE_THRESHOLD = 0.5
# MODULARITY_THRESHOLD = 1.0
. Output only the next line. | return list(set(list1) | set(list2)) |
Predict the next line after this snippet: <|code_start|>
def getLCOM(elementList):
disconnectedElements = 0
while len(elementList) > 0:
disconnectedElements += 1
curElement = elementList.pop()
variableList = curElement.getUsedVariables()
i = 0
while len(elementList) > 0 and i < len(elementList):
elementToCompare = elementList[i]
curVariableList = elementToCompare.getUsedVariables()
if len(Utilities.intersection(curVariableList, variableList)) > 0:
variableList = Utilities.summation(curVariableList, variableList)
elementList.pop(i)
i += 1
#print("Computing LCOM : disconnected elements - " + str(disconnectedElements))
if disconnectedElements > 0:
LCOM = float("{:.2f}".format(1.0/disconnectedElements))
else:
LCOM = float(1.0)
<|code_end|>
using the current file's imports:
from SmellDetector import Utilities
and any relevant context from other files:
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | return LCOM |
Predict the next line for this snippet: <|code_start|>
class TestAggregator(TestCase):
def test_aggregate(self):
outFileName = "/Users/Tushar/Documents/Research/PuppetQuality/Puppet-lint_aggregator/testOut.csv"
outFile = open(outFileName, 'w')
outFile.write(CONSTS.HEADER)
Aggregator.aggregate("/Users/Tushar/Documents/Research/PuppetQuality/Puppet-lint_aggregator/test1/", "test1", outFile)
Aggregator.aggregate("/Users/Tushar/Documents/Research/PuppetQuality/Puppet-lint_aggregator/test2/", "test2", outFile)
outFile.close()
outReadFile = open(outFileName, 'r')
<|code_end|>
with the help of current file imports:
from unittest import TestCase
from SmellDetector import Constants as CONSTS, Analyzer
import Aggregator
and context from other files:
# Path: SmellDetector/Constants.py
# REPO_ROOT = "/Users/user/Desktop/puppetAnalysis"
# AGGREGATOR_FILE = "AggregatedOutput.csv"
# CSV_HEADER = "Repo_name,PuppetFileCount,ClassCount,DefineCount,FileResourceCount,PackageResourceCount,\
# ServiceResourceCount,ExecCount,LOC,MultifacetedAbs,UnnecessaryAbs,ImperativeAbs,MissingAbs,\
# InsufficientMod,UnstructuredMod,TightlyCoupledMod,DuplicateAbs,MissingDep,BrokenHie,HairballStr,\
# DeficientEnc,WeakendMod\n"
# PUPPETEER_OUT_FILE = "Puppeteer_output.txt"
# PUPPET_FILE_COUNT = "Puppet file count: "
# TOTAL_CLASS_DECLS = "Total class declarations: "
# TOTAL_DEFINE_DECLS = "Total define declarations: "
# TOTAL_FILE_RES_DECLS = "Total file declarations: "
# TOTAL_PACKAGE_RES_DECLS = "Total package declarations: "
# TOTAL_SERVICE_RES_DECLS = "Total service declarations: "
# TOTAL_EXEC_DECLS = "Total exec declarations: "
# TOTAL_LOC = "Total LOC: "
# DEBUG_ON = False
# SMELL_MUL_ABS_1 = "Multifaceted Abstraction - Form 1"
# SMELL_MUL_ABS_2 = "Multifaceted Abstraction - Form 2"
# SMELL_UNN_ABS = "Unnecessary Abstraction"
# SMELL_IMP_ABS = "Imperative Abstraction"
# SMELL_MIS_ABS = "Missing Abstraction"
# SMELL_INS_MOD_1 = "Insufficient Modularization - Form 1"
# SMELL_INS_MOD_2 = "Insufficient Modularization - Form 2"
# SMELL_INS_MOD_3 = "Insufficient Modularization - Form 3"
# SMELL_UNS_MOD_1 = "Unstructured Module - Form 1"
# SMELL_UNS_MOD_2 = "Unstructured Module - Form 2"
# SMELL_UNS_MOD_3 = "Unstructured Module - Form 3"
# SMELL_TC_MOD = "Tightly-coupled Module"
# SMELL_DUP_ABS = "Duplicate Abstraction"
# SMELL_BRO_HIE = "Broken Hierarchy"
# SMELL_MIS_DEP = "Missing Dependency"
# SMELL_HAI_STR = "Hairball Structure"
# SMELL_DEF_ENC = "Deficient Encapsulation"
# SMELL_WEA_MOD = "Weakend Modularity"
# FILE_RES = " File "
# SERVICE_RES = " Service "
# PACKAGE_RES = " Package "
# CLASS_RES = " Class "
# DEFINE_RES = " Define "
# MODULE_RES = " Module "
# REPO_RES = " Repo "
# NODES_RES = " Node "
# REPO_MANIFEST = " Manifest(Repo) "
# MODULE_MANIFEST = " Manifest(Module) "
# OTHERFILES = " Others "
# MODULES = "modules"
# MANIFESTS = "manifests"
# LCOM_THRESHOLD = 0.7
# SIZE_THRESHOLD_UNNABS = 2
# LOC_THRESHOLD_UNNABS = 3
# IMPABS_THRESHOLD = 0.2
# IMPABS_MAXEXECCOUNT = 2
# MISABS_MAX_NON_ABS_COUNT = 2
# MAX_CLASS_LOC_THRESHOLD = 40
# MAX_DEFINE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD
# MAX_MODULE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD * 2
# MAX_NESTING_DEPTH = 3
# MAX_MANIFESTS_PUPPET_FILES = 5
# MAX_ALLOWED_NONSTANDARD_FILES = 3
# MAX_GRAPH_DEGREE_THRESHOLD = 0.5
# MODULARITY_THRESHOLD = 1.0
#
# Path: SmellDetector/Analyzer.py
# def analyze(folder, repoName):
, which may contain function names, class names, or code. Output only the next line. | self.assertGreater(len(outReadFile.read()), 0) |
Given the following code snippet before the placeholder: <|code_start|> fileObj.getNoOfServiceDeclarations() + execDecls
if float(totalDeclarations * CONSTS.IMPABS_THRESHOLD) <= float(
execDecls) and execDecls > CONSTS.IMPABS_MAXEXECCOUNT:
Utilities.reportSmell(outputFile, fileObj.fileName, CONSTS.SMELL_IMP_ABS, CONSTS.FILE_RES)
# In order to detect duplicate abstraction smell, we first run cpd on all repositories (repo wise) and the result
# must be stored at the root of each repo in a file ending with "cpd.xml"
def detectDuplicateAbs(folder, outputFile):
cpdXmlFile = getCpdXmlFile(folder)
if cpdXmlFile:
file = open(os.path.join(folder, cpdXmlFile), 'r', errors='ignore')
fileContent = file.read()
compiledRE = re.compile("<duplication lines=")
for i in re.findall(compiledRE, fileContent):
Utilities.reportSmell(outputFile, folder, CONSTS.SMELL_DUP_ABS, CONSTS.FILE_RES)
def getCpdXmlFile(folder):
for aFile in os.listdir(folder):
if aFile == "cpd.xml":
return aFile
return ""
def detectMissingAbs(folder, outputFile):
for root, dirs, files in os.walk(folder):
for file in files:
if file.endswith(".pp") and not os.path.islink(os.path.join(root, file)):
fileObj = SourceModel.SM_File.SM_File(os.path.join(root, file))
detectMisAbs(fileObj, outputFile)
def detectMisAbs(fileObj, outputFile):
<|code_end|>
, predict the next line using imports from the current file:
import os
import re
import SourceModel.SM_File
from SmellDetector import Constants as CONSTS, Utilities
and context including class names, function names, and sometimes code from other files:
# Path: SmellDetector/Constants.py
# REPO_ROOT = "/Users/user/Desktop/puppetAnalysis"
# AGGREGATOR_FILE = "AggregatedOutput.csv"
# CSV_HEADER = "Repo_name,PuppetFileCount,ClassCount,DefineCount,FileResourceCount,PackageResourceCount,\
# ServiceResourceCount,ExecCount,LOC,MultifacetedAbs,UnnecessaryAbs,ImperativeAbs,MissingAbs,\
# InsufficientMod,UnstructuredMod,TightlyCoupledMod,DuplicateAbs,MissingDep,BrokenHie,HairballStr,\
# DeficientEnc,WeakendMod\n"
# PUPPETEER_OUT_FILE = "Puppeteer_output.txt"
# PUPPET_FILE_COUNT = "Puppet file count: "
# TOTAL_CLASS_DECLS = "Total class declarations: "
# TOTAL_DEFINE_DECLS = "Total define declarations: "
# TOTAL_FILE_RES_DECLS = "Total file declarations: "
# TOTAL_PACKAGE_RES_DECLS = "Total package declarations: "
# TOTAL_SERVICE_RES_DECLS = "Total service declarations: "
# TOTAL_EXEC_DECLS = "Total exec declarations: "
# TOTAL_LOC = "Total LOC: "
# DEBUG_ON = False
# SMELL_MUL_ABS_1 = "Multifaceted Abstraction - Form 1"
# SMELL_MUL_ABS_2 = "Multifaceted Abstraction - Form 2"
# SMELL_UNN_ABS = "Unnecessary Abstraction"
# SMELL_IMP_ABS = "Imperative Abstraction"
# SMELL_MIS_ABS = "Missing Abstraction"
# SMELL_INS_MOD_1 = "Insufficient Modularization - Form 1"
# SMELL_INS_MOD_2 = "Insufficient Modularization - Form 2"
# SMELL_INS_MOD_3 = "Insufficient Modularization - Form 3"
# SMELL_UNS_MOD_1 = "Unstructured Module - Form 1"
# SMELL_UNS_MOD_2 = "Unstructured Module - Form 2"
# SMELL_UNS_MOD_3 = "Unstructured Module - Form 3"
# SMELL_TC_MOD = "Tightly-coupled Module"
# SMELL_DUP_ABS = "Duplicate Abstraction"
# SMELL_BRO_HIE = "Broken Hierarchy"
# SMELL_MIS_DEP = "Missing Dependency"
# SMELL_HAI_STR = "Hairball Structure"
# SMELL_DEF_ENC = "Deficient Encapsulation"
# SMELL_WEA_MOD = "Weakend Modularity"
# FILE_RES = " File "
# SERVICE_RES = " Service "
# PACKAGE_RES = " Package "
# CLASS_RES = " Class "
# DEFINE_RES = " Define "
# MODULE_RES = " Module "
# REPO_RES = " Repo "
# NODES_RES = " Node "
# REPO_MANIFEST = " Manifest(Repo) "
# MODULE_MANIFEST = " Manifest(Module) "
# OTHERFILES = " Others "
# MODULES = "modules"
# MANIFESTS = "manifests"
# LCOM_THRESHOLD = 0.7
# SIZE_THRESHOLD_UNNABS = 2
# LOC_THRESHOLD_UNNABS = 3
# IMPABS_THRESHOLD = 0.2
# IMPABS_MAXEXECCOUNT = 2
# MISABS_MAX_NON_ABS_COUNT = 2
# MAX_CLASS_LOC_THRESHOLD = 40
# MAX_DEFINE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD
# MAX_MODULE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD * 2
# MAX_NESTING_DEPTH = 3
# MAX_MANIFESTS_PUPPET_FILES = 5
# MAX_ALLOWED_NONSTANDARD_FILES = 3
# MAX_GRAPH_DEGREE_THRESHOLD = 0.5
# MODULARITY_THRESHOLD = 1.0
#
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | classAndDefineCount = len(fileObj.getOuterClassList() + fileObj.getOuterDefineList()) |
Given the code snippet: <|code_start|>
class SM_ServiceResource(SourceModel.SM_Element.SM_Element):
def __init__(self, text):
self.resourceText = text
super().__init__(text)
def getUsedVariables(self):
return super().getUsedVariables()
def getPhysicalResourceDeclarationCount(self):
compiledRE = re.compile(r'\'.+\'\W*:|\".+\":')
tempVar = compiledRE.findall(self.resourceText)
Utilities.myPrint("Found service declarations: " + str(tempVar))
return len(tempVar)
def getResourceName(self):
match = re.search(SMCONSTS.SERVICE_GROUP_REGEX, self.resourceText)
name = ""
if match:
<|code_end|>
, generate the next line using the imports in this file:
import re
import SourceModel.SM_Constants as SMCONSTS
import SourceModel.SM_Element
from SmellDetector import Utilities
and context (functions, classes, or occasionally code) from other files:
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | name = match.group(1) |
Using the snippet: <|code_start|> outFileName = "tmp/unstructuredModForm3Test.txt"
outFile = open(outFileName, 'w')
ModSmellDectector.detectUnsModForm3(folderName, outFile)
outFile.close()
outFileRead = open(outFileName, 'r')
self.assertGreater(len(outFileRead.read()), 0)
def test_detectTCMod(self):
#fileName = "/Users/Tushar/Documents/Research/PuppetQuality/Repos/operations-puppet-production/manifests/role/authdns.pp"
fileName = "/Users/Tushar/Documents/Research/PuppetQuality/Repos/cmits/cmits-example/modules-unclass/searde_svn/manifests/server.pp"
outFileName = "tmp/TCModTest.txt"
fileObj = SourceModel.SM_File.SM_File(fileName)
outFile = open(outFileName, 'w')
ModSmellDectector.detectTCMod(fileObj, outFile)
outFile.close()
outFileRead = open(outFileName, 'r')
self.assertGreater(len(outFileRead.read()), 0)
def test_detectHairballStr(self):
folderName = "/Users/Tushar/Documents/Research/PuppetQuality/Repos/operations-puppet/"
outFileName = "tmp/getGraphTest.txt"
outFile = open(outFileName, 'w')
graph = ModSmellDectector.getGraph(folderName)
ModSmellDectector.detectHaiStr(graph, folderName, outFile)
#graph.printGraph()
outFile.close()
outFileRead = open(outFileName, 'r')
self.assertGreater(len(outFileRead.read()), 0)
def test_detectWeakendMod(self):
<|code_end|>
, determine the next line of code. You have imports:
from unittest import TestCase
from SmellDetector import ModSmellDectector
import SourceModel.SM_File
and context (class names, function names, or code) available:
# Path: SmellDetector/ModSmellDectector.py
# def detectSmells(folder, outputFile):
# def detectInsufficientMod(folder, outputFile):
# def detectUnstructuredMod(folder, outputFile):
# def detectTightlyCoupledMod(folder, outputFile):
# def detectHairballStrAndWeakendMod(folder, outputFile):
# def detectInsufficientModForm1(folder, outputFile):
# def detectInsModForm1(fileObj, outputFile):
# def detectInsufficientModForm2(folder, outputFile):
# def detectInsModForm2(fileObj, outputFile):
# def detectInsufficientModForm3(folder, outputFile):
# def detectInsModForm3(fileobj, outputFile):
# def detectUnstructuredModForm1(folder, outputFile):
# def isModulesExists(folder):
# def getModulesFolder(folder):
# def getManifestsFolder(folder):
# def detectUnstructuredModForm2(folder, outputFile):
# def detectUnsModForm2(folder, outputFile):
# def detectUnstructuredModForm3(folder, outputFile):
# def detectUnsModForm3(folder, outputFile):
# def detectTCMod(fileObj, outputFile):
# def getGraph(folder):
# def addGraphNodes(folder, graph):
# def addGraphNodesFromModules(folder, graph):
# def addGraphResources(node, aModule):
# def addResources(fileObj, node):
# def addGraphNodesFromRestPuppetFiles(folder, graph):
# def addGraphEdges(folder, graph):
# def addGraphEdgesFromModules(folder, graph):
# def addGraphEdgesByNode(node, graph, aModule):
# def addEdges(fileObj, node, graph):
# def searchDependentNode(graph, node, name, type):
# def addGraphEdgesFromRestPuppetFiles(folder, graph):
# def detectHaiStr(graph, folder, outputFile):
# def detectWeakendMod(graph, folder, outputFile):
. Output only the next line. | folderName = "/Users/Tushar/Documents/Research/PuppetQuality/Repos/devbox/modules/php/" |
Based on the snippet: <|code_start|>
def detectSmells(folder, outputFile):
detectDeficientEnc(folder, outputFile)
def detectDeficientEnc(folder, outputFile):
for root, dirs, files in os.walk(folder):
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import SourceModel.SM_File
from SmellDetector import Constants as CONSTS, Utilities
and context (classes, functions, sometimes code) from other files:
# Path: SmellDetector/Constants.py
# REPO_ROOT = "/Users/user/Desktop/puppetAnalysis"
# AGGREGATOR_FILE = "AggregatedOutput.csv"
# CSV_HEADER = "Repo_name,PuppetFileCount,ClassCount,DefineCount,FileResourceCount,PackageResourceCount,\
# ServiceResourceCount,ExecCount,LOC,MultifacetedAbs,UnnecessaryAbs,ImperativeAbs,MissingAbs,\
# InsufficientMod,UnstructuredMod,TightlyCoupledMod,DuplicateAbs,MissingDep,BrokenHie,HairballStr,\
# DeficientEnc,WeakendMod\n"
# PUPPETEER_OUT_FILE = "Puppeteer_output.txt"
# PUPPET_FILE_COUNT = "Puppet file count: "
# TOTAL_CLASS_DECLS = "Total class declarations: "
# TOTAL_DEFINE_DECLS = "Total define declarations: "
# TOTAL_FILE_RES_DECLS = "Total file declarations: "
# TOTAL_PACKAGE_RES_DECLS = "Total package declarations: "
# TOTAL_SERVICE_RES_DECLS = "Total service declarations: "
# TOTAL_EXEC_DECLS = "Total exec declarations: "
# TOTAL_LOC = "Total LOC: "
# DEBUG_ON = False
# SMELL_MUL_ABS_1 = "Multifaceted Abstraction - Form 1"
# SMELL_MUL_ABS_2 = "Multifaceted Abstraction - Form 2"
# SMELL_UNN_ABS = "Unnecessary Abstraction"
# SMELL_IMP_ABS = "Imperative Abstraction"
# SMELL_MIS_ABS = "Missing Abstraction"
# SMELL_INS_MOD_1 = "Insufficient Modularization - Form 1"
# SMELL_INS_MOD_2 = "Insufficient Modularization - Form 2"
# SMELL_INS_MOD_3 = "Insufficient Modularization - Form 3"
# SMELL_UNS_MOD_1 = "Unstructured Module - Form 1"
# SMELL_UNS_MOD_2 = "Unstructured Module - Form 2"
# SMELL_UNS_MOD_3 = "Unstructured Module - Form 3"
# SMELL_TC_MOD = "Tightly-coupled Module"
# SMELL_DUP_ABS = "Duplicate Abstraction"
# SMELL_BRO_HIE = "Broken Hierarchy"
# SMELL_MIS_DEP = "Missing Dependency"
# SMELL_HAI_STR = "Hairball Structure"
# SMELL_DEF_ENC = "Deficient Encapsulation"
# SMELL_WEA_MOD = "Weakend Modularity"
# FILE_RES = " File "
# SERVICE_RES = " Service "
# PACKAGE_RES = " Package "
# CLASS_RES = " Class "
# DEFINE_RES = " Define "
# MODULE_RES = " Module "
# REPO_RES = " Repo "
# NODES_RES = " Node "
# REPO_MANIFEST = " Manifest(Repo) "
# MODULE_MANIFEST = " Manifest(Module) "
# OTHERFILES = " Others "
# MODULES = "modules"
# MANIFESTS = "manifests"
# LCOM_THRESHOLD = 0.7
# SIZE_THRESHOLD_UNNABS = 2
# LOC_THRESHOLD_UNNABS = 3
# IMPABS_THRESHOLD = 0.2
# IMPABS_MAXEXECCOUNT = 2
# MISABS_MAX_NON_ABS_COUNT = 2
# MAX_CLASS_LOC_THRESHOLD = 40
# MAX_DEFINE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD
# MAX_MODULE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD * 2
# MAX_NESTING_DEPTH = 3
# MAX_MANIFESTS_PUPPET_FILES = 5
# MAX_ALLOWED_NONSTANDARD_FILES = 3
# MAX_GRAPH_DEGREE_THRESHOLD = 0.5
# MODULARITY_THRESHOLD = 1.0
#
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | for file in files: |
Using the snippet: <|code_start|>def getPackageCount(line, packageCount):
pkgResourceCountIndex = line.find(CONSTS.TOTAL_PACKAGE_RES_DECLS)
if pkgResourceCountIndex >= 0:
packageCount = int(line[pkgResourceCountIndex + len(CONSTS.TOTAL_PACKAGE_RES_DECLS): len(line)])
return packageCount
def getFileResourceCount(fileResourceCount, line):
fileResourceCountIndex = line.find(CONSTS.TOTAL_FILE_RES_DECLS)
if fileResourceCountIndex >= 0:
fileResourceCount = int(line[fileResourceCountIndex + len(CONSTS.TOTAL_FILE_RES_DECLS): len(line)])
return fileResourceCount
def getDefineCount(defineCount, line):
defineCountIndex = line.find(CONSTS.TOTAL_DEFINE_DECLS)
if defineCountIndex >= 0:
defineCount = int(line[defineCountIndex + len(CONSTS.TOTAL_DEFINE_DECLS): len(line)])
return defineCount
def getClassCount(classCount, line):
classCountIndex = line.find(CONSTS.TOTAL_CLASS_DECLS)
if classCountIndex >= 0:
classCount = int(line[classCountIndex + len(CONSTS.TOTAL_CLASS_DECLS): len(line)])
return classCount
def getFileCount(fileCount, line):
fileCountIndex = line.find(CONSTS.PUPPET_FILE_COUNT)
<|code_end|>
, determine the next line of code. You have imports:
from SmellDetector import Constants as CONSTS
and context (class names, function names, or code) available:
# Path: SmellDetector/Constants.py
# REPO_ROOT = "/Users/user/Desktop/puppetAnalysis"
# AGGREGATOR_FILE = "AggregatedOutput.csv"
# CSV_HEADER = "Repo_name,PuppetFileCount,ClassCount,DefineCount,FileResourceCount,PackageResourceCount,\
# ServiceResourceCount,ExecCount,LOC,MultifacetedAbs,UnnecessaryAbs,ImperativeAbs,MissingAbs,\
# InsufficientMod,UnstructuredMod,TightlyCoupledMod,DuplicateAbs,MissingDep,BrokenHie,HairballStr,\
# DeficientEnc,WeakendMod\n"
# PUPPETEER_OUT_FILE = "Puppeteer_output.txt"
# PUPPET_FILE_COUNT = "Puppet file count: "
# TOTAL_CLASS_DECLS = "Total class declarations: "
# TOTAL_DEFINE_DECLS = "Total define declarations: "
# TOTAL_FILE_RES_DECLS = "Total file declarations: "
# TOTAL_PACKAGE_RES_DECLS = "Total package declarations: "
# TOTAL_SERVICE_RES_DECLS = "Total service declarations: "
# TOTAL_EXEC_DECLS = "Total exec declarations: "
# TOTAL_LOC = "Total LOC: "
# DEBUG_ON = False
# SMELL_MUL_ABS_1 = "Multifaceted Abstraction - Form 1"
# SMELL_MUL_ABS_2 = "Multifaceted Abstraction - Form 2"
# SMELL_UNN_ABS = "Unnecessary Abstraction"
# SMELL_IMP_ABS = "Imperative Abstraction"
# SMELL_MIS_ABS = "Missing Abstraction"
# SMELL_INS_MOD_1 = "Insufficient Modularization - Form 1"
# SMELL_INS_MOD_2 = "Insufficient Modularization - Form 2"
# SMELL_INS_MOD_3 = "Insufficient Modularization - Form 3"
# SMELL_UNS_MOD_1 = "Unstructured Module - Form 1"
# SMELL_UNS_MOD_2 = "Unstructured Module - Form 2"
# SMELL_UNS_MOD_3 = "Unstructured Module - Form 3"
# SMELL_TC_MOD = "Tightly-coupled Module"
# SMELL_DUP_ABS = "Duplicate Abstraction"
# SMELL_BRO_HIE = "Broken Hierarchy"
# SMELL_MIS_DEP = "Missing Dependency"
# SMELL_HAI_STR = "Hairball Structure"
# SMELL_DEF_ENC = "Deficient Encapsulation"
# SMELL_WEA_MOD = "Weakend Modularity"
# FILE_RES = " File "
# SERVICE_RES = " Service "
# PACKAGE_RES = " Package "
# CLASS_RES = " Class "
# DEFINE_RES = " Define "
# MODULE_RES = " Module "
# REPO_RES = " Repo "
# NODES_RES = " Node "
# REPO_MANIFEST = " Manifest(Repo) "
# MODULE_MANIFEST = " Manifest(Module) "
# OTHERFILES = " Others "
# MODULES = "modules"
# MANIFESTS = "manifests"
# LCOM_THRESHOLD = 0.7
# SIZE_THRESHOLD_UNNABS = 2
# LOC_THRESHOLD_UNNABS = 3
# IMPABS_THRESHOLD = 0.2
# IMPABS_MAXEXECCOUNT = 2
# MISABS_MAX_NON_ABS_COUNT = 2
# MAX_CLASS_LOC_THRESHOLD = 40
# MAX_DEFINE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD
# MAX_MODULE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD * 2
# MAX_NESTING_DEPTH = 3
# MAX_MANIFESTS_PUPPET_FILES = 5
# MAX_ALLOWED_NONSTANDARD_FILES = 3
# MAX_GRAPH_DEGREE_THRESHOLD = 0.5
# MODULARITY_THRESHOLD = 1.0
. Output only the next line. | if fileCountIndex >= 0: |
Here is a snippet: <|code_start|>
class SM_FileResource(SourceModel.SM_Element.SM_Element):
def __init__(self, text):
self.resourceText = text
super().__init__(text)
def getUsedVariables(self):
return super().getUsedVariables()
def getPhysicalResourceDeclarationCount(self):
compiledRE = re.compile(r'\'.+\'\W*:|\".+\":')
tempVar = compiledRE.findall(self.resourceText)
Utilities.myPrint("Found file declarations: " + str(tempVar))
return len(tempVar)
def getResourceName(self):
match = re.search(SMCONSTS.FILE_GROUP_REGEX, self.resourceText)
name =""
if match:
name = match.group(1)
return str(name)
def getDependentResource(self):
resultList = []
self.getDependentResource_(resultList, SMCONSTS.DEPENDENT_PACKAGE, SMCONSTS.DEPENDENT_GROUP_PACKAGE, SMCONSTS.PACKAGE)
self.getDependentResource_(resultList, SMCONSTS.DEPENDENT_SERVICE, SMCONSTS.DEPENDENT_GROUP_SERVICE, SMCONSTS.SERVICE)
self.getDependentResource_(resultList, SMCONSTS.DEPENDENT_FILE, SMCONSTS.DEPENDENT_GROUP_FILE, SMCONSTS.FILE)
<|code_end|>
. Write the next line using the current file imports:
import re
import SourceModel.SM_Constants as SMCONSTS
import SourceModel.SM_Element
from SmellDetector import Utilities
and context from other files:
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
, which may include functions, classes, or code. Output only the next line. | self.getDependentResource_(resultList, SMCONSTS.DEPENDENT_CLASS, SMCONSTS.DEPENDENT_GROUP_CLASS, SMCONSTS.CLASS) |
Based on the snippet: <|code_start|>
def collectSizeMetrics(folder, outputFile):
totalClasses = 0
totalDefines = 0
totalFiles = 0
totalPackages = 0
totalServices = 0
totalExecs = 0
totalLOC = 0
for root, dirs, files in os.walk(folder):
for file in files:
if file.endswith(".pp") and not os.path.islink(os.path.join(root, file)):
Utilities.myPrint("Reading file: " + os.path.join(root, file))
fileObj = SourceModel.SM_File.SM_File(os.path.join(root, file))
totalClasses += fileObj.getNoOfClassDeclarations()
totalDefines += fileObj.getNoOfDefineDeclarations()
totalFiles += fileObj.getNoOfFileDeclarations()
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import SourceModel.SM_File
from SmellDetector import Constants as CONSTS, Utilities
and context (classes, functions, sometimes code) from other files:
# Path: SmellDetector/Constants.py
# REPO_ROOT = "/Users/user/Desktop/puppetAnalysis"
# AGGREGATOR_FILE = "AggregatedOutput.csv"
# CSV_HEADER = "Repo_name,PuppetFileCount,ClassCount,DefineCount,FileResourceCount,PackageResourceCount,\
# ServiceResourceCount,ExecCount,LOC,MultifacetedAbs,UnnecessaryAbs,ImperativeAbs,MissingAbs,\
# InsufficientMod,UnstructuredMod,TightlyCoupledMod,DuplicateAbs,MissingDep,BrokenHie,HairballStr,\
# DeficientEnc,WeakendMod\n"
# PUPPETEER_OUT_FILE = "Puppeteer_output.txt"
# PUPPET_FILE_COUNT = "Puppet file count: "
# TOTAL_CLASS_DECLS = "Total class declarations: "
# TOTAL_DEFINE_DECLS = "Total define declarations: "
# TOTAL_FILE_RES_DECLS = "Total file declarations: "
# TOTAL_PACKAGE_RES_DECLS = "Total package declarations: "
# TOTAL_SERVICE_RES_DECLS = "Total service declarations: "
# TOTAL_EXEC_DECLS = "Total exec declarations: "
# TOTAL_LOC = "Total LOC: "
# DEBUG_ON = False
# SMELL_MUL_ABS_1 = "Multifaceted Abstraction - Form 1"
# SMELL_MUL_ABS_2 = "Multifaceted Abstraction - Form 2"
# SMELL_UNN_ABS = "Unnecessary Abstraction"
# SMELL_IMP_ABS = "Imperative Abstraction"
# SMELL_MIS_ABS = "Missing Abstraction"
# SMELL_INS_MOD_1 = "Insufficient Modularization - Form 1"
# SMELL_INS_MOD_2 = "Insufficient Modularization - Form 2"
# SMELL_INS_MOD_3 = "Insufficient Modularization - Form 3"
# SMELL_UNS_MOD_1 = "Unstructured Module - Form 1"
# SMELL_UNS_MOD_2 = "Unstructured Module - Form 2"
# SMELL_UNS_MOD_3 = "Unstructured Module - Form 3"
# SMELL_TC_MOD = "Tightly-coupled Module"
# SMELL_DUP_ABS = "Duplicate Abstraction"
# SMELL_BRO_HIE = "Broken Hierarchy"
# SMELL_MIS_DEP = "Missing Dependency"
# SMELL_HAI_STR = "Hairball Structure"
# SMELL_DEF_ENC = "Deficient Encapsulation"
# SMELL_WEA_MOD = "Weakend Modularity"
# FILE_RES = " File "
# SERVICE_RES = " Service "
# PACKAGE_RES = " Package "
# CLASS_RES = " Class "
# DEFINE_RES = " Define "
# MODULE_RES = " Module "
# REPO_RES = " Repo "
# NODES_RES = " Node "
# REPO_MANIFEST = " Manifest(Repo) "
# MODULE_MANIFEST = " Manifest(Module) "
# OTHERFILES = " Others "
# MODULES = "modules"
# MANIFESTS = "manifests"
# LCOM_THRESHOLD = 0.7
# SIZE_THRESHOLD_UNNABS = 2
# LOC_THRESHOLD_UNNABS = 3
# IMPABS_THRESHOLD = 0.2
# IMPABS_MAXEXECCOUNT = 2
# MISABS_MAX_NON_ABS_COUNT = 2
# MAX_CLASS_LOC_THRESHOLD = 40
# MAX_DEFINE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD
# MAX_MODULE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD * 2
# MAX_NESTING_DEPTH = 3
# MAX_MANIFESTS_PUPPET_FILES = 5
# MAX_ALLOWED_NONSTANDARD_FILES = 3
# MAX_GRAPH_DEGREE_THRESHOLD = 0.5
# MODULARITY_THRESHOLD = 1.0
#
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | totalPackages += fileObj.getNoOfPackageDeclarations() |
Given the following code snippet before the placeholder: <|code_start|>class SM_PackageResource(SourceModel.SM_Element.SM_Element):
def __init__(self, text):
self.resourceText = text
super().__init__(text)
def getUsedVariables(self):
return super().getUsedVariables()
def getPhysicalResourceDeclarationCount(self):
pkg_count = 0
compiledRE = re.compile(r'\'.+\'\W*:|\".+\":')
tempVar = compiledRE.findall(self.resourceText)
Utilities.myPrint("Found package declarations: " + str(tempVar))
pkg_count = len(tempVar)
# Find list type package declarations
compiledRE = re.compile(r'{\[((\".+?\"),?)+\]:\s*}')
result = compiledRE.finditer(self.resourceText)
all_pkgs = ""
for m in result:
all_pkgs = m.group(1)
pkgs = all_pkgs.split(',')
for pkg in pkgs:
Utilities.myPrint("Found package declarations: " + str(pkg))
pkg_count += len(pkgs)
return pkg_count
def getResourceName(self):
match = re.search(SMCONSTS.PACKAGE_GROUP_REGEX, self.resourceText)
name =""
if match:
<|code_end|>
, predict the next line using imports from the current file:
import re
import SourceModel.SM_Constants as SMCONSTS
import SourceModel.SM_Element
from SmellDetector import Utilities
and context including class names, function names, and sometimes code from other files:
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | name = match.group(1) |
Predict the next line after this snippet: <|code_start|>
root = CONSTS.REPO_ROOT
print("Initiating Analyzer...")
totalRepos = len(os.listdir(root))
currentItem = 0
for item in os.listdir(root):
currentFolder = os.path.join(root, item)
#print("Anlyzing: " + currentFolder)
if not os.path.isfile(currentFolder):
Analyzer.analyze(currentFolder, item)
currentItem += 1
<|code_end|>
using the current file's imports:
import os
import Aggregator
from SmellDetector import Constants as CONSTS, Analyzer
and any relevant context from other files:
# Path: SmellDetector/Constants.py
# REPO_ROOT = "/Users/user/Desktop/puppetAnalysis"
# AGGREGATOR_FILE = "AggregatedOutput.csv"
# CSV_HEADER = "Repo_name,PuppetFileCount,ClassCount,DefineCount,FileResourceCount,PackageResourceCount,\
# ServiceResourceCount,ExecCount,LOC,MultifacetedAbs,UnnecessaryAbs,ImperativeAbs,MissingAbs,\
# InsufficientMod,UnstructuredMod,TightlyCoupledMod,DuplicateAbs,MissingDep,BrokenHie,HairballStr,\
# DeficientEnc,WeakendMod\n"
# PUPPETEER_OUT_FILE = "Puppeteer_output.txt"
# PUPPET_FILE_COUNT = "Puppet file count: "
# TOTAL_CLASS_DECLS = "Total class declarations: "
# TOTAL_DEFINE_DECLS = "Total define declarations: "
# TOTAL_FILE_RES_DECLS = "Total file declarations: "
# TOTAL_PACKAGE_RES_DECLS = "Total package declarations: "
# TOTAL_SERVICE_RES_DECLS = "Total service declarations: "
# TOTAL_EXEC_DECLS = "Total exec declarations: "
# TOTAL_LOC = "Total LOC: "
# DEBUG_ON = False
# SMELL_MUL_ABS_1 = "Multifaceted Abstraction - Form 1"
# SMELL_MUL_ABS_2 = "Multifaceted Abstraction - Form 2"
# SMELL_UNN_ABS = "Unnecessary Abstraction"
# SMELL_IMP_ABS = "Imperative Abstraction"
# SMELL_MIS_ABS = "Missing Abstraction"
# SMELL_INS_MOD_1 = "Insufficient Modularization - Form 1"
# SMELL_INS_MOD_2 = "Insufficient Modularization - Form 2"
# SMELL_INS_MOD_3 = "Insufficient Modularization - Form 3"
# SMELL_UNS_MOD_1 = "Unstructured Module - Form 1"
# SMELL_UNS_MOD_2 = "Unstructured Module - Form 2"
# SMELL_UNS_MOD_3 = "Unstructured Module - Form 3"
# SMELL_TC_MOD = "Tightly-coupled Module"
# SMELL_DUP_ABS = "Duplicate Abstraction"
# SMELL_BRO_HIE = "Broken Hierarchy"
# SMELL_MIS_DEP = "Missing Dependency"
# SMELL_HAI_STR = "Hairball Structure"
# SMELL_DEF_ENC = "Deficient Encapsulation"
# SMELL_WEA_MOD = "Weakend Modularity"
# FILE_RES = " File "
# SERVICE_RES = " Service "
# PACKAGE_RES = " Package "
# CLASS_RES = " Class "
# DEFINE_RES = " Define "
# MODULE_RES = " Module "
# REPO_RES = " Repo "
# NODES_RES = " Node "
# REPO_MANIFEST = " Manifest(Repo) "
# MODULE_MANIFEST = " Manifest(Module) "
# OTHERFILES = " Others "
# MODULES = "modules"
# MANIFESTS = "manifests"
# LCOM_THRESHOLD = 0.7
# SIZE_THRESHOLD_UNNABS = 2
# LOC_THRESHOLD_UNNABS = 3
# IMPABS_THRESHOLD = 0.2
# IMPABS_MAXEXECCOUNT = 2
# MISABS_MAX_NON_ABS_COUNT = 2
# MAX_CLASS_LOC_THRESHOLD = 40
# MAX_DEFINE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD
# MAX_MODULE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD * 2
# MAX_NESTING_DEPTH = 3
# MAX_MANIFESTS_PUPPET_FILES = 5
# MAX_ALLOWED_NONSTANDARD_FILES = 3
# MAX_GRAPH_DEGREE_THRESHOLD = 0.5
# MODULARITY_THRESHOLD = 1.0
#
# Path: SmellDetector/Analyzer.py
# def analyze(folder, repoName):
. Output only the next line. | print (str("{:.2f}".format(float(currentItem * 100)/float(totalRepos))) + "% analysis done.") |
Here is a snippet: <|code_start|> def test_detectMulAbsInModule_NegativeCase(self):
fileName = "/Users/Tushar/Documents/Research/PuppetQuality/Repos/cmits/cmits-example/modules-unclass/automount/manifests/subdir.pp"
testFile = "tmp/multifacetedAbsForm2ModuleTest.txt"
fileObj = SourceModel.SM_File.SM_File(fileName)
outFile = open(testFile, 'w')
AbsSmellDectector.detectMulAbsInModule(fileObj, outFile)
outFile.close()
outFileRead = open(testFile, 'r')
self.assertEquals(len(outFileRead.read()), 0)
def test_detectUnnAbsInClasses(self):
fileName = "/Users/Tushar/Documents/Research/PuppetQuality/Repos/cmits/cmits-example/modules-unclass/location/manifests/no/redhat.pp"
testFile = "tmp/unnecessaryAbsTest.txt"
fileObj = SourceModel.SM_File.SM_File(fileName)
outFile = open(testFile, 'w')
AbsSmellDectector.detectUnnAbsInClasses(fileObj, outFile)
outFile.close()
outFileRead = open(testFile, 'r')
self.assertGreater(len(outFileRead.read()), 0)
def test_detectUnnAbsInDefine(self):
fileName = "/Users/Tushar/Documents/Research/PuppetQuality/Repos/cmits/cmits-example/modules-unclass/hpc_cluster/spec/fixtures/modules/proxy/manifests/yum.pp"
testFile = "tmp/unnecessaryAbsTest.txt"
fileObj = SourceModel.SM_File.SM_File(fileName)
outFile = open(testFile, 'w')
AbsSmellDectector.detectUnnAbsInDefine(fileObj, outFile)
outFile.close()
outFileRead = open(testFile, 'r')
self.assertGreater(len(outFileRead.read()), 0)
<|code_end|>
. Write the next line using the current file imports:
from unittest import TestCase
from SmellDetector import AbsSmellDectector
import SourceModel.SM_File
and context from other files:
# Path: SmellDetector/AbsSmellDectector.py
# def detectSmells(folder, outputFile):
# def detectMultifacetedAbs(folder, outputFile):
# def detectUnnecessaryAbs(folder, outputFile):
# def detectImperativeAbs(folder, outputFile):
# def detectImpAbs(fileObj, outputFile):
# def detectDuplicateAbs(folder, outputFile):
# def getCpdXmlFile(folder):
# def detectMissingAbs(folder, outputFile):
# def detectMisAbs(fileObj, outputFile):
# def detectMultifacetedAbsForm1(folder, outputFile):
# def checkWithFileResource(fileObj, outputFile):
# def checkWithServiceResource(fileObj, outputFile):
# def checkWithPackageResource(fileObj, outputFile):
# def detectMultifacetedAbsForm2(folder, outputFile):
# def detectMulAbsInClass(fileObj, outputFile):
# def detectMulAbsInDefine(fileObj, outputFile):
# def detectMulAbsInModule(fileObj, outputFile):
# def detectUnnAbsInClasses(fileObj, outputFile):
# def detectUnnAbsInDefine(fileObj, outputFile):
# def detectUnnAbsInModules(fileObj, outputFile):
, which may include functions, classes, or code. Output only the next line. | def test_detectUnnAbsInModules(self): |
Given the following code snippet before the placeholder: <|code_start|>
def analyze(folder, repoName):
outputFile = open(folder + "/" + CONSTS.PUPPETEER_OUT_FILE, 'w')
puppetFileCount = FileOperations.countPuppetFiles(folder)
outputFile.write(CONSTS.PUPPET_FILE_COUNT + str(puppetFileCount) + "\n")
Utilities.myPrint(CONSTS.PUPPET_FILE_COUNT + str(puppetFileCount))
SizeMetrics.collectSizeMetrics(folder, outputFile)
SmellDectector.detectSmells(folder, outputFile)
<|code_end|>
, predict the next line using imports from the current file:
import SmellDetector.Constants as CONSTS
from SmellDetector import SmellDectector, SizeMetrics, FileOperations, Utilities
and context including class names, function names, and sometimes code from other files:
# Path: SmellDetector/SmellDectector.py
# def detectSmells(folder, outputFile):
#
# Path: SmellDetector/SizeMetrics.py
# def collectSizeMetrics(folder, outputFile):
#
# Path: SmellDetector/FileOperations.py
# def countPuppetFiles(folder):
#
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | outputFile.close() |
Given the following code snippet before the placeholder: <|code_start|>
def analyze(folder, repoName):
outputFile = open(folder + "/" + CONSTS.PUPPETEER_OUT_FILE, 'w')
puppetFileCount = FileOperations.countPuppetFiles(folder)
outputFile.write(CONSTS.PUPPET_FILE_COUNT + str(puppetFileCount) + "\n")
Utilities.myPrint(CONSTS.PUPPET_FILE_COUNT + str(puppetFileCount))
SizeMetrics.collectSizeMetrics(folder, outputFile)
SmellDectector.detectSmells(folder, outputFile)
<|code_end|>
, predict the next line using imports from the current file:
import SmellDetector.Constants as CONSTS
from SmellDetector import SmellDectector, SizeMetrics, FileOperations, Utilities
and context including class names, function names, and sometimes code from other files:
# Path: SmellDetector/SmellDectector.py
# def detectSmells(folder, outputFile):
#
# Path: SmellDetector/SizeMetrics.py
# def collectSizeMetrics(folder, outputFile):
#
# Path: SmellDetector/FileOperations.py
# def countPuppetFiles(folder):
#
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | outputFile.close() |
Given the following code snippet before the placeholder: <|code_start|>
def detectSmells(folder, outputFile):
detectMissingDep(folder, outputFile)
def detectMissingDep(folder, outputFile):
detectMissingModules(folder, outputFile)
def detectMissingModules(folder, outputFile):
#print("%s" % (inspect.stack()[0][3]))
classNamesSet = set()
<|code_end|>
, predict the next line using imports from the current file:
import os
import SourceModel.SM_File
from SmellDetector import Constants as CONSTS, Utilities
and context including class names, function names, and sometimes code from other files:
# Path: SmellDetector/Constants.py
# REPO_ROOT = "/Users/user/Desktop/puppetAnalysis"
# AGGREGATOR_FILE = "AggregatedOutput.csv"
# CSV_HEADER = "Repo_name,PuppetFileCount,ClassCount,DefineCount,FileResourceCount,PackageResourceCount,\
# ServiceResourceCount,ExecCount,LOC,MultifacetedAbs,UnnecessaryAbs,ImperativeAbs,MissingAbs,\
# InsufficientMod,UnstructuredMod,TightlyCoupledMod,DuplicateAbs,MissingDep,BrokenHie,HairballStr,\
# DeficientEnc,WeakendMod\n"
# PUPPETEER_OUT_FILE = "Puppeteer_output.txt"
# PUPPET_FILE_COUNT = "Puppet file count: "
# TOTAL_CLASS_DECLS = "Total class declarations: "
# TOTAL_DEFINE_DECLS = "Total define declarations: "
# TOTAL_FILE_RES_DECLS = "Total file declarations: "
# TOTAL_PACKAGE_RES_DECLS = "Total package declarations: "
# TOTAL_SERVICE_RES_DECLS = "Total service declarations: "
# TOTAL_EXEC_DECLS = "Total exec declarations: "
# TOTAL_LOC = "Total LOC: "
# DEBUG_ON = False
# SMELL_MUL_ABS_1 = "Multifaceted Abstraction - Form 1"
# SMELL_MUL_ABS_2 = "Multifaceted Abstraction - Form 2"
# SMELL_UNN_ABS = "Unnecessary Abstraction"
# SMELL_IMP_ABS = "Imperative Abstraction"
# SMELL_MIS_ABS = "Missing Abstraction"
# SMELL_INS_MOD_1 = "Insufficient Modularization - Form 1"
# SMELL_INS_MOD_2 = "Insufficient Modularization - Form 2"
# SMELL_INS_MOD_3 = "Insufficient Modularization - Form 3"
# SMELL_UNS_MOD_1 = "Unstructured Module - Form 1"
# SMELL_UNS_MOD_2 = "Unstructured Module - Form 2"
# SMELL_UNS_MOD_3 = "Unstructured Module - Form 3"
# SMELL_TC_MOD = "Tightly-coupled Module"
# SMELL_DUP_ABS = "Duplicate Abstraction"
# SMELL_BRO_HIE = "Broken Hierarchy"
# SMELL_MIS_DEP = "Missing Dependency"
# SMELL_HAI_STR = "Hairball Structure"
# SMELL_DEF_ENC = "Deficient Encapsulation"
# SMELL_WEA_MOD = "Weakend Modularity"
# FILE_RES = " File "
# SERVICE_RES = " Service "
# PACKAGE_RES = " Package "
# CLASS_RES = " Class "
# DEFINE_RES = " Define "
# MODULE_RES = " Module "
# REPO_RES = " Repo "
# NODES_RES = " Node "
# REPO_MANIFEST = " Manifest(Repo) "
# MODULE_MANIFEST = " Manifest(Module) "
# OTHERFILES = " Others "
# MODULES = "modules"
# MANIFESTS = "manifests"
# LCOM_THRESHOLD = 0.7
# SIZE_THRESHOLD_UNNABS = 2
# LOC_THRESHOLD_UNNABS = 3
# IMPABS_THRESHOLD = 0.2
# IMPABS_MAXEXECCOUNT = 2
# MISABS_MAX_NON_ABS_COUNT = 2
# MAX_CLASS_LOC_THRESHOLD = 40
# MAX_DEFINE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD
# MAX_MODULE_LOC_THRESHOLD = MAX_CLASS_LOC_THRESHOLD * 2
# MAX_NESTING_DEPTH = 3
# MAX_MANIFESTS_PUPPET_FILES = 5
# MAX_ALLOWED_NONSTANDARD_FILES = 3
# MAX_GRAPH_DEGREE_THRESHOLD = 0.5
# MODULARITY_THRESHOLD = 1.0
#
# Path: SmellDetector/Utilities.py
# def myPrint(msg):
# def reportSmell(outputFile, fileName, smellName, reason):
# def intersection(list1, list2):
# def summation(list1, list2):
. Output only the next line. | includeClassSet = set() |
Given the following code snippet before the placeholder: <|code_start|> def __init__(self, date_col=None, order_by=(), sampling_expr=None,
index_granularity=8192, replica_table_path=None, replica_name=None, partition_key=None,
primary_key=None):
assert type(order_by) in (list, tuple), 'order_by must be a list or tuple'
assert date_col is None or isinstance(date_col, str), 'date_col must be string if present'
assert primary_key is None or type(primary_key) in (list, tuple), 'primary_key must be a list or tuple'
assert partition_key is None or type(partition_key) in (list, tuple),\
'partition_key must be tuple or list if present'
assert (replica_table_path is None) == (replica_name is None), \
'both replica_table_path and replica_name must be specified'
# These values conflict with each other (old and new syntax of table engines.
# So let's control only one of them is given.
assert date_col or partition_key, "You must set either date_col or partition_key"
self.date_col = date_col
self.partition_key = partition_key if partition_key else ('toYYYYMM(`%s`)' % date_col,)
self.primary_key = primary_key
self.order_by = order_by
self.sampling_expr = sampling_expr
self.index_granularity = index_granularity
self.replica_table_path = replica_table_path
self.replica_name = replica_name
# I changed field name for new reality and syntax
@property
def key_cols(self):
logger.warning('`key_cols` attribute is deprecated and may be removed in future. Use `order_by` attribute instead')
return self.order_by
<|code_end|>
, predict the next line using imports from the current file:
import logging
from .utils import comma_join, get_subclass_names
from infi.clickhouse_orm.database import DatabaseException
from .models import ModelBase
and context including class names, function names, and sometimes code from other files:
# Path: src/infi/clickhouse_orm/utils.py
# def comma_join(items, stringify=False):
# """
# Joins an iterable of strings with commas.
# """
# if stringify:
# return ', '.join(str(item) for item in items)
# else:
# return ', '.join(items)
#
# def get_subclass_names(locals, base_class):
# from inspect import isclass
# return [c.__name__ for c in locals.values() if isclass(c) and issubclass(c, base_class)]
. Output only the next line. | @key_cols.setter |
Next line prediction: <|code_start|>
class CollapsingMergeTree(MergeTree):
def __init__(self, date_col=None, order_by=(), sign_col='sign', sampling_expr=None,
index_granularity=8192, replica_table_path=None, replica_name=None, partition_key=None,
primary_key=None):
super(CollapsingMergeTree, self).__init__(date_col, order_by, sampling_expr, index_granularity,
replica_table_path, replica_name, partition_key, primary_key)
self.sign_col = sign_col
def _build_sql_params(self, db):
params = super(CollapsingMergeTree, self)._build_sql_params(db)
params.append(self.sign_col)
return params
class SummingMergeTree(MergeTree):
def __init__(self, date_col=None, order_by=(), summing_cols=None, sampling_expr=None,
index_granularity=8192, replica_table_path=None, replica_name=None, partition_key=None,
primary_key=None):
super(SummingMergeTree, self).__init__(date_col, order_by, sampling_expr, index_granularity, replica_table_path,
replica_name, partition_key, primary_key)
assert type is None or type(summing_cols) in (list, tuple), 'summing_cols must be a list or tuple'
self.summing_cols = summing_cols
def _build_sql_params(self, db):
params = super(SummingMergeTree, self)._build_sql_params(db)
if self.summing_cols:
params.append('(%s)' % comma_join(self.summing_cols))
<|code_end|>
. Use current file imports:
(import logging
from .utils import comma_join, get_subclass_names
from infi.clickhouse_orm.database import DatabaseException
from .models import ModelBase)
and context including class names, function names, or small code snippets from other files:
# Path: src/infi/clickhouse_orm/utils.py
# def comma_join(items, stringify=False):
# """
# Joins an iterable of strings with commas.
# """
# if stringify:
# return ', '.join(str(item) for item in items)
# else:
# return ', '.join(items)
#
# def get_subclass_names(locals, base_class):
# from inspect import isclass
# return [c.__name__ for c in locals.values() if isclass(c) and issubclass(c, base_class)]
. Output only the next line. | return params |
Continue the code snippet: <|code_start|>
class ConstraintsTest(unittest.TestCase):
def setUp(self):
self.database = Database('test-db', log_statements=True)
if self.database.server_version < (19, 14, 3, 3):
raise unittest.SkipTest('ClickHouse version too old')
<|code_end|>
. Use current file imports:
import unittest
from infi.clickhouse_orm import *
from .base_test_with_data import Person
and context (classes, functions, or code) from other files:
# Path: tests/base_test_with_data.py
# class Person(Model):
#
# first_name = StringField()
# last_name = LowCardinalityField(StringField())
# birthday = DateField()
# height = Float32Field()
# passport = NullableField(UInt32Field())
#
# engine = MergeTree('birthday', ('first_name', 'last_name', 'birthday'))
. Output only the next line. | self.database.create_table(PersonWithConstraints) |
Given the following code snippet before the placeholder: <|code_start|> self._test_func(F.replaceOne(haystack, 'l', 'L'), 'heLlo')
self._test_func(F.replaceRegexpAll(haystack, '[eo]', 'X'), 'hXllX')
self._test_func(F.replaceRegexpOne(haystack, '[eo]', 'X'), 'hXllo')
self._test_func(F.regexpQuoteMeta('[eo]'), '\\[eo\\]')
def test_math_functions(self):
x = 17
y = 3
self._test_func(F.e())
self._test_func(F.pi())
self._test_func(F.exp(x))
self._test_func(F.exp10(x))
self._test_func(F.exp2(x))
self._test_func(F.log(x))
self._test_func(F.log10(x))
self._test_func(F.log2(x))
self._test_func(F.ln(x))
self._test_func(F.sqrt(x))
self._test_func(F.cbrt(x))
self._test_func(F.erf(x))
self._test_func(F.erfc(x))
self._test_func(F.lgamma(x))
self._test_func(F.tgamma(x))
self._test_func(F.sin(x))
self._test_func(F.cos(x))
self._test_func(F.tan(x))
self._test_func(F.asin(x))
self._test_func(F.acos(x))
self._test_func(F.atan(x))
self._test_func(F.pow(x, y))
<|code_end|>
, predict the next line using imports from the current file:
import unittest
import pytz
import logging
from .base_test_with_data import *
from .test_querysets import SampleModel
from datetime import date, datetime, tzinfo, timedelta
from ipaddress import IPv4Address, IPv6Address
from decimal import Decimal
from infi.clickhouse_orm.database import ServerError
from infi.clickhouse_orm.utils import NO_VALUE
from infi.clickhouse_orm.funcs import F
from uuid import UUID
and context including class names, function names, and sometimes code from other files:
# Path: tests/test_querysets.py
# class SampleModel(Model):
#
# timestamp = DateTimeField()
# materialized_date = DateField(materialized='toDate(timestamp)')
# num = Int32Field()
# color = Enum8Field(Color)
# num_squared = Int32Field(alias='num*num')
#
# engine = MergeTree('materialized_date', ('materialized_date',))
. Output only the next line. | self._test_func(F.power(x, y)) |
Predict the next line for this snippet: <|code_start|> "model": {
"resource_name": "tasks",
"description": "Represent a task to do in a list",
"entity_name": "TheTask",
"package": "todo-list",
"get": true,
"update": true,
"delete": true,
"rest_name": "task",
"extends": [
"@description",
"@title"
]
},
"attributes": [
{
"name": "status",
"min_length": 1,
"exposed": true,
"filterable": true,
"unique_scope": "no",
"allowed_choices": [
"TODO",
"DONE"
],
"max_length": 2048,
"orderable": true,
"type": "enum",
"description": "The status of the task",
"subtype": "test"
<|code_end|>
with the help of current file imports:
import json
from unittest import TestCase
from monolithe.specifications import Specification
from monolithe.config import MonolitheConfig
and context from other files:
# Path: monolithe/config.py
# class MonolitheConfig(object):
#
# def __init__(self, path=None):
# self.path = path
# self.config = None
# self.mapping = None
# self.language = 'python'
#
# if self.path:
# if not os.path.exists(path):
# raise Exception("Could not find path %s" % path)
# config = ConfigParser()
# config.read(path)
# self.set_config(config)
#
# def copy(self):
# # duplicate the config parser
# conf_data = io.StringIO()
# self.config.write(conf_data)
# conf_data.seek(0)
# new_config_parser = ConfigParser()
# new_config_parser.readfp(conf_data)
#
# # create a new MonolitheConfig and give it the duplicate config parser
# monolithe_config_copy = MonolitheConfig(path=self.path)
# monolithe_config_copy.set_config(new_config_parser)
#
# return monolithe_config_copy
#
# def set_config(self, config):
# self.config = config
#
# # vanilla
# self.user_vanilla = self.get_option("user_vanilla", "transformer")
#
# # mapping
# if not self.path:
# return
#
# mapping_path = "%s/mapping.ini" % os.path.dirname(self.path)
#
# if not os.path.exists(self.path):
# return
#
# self.mapping = ConfigParser()
# self.mapping.read(mapping_path)
#
# def get_option(self, option, section="monolithe", **kwargs):
# return self.config.get(section, option, **kwargs)
#
# def set_option(self, option, value, section="monolithe"):
# return self.config.set(section, option, value)
#
# def map_attribute(self, rest_name, attribute_name):
# if self.mapping is None \
# or not self.mapping.has_section(rest_name) \
# or not self.mapping.has_option(rest_name, attribute_name):
# return attribute_name
#
# return self.mapping.get(rest_name, attribute_name)
, which may contain function names, class names, or code. Output only the next line. | }, |
Using the snippet: <|code_start|># Flask and plugins
# enmodal libraries
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__))))
# psycopg2
# misc
# config
config = configparser.RawConfigParser()
config.read(os.path.abspath(os.path.join(os.path.dirname(__file__), 'settings.cfg')))
PORT_HTTP = int(config.get('flask', 'port_http'))
SESSIONS_HOST = config.get('sessions', 'host')
SESSIONS_PORT = config.get('sessions', 'port')
SESSIONS_DBNAME = config.get('sessions', 'dbname')
SESSIONS_USER = config.get('sessions', 'user')
SESSIONS_PASSWORD = config.get('sessions', 'password')
SESSIONS_CONN_STRING = "host='"+SESSIONS_HOST+"' port='"+SESSIONS_PORT+"' dbname='"+SESSIONS_DBNAME+"' user='"+SESSIONS_USER+"' password='"+SESSIONS_PASSWORD+"'"
SESSIONS_SECRET_KEY_PUBLIC = int(config.get('sessions', 'secret_key_public'), 16)
SESSIONS_SECRET_KEY_PRIVATE = int(config.get('sessions', 'secret_key_private'), 16)
<|code_end|>
, determine the next line of code. You have imports:
from flask import Flask, render_template, request, after_this_request
from flask_login import LoginManager, UserMixin, current_user, login_required, login_user, logout_user
from EnmodalCore import enmodal
from EnmodalMap import enmodal_map
from EnmodalSessions import *
from EnmodalGTFS import enmodal_gtfs
import os
import sys
import psycopg2
import psycopg2.extras
import uuid
import json
import configparser
and context (class names, function names, or code) available:
# Path: EnmodalCore.py
# PORT = int(config.get('flask', 'port_http'))
# SESSIONS_HOST = config.get('sessions', 'host')
# SESSIONS_PORT = config.get('sessions', 'port')
# SESSIONS_DBNAME = config.get('sessions', 'dbname')
# SESSIONS_USER = config.get('sessions', 'user')
# SESSIONS_PASSWORD = config.get('sessions', 'password')
# SESSIONS_CONN_STRING = "host='"+SESSIONS_HOST+"' port='"+SESSIONS_PORT+"' dbname='"+SESSIONS_DBNAME+"' user='"+SESSIONS_USER+"' password='"+SESSIONS_PASSWORD+"'"
# SESSIONS_SECRET_KEY_PUBLIC = int(config.get('sessions', 'secret_key_public'), 16)
# SESSIONS_SECRET_KEY_PRIVATE = int(config.get('sessions', 'secret_key_private'), 16)
# SESSION_EXPIRATION_TIME = int(config.get('sessions', 'expiration_time'))
# def gzipped(f):
# def view_func(*args, **kwargs):
# def zipper(response):
# def route_main():
# def view():
# def route_station_add():
# def route_lat_lng_info():
# def route_station_remove():
# def route_station_update():
# def route_transfer_add():
# def route_stop_add():
# def route_stop_remove():
# def route_stop_update_station():
# def route_line_add():
# def route_line_update():
# def route_line_info():
# def route_edge_add():
# def route_edge_remove():
# def route_service_add():
# def route_service_info():
# def route_map_info():
# def route_graphviz():
# def route_get_hexagons():
# def route_transit_model():
# def route_clear_settings():
# def route_street_path():
# def run_server():
#
# Path: EnmodalMap.py
# SESSIONS_HOST = config.get('sessions', 'host')
# SESSIONS_PORT = config.get('sessions', 'port')
# SESSIONS_DBNAME = config.get('sessions', 'dbname')
# SESSIONS_USER = config.get('sessions', 'user')
# SESSIONS_PASSWORD = config.get('sessions', 'password')
# SESSIONS_CONN_STRING = "host='"+SESSIONS_HOST+"' port='"+SESSIONS_PORT+"' dbname='"+SESSIONS_DBNAME+"' user='"+SESSIONS_USER+"' password='"+SESSIONS_PASSWORD+"'"
# SESSIONS_SECRET_KEY_PUBLIC = int(config.get('sessions', 'secret_key_public'), 16)
# SESSIONS_SECRET_KEY_PRIVATE = int(config.get('sessions', 'secret_key_private'), 16)
# SESSION_EXPIRATION_TIME = int(config.get('sessions', 'expiration_time'))
# UPLOAD_FOLDER = config.get('flask', 'upload_folder')
# def allowed_file(filename):
# def uploaded_file(filename):
# def save_session(s, user_id, take_snapshot):
# def route_session_save():
# def route_session_load():
# def route_session_push():
# def route_session_import_json():
#
# Path: EnmodalGTFS.py
# SESSIONS_HOST = config.get('sessions', 'host')
# SESSIONS_PORT = config.get('sessions', 'port')
# SESSIONS_DBNAME = config.get('sessions', 'dbname')
# SESSIONS_USER = config.get('sessions', 'user')
# SESSIONS_PASSWORD = config.get('sessions', 'password')
# SESSIONS_CONN_STRING = "host='"+SESSIONS_HOST+"' port='"+SESSIONS_PORT+"' dbname='"+SESSIONS_DBNAME+"' user='"+SESSIONS_USER+"' password='"+SESSIONS_PASSWORD+"'"
# SESSIONS_SECRET_KEY_PUBLIC = int(config.get('sessions', 'secret_key_public'), 16)
# SESSIONS_SECRET_KEY_PRIVATE = int(config.get('sessions', 'secret_key_private'), 16)
# SESSION_EXPIRATION_TIME = int(config.get('sessions', 'expiration_time'))
# UPLOAD_FOLDER = config.get('flask', 'upload_folder')
# AGENCY_PROPERTIES = ['agency_id', 'agency_name']
# ROUTE_PROPERTIES = ['route_id', 'route_short_name', 'route_long_name', 'route_color', 'route_text_color']
# def allowed_file(filename):
# def uploaded_file(filename):
# def route_gtfs_upload():
# def route_to_line(m, route):
# def stop_to_station(m, stop):
# def remove_bom_inplace(path):
# def gtfs_to_simple_map(zip_folder_location):
# def contains_sublist(lst, sublst):
# def gtfs_to_full_map(zip_folder_location, import_filter):
# def route_gtfs_analyze():
# def route_gtfs_import():
. Output only the next line. | SESSION_EXPIRATION_TIME = int(config.get('sessions', 'expiration_time')) |
Here is a snippet: <|code_start|>application.secret_key = config.get('flask', 'secret_key')
login_manager = LoginManager()
login_manager.init_app(application)
application.register_blueprint(enmodal_map)
application.register_blueprint(enmodal_gtfs)
@login_manager.user_loader
def load_user(user):
return User.get(user)
@application.route('/session')
def route_session_status():
s = EnmodalSession()
session_manager.add(s)
a = session_manager.auth_by_key(s.private_key())
return_obj = {"is_private": a.editable, "public_key": '{:16x}'.format(a.session.public_key())}
if a.editable:
return_obj["private_key"] = '{:16x}'.format(a.session.private_key())
del a
return json.dumps(return_obj)
def run_server():
application.run(port = PORT_HTTP)
if __name__ == "__main__":
if not os.path.isdir(UPLOAD_FOLDER):
<|code_end|>
. Write the next line using the current file imports:
from flask import Flask, render_template, request, after_this_request
from flask_login import LoginManager, UserMixin, current_user, login_required, login_user, logout_user
from EnmodalCore import enmodal
from EnmodalMap import enmodal_map
from EnmodalSessions import *
from EnmodalGTFS import enmodal_gtfs
import os
import sys
import psycopg2
import psycopg2.extras
import uuid
import json
import configparser
and context from other files:
# Path: EnmodalCore.py
# PORT = int(config.get('flask', 'port_http'))
# SESSIONS_HOST = config.get('sessions', 'host')
# SESSIONS_PORT = config.get('sessions', 'port')
# SESSIONS_DBNAME = config.get('sessions', 'dbname')
# SESSIONS_USER = config.get('sessions', 'user')
# SESSIONS_PASSWORD = config.get('sessions', 'password')
# SESSIONS_CONN_STRING = "host='"+SESSIONS_HOST+"' port='"+SESSIONS_PORT+"' dbname='"+SESSIONS_DBNAME+"' user='"+SESSIONS_USER+"' password='"+SESSIONS_PASSWORD+"'"
# SESSIONS_SECRET_KEY_PUBLIC = int(config.get('sessions', 'secret_key_public'), 16)
# SESSIONS_SECRET_KEY_PRIVATE = int(config.get('sessions', 'secret_key_private'), 16)
# SESSION_EXPIRATION_TIME = int(config.get('sessions', 'expiration_time'))
# def gzipped(f):
# def view_func(*args, **kwargs):
# def zipper(response):
# def route_main():
# def view():
# def route_station_add():
# def route_lat_lng_info():
# def route_station_remove():
# def route_station_update():
# def route_transfer_add():
# def route_stop_add():
# def route_stop_remove():
# def route_stop_update_station():
# def route_line_add():
# def route_line_update():
# def route_line_info():
# def route_edge_add():
# def route_edge_remove():
# def route_service_add():
# def route_service_info():
# def route_map_info():
# def route_graphviz():
# def route_get_hexagons():
# def route_transit_model():
# def route_clear_settings():
# def route_street_path():
# def run_server():
#
# Path: EnmodalMap.py
# SESSIONS_HOST = config.get('sessions', 'host')
# SESSIONS_PORT = config.get('sessions', 'port')
# SESSIONS_DBNAME = config.get('sessions', 'dbname')
# SESSIONS_USER = config.get('sessions', 'user')
# SESSIONS_PASSWORD = config.get('sessions', 'password')
# SESSIONS_CONN_STRING = "host='"+SESSIONS_HOST+"' port='"+SESSIONS_PORT+"' dbname='"+SESSIONS_DBNAME+"' user='"+SESSIONS_USER+"' password='"+SESSIONS_PASSWORD+"'"
# SESSIONS_SECRET_KEY_PUBLIC = int(config.get('sessions', 'secret_key_public'), 16)
# SESSIONS_SECRET_KEY_PRIVATE = int(config.get('sessions', 'secret_key_private'), 16)
# SESSION_EXPIRATION_TIME = int(config.get('sessions', 'expiration_time'))
# UPLOAD_FOLDER = config.get('flask', 'upload_folder')
# def allowed_file(filename):
# def uploaded_file(filename):
# def save_session(s, user_id, take_snapshot):
# def route_session_save():
# def route_session_load():
# def route_session_push():
# def route_session_import_json():
#
# Path: EnmodalGTFS.py
# SESSIONS_HOST = config.get('sessions', 'host')
# SESSIONS_PORT = config.get('sessions', 'port')
# SESSIONS_DBNAME = config.get('sessions', 'dbname')
# SESSIONS_USER = config.get('sessions', 'user')
# SESSIONS_PASSWORD = config.get('sessions', 'password')
# SESSIONS_CONN_STRING = "host='"+SESSIONS_HOST+"' port='"+SESSIONS_PORT+"' dbname='"+SESSIONS_DBNAME+"' user='"+SESSIONS_USER+"' password='"+SESSIONS_PASSWORD+"'"
# SESSIONS_SECRET_KEY_PUBLIC = int(config.get('sessions', 'secret_key_public'), 16)
# SESSIONS_SECRET_KEY_PRIVATE = int(config.get('sessions', 'secret_key_private'), 16)
# SESSION_EXPIRATION_TIME = int(config.get('sessions', 'expiration_time'))
# UPLOAD_FOLDER = config.get('flask', 'upload_folder')
# AGENCY_PROPERTIES = ['agency_id', 'agency_name']
# ROUTE_PROPERTIES = ['route_id', 'route_short_name', 'route_long_name', 'route_color', 'route_text_color']
# def allowed_file(filename):
# def uploaded_file(filename):
# def route_gtfs_upload():
# def route_to_line(m, route):
# def stop_to_station(m, stop):
# def remove_bom_inplace(path):
# def gtfs_to_simple_map(zip_folder_location):
# def contains_sublist(lst, sublst):
# def gtfs_to_full_map(zip_folder_location, import_filter):
# def route_gtfs_analyze():
# def route_gtfs_import():
, which may include functions, classes, or code. Output only the next line. | os.mkdir(UPLOAD_FOLDER) |
Predict the next line for this snippet: <|code_start|># Flask and plugins
# enmodal libraries
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__))))
# psycopg2
# misc
# config
config = configparser.RawConfigParser()
config.read(os.path.abspath(os.path.join(os.path.dirname(__file__), 'settings.cfg')))
PORT_HTTP = int(config.get('flask', 'port_http'))
<|code_end|>
with the help of current file imports:
from flask import Flask, render_template, request, after_this_request
from flask_login import LoginManager, UserMixin, current_user, login_required, login_user, logout_user
from EnmodalCore import enmodal
from EnmodalMap import enmodal_map
from EnmodalSessions import *
from EnmodalGTFS import enmodal_gtfs
import os
import sys
import psycopg2
import psycopg2.extras
import uuid
import json
import configparser
and context from other files:
# Path: EnmodalCore.py
# PORT = int(config.get('flask', 'port_http'))
# SESSIONS_HOST = config.get('sessions', 'host')
# SESSIONS_PORT = config.get('sessions', 'port')
# SESSIONS_DBNAME = config.get('sessions', 'dbname')
# SESSIONS_USER = config.get('sessions', 'user')
# SESSIONS_PASSWORD = config.get('sessions', 'password')
# SESSIONS_CONN_STRING = "host='"+SESSIONS_HOST+"' port='"+SESSIONS_PORT+"' dbname='"+SESSIONS_DBNAME+"' user='"+SESSIONS_USER+"' password='"+SESSIONS_PASSWORD+"'"
# SESSIONS_SECRET_KEY_PUBLIC = int(config.get('sessions', 'secret_key_public'), 16)
# SESSIONS_SECRET_KEY_PRIVATE = int(config.get('sessions', 'secret_key_private'), 16)
# SESSION_EXPIRATION_TIME = int(config.get('sessions', 'expiration_time'))
# def gzipped(f):
# def view_func(*args, **kwargs):
# def zipper(response):
# def route_main():
# def view():
# def route_station_add():
# def route_lat_lng_info():
# def route_station_remove():
# def route_station_update():
# def route_transfer_add():
# def route_stop_add():
# def route_stop_remove():
# def route_stop_update_station():
# def route_line_add():
# def route_line_update():
# def route_line_info():
# def route_edge_add():
# def route_edge_remove():
# def route_service_add():
# def route_service_info():
# def route_map_info():
# def route_graphviz():
# def route_get_hexagons():
# def route_transit_model():
# def route_clear_settings():
# def route_street_path():
# def run_server():
#
# Path: EnmodalMap.py
# SESSIONS_HOST = config.get('sessions', 'host')
# SESSIONS_PORT = config.get('sessions', 'port')
# SESSIONS_DBNAME = config.get('sessions', 'dbname')
# SESSIONS_USER = config.get('sessions', 'user')
# SESSIONS_PASSWORD = config.get('sessions', 'password')
# SESSIONS_CONN_STRING = "host='"+SESSIONS_HOST+"' port='"+SESSIONS_PORT+"' dbname='"+SESSIONS_DBNAME+"' user='"+SESSIONS_USER+"' password='"+SESSIONS_PASSWORD+"'"
# SESSIONS_SECRET_KEY_PUBLIC = int(config.get('sessions', 'secret_key_public'), 16)
# SESSIONS_SECRET_KEY_PRIVATE = int(config.get('sessions', 'secret_key_private'), 16)
# SESSION_EXPIRATION_TIME = int(config.get('sessions', 'expiration_time'))
# UPLOAD_FOLDER = config.get('flask', 'upload_folder')
# def allowed_file(filename):
# def uploaded_file(filename):
# def save_session(s, user_id, take_snapshot):
# def route_session_save():
# def route_session_load():
# def route_session_push():
# def route_session_import_json():
#
# Path: EnmodalGTFS.py
# SESSIONS_HOST = config.get('sessions', 'host')
# SESSIONS_PORT = config.get('sessions', 'port')
# SESSIONS_DBNAME = config.get('sessions', 'dbname')
# SESSIONS_USER = config.get('sessions', 'user')
# SESSIONS_PASSWORD = config.get('sessions', 'password')
# SESSIONS_CONN_STRING = "host='"+SESSIONS_HOST+"' port='"+SESSIONS_PORT+"' dbname='"+SESSIONS_DBNAME+"' user='"+SESSIONS_USER+"' password='"+SESSIONS_PASSWORD+"'"
# SESSIONS_SECRET_KEY_PUBLIC = int(config.get('sessions', 'secret_key_public'), 16)
# SESSIONS_SECRET_KEY_PRIVATE = int(config.get('sessions', 'secret_key_private'), 16)
# SESSION_EXPIRATION_TIME = int(config.get('sessions', 'expiration_time'))
# UPLOAD_FOLDER = config.get('flask', 'upload_folder')
# AGENCY_PROPERTIES = ['agency_id', 'agency_name']
# ROUTE_PROPERTIES = ['route_id', 'route_short_name', 'route_long_name', 'route_color', 'route_text_color']
# def allowed_file(filename):
# def uploaded_file(filename):
# def route_gtfs_upload():
# def route_to_line(m, route):
# def stop_to_station(m, stop):
# def remove_bom_inplace(path):
# def gtfs_to_simple_map(zip_folder_location):
# def contains_sublist(lst, sublst):
# def gtfs_to_full_map(zip_folder_location, import_filter):
# def route_gtfs_analyze():
# def route_gtfs_import():
, which may contain function names, class names, or code. Output only the next line. | SESSIONS_HOST = config.get('sessions', 'host') |
Predict the next line for this snippet: <|code_start|>def test_expected():
if batterypower():
return
for path in expecteddir.glob('**/*'):
if not path.is_dir():
yield (_comparepng if path.name.endswith(pngsuffix) else _comparetxt), path
def _comparetxt(path):
relpath = path.relative_to(expecteddir)
actualpath = actualdir / relpath
actualpath.parent.mkdir(parents = True, exist_ok = True)
configpath = project / relpath.parent / f"{relpath.name}.arid"
if configpath.exists():
with configpath.open() as f:
config = ['--config', f.read()]
else:
config = []
with open(actualpath, 'w') as stream, threadlocals(stream = stream):
main_lc2txt(['--ignore-settings', *config,
'--config', 'local = $pyref(lurlene.util local)',
'--config', 'rollstream = $py[config.local.stream]',
str(project / relpath.parent / f"{relpath.name}.py")])
tc = TestCase()
tc.maxDiff = None
with path.open() as f, actualpath.open() as g:
tc.assertEqual(f.read(), g.read())
def _comparepng(path):
relpath = path.relative_to(expecteddir)
actualpath = actualdir / relpath
<|code_end|>
with the help of current file imports:
from .main import main_lc2txt, main_lc2wav
from .power import batterypower
from base64 import a85encode
from lagoon import sox
from lurlene.util import threadlocals
from pathlib import Path
from PIL import Image, ImageChops
from tempfile import NamedTemporaryFile
from unittest import TestCase
and context from other files:
# Path: pym2149/main.py
# def main_lc2txt(args = sys.argv[1:]):
# 'Render a Lurlene song to logging.'
# from . import txt
# initlogging()
# config, di = boot(ConfigName('inpath', '--section', name = 'txt', args = args))
# with di:
# di.add(loadcontext)
# di.add(LurleneBridge)
# txt.configure(di)
# di.add(SimpleChipTimer)
# di.add(LogicalBundle)
# di.add(Player)
# di.all(Started)
# di(MainThread).sleep()
#
# def main_lc2wav(args = sys.argv[1:]):
# 'Render a Lurlene song to WAV.'
# from . import out
# initlogging()
# config, di = boot(ConfigName('inpath', '--section', 'outpath', args = args))
# with di:
# di.add(loadcontext)
# di.add(LurleneBridge)
# out.configure(di)
# di.add(ChipTimer)
# di.add(LogicalBundle)
# di.add(Player)
# di.all(Started)
# di(MainThread).sleep()
#
# Path: pym2149/power.py
# def batterypower():
# try:
# from lagoon import upower
# except ImportError:
# return # Run all tests.
# def states():
# for line in upower.__show_info('/org/freedesktop/UPower/devices/battery_C173').splitlines():
# words = wordpattern.findall(line)
# if 2 == len(words) and 'state:' == words[0]:
# yield words[1]
# states = list(states())
# if states:
# state, = states
# return statetobatterypower[state]
, which may contain function names, class names, or code. Output only the next line. | actualpath.parent.mkdir(parents = True, exist_ok = True) |
Predict the next line after this snippet: <|code_start|> if batterypower():
return
for path in expecteddir.glob('**/*'):
if not path.is_dir():
yield (_comparepng if path.name.endswith(pngsuffix) else _comparetxt), path
def _comparetxt(path):
relpath = path.relative_to(expecteddir)
actualpath = actualdir / relpath
actualpath.parent.mkdir(parents = True, exist_ok = True)
configpath = project / relpath.parent / f"{relpath.name}.arid"
if configpath.exists():
with configpath.open() as f:
config = ['--config', f.read()]
else:
config = []
with open(actualpath, 'w') as stream, threadlocals(stream = stream):
main_lc2txt(['--ignore-settings', *config,
'--config', 'local = $pyref(lurlene.util local)',
'--config', 'rollstream = $py[config.local.stream]',
str(project / relpath.parent / f"{relpath.name}.py")])
tc = TestCase()
tc.maxDiff = None
with path.open() as f, actualpath.open() as g:
tc.assertEqual(f.read(), g.read())
def _comparepng(path):
relpath = path.relative_to(expecteddir)
actualpath = actualdir / relpath
actualpath.parent.mkdir(parents = True, exist_ok = True)
<|code_end|>
using the current file's imports:
from .main import main_lc2txt, main_lc2wav
from .power import batterypower
from base64 import a85encode
from lagoon import sox
from lurlene.util import threadlocals
from pathlib import Path
from PIL import Image, ImageChops
from tempfile import NamedTemporaryFile
from unittest import TestCase
and any relevant context from other files:
# Path: pym2149/main.py
# def main_lc2txt(args = sys.argv[1:]):
# 'Render a Lurlene song to logging.'
# from . import txt
# initlogging()
# config, di = boot(ConfigName('inpath', '--section', name = 'txt', args = args))
# with di:
# di.add(loadcontext)
# di.add(LurleneBridge)
# txt.configure(di)
# di.add(SimpleChipTimer)
# di.add(LogicalBundle)
# di.add(Player)
# di.all(Started)
# di(MainThread).sleep()
#
# def main_lc2wav(args = sys.argv[1:]):
# 'Render a Lurlene song to WAV.'
# from . import out
# initlogging()
# config, di = boot(ConfigName('inpath', '--section', 'outpath', args = args))
# with di:
# di.add(loadcontext)
# di.add(LurleneBridge)
# out.configure(di)
# di.add(ChipTimer)
# di.add(LogicalBundle)
# di.add(Player)
# di.all(Started)
# di(MainThread).sleep()
#
# Path: pym2149/power.py
# def batterypower():
# try:
# from lagoon import upower
# except ImportError:
# return # Run all tests.
# def states():
# for line in upower.__show_info('/org/freedesktop/UPower/devices/battery_C173').splitlines():
# words = wordpattern.findall(line)
# if 2 == len(words) and 'state:' == words[0]:
# yield words[1]
# states = list(states())
# if states:
# state, = states
# return statetobatterypower[state]
. Output only the next line. | with NamedTemporaryFile() as wavfile: |
Using the snippet: <|code_start|># Copyright 2014, 2018, 2019, 2020 Andrzej Cichocki
# This file is part of pym2149.
#
# pym2149 is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class TestMFPTimer(TestCase):
def test_setfreq(self):
timer = MFPTimer()
timer.effect.value = PWMEffect
timer.freq.value = 1000
self.assertEqual(2460, timer._getnormperiod()) # Close.
timer.freq.value = 100
<|code_end|>
, determine the next line of code. You have imports:
from .dac import PWMEffect
from .mfp import MFPTimer
from unittest import TestCase
and context (class names, function names, or code) available:
# Path: pym2149/dac.py
# class PWMEffect(FixedLevelEffect):
# 'Interrupt setup/routine alternates fixed level between fixedreg and zero.'
#
# level4toshape = level4totone5shape
#
# Path: pym2149/mfp.py
# class MFPTimer:
#
# def __init__(self):
# self.control = Reg()
# self.data = Reg()
# # TODO LATER: Verify that TDR 0 indeed behaves like 0x100.
# self.effectivedata = Reg().link(lambda tdr: tdr if tdr else 0x100, self.data)
# self.control.value = 0
# self.data.value = 0
# self.effect = Reg(NullEffect)
# self.control_data = Reg()
# self.control.link(lambda cd: cd[0], self.control_data)
# self.data.link(lambda cd: cd[1], self.control_data)
# self.freq = Reg()
# # XXX: Should change of wavelength trigger this link?
# self.control_data.link(self._findtcrtdr, self.freq)
# self.prescalerornone = Reg().link(lambda tcr: prescalers.get(tcr), self.control)
# self.repeat = Reg().link(lambda _: None, self.effect)
#
# def update(self, tcr, tdr, effect):
# self.control_data.value = tcr, tdr
# self.effect.value = effect
#
# def _findtcrtdr(self, freq):
# if not freq:
# return 0, self.data.value # Stop timer.
# diff = float('inf')
# for tcr, prescaler in prescalers.items():
# prescaler *= self.effect.value.wavelength # Avoid having to multiply twice.
# etdr = int(round(mfpclock / (freq * prescaler)))
# if 1 <= etdr and etdr <= 0x100:
# d = abs(mfpclock / (etdr * prescaler) - freq)
# if d < diff:
# tcrtdr = tcr, etdr & 0xff
# diff = d
# return tcrtdr
#
# def _getnormperiod(self):
# return prescalers[self.control.value] * self.effectivedata.value * self.effect.value.wavelength
#
# def getfreq(self): # Currently only called when effect is not None.
# return mfpclock / self._getnormperiod()
. Output only the next line. | self.assertEqual(24576, timer._getnormperiod()) # Exact. |
Using the snippet: <|code_start|># Copyright 2014, 2018, 2019, 2020 Andrzej Cichocki
# This file is part of pym2149.
#
# pym2149 is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class TestMFPTimer(TestCase):
def test_setfreq(self):
timer = MFPTimer()
timer.effect.value = PWMEffect
<|code_end|>
, determine the next line of code. You have imports:
from .dac import PWMEffect
from .mfp import MFPTimer
from unittest import TestCase
and context (class names, function names, or code) available:
# Path: pym2149/dac.py
# class PWMEffect(FixedLevelEffect):
# 'Interrupt setup/routine alternates fixed level between fixedreg and zero.'
#
# level4toshape = level4totone5shape
#
# Path: pym2149/mfp.py
# class MFPTimer:
#
# def __init__(self):
# self.control = Reg()
# self.data = Reg()
# # TODO LATER: Verify that TDR 0 indeed behaves like 0x100.
# self.effectivedata = Reg().link(lambda tdr: tdr if tdr else 0x100, self.data)
# self.control.value = 0
# self.data.value = 0
# self.effect = Reg(NullEffect)
# self.control_data = Reg()
# self.control.link(lambda cd: cd[0], self.control_data)
# self.data.link(lambda cd: cd[1], self.control_data)
# self.freq = Reg()
# # XXX: Should change of wavelength trigger this link?
# self.control_data.link(self._findtcrtdr, self.freq)
# self.prescalerornone = Reg().link(lambda tcr: prescalers.get(tcr), self.control)
# self.repeat = Reg().link(lambda _: None, self.effect)
#
# def update(self, tcr, tdr, effect):
# self.control_data.value = tcr, tdr
# self.effect.value = effect
#
# def _findtcrtdr(self, freq):
# if not freq:
# return 0, self.data.value # Stop timer.
# diff = float('inf')
# for tcr, prescaler in prescalers.items():
# prescaler *= self.effect.value.wavelength # Avoid having to multiply twice.
# etdr = int(round(mfpclock / (freq * prescaler)))
# if 1 <= etdr and etdr <= 0x100:
# d = abs(mfpclock / (etdr * prescaler) - freq)
# if d < diff:
# tcrtdr = tcr, etdr & 0xff
# diff = d
# return tcrtdr
#
# def _getnormperiod(self):
# return prescalers[self.control.value] * self.effectivedata.value * self.effect.value.wavelength
#
# def getfreq(self): # Currently only called when effect is not None.
# return mfpclock / self._getnormperiod()
. Output only the next line. | timer.freq.value = 1000 |
Here is a snippet: <|code_start|># Copyright 2014, 2018, 2019, 2020 Andrzej Cichocki
# This file is part of pym2149.
#
# pym2149 is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class Counter(BufNode):
buftype = BufType(None, np.int64) # Closest thing to int.
def __init__(self, x = 0):
super().__init__(self.buftype)
self.x = self.buftype.dtype(x)
def callimpl(self):
for frameindex in range(self.block.framecount):
self.blockbuf.fillpart(frameindex, frameindex + 1, self.x)
<|code_end|>
. Write the next line using the current file imports:
from .buf import BufType
from .mix import IdealMixer, Multiplexer
from .nod import Block, BufNode, Container
from .out import TrivialOutChannel
from unittest import TestCase
import numpy as np
and context from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/mix.py
# class IdealMixer(BufNode):
#
# def __init__(self, container, log2maxpeaktopeak, chipamps):
# log.debug("Mix is trivial: %s", not chipamps.nontrivial)
# buftype = BufType.float
# if chipamps.nontrivial:
# if len(container) != chipamps.size():
# raise Exception(f"Expected {len(container)} chipamps but got: {chipamps.size()}")
# self.contrib = buftype()
# self.callimpl = self.nontrivialcallimpl
# else:
# self.callimpl = self.trivialcallimpl
# super().__init__(buftype)
# self.datum = buftype.dtype(2 ** (log2maxpeaktopeak - 1.5)) # Half power point, very close to -3 dB.
# self.container = container
# self.chipamps = chipamps
#
# def nontrivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# contrib = self.contrib.ensureandcrop(self.block.framecount)
# for buf, amp in zip(self.chain(self.container), self.chain(self.chipamps)):
# if amp:
# contrib.copybuf(buf)
# contrib.mul(amp)
# self.blockbuf.subbuf(contrib)
#
# def trivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# for buf in self.chain(self.container):
# self.blockbuf.subbuf(buf)
#
# class Multiplexer(Node):
#
# def __init__(self, buftype, streams):
# super().__init__()
# self.multi = buftype()
# self.channels = len(streams)
# self.streams = streams
#
# def callimpl(self):
# for i, stream in enumerate(self.streams):
# buf = self.chain(stream)
# if not i:
# # BufNode can't do this because size is not framecount:
# size = len(buf)
# multi = self.multi.ensureandcrop(size * self.channels)
# multi.putstrided(i, i + self.channels * size, self.channels, buf.buf)
# return multi
#
# Path: pym2149/nod.py
# class Block:
#
# def __init__(self, framecount):
# # If it's a numpy type it can cause overflow in osc module, so ensure arbitrary precision:
# self.framecount = int(framecount)
#
# def __repr__(self):
# return f"{type(self).__name__}({self.framecount!r})"
#
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# class Container(Node):
#
# def __init__(self, nodes):
# super().__init__()
# self.nodes = nodes
#
# def callimpl(self):
# return [self.chain(node) for node in self.nodes]
#
# def __len__(self):
# return len(self.nodes)
#
# Path: pym2149/out.py
# class TrivialOutChannel:
#
# nontrivial = False
, which may include functions, classes, or code. Output only the next line. | self.x += 1 |
Predict the next line for this snippet: <|code_start|>
buftype = BufType(None, np.int64) # Closest thing to int.
def __init__(self, x = 0):
super().__init__(self.buftype)
self.x = self.buftype.dtype(x)
def callimpl(self):
for frameindex in range(self.block.framecount):
self.blockbuf.fillpart(frameindex, frameindex + 1, self.x)
self.x += 1
class TestIdealMixer(TestCase):
def expect(self, m, values, actual):
self.assertEqual(len(values), len(actual))
for i in range(len(values)):
self.assertAlmostEqual(m.datum - values[i], actual.buf[i])
def test_works(self):
c = Container([Counter(10), Counter()])
m = IdealMixer(c, 16, TrivialOutChannel)
self.expect(m, [10, 12, 14, 16, 18], m.call(Block(5)))
# Check the buffer is actually cleared first:
self.expect(m, [20, 22, 24, 26, 28], m.call(Block(5)))
class TestMultiplexer(TestCase):
def test_works(self):
a = Counter()
<|code_end|>
with the help of current file imports:
from .buf import BufType
from .mix import IdealMixer, Multiplexer
from .nod import Block, BufNode, Container
from .out import TrivialOutChannel
from unittest import TestCase
import numpy as np
and context from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/mix.py
# class IdealMixer(BufNode):
#
# def __init__(self, container, log2maxpeaktopeak, chipamps):
# log.debug("Mix is trivial: %s", not chipamps.nontrivial)
# buftype = BufType.float
# if chipamps.nontrivial:
# if len(container) != chipamps.size():
# raise Exception(f"Expected {len(container)} chipamps but got: {chipamps.size()}")
# self.contrib = buftype()
# self.callimpl = self.nontrivialcallimpl
# else:
# self.callimpl = self.trivialcallimpl
# super().__init__(buftype)
# self.datum = buftype.dtype(2 ** (log2maxpeaktopeak - 1.5)) # Half power point, very close to -3 dB.
# self.container = container
# self.chipamps = chipamps
#
# def nontrivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# contrib = self.contrib.ensureandcrop(self.block.framecount)
# for buf, amp in zip(self.chain(self.container), self.chain(self.chipamps)):
# if amp:
# contrib.copybuf(buf)
# contrib.mul(amp)
# self.blockbuf.subbuf(contrib)
#
# def trivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# for buf in self.chain(self.container):
# self.blockbuf.subbuf(buf)
#
# class Multiplexer(Node):
#
# def __init__(self, buftype, streams):
# super().__init__()
# self.multi = buftype()
# self.channels = len(streams)
# self.streams = streams
#
# def callimpl(self):
# for i, stream in enumerate(self.streams):
# buf = self.chain(stream)
# if not i:
# # BufNode can't do this because size is not framecount:
# size = len(buf)
# multi = self.multi.ensureandcrop(size * self.channels)
# multi.putstrided(i, i + self.channels * size, self.channels, buf.buf)
# return multi
#
# Path: pym2149/nod.py
# class Block:
#
# def __init__(self, framecount):
# # If it's a numpy type it can cause overflow in osc module, so ensure arbitrary precision:
# self.framecount = int(framecount)
#
# def __repr__(self):
# return f"{type(self).__name__}({self.framecount!r})"
#
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# class Container(Node):
#
# def __init__(self, nodes):
# super().__init__()
# self.nodes = nodes
#
# def callimpl(self):
# return [self.chain(node) for node in self.nodes]
#
# def __len__(self):
# return len(self.nodes)
#
# Path: pym2149/out.py
# class TrivialOutChannel:
#
# nontrivial = False
, which may contain function names, class names, or code. Output only the next line. | b = Counter(10) |
Predict the next line for this snippet: <|code_start|> buftype = BufType(None, np.int64) # Closest thing to int.
def __init__(self, x = 0):
super().__init__(self.buftype)
self.x = self.buftype.dtype(x)
def callimpl(self):
for frameindex in range(self.block.framecount):
self.blockbuf.fillpart(frameindex, frameindex + 1, self.x)
self.x += 1
class TestIdealMixer(TestCase):
def expect(self, m, values, actual):
self.assertEqual(len(values), len(actual))
for i in range(len(values)):
self.assertAlmostEqual(m.datum - values[i], actual.buf[i])
def test_works(self):
c = Container([Counter(10), Counter()])
m = IdealMixer(c, 16, TrivialOutChannel)
self.expect(m, [10, 12, 14, 16, 18], m.call(Block(5)))
# Check the buffer is actually cleared first:
self.expect(m, [20, 22, 24, 26, 28], m.call(Block(5)))
class TestMultiplexer(TestCase):
def test_works(self):
a = Counter()
b = Counter(10)
<|code_end|>
with the help of current file imports:
from .buf import BufType
from .mix import IdealMixer, Multiplexer
from .nod import Block, BufNode, Container
from .out import TrivialOutChannel
from unittest import TestCase
import numpy as np
and context from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/mix.py
# class IdealMixer(BufNode):
#
# def __init__(self, container, log2maxpeaktopeak, chipamps):
# log.debug("Mix is trivial: %s", not chipamps.nontrivial)
# buftype = BufType.float
# if chipamps.nontrivial:
# if len(container) != chipamps.size():
# raise Exception(f"Expected {len(container)} chipamps but got: {chipamps.size()}")
# self.contrib = buftype()
# self.callimpl = self.nontrivialcallimpl
# else:
# self.callimpl = self.trivialcallimpl
# super().__init__(buftype)
# self.datum = buftype.dtype(2 ** (log2maxpeaktopeak - 1.5)) # Half power point, very close to -3 dB.
# self.container = container
# self.chipamps = chipamps
#
# def nontrivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# contrib = self.contrib.ensureandcrop(self.block.framecount)
# for buf, amp in zip(self.chain(self.container), self.chain(self.chipamps)):
# if amp:
# contrib.copybuf(buf)
# contrib.mul(amp)
# self.blockbuf.subbuf(contrib)
#
# def trivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# for buf in self.chain(self.container):
# self.blockbuf.subbuf(buf)
#
# class Multiplexer(Node):
#
# def __init__(self, buftype, streams):
# super().__init__()
# self.multi = buftype()
# self.channels = len(streams)
# self.streams = streams
#
# def callimpl(self):
# for i, stream in enumerate(self.streams):
# buf = self.chain(stream)
# if not i:
# # BufNode can't do this because size is not framecount:
# size = len(buf)
# multi = self.multi.ensureandcrop(size * self.channels)
# multi.putstrided(i, i + self.channels * size, self.channels, buf.buf)
# return multi
#
# Path: pym2149/nod.py
# class Block:
#
# def __init__(self, framecount):
# # If it's a numpy type it can cause overflow in osc module, so ensure arbitrary precision:
# self.framecount = int(framecount)
#
# def __repr__(self):
# return f"{type(self).__name__}({self.framecount!r})"
#
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# class Container(Node):
#
# def __init__(self, nodes):
# super().__init__()
# self.nodes = nodes
#
# def callimpl(self):
# return [self.chain(node) for node in self.nodes]
#
# def __len__(self):
# return len(self.nodes)
#
# Path: pym2149/out.py
# class TrivialOutChannel:
#
# nontrivial = False
, which may contain function names, class names, or code. Output only the next line. | c = Counter(30) |
Continue the code snippet: <|code_start|># it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class Counter(BufNode):
buftype = BufType(None, np.int64) # Closest thing to int.
def __init__(self, x = 0):
super().__init__(self.buftype)
self.x = self.buftype.dtype(x)
def callimpl(self):
for frameindex in range(self.block.framecount):
self.blockbuf.fillpart(frameindex, frameindex + 1, self.x)
self.x += 1
class TestIdealMixer(TestCase):
def expect(self, m, values, actual):
self.assertEqual(len(values), len(actual))
<|code_end|>
. Use current file imports:
from .buf import BufType
from .mix import IdealMixer, Multiplexer
from .nod import Block, BufNode, Container
from .out import TrivialOutChannel
from unittest import TestCase
import numpy as np
and context (classes, functions, or code) from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/mix.py
# class IdealMixer(BufNode):
#
# def __init__(self, container, log2maxpeaktopeak, chipamps):
# log.debug("Mix is trivial: %s", not chipamps.nontrivial)
# buftype = BufType.float
# if chipamps.nontrivial:
# if len(container) != chipamps.size():
# raise Exception(f"Expected {len(container)} chipamps but got: {chipamps.size()}")
# self.contrib = buftype()
# self.callimpl = self.nontrivialcallimpl
# else:
# self.callimpl = self.trivialcallimpl
# super().__init__(buftype)
# self.datum = buftype.dtype(2 ** (log2maxpeaktopeak - 1.5)) # Half power point, very close to -3 dB.
# self.container = container
# self.chipamps = chipamps
#
# def nontrivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# contrib = self.contrib.ensureandcrop(self.block.framecount)
# for buf, amp in zip(self.chain(self.container), self.chain(self.chipamps)):
# if amp:
# contrib.copybuf(buf)
# contrib.mul(amp)
# self.blockbuf.subbuf(contrib)
#
# def trivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# for buf in self.chain(self.container):
# self.blockbuf.subbuf(buf)
#
# class Multiplexer(Node):
#
# def __init__(self, buftype, streams):
# super().__init__()
# self.multi = buftype()
# self.channels = len(streams)
# self.streams = streams
#
# def callimpl(self):
# for i, stream in enumerate(self.streams):
# buf = self.chain(stream)
# if not i:
# # BufNode can't do this because size is not framecount:
# size = len(buf)
# multi = self.multi.ensureandcrop(size * self.channels)
# multi.putstrided(i, i + self.channels * size, self.channels, buf.buf)
# return multi
#
# Path: pym2149/nod.py
# class Block:
#
# def __init__(self, framecount):
# # If it's a numpy type it can cause overflow in osc module, so ensure arbitrary precision:
# self.framecount = int(framecount)
#
# def __repr__(self):
# return f"{type(self).__name__}({self.framecount!r})"
#
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# class Container(Node):
#
# def __init__(self, nodes):
# super().__init__()
# self.nodes = nodes
#
# def callimpl(self):
# return [self.chain(node) for node in self.nodes]
#
# def __len__(self):
# return len(self.nodes)
#
# Path: pym2149/out.py
# class TrivialOutChannel:
#
# nontrivial = False
. Output only the next line. | for i in range(len(values)): |
Based on the snippet: <|code_start|># Copyright 2014, 2018, 2019, 2020 Andrzej Cichocki
# This file is part of pym2149.
#
# pym2149 is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class Counter(BufNode):
buftype = BufType(None, np.int64) # Closest thing to int.
def __init__(self, x = 0):
super().__init__(self.buftype)
self.x = self.buftype.dtype(x)
<|code_end|>
, predict the immediate next line with the help of imports:
from .buf import BufType
from .mix import IdealMixer, Multiplexer
from .nod import Block, BufNode, Container
from .out import TrivialOutChannel
from unittest import TestCase
import numpy as np
and context (classes, functions, sometimes code) from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/mix.py
# class IdealMixer(BufNode):
#
# def __init__(self, container, log2maxpeaktopeak, chipamps):
# log.debug("Mix is trivial: %s", not chipamps.nontrivial)
# buftype = BufType.float
# if chipamps.nontrivial:
# if len(container) != chipamps.size():
# raise Exception(f"Expected {len(container)} chipamps but got: {chipamps.size()}")
# self.contrib = buftype()
# self.callimpl = self.nontrivialcallimpl
# else:
# self.callimpl = self.trivialcallimpl
# super().__init__(buftype)
# self.datum = buftype.dtype(2 ** (log2maxpeaktopeak - 1.5)) # Half power point, very close to -3 dB.
# self.container = container
# self.chipamps = chipamps
#
# def nontrivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# contrib = self.contrib.ensureandcrop(self.block.framecount)
# for buf, amp in zip(self.chain(self.container), self.chain(self.chipamps)):
# if amp:
# contrib.copybuf(buf)
# contrib.mul(amp)
# self.blockbuf.subbuf(contrib)
#
# def trivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# for buf in self.chain(self.container):
# self.blockbuf.subbuf(buf)
#
# class Multiplexer(Node):
#
# def __init__(self, buftype, streams):
# super().__init__()
# self.multi = buftype()
# self.channels = len(streams)
# self.streams = streams
#
# def callimpl(self):
# for i, stream in enumerate(self.streams):
# buf = self.chain(stream)
# if not i:
# # BufNode can't do this because size is not framecount:
# size = len(buf)
# multi = self.multi.ensureandcrop(size * self.channels)
# multi.putstrided(i, i + self.channels * size, self.channels, buf.buf)
# return multi
#
# Path: pym2149/nod.py
# class Block:
#
# def __init__(self, framecount):
# # If it's a numpy type it can cause overflow in osc module, so ensure arbitrary precision:
# self.framecount = int(framecount)
#
# def __repr__(self):
# return f"{type(self).__name__}({self.framecount!r})"
#
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# class Container(Node):
#
# def __init__(self, nodes):
# super().__init__()
# self.nodes = nodes
#
# def callimpl(self):
# return [self.chain(node) for node in self.nodes]
#
# def __len__(self):
# return len(self.nodes)
#
# Path: pym2149/out.py
# class TrivialOutChannel:
#
# nontrivial = False
. Output only the next line. | def callimpl(self): |
Here is a snippet: <|code_start|># Copyright 2014, 2018, 2019, 2020 Andrzej Cichocki
# This file is part of pym2149.
#
# pym2149 is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class Counter(BufNode):
buftype = BufType(None, np.int64) # Closest thing to int.
def __init__(self, x = 0):
<|code_end|>
. Write the next line using the current file imports:
from .buf import BufType
from .mix import IdealMixer, Multiplexer
from .nod import Block, BufNode, Container
from .out import TrivialOutChannel
from unittest import TestCase
import numpy as np
and context from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/mix.py
# class IdealMixer(BufNode):
#
# def __init__(self, container, log2maxpeaktopeak, chipamps):
# log.debug("Mix is trivial: %s", not chipamps.nontrivial)
# buftype = BufType.float
# if chipamps.nontrivial:
# if len(container) != chipamps.size():
# raise Exception(f"Expected {len(container)} chipamps but got: {chipamps.size()}")
# self.contrib = buftype()
# self.callimpl = self.nontrivialcallimpl
# else:
# self.callimpl = self.trivialcallimpl
# super().__init__(buftype)
# self.datum = buftype.dtype(2 ** (log2maxpeaktopeak - 1.5)) # Half power point, very close to -3 dB.
# self.container = container
# self.chipamps = chipamps
#
# def nontrivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# contrib = self.contrib.ensureandcrop(self.block.framecount)
# for buf, amp in zip(self.chain(self.container), self.chain(self.chipamps)):
# if amp:
# contrib.copybuf(buf)
# contrib.mul(amp)
# self.blockbuf.subbuf(contrib)
#
# def trivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# for buf in self.chain(self.container):
# self.blockbuf.subbuf(buf)
#
# class Multiplexer(Node):
#
# def __init__(self, buftype, streams):
# super().__init__()
# self.multi = buftype()
# self.channels = len(streams)
# self.streams = streams
#
# def callimpl(self):
# for i, stream in enumerate(self.streams):
# buf = self.chain(stream)
# if not i:
# # BufNode can't do this because size is not framecount:
# size = len(buf)
# multi = self.multi.ensureandcrop(size * self.channels)
# multi.putstrided(i, i + self.channels * size, self.channels, buf.buf)
# return multi
#
# Path: pym2149/nod.py
# class Block:
#
# def __init__(self, framecount):
# # If it's a numpy type it can cause overflow in osc module, so ensure arbitrary precision:
# self.framecount = int(framecount)
#
# def __repr__(self):
# return f"{type(self).__name__}({self.framecount!r})"
#
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# class Container(Node):
#
# def __init__(self, nodes):
# super().__init__()
# self.nodes = nodes
#
# def callimpl(self):
# return [self.chain(node) for node in self.nodes]
#
# def __len__(self):
# return len(self.nodes)
#
# Path: pym2149/out.py
# class TrivialOutChannel:
#
# nontrivial = False
, which may include functions, classes, or code. Output only the next line. | super().__init__(self.buftype) |
Continue the code snippet: <|code_start|>
buftype = BufType(None, np.int64) # Closest thing to int.
def __init__(self, x = 0):
super().__init__(self.buftype)
self.x = self.buftype.dtype(x)
def callimpl(self):
for frameindex in range(self.block.framecount):
self.blockbuf.fillpart(frameindex, frameindex + 1, self.x)
self.x += 1
class TestIdealMixer(TestCase):
def expect(self, m, values, actual):
self.assertEqual(len(values), len(actual))
for i in range(len(values)):
self.assertAlmostEqual(m.datum - values[i], actual.buf[i])
def test_works(self):
c = Container([Counter(10), Counter()])
m = IdealMixer(c, 16, TrivialOutChannel)
self.expect(m, [10, 12, 14, 16, 18], m.call(Block(5)))
# Check the buffer is actually cleared first:
self.expect(m, [20, 22, 24, 26, 28], m.call(Block(5)))
class TestMultiplexer(TestCase):
def test_works(self):
a = Counter()
<|code_end|>
. Use current file imports:
from .buf import BufType
from .mix import IdealMixer, Multiplexer
from .nod import Block, BufNode, Container
from .out import TrivialOutChannel
from unittest import TestCase
import numpy as np
and context (classes, functions, or code) from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/mix.py
# class IdealMixer(BufNode):
#
# def __init__(self, container, log2maxpeaktopeak, chipamps):
# log.debug("Mix is trivial: %s", not chipamps.nontrivial)
# buftype = BufType.float
# if chipamps.nontrivial:
# if len(container) != chipamps.size():
# raise Exception(f"Expected {len(container)} chipamps but got: {chipamps.size()}")
# self.contrib = buftype()
# self.callimpl = self.nontrivialcallimpl
# else:
# self.callimpl = self.trivialcallimpl
# super().__init__(buftype)
# self.datum = buftype.dtype(2 ** (log2maxpeaktopeak - 1.5)) # Half power point, very close to -3 dB.
# self.container = container
# self.chipamps = chipamps
#
# def nontrivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# contrib = self.contrib.ensureandcrop(self.block.framecount)
# for buf, amp in zip(self.chain(self.container), self.chain(self.chipamps)):
# if amp:
# contrib.copybuf(buf)
# contrib.mul(amp)
# self.blockbuf.subbuf(contrib)
#
# def trivialcallimpl(self):
# self.blockbuf.fill_same(self.datum)
# for buf in self.chain(self.container):
# self.blockbuf.subbuf(buf)
#
# class Multiplexer(Node):
#
# def __init__(self, buftype, streams):
# super().__init__()
# self.multi = buftype()
# self.channels = len(streams)
# self.streams = streams
#
# def callimpl(self):
# for i, stream in enumerate(self.streams):
# buf = self.chain(stream)
# if not i:
# # BufNode can't do this because size is not framecount:
# size = len(buf)
# multi = self.multi.ensureandcrop(size * self.channels)
# multi.putstrided(i, i + self.channels * size, self.channels, buf.buf)
# return multi
#
# Path: pym2149/nod.py
# class Block:
#
# def __init__(self, framecount):
# # If it's a numpy type it can cause overflow in osc module, so ensure arbitrary precision:
# self.framecount = int(framecount)
#
# def __repr__(self):
# return f"{type(self).__name__}({self.framecount!r})"
#
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# class Container(Node):
#
# def __init__(self, nodes):
# super().__init__()
# self.nodes = nodes
#
# def callimpl(self):
# return [self.chain(node) for node in self.nodes]
#
# def __len__(self):
# return len(self.nodes)
#
# Path: pym2149/out.py
# class TrivialOutChannel:
#
# nontrivial = False
. Output only the next line. | b = Counter(10) |
Here is a snippet: <|code_start|> ctrl = next(g)
if ctrl <= 0xF:
chip.R[ctrl].value = next(g)
elif 0x80 == ctrl:
softreg = next(g)
elif 0x81 == ctrl:
targetreg = chip.R[next(g)]
adjust = next(g)
if adjust >= 0x80:
adjust -= 0x100 # Convert back to signed.
last = next(g)
while True:
softreg += adjust # Yes, this is done up-front.
# The real thing simply uses the truncation on overflow:
targetreg.value = softreg
yield
# That's right, if we skip past it we loop forever:
if last == softreg:
break
elif issleepcommand(ctrl):
ticks = next(g)
if not ticks:
break
ticks += 1 # Apparently!
for _ in range(ticks):
yield
else:
raise BadCommandException(ctrl)
def issleepcommand(ctrl):
<|code_end|>
. Write the next line using the current file imports:
from .iface import Prerecorded
import logging, math
and context from other files:
# Path: pym2149/iface.py
# class Prerecorded: pass
, which may include functions, classes, or code. Output only the next line. | return ctrl >= 0x82 |
Continue the code snippet: <|code_start|># Copyright 2014, 2018, 2019, 2020 Andrzej Cichocki
# This file is part of pym2149.
#
# pym2149 is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class TestLfsr(TestCase):
def test_correctsequence(self):
# Subsequence of the real LFSR from Hatari mailing list:
expected = (0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0)
# According to qnoispec, raw LFSR 1 maps to amp 0, so we flip our LFSR:
expected = [1 - x for x in expected]
actual = tuple(Lfsr(ym2149nzdegrees))
<|code_end|>
. Use current file imports:
from .lfsr import Lfsr
from .ym2149 import ym2149nzdegrees
from unittest import TestCase
and context (classes, functions, or code) from other files:
# Path: pym2149/lfsr.py
# class Lfsr:
#
# def __init__(self, nzdegrees):
# self.mask = sum(1 << (nzd - 1) for nzd in nzdegrees)
# self.x = 1
#
# def __call__(self):
# bit = self.x & 1
# self.x >>= 1
# if bit:
# self.x ^= self.mask
# return 1 - bit # Authentic, see qnoispec.
#
# def __iter__(self):
# first = self.x
# while True:
# yield self()
# if first == self.x:
# break
#
# Path: pym2149/ym2149.py
# TP = lambda f, r: ((r & 0x0f) << 8) | f
# NP = lambda p: p & 0x1f
# EP = lambda f, r: (r << 8) | f
# class MixerFlag:
# class LogicalRegisters:
# class PhysicalRegisters:
# class YM2149(Container):
# def __init__(self, bit):
# def __call__(self, m):
# def __init__(self, config, clockinfo, minnoiseperiod = 1):
# def __init__(self, config, logical):
# def __init__(self, config, clockinfo, ampscale, logical):
# def callimpl(self):
. Output only the next line. | self.assertTrue(''.join(map(str, expected)) in ''.join(map(str, actual))) |
Predict the next line for this snippet: <|code_start|># Copyright 2014, 2018, 2019, 2020 Andrzej Cichocki
# This file is part of pym2149.
#
# pym2149 is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class TxtPlatform(Platform, metaclass = AmpScale):
# Neither of these is significant for this script:
outputrate = 44100
log2maxpeaktopeak = 1
<|code_end|>
with the help of current file imports:
from .iface import AmpScale, Platform, Stream
from diapyr import types
and context from other files:
# Path: pym2149/iface.py
# class AmpScale(type): pass
#
# class Platform: pass
#
# class Stream: pass
, which may contain function names, class names, or code. Output only the next line. | @types() |
Given the code snippet: <|code_start|># but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class TxtPlatform(Platform, metaclass = AmpScale):
# Neither of these is significant for this script:
outputrate = 44100
log2maxpeaktopeak = 1
@types()
def __init__(self):
pass
class NullStream(Stream):
@types()
def __init__(self):
pass
def call(self, block):
pass
def flush(self):
pass
<|code_end|>
, generate the next line using the imports in this file:
from .iface import AmpScale, Platform, Stream
from diapyr import types
and context (functions, classes, or occasionally code) from other files:
# Path: pym2149/iface.py
# class AmpScale(type): pass
#
# class Platform: pass
#
# class Stream: pass
. Output only the next line. | def configure(di): |
Continue the code snippet: <|code_start|># MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class TxtPlatform(Platform, metaclass = AmpScale):
# Neither of these is significant for this script:
outputrate = 44100
log2maxpeaktopeak = 1
@types()
def __init__(self):
pass
class NullStream(Stream):
@types()
def __init__(self):
pass
def call(self, block):
pass
def flush(self):
pass
def configure(di):
<|code_end|>
. Use current file imports:
from .iface import AmpScale, Platform, Stream
from diapyr import types
and context (classes, functions, or code) from other files:
# Path: pym2149/iface.py
# class AmpScale(type): pass
#
# class Platform: pass
#
# class Stream: pass
. Output only the next line. | di.add(TxtPlatform) |
Using the snippet: <|code_start|>
def __init__(self, tone, noise, toneflagreg, noiseflagreg):
super().__init__(BufType.signal)
self.tone = tone
self.noise = noise
self.toneflagreg = toneflagreg
self.noiseflagreg = noiseflagreg
def callimpl(self):
# The truth table options are {AND, OR, XOR}.
# Other functions are negations of these, the 2 constants, or not symmetric.
# XOR sounds just like noise so it can't be that.
# AND and OR have the same frequency spectrum so either will sound good.
# We use AND as zero is preferred over envelope, see qbmixenv:
noiseflag = self.noiseflagreg.value
if self.toneflagreg.value:
self.blockbuf.copybuf(self.chain(self.tone))
if noiseflag:
self.blockbuf.andbuf(self.chain(self.noise))
elif noiseflag:
self.blockbuf.copybuf(self.chain(self.noise))
else:
# Fixed and variable levels should work, see qanlgmix and qenvpbuf:
self.blockbuf.fill_i1(1)
class Multiplexer(Node):
def __init__(self, buftype, streams):
super().__init__()
self.multi = buftype()
<|code_end|>
, determine the next line of code. You have imports:
from .buf import BufType
from .nod import BufNode, Node
import logging
and context (class names, function names, or code) available:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/nod.py
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# class Node:
#
# def __init__(self):
# self.block = None
#
# def call(self, block): # I think we don't default masked to False to ensure it is propagated.
# return self(block, False)
#
# def __call__(self, block, masked):
# if self.block != block:
# self.block = block
# self.masked = masked
# self.result = self.callimpl()
# elif not masked and self.masked:
# log.warning("This node has already executed masked: %s", self)
# return self.result
#
# def chain(self, node):
# return node(self.block, self.masked)
. Output only the next line. | self.channels = len(streams) |
Here is a snippet: <|code_start|># GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
log = logging.getLogger(__name__)
class BinMix(BufNode):
def __init__(self, tone, noise, toneflagreg, noiseflagreg):
super().__init__(BufType.signal)
self.tone = tone
self.noise = noise
self.toneflagreg = toneflagreg
self.noiseflagreg = noiseflagreg
def callimpl(self):
# The truth table options are {AND, OR, XOR}.
# Other functions are negations of these, the 2 constants, or not symmetric.
# XOR sounds just like noise so it can't be that.
# AND and OR have the same frequency spectrum so either will sound good.
# We use AND as zero is preferred over envelope, see qbmixenv:
noiseflag = self.noiseflagreg.value
if self.toneflagreg.value:
self.blockbuf.copybuf(self.chain(self.tone))
if noiseflag:
self.blockbuf.andbuf(self.chain(self.noise))
elif noiseflag:
self.blockbuf.copybuf(self.chain(self.noise))
<|code_end|>
. Write the next line using the current file imports:
from .buf import BufType
from .nod import BufNode, Node
import logging
and context from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/nod.py
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# class Node:
#
# def __init__(self):
# self.block = None
#
# def call(self, block): # I think we don't default masked to False to ensure it is propagated.
# return self(block, False)
#
# def __call__(self, block, masked):
# if self.block != block:
# self.block = block
# self.masked = masked
# self.result = self.callimpl()
# elif not masked and self.masked:
# log.warning("This node has already executed masked: %s", self)
# return self.result
#
# def chain(self, node):
# return node(self.block, self.masked)
, which may include functions, classes, or code. Output only the next line. | else: |
Given the code snippet: <|code_start|> self.blockbuf.fill_i1(1)
class Multiplexer(Node):
def __init__(self, buftype, streams):
super().__init__()
self.multi = buftype()
self.channels = len(streams)
self.streams = streams
def callimpl(self):
for i, stream in enumerate(self.streams):
buf = self.chain(stream)
if not i:
# BufNode can't do this because size is not framecount:
size = len(buf)
multi = self.multi.ensureandcrop(size * self.channels)
multi.putstrided(i, i + self.channels * size, self.channels, buf.buf)
return multi
class IdealMixer(BufNode):
def __init__(self, container, log2maxpeaktopeak, chipamps):
log.debug("Mix is trivial: %s", not chipamps.nontrivial)
buftype = BufType.float
if chipamps.nontrivial:
if len(container) != chipamps.size():
raise Exception(f"Expected {len(container)} chipamps but got: {chipamps.size()}")
self.contrib = buftype()
self.callimpl = self.nontrivialcallimpl
<|code_end|>
, generate the next line using the imports in this file:
from .buf import BufType
from .nod import BufNode, Node
import logging
and context (functions, classes, or occasionally code) from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/nod.py
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# class Node:
#
# def __init__(self):
# self.block = None
#
# def call(self, block): # I think we don't default masked to False to ensure it is propagated.
# return self(block, False)
#
# def __call__(self, block, masked):
# if self.block != block:
# self.block = block
# self.masked = masked
# self.result = self.callimpl()
# elif not masked and self.masked:
# log.warning("This node has already executed masked: %s", self)
# return self.result
#
# def chain(self, node):
# return node(self.block, self.masked)
. Output only the next line. | else: |
Here is a snippet: <|code_start|>class MainThread:
@types(Config, MainBackground)
def __init__(self, config, player):
self.profile = config.profile
self.trace = config.trace
self.player = player
def sleep(self):
if self.profile or self.trace:
sleeptime = self.profile.time if self.profile else self.trace
log.debug("Continue for %.3f seconds.", sleeptime)
time.sleep(sleeptime)
log.debug('End of profile, shutting down.')
else:
log.debug('Continue until end of data or interrupt.')
try:
self.player.future.result()
log.debug('End of data, shutting down.')
except KeyboardInterrupt:
log.debug('Caught interrupt, shutting down.')
class EMA:
def __init__(self, alpha, initial):
self.alpha = alpha
self.value = initial
def __call__(self, instantaneous):
self.value = self.alpha * instantaneous + (1 - self.alpha) * self.value
<|code_end|>
. Write the next line using the current file imports:
from .iface import Config
from diapyr import types
from splut.bg import MainBackground
import logging, time
and context from other files:
# Path: pym2149/iface.py
# class Config(lurlene.iface.Config): pass
, which may include functions, classes, or code. Output only the next line. | return self.value |
Given the following code snippet before the placeholder: <|code_start|># it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
log = logging.getLogger(__name__)
class ConfigName:
namespace = 'pym2149'
def __init__(self, *params, args = sys.argv[1:], name = 'defaultconf'):
parser = ArgumentParser()
parser.add_argument('--repr', action = 'append', default = [])
parser.add_argument('--config', action = 'append', default = [])
parser.add_argument('--ignore-settings', action = 'store_true')
for param in params:
parser.add_argument(param)
self.additems = parser.parse_args(args)
self.path = Path(__file__).resolve().parent / f"{name}.arid"
@types(DI, this = Config)
<|code_end|>
, predict the next line using imports from the current file:
from .iface import Config
from argparse import ArgumentParser
from aridity import NoSuchPathException
from aridity.config import ConfigCtrl
from aridity.model import wrap
from diapyr import DI, types, UnsatisfiableRequestException
from importlib import import_module
from pathlib import Path
import logging, sys
and context including class names, function names, and sometimes code from other files:
# Path: pym2149/iface.py
# class Config(lurlene.iface.Config): pass
. Output only the next line. | def loadconfig(self, di): |
Continue the code snippet: <|code_start|>#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class Level(BufNode):
def __init__(self, levelmodereg, fixedreg, env, signal, rtone, timereffectreg):
super().__init__(BufType.signal) # Must be suitable for use as index downstream.
self.levelmodereg = levelmodereg
self.fixedreg = fixedreg
self.env = env
self.signal = signal
self.rtone = rtone
self.timereffectreg = timereffectreg
def callimpl(self):
self.timereffectreg.value.putlevel5(self)
@singleton
class NullEffect:
'All registers are non-virtual and write directly to chip, the timer does not interfere.'
def putlevel5(self, node):
node.blockbuf.copybuf(node.chain(node.signal))
<|code_end|>
. Use current file imports:
from .buf import BufType
from .nod import BufNode
from .shapes import level4to5, level5toamp, level4tosinus5shape, level4totone5shape
from diapyr.util import singleton
import numpy as np
and context (classes, functions, or code) from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/nod.py
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# Path: pym2149/shapes.py
# def level5toamp(level):
# def _amptolevel4(amp):
# def level4to5(level4):
# def level4to5(cls, data4, introlen = defaultintrolen):
# def __init__(self, g, introlen = defaultintrolen):
# def wavelength(self):
# def _meansin(x1, x2):
# def _sinsliceamp(i, n, skew):
# def _sinuslevel4(steps, maxlevel4, skew):
# def makesample5shape(data, signed, is4bit):
# class Shape:
. Output only the next line. | if node.levelmodereg.value: |
Using the snippet: <|code_start|> self.fixedreg = fixedreg
self.env = env
self.signal = signal
self.rtone = rtone
self.timereffectreg = timereffectreg
def callimpl(self):
self.timereffectreg.value.putlevel5(self)
@singleton
class NullEffect:
'All registers are non-virtual and write directly to chip, the timer does not interfere.'
def putlevel5(self, node):
node.blockbuf.copybuf(node.chain(node.signal))
if node.levelmodereg.value:
node.blockbuf.mulbuf(node.chain(node.env))
else:
# According to block diagram, the level is already 5-bit when combining with binary signal:
node.blockbuf.mul(level4to5(node.fixedreg.value))
class FixedLevelEffect:
'Registers levelmodereg and fixedreg are virtual, of which levelmodereg is ignored.'
def __init__(self):
self.wavelength, = {shape.wavelength() for shape in self.level4toshape}
def getshape(self, fixedreg):
return self.level4toshape[fixedreg.value]
<|code_end|>
, determine the next line of code. You have imports:
from .buf import BufType
from .nod import BufNode
from .shapes import level4to5, level5toamp, level4tosinus5shape, level4totone5shape
from diapyr.util import singleton
import numpy as np
and context (class names, function names, or code) available:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/nod.py
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# Path: pym2149/shapes.py
# def level5toamp(level):
# def _amptolevel4(amp):
# def level4to5(level4):
# def level4to5(cls, data4, introlen = defaultintrolen):
# def __init__(self, g, introlen = defaultintrolen):
# def wavelength(self):
# def _meansin(x1, x2):
# def _sinsliceamp(i, n, skew):
# def _sinuslevel4(steps, maxlevel4, skew):
# def makesample5shape(data, signed, is4bit):
# class Shape:
. Output only the next line. | def putlevel5(self, node): |
Continue the code snippet: <|code_start|># (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class Level(BufNode):
def __init__(self, levelmodereg, fixedreg, env, signal, rtone, timereffectreg):
super().__init__(BufType.signal) # Must be suitable for use as index downstream.
self.levelmodereg = levelmodereg
self.fixedreg = fixedreg
self.env = env
self.signal = signal
self.rtone = rtone
self.timereffectreg = timereffectreg
def callimpl(self):
self.timereffectreg.value.putlevel5(self)
@singleton
class NullEffect:
'All registers are non-virtual and write directly to chip, the timer does not interfere.'
def putlevel5(self, node):
<|code_end|>
. Use current file imports:
from .buf import BufType
from .nod import BufNode
from .shapes import level4to5, level5toamp, level4tosinus5shape, level4totone5shape
from diapyr.util import singleton
import numpy as np
and context (classes, functions, or code) from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/nod.py
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# Path: pym2149/shapes.py
# def level5toamp(level):
# def _amptolevel4(amp):
# def level4to5(level4):
# def level4to5(cls, data4, introlen = defaultintrolen):
# def __init__(self, g, introlen = defaultintrolen):
# def wavelength(self):
# def _meansin(x1, x2):
# def _sinsliceamp(i, n, skew):
# def _sinuslevel4(steps, maxlevel4, skew):
# def makesample5shape(data, signed, is4bit):
# class Shape:
. Output only the next line. | node.blockbuf.copybuf(node.chain(node.signal)) |
Continue the code snippet: <|code_start|># the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class Level(BufNode):
def __init__(self, levelmodereg, fixedreg, env, signal, rtone, timereffectreg):
super().__init__(BufType.signal) # Must be suitable for use as index downstream.
self.levelmodereg = levelmodereg
self.fixedreg = fixedreg
self.env = env
self.signal = signal
self.rtone = rtone
self.timereffectreg = timereffectreg
def callimpl(self):
self.timereffectreg.value.putlevel5(self)
@singleton
class NullEffect:
'All registers are non-virtual and write directly to chip, the timer does not interfere.'
<|code_end|>
. Use current file imports:
from .buf import BufType
from .nod import BufNode
from .shapes import level4to5, level5toamp, level4tosinus5shape, level4totone5shape
from diapyr.util import singleton
import numpy as np
and context (classes, functions, or code) from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/nod.py
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# Path: pym2149/shapes.py
# def level5toamp(level):
# def _amptolevel4(amp):
# def level4to5(level4):
# def level4to5(cls, data4, introlen = defaultintrolen):
# def __init__(self, g, introlen = defaultintrolen):
# def wavelength(self):
# def _meansin(x1, x2):
# def _sinsliceamp(i, n, skew):
# def _sinuslevel4(steps, maxlevel4, skew):
# def makesample5shape(data, signed, is4bit):
# class Shape:
. Output only the next line. | def putlevel5(self, node): |
Predict the next line after this snippet: <|code_start|> super().__init__(BufType.signal) # Must be suitable for use as index downstream.
self.levelmodereg = levelmodereg
self.fixedreg = fixedreg
self.env = env
self.signal = signal
self.rtone = rtone
self.timereffectreg = timereffectreg
def callimpl(self):
self.timereffectreg.value.putlevel5(self)
@singleton
class NullEffect:
'All registers are non-virtual and write directly to chip, the timer does not interfere.'
def putlevel5(self, node):
node.blockbuf.copybuf(node.chain(node.signal))
if node.levelmodereg.value:
node.blockbuf.mulbuf(node.chain(node.env))
else:
# According to block diagram, the level is already 5-bit when combining with binary signal:
node.blockbuf.mul(level4to5(node.fixedreg.value))
class FixedLevelEffect:
'Registers levelmodereg and fixedreg are virtual, of which levelmodereg is ignored.'
def __init__(self):
self.wavelength, = {shape.wavelength() for shape in self.level4toshape}
def getshape(self, fixedreg):
<|code_end|>
using the current file's imports:
from .buf import BufType
from .nod import BufNode
from .shapes import level4to5, level5toamp, level4tosinus5shape, level4totone5shape
from diapyr.util import singleton
import numpy as np
and any relevant context from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/nod.py
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
#
# Path: pym2149/shapes.py
# def level5toamp(level):
# def _amptolevel4(amp):
# def level4to5(level4):
# def level4to5(cls, data4, introlen = defaultintrolen):
# def __init__(self, g, introlen = defaultintrolen):
# def wavelength(self):
# def _meansin(x1, x2):
# def _sinsliceamp(i, n, skew):
# def _sinuslevel4(steps, maxlevel4, skew):
# def makesample5shape(data, signed, is4bit):
# class Shape:
. Output only the next line. | return self.level4toshape[fixedreg.value] |
Continue the code snippet: <|code_start|>
def level5toamp(level):
return 2 ** ((level - 31) / 4)
def _amptolevel4(amp):
return max(0, int(round(15 + 2 * math.log(amp) / log2)))
def level4to5(level4):
return level4 * 2 + 1 # Observe 4-bit 0 is 5-bit 1.
class Shape:
defaultintrolen = 0
pyrbotype = dict(buf = [signaldtype], size = u4, introlen = u4)
@classmethod
def level4to5(cls, data4, introlen = defaultintrolen):
return cls(map(level4to5, data4), introlen)
def __init__(self, g, introlen = defaultintrolen):
self.buf = np.fromiter(g, signaldtype)
self.size = self.buf.size
self.introlen = introlen
def wavelength(self):
return self.size - self.introlen
rawtoneshape = 1, 0
toneshape = Shape(rawtoneshape)
<|code_end|>
. Use current file imports:
from .const import u4
from minBlepy.shapes import floatdtype
import math, numpy as np
and context (classes, functions, or code) from other files:
# Path: pym2149/const.py
. Output only the next line. | def _meansin(x1, x2): |
Given snippet: <|code_start|># Copyright 2014, 2018, 2019, 2020 Andrzej Cichocki
# This file is part of pym2149.
#
# pym2149 is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class TestPhysicalRegisters(TestCase):
chipchannels = 1
maxtoneperiod = 0xfff
maxnoiseperiod = 0x1f
maxenvperiod = None
mintoneperiod = None
def test_toneperiodmask(self):
lr = LogicalRegisters(self, self)
pr = PhysicalRegisters(self, lr)
self.assertEqual(0x000, lr.toneperiods[0].value)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .ym2149 import LogicalRegisters, PhysicalRegisters
from unittest import TestCase
and context:
# Path: pym2149/ym2149.py
# class LogicalRegisters:
#
# @types(Config, ClockInfo)
# def __init__(self, config, clockinfo, minnoiseperiod = 1):
# channels = range(config.chipchannels)
# # TODO: Make effective tone period user-readable without exposing mintoneperiod.
# # Clamping 0 to 1 is authentic for all 3 kinds of period, see qtonpzer, qnoispec, qenvpzer respectively:
# self.toneperiods = [Reg(maxval = config.maxtoneperiod, minval = clockinfo.mintoneperiod) for _ in channels]
# self.noiseperiod = Reg(maxval = config.maxnoiseperiod, minval = minnoiseperiod)
# self.toneflags = [Reg() for _ in channels]
# self.noiseflags = [Reg() for _ in channels]
# self.fixedlevels = [Reg(maxval = 0x0f, minval = 0) for _ in channels]
# self.levelmodes = [Reg() for _ in channels]
# self.envshape = VersionReg(maxval = 0x0f, minval = 0)
# self.envperiod = Reg(maxval = config.maxenvperiod, minval = 1)
# initialmixerflag = MixerFlag(0)(0) # Result is the same whatever the bit.
# for c in channels:
# self.toneperiods[c].value = TP(0, 0)
# self.toneflags[c].value = initialmixerflag
# self.noiseflags[c].value = initialmixerflag
# self.fixedlevels[c].value = 0
# self.levelmodes[c].value = getlevelmode(0)
# self.noiseperiod.value = 0
# self.envperiod.value = EP(0, 0)
# self.envshape.value = 0
# self.timers = tuple(MFPTimer() for _ in channels)
#
# class PhysicalRegisters:
#
# supportedchannels = 3
# timers = property(lambda self: self.logical.timers)
# levelbase = 0x8
#
# @types(Config, LogicalRegisters)
# def __init__(self, config, logical):
# # XXX: Add reverse wiring?
# # Like the real thing we have 16 registers, this impl ignores the last 2:
# self.R = tuple(Reg() for _ in range(16)) # Assume all incoming values are in [0, 255].
# # We only have registers for the authentic number of channels:
# for c in range(min(self.supportedchannels, config.chipchannels)):
# logical.toneperiods[c].link(TP, self.R[c * 2], self.R[c * 2 + 1])
# logical.toneflags[c].link(MixerFlag(c), self.R[0x7])
# logical.noiseflags[c].link(MixerFlag(self.supportedchannels + c), self.R[0x7])
# logical.fixedlevels[c].link(lambda l: l & 0x0f, self.R[self.levelbase + c])
# logical.levelmodes[c].link(getlevelmode, self.R[self.levelbase + c])
# logical.noiseperiod.link(NP, self.R[0x6])
# logical.envperiod.link(EP, self.R[0xB], self.R[0xC])
# logical.envshape.link(lambda s: s & 0x0f, self.R[0xD])
# for r in self.R:
# r.value = 0
# self.logical = logical
which might include code, classes, or functions. Output only the next line. | pr.R[0].value = 0x21 |
Given snippet: <|code_start|># Copyright 2014, 2018, 2019, 2020 Andrzej Cichocki
# This file is part of pym2149.
#
# pym2149 is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class Ramps(BufNode):
buftype = BufType.signal
def __init__(self):
super().__init__(self.buftype)
def callimpl(self):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .buf import BufType
from .dac import Dac
from .nod import Block, BufNode
from unittest import TestCase
and context:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/dac.py
# class Dac(BufNode):
#
# def __init__(self, level, log2maxpeaktopeak, ampshare):
# buftype = BufType.float
# super().__init__(buftype)
# # We take off .5 so that the peak amplitude is about -3 dB:
# maxpeaktopeak = (2 ** (log2maxpeaktopeak - .5)) / ampshare
# # Lookup of ideal amplitudes:
# self.leveltopeaktopeak = np.fromiter((level5toamp(v) * maxpeaktopeak for v in range(32)), buftype.dtype)
# self.level = level
#
# def callimpl(self):
# self.blockbuf.mapbuf(self.chain(self.level), self.leveltopeaktopeak)
#
# Path: pym2149/nod.py
# class Block:
#
# def __init__(self, framecount):
# # If it's a numpy type it can cause overflow in osc module, so ensure arbitrary precision:
# self.framecount = int(framecount)
#
# def __repr__(self):
# return f"{type(self).__name__}({self.framecount!r})"
#
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
which might include code, classes, or functions. Output only the next line. | for i in range(self.block.framecount): |
Predict the next line for this snippet: <|code_start|>
# This file is part of pym2149.
#
# pym2149 is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class Ramps(BufNode):
buftype = BufType.signal
def __init__(self):
super().__init__(self.buftype)
def callimpl(self):
for i in range(self.block.framecount):
self.blockbuf.fillpart(i, i + 1, self.buftype.dtype(i))
class TestDac(TestCase):
<|code_end|>
with the help of current file imports:
from .buf import BufType
from .dac import Dac
from .nod import Block, BufNode
from unittest import TestCase
and context from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/dac.py
# class Dac(BufNode):
#
# def __init__(self, level, log2maxpeaktopeak, ampshare):
# buftype = BufType.float
# super().__init__(buftype)
# # We take off .5 so that the peak amplitude is about -3 dB:
# maxpeaktopeak = (2 ** (log2maxpeaktopeak - .5)) / ampshare
# # Lookup of ideal amplitudes:
# self.leveltopeaktopeak = np.fromiter((level5toamp(v) * maxpeaktopeak for v in range(32)), buftype.dtype)
# self.level = level
#
# def callimpl(self):
# self.blockbuf.mapbuf(self.chain(self.level), self.leveltopeaktopeak)
#
# Path: pym2149/nod.py
# class Block:
#
# def __init__(self, framecount):
# # If it's a numpy type it can cause overflow in osc module, so ensure arbitrary precision:
# self.framecount = int(framecount)
#
# def __repr__(self):
# return f"{type(self).__name__}({self.framecount!r})"
#
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
, which may contain function names, class names, or code. Output only the next line. | def test_works(self): |
Next line prediction: <|code_start|># Copyright 2014, 2018, 2019, 2020 Andrzej Cichocki
# This file is part of pym2149.
#
# pym2149 is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class Ramps(BufNode):
buftype = BufType.signal
def __init__(self):
super().__init__(self.buftype)
<|code_end|>
. Use current file imports:
(from .buf import BufType
from .dac import Dac
from .nod import Block, BufNode
from unittest import TestCase)
and context including class names, function names, or small code snippets from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/dac.py
# class Dac(BufNode):
#
# def __init__(self, level, log2maxpeaktopeak, ampshare):
# buftype = BufType.float
# super().__init__(buftype)
# # We take off .5 so that the peak amplitude is about -3 dB:
# maxpeaktopeak = (2 ** (log2maxpeaktopeak - .5)) / ampshare
# # Lookup of ideal amplitudes:
# self.leveltopeaktopeak = np.fromiter((level5toamp(v) * maxpeaktopeak for v in range(32)), buftype.dtype)
# self.level = level
#
# def callimpl(self):
# self.blockbuf.mapbuf(self.chain(self.level), self.leveltopeaktopeak)
#
# Path: pym2149/nod.py
# class Block:
#
# def __init__(self, framecount):
# # If it's a numpy type it can cause overflow in osc module, so ensure arbitrary precision:
# self.framecount = int(framecount)
#
# def __repr__(self):
# return f"{type(self).__name__}({self.framecount!r})"
#
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
. Output only the next line. | def callimpl(self): |
Next line prediction: <|code_start|>
# This file is part of pym2149.
#
# pym2149 is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# pym2149 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with pym2149. If not, see <http://www.gnu.org/licenses/>.
class Ramps(BufNode):
buftype = BufType.signal
def __init__(self):
super().__init__(self.buftype)
def callimpl(self):
for i in range(self.block.framecount):
self.blockbuf.fillpart(i, i + 1, self.buftype.dtype(i))
class TestDac(TestCase):
<|code_end|>
. Use current file imports:
(from .buf import BufType
from .dac import Dac
from .nod import Block, BufNode
from unittest import TestCase)
and context including class names, function names, or small code snippets from other files:
# Path: pym2149/buf.py
# class BufType:
#
# def __init__(self, _, dtype):
# self.dtype = dtype
#
# def __call__(self):
# return MasterBuf(self.dtype)
#
# Path: pym2149/dac.py
# class Dac(BufNode):
#
# def __init__(self, level, log2maxpeaktopeak, ampshare):
# buftype = BufType.float
# super().__init__(buftype)
# # We take off .5 so that the peak amplitude is about -3 dB:
# maxpeaktopeak = (2 ** (log2maxpeaktopeak - .5)) / ampshare
# # Lookup of ideal amplitudes:
# self.leveltopeaktopeak = np.fromiter((level5toamp(v) * maxpeaktopeak for v in range(32)), buftype.dtype)
# self.level = level
#
# def callimpl(self):
# self.blockbuf.mapbuf(self.chain(self.level), self.leveltopeaktopeak)
#
# Path: pym2149/nod.py
# class Block:
#
# def __init__(self, framecount):
# # If it's a numpy type it can cause overflow in osc module, so ensure arbitrary precision:
# self.framecount = int(framecount)
#
# def __repr__(self):
# return f"{type(self).__name__}({self.framecount!r})"
#
# class BufNode(Node):
#
# def __init__(self, buftype, channels = 1):
# super().__init__()
# self.masterbuf = buftype()
# self.channels = channels
# self.realcallimpl = self.callimpl
# self.callimpl = self.makeresult
#
# def makeresult(self):
# self.blockbuf = self.masterbuf.ensureandcrop(self.block.framecount * self.channels)
# resultornone = self.realcallimpl()
# if resultornone is not None:
# return resultornone
# return self.blockbuf
. Output only the next line. | def test_works(self): |
Based on the snippet: <|code_start|>
# Does not support quoted whitespace, but we're only interested in numbers:
pattern = re.compile(r'^(\S+)?(?:\s+(\S+)(?:\s+(\S+))?)?')
def __init__(self, line):
self.label, self.directive, self.argstext = self.pattern.search(line).groups()
class Label:
def __init__(self, bytecode, index):
self.bytecode = bytecode
self.index = index
def __iter__(self):
return itertools.islice(self.bytecode, self.index, None)
def readlabeltobytecode(f):
labels = {}
bytecode = BytecodeBuilder(True)
for line in map(Line, f):
if line.label is not None:
labels[line.label] = bytecode.startingnow() # Last one wins.
if line.directive is not None:
bytecode.process(line)
return labels
class NoSuchLabelException(Exception): pass
def readbytecode(f, findlabel):
bytecode = None
<|code_end|>
, predict the immediate next line with the help of imports:
from .dosound import issleepcommand
import itertools, re
and context (classes, functions, sometimes code) from other files:
# Path: pym2149/dosound.py
# def issleepcommand(ctrl):
# return ctrl >= 0x82
. Output only the next line. | for line in map(Line, f): |
Given snippet: <|code_start|> except:
self.f.close()
raise
def frames(self, chip):
for frame in self.ym:
frame.applydata(chip)
yield
def stop(self):
self.f.close()
class UnpackedFile:
def __init__(self, path):
self.tmpdir = tempfile.mkdtemp()
try:
# Observe we redirect stdout so it doesn't get played:
lha.x(os.path.abspath(path), cwd = self.tmpdir, stdout = sys.stderr)
name, = os.listdir(self.tmpdir)
self.f = open(os.path.join(self.tmpdir, name), 'rb')
except:
self.clean()
raise
def clean(self):
log.debug("Deleting temporary folder: %s", self.tmpdir)
shutil.rmtree(self.tmpdir)
def __getattr__(self, name):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .clock import stclock
from .dac import DigiDrumEffect, NullEffect, PWMEffect, SinusEffect
from .iface import Config, YMFile
from .shapes import makesample5shape
from .ym2149 import PhysicalRegisters
from contextlib import contextmanager
from diapyr import types
from diapyr.util import singleton
from lagoon import lha
import logging, os, shutil, struct, sys, tempfile
and context:
# Path: pym2149/clock.py
# class ClockInfo:
# def _shapescale(cls, shape):
# def __init__(self, config, platform, ymfile = None):
# def _toneperiodclampor0(self, outrate):
# def _convert(self, freqorperiod, scale):
# def toneperiod(self, freq):
# def noiseperiod(self, freq):
# def envperiod(self, freq, shape):
# def tonefreq(self, period):
# def envfreq(self, period, shape):
#
# Path: pym2149/dac.py
# class DigiDrumEffect:
# 'Like SinusEffect but in addition toneflagreg and noiseflagreg are virtual and we ignore them.'
#
# def __init__(self, sample5shape):
# self.sample5shape = sample5shape
#
# def getshape(self, fixedreg):
# return self.sample5shape
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.rtone))
#
# class NullEffect:
# 'All registers are non-virtual and write directly to chip, the timer does not interfere.'
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.signal))
# if node.levelmodereg.value:
# node.blockbuf.mulbuf(node.chain(node.env))
# else:
# # According to block diagram, the level is already 5-bit when combining with binary signal:
# node.blockbuf.mul(level4to5(node.fixedreg.value))
#
# class PWMEffect(FixedLevelEffect):
# 'Interrupt setup/routine alternates fixed level between fixedreg and zero.'
#
# level4toshape = level4totone5shape
#
# class SinusEffect(FixedLevelEffect):
# 'Interrupt setup/routine sets fixed level to sample value as scaled by fixedreg.'
#
# level4toshape = level4tosinus5shape
#
# Path: pym2149/iface.py
# class Config(lurlene.iface.Config): pass
#
# class YMFile(Prerecorded): pass
#
# Path: pym2149/shapes.py
# def makesample5shape(data, signed, is4bit):
# if is4bit:
# data4 = data
# else:
# if signed:
# data = [(d + 0x80) & 0xff for d in data]
# d0 = min(data)
# data4 = (_amptolevel4(((d - d0) + .5) / 0x100) for d in data)
# return Shape.level4to5(data4, len(data) - 1)
#
# Path: pym2149/ym2149.py
# class PhysicalRegisters:
#
# supportedchannels = 3
# timers = property(lambda self: self.logical.timers)
# levelbase = 0x8
#
# @types(Config, LogicalRegisters)
# def __init__(self, config, logical):
# # XXX: Add reverse wiring?
# # Like the real thing we have 16 registers, this impl ignores the last 2:
# self.R = tuple(Reg() for _ in range(16)) # Assume all incoming values are in [0, 255].
# # We only have registers for the authentic number of channels:
# for c in range(min(self.supportedchannels, config.chipchannels)):
# logical.toneperiods[c].link(TP, self.R[c * 2], self.R[c * 2 + 1])
# logical.toneflags[c].link(MixerFlag(c), self.R[0x7])
# logical.noiseflags[c].link(MixerFlag(self.supportedchannels + c), self.R[0x7])
# logical.fixedlevels[c].link(lambda l: l & 0x0f, self.R[self.levelbase + c])
# logical.levelmodes[c].link(getlevelmode, self.R[self.levelbase + c])
# logical.noiseperiod.link(NP, self.R[0x6])
# logical.envperiod.link(EP, self.R[0xB], self.R[0xC])
# logical.envshape.link(lambda s: s & 0x0f, self.R[0xD])
# for r in self.R:
# r.value = 0
# self.logical = logical
which might include code, classes, or functions. Output only the next line. | return getattr(self.f, name) |
Continue the code snippet: <|code_start|> self.logignoringloopinfo()
else:
self.skip(self.framecount * self.framesize)
loopframe = self.readloopframe()
self.skip(-(self.framecount * self.framesize + 4))
self.loopinfo = LoopInfo(loopframe, self.f.tell() + loopframe)
@singleton
class EternalTTL:
def decr(self):
pass
def exhausted(self):
pass
class FramesTTL:
def __init__(self, frames):
self.frames = frames
def decr(self):
self.frames -= 1
def exhausted(self):
return not self.frames
class SampleTTL:
def __init__(self, repeatreg):
<|code_end|>
. Use current file imports:
from .clock import stclock
from .dac import DigiDrumEffect, NullEffect, PWMEffect, SinusEffect
from .iface import Config, YMFile
from .shapes import makesample5shape
from .ym2149 import PhysicalRegisters
from contextlib import contextmanager
from diapyr import types
from diapyr.util import singleton
from lagoon import lha
import logging, os, shutil, struct, sys, tempfile
and context (classes, functions, or code) from other files:
# Path: pym2149/clock.py
# class ClockInfo:
# def _shapescale(cls, shape):
# def __init__(self, config, platform, ymfile = None):
# def _toneperiodclampor0(self, outrate):
# def _convert(self, freqorperiod, scale):
# def toneperiod(self, freq):
# def noiseperiod(self, freq):
# def envperiod(self, freq, shape):
# def tonefreq(self, period):
# def envfreq(self, period, shape):
#
# Path: pym2149/dac.py
# class DigiDrumEffect:
# 'Like SinusEffect but in addition toneflagreg and noiseflagreg are virtual and we ignore them.'
#
# def __init__(self, sample5shape):
# self.sample5shape = sample5shape
#
# def getshape(self, fixedreg):
# return self.sample5shape
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.rtone))
#
# class NullEffect:
# 'All registers are non-virtual and write directly to chip, the timer does not interfere.'
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.signal))
# if node.levelmodereg.value:
# node.blockbuf.mulbuf(node.chain(node.env))
# else:
# # According to block diagram, the level is already 5-bit when combining with binary signal:
# node.blockbuf.mul(level4to5(node.fixedreg.value))
#
# class PWMEffect(FixedLevelEffect):
# 'Interrupt setup/routine alternates fixed level between fixedreg and zero.'
#
# level4toshape = level4totone5shape
#
# class SinusEffect(FixedLevelEffect):
# 'Interrupt setup/routine sets fixed level to sample value as scaled by fixedreg.'
#
# level4toshape = level4tosinus5shape
#
# Path: pym2149/iface.py
# class Config(lurlene.iface.Config): pass
#
# class YMFile(Prerecorded): pass
#
# Path: pym2149/shapes.py
# def makesample5shape(data, signed, is4bit):
# if is4bit:
# data4 = data
# else:
# if signed:
# data = [(d + 0x80) & 0xff for d in data]
# d0 = min(data)
# data4 = (_amptolevel4(((d - d0) + .5) / 0x100) for d in data)
# return Shape.level4to5(data4, len(data) - 1)
#
# Path: pym2149/ym2149.py
# class PhysicalRegisters:
#
# supportedchannels = 3
# timers = property(lambda self: self.logical.timers)
# levelbase = 0x8
#
# @types(Config, LogicalRegisters)
# def __init__(self, config, logical):
# # XXX: Add reverse wiring?
# # Like the real thing we have 16 registers, this impl ignores the last 2:
# self.R = tuple(Reg() for _ in range(16)) # Assume all incoming values are in [0, 255].
# # We only have registers for the authentic number of channels:
# for c in range(min(self.supportedchannels, config.chipchannels)):
# logical.toneperiods[c].link(TP, self.R[c * 2], self.R[c * 2 + 1])
# logical.toneflags[c].link(MixerFlag(c), self.R[0x7])
# logical.noiseflags[c].link(MixerFlag(self.supportedchannels + c), self.R[0x7])
# logical.fixedlevels[c].link(lambda l: l & 0x0f, self.R[self.levelbase + c])
# logical.levelmodes[c].link(getlevelmode, self.R[self.levelbase + c])
# logical.noiseperiod.link(NP, self.R[0x6])
# logical.envperiod.link(EP, self.R[0xB], self.R[0xC])
# logical.envshape.link(lambda s: s & 0x0f, self.R[0xD])
# for r in self.R:
# r.value = 0
# self.logical = logical
. Output only the next line. | self.repeatreg = repeatreg |
Based on the snippet: <|code_start|> frame[i] = ord(self.f.read(1))
self.skip(-1 + self.framecount)
frame[self.framesize - 1] = ord(self.f.read(1))
self.skip(-(self.framesize - 1) * self.framecount)
return frame
def simpleframe(self):
return [ord(c) for c in self.f.read(self.framesize)]
def step(self):
frame = self.frameobj(self)
self.frameindex += 1
return frame
def __iter__(self):
while self.frameindex < self.framecount:
yield self.step()
if self.loopinfo is None:
return
while True:
if not (self.frameindex - self.framecount) % (self.framecount - self.loopinfo.frame):
log.debug("Looping to frame %s.", self.loopinfo.frame)
self.f.seek(self.loopinfo.offset)
yield self.step()
def close(self):
self.f.close()
class PlainFrame:
<|code_end|>
, predict the immediate next line with the help of imports:
from .clock import stclock
from .dac import DigiDrumEffect, NullEffect, PWMEffect, SinusEffect
from .iface import Config, YMFile
from .shapes import makesample5shape
from .ym2149 import PhysicalRegisters
from contextlib import contextmanager
from diapyr import types
from diapyr.util import singleton
from lagoon import lha
import logging, os, shutil, struct, sys, tempfile
and context (classes, functions, sometimes code) from other files:
# Path: pym2149/clock.py
# class ClockInfo:
# def _shapescale(cls, shape):
# def __init__(self, config, platform, ymfile = None):
# def _toneperiodclampor0(self, outrate):
# def _convert(self, freqorperiod, scale):
# def toneperiod(self, freq):
# def noiseperiod(self, freq):
# def envperiod(self, freq, shape):
# def tonefreq(self, period):
# def envfreq(self, period, shape):
#
# Path: pym2149/dac.py
# class DigiDrumEffect:
# 'Like SinusEffect but in addition toneflagreg and noiseflagreg are virtual and we ignore them.'
#
# def __init__(self, sample5shape):
# self.sample5shape = sample5shape
#
# def getshape(self, fixedreg):
# return self.sample5shape
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.rtone))
#
# class NullEffect:
# 'All registers are non-virtual and write directly to chip, the timer does not interfere.'
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.signal))
# if node.levelmodereg.value:
# node.blockbuf.mulbuf(node.chain(node.env))
# else:
# # According to block diagram, the level is already 5-bit when combining with binary signal:
# node.blockbuf.mul(level4to5(node.fixedreg.value))
#
# class PWMEffect(FixedLevelEffect):
# 'Interrupt setup/routine alternates fixed level between fixedreg and zero.'
#
# level4toshape = level4totone5shape
#
# class SinusEffect(FixedLevelEffect):
# 'Interrupt setup/routine sets fixed level to sample value as scaled by fixedreg.'
#
# level4toshape = level4tosinus5shape
#
# Path: pym2149/iface.py
# class Config(lurlene.iface.Config): pass
#
# class YMFile(Prerecorded): pass
#
# Path: pym2149/shapes.py
# def makesample5shape(data, signed, is4bit):
# if is4bit:
# data4 = data
# else:
# if signed:
# data = [(d + 0x80) & 0xff for d in data]
# d0 = min(data)
# data4 = (_amptolevel4(((d - d0) + .5) / 0x100) for d in data)
# return Shape.level4to5(data4, len(data) - 1)
#
# Path: pym2149/ym2149.py
# class PhysicalRegisters:
#
# supportedchannels = 3
# timers = property(lambda self: self.logical.timers)
# levelbase = 0x8
#
# @types(Config, LogicalRegisters)
# def __init__(self, config, logical):
# # XXX: Add reverse wiring?
# # Like the real thing we have 16 registers, this impl ignores the last 2:
# self.R = tuple(Reg() for _ in range(16)) # Assume all incoming values are in [0, 255].
# # We only have registers for the authentic number of channels:
# for c in range(min(self.supportedchannels, config.chipchannels)):
# logical.toneperiods[c].link(TP, self.R[c * 2], self.R[c * 2 + 1])
# logical.toneflags[c].link(MixerFlag(c), self.R[0x7])
# logical.noiseflags[c].link(MixerFlag(self.supportedchannels + c), self.R[0x7])
# logical.fixedlevels[c].link(lambda l: l & 0x0f, self.R[self.levelbase + c])
# logical.levelmodes[c].link(getlevelmode, self.R[self.levelbase + c])
# logical.noiseperiod.link(NP, self.R[0x6])
# logical.envperiod.link(EP, self.R[0xB], self.R[0xC])
# logical.envshape.link(lambda s: s & 0x0f, self.R[0xD])
# for r in self.R:
# r.value = 0
# self.logical = logical
. Output only the next line. | def __init__(self, ym): |
Given the code snippet: <|code_start|>
class YM5(YM56):
formatid = 'YM5!'
frameobj = Frame5
class YM6(YM56):
formatid = 'YM6!'
frameobj = Frame6
logsyncbuzzer = True
class YMOpen(YMFile):
impls = {i.formatid.encode(): i for i in [YM2, YM3, YM3b, YM5, YM6]}
magic = b'YM'
@types(Config)
def __init__(self, config):
self.path = config.inpath
self.once = config.ignoreloop
def start(self):
self.startimpl()
for info in self.ym.info:
log.info(info)
self.nominalclock = self.ym.clock
self.pianorollheight = self.updaterate = self.ym.framefreq
def startimpl(self):
<|code_end|>
, generate the next line using the imports in this file:
from .clock import stclock
from .dac import DigiDrumEffect, NullEffect, PWMEffect, SinusEffect
from .iface import Config, YMFile
from .shapes import makesample5shape
from .ym2149 import PhysicalRegisters
from contextlib import contextmanager
from diapyr import types
from diapyr.util import singleton
from lagoon import lha
import logging, os, shutil, struct, sys, tempfile
and context (functions, classes, or occasionally code) from other files:
# Path: pym2149/clock.py
# class ClockInfo:
# def _shapescale(cls, shape):
# def __init__(self, config, platform, ymfile = None):
# def _toneperiodclampor0(self, outrate):
# def _convert(self, freqorperiod, scale):
# def toneperiod(self, freq):
# def noiseperiod(self, freq):
# def envperiod(self, freq, shape):
# def tonefreq(self, period):
# def envfreq(self, period, shape):
#
# Path: pym2149/dac.py
# class DigiDrumEffect:
# 'Like SinusEffect but in addition toneflagreg and noiseflagreg are virtual and we ignore them.'
#
# def __init__(self, sample5shape):
# self.sample5shape = sample5shape
#
# def getshape(self, fixedreg):
# return self.sample5shape
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.rtone))
#
# class NullEffect:
# 'All registers are non-virtual and write directly to chip, the timer does not interfere.'
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.signal))
# if node.levelmodereg.value:
# node.blockbuf.mulbuf(node.chain(node.env))
# else:
# # According to block diagram, the level is already 5-bit when combining with binary signal:
# node.blockbuf.mul(level4to5(node.fixedreg.value))
#
# class PWMEffect(FixedLevelEffect):
# 'Interrupt setup/routine alternates fixed level between fixedreg and zero.'
#
# level4toshape = level4totone5shape
#
# class SinusEffect(FixedLevelEffect):
# 'Interrupt setup/routine sets fixed level to sample value as scaled by fixedreg.'
#
# level4toshape = level4tosinus5shape
#
# Path: pym2149/iface.py
# class Config(lurlene.iface.Config): pass
#
# class YMFile(Prerecorded): pass
#
# Path: pym2149/shapes.py
# def makesample5shape(data, signed, is4bit):
# if is4bit:
# data4 = data
# else:
# if signed:
# data = [(d + 0x80) & 0xff for d in data]
# d0 = min(data)
# data4 = (_amptolevel4(((d - d0) + .5) / 0x100) for d in data)
# return Shape.level4to5(data4, len(data) - 1)
#
# Path: pym2149/ym2149.py
# class PhysicalRegisters:
#
# supportedchannels = 3
# timers = property(lambda self: self.logical.timers)
# levelbase = 0x8
#
# @types(Config, LogicalRegisters)
# def __init__(self, config, logical):
# # XXX: Add reverse wiring?
# # Like the real thing we have 16 registers, this impl ignores the last 2:
# self.R = tuple(Reg() for _ in range(16)) # Assume all incoming values are in [0, 255].
# # We only have registers for the authentic number of channels:
# for c in range(min(self.supportedchannels, config.chipchannels)):
# logical.toneperiods[c].link(TP, self.R[c * 2], self.R[c * 2 + 1])
# logical.toneflags[c].link(MixerFlag(c), self.R[0x7])
# logical.noiseflags[c].link(MixerFlag(self.supportedchannels + c), self.R[0x7])
# logical.fixedlevels[c].link(lambda l: l & 0x0f, self.R[self.levelbase + c])
# logical.levelmodes[c].link(getlevelmode, self.R[self.levelbase + c])
# logical.noiseperiod.link(NP, self.R[0x6])
# logical.envperiod.link(EP, self.R[0xB], self.R[0xC])
# logical.envshape.link(lambda s: s & 0x0f, self.R[0xD])
# for r in self.R:
# r.value = 0
# self.logical = logical
. Output only the next line. | self.f = open(self.path, 'rb') |
Based on the snippet: <|code_start|> formatid = 'YM2!'
def __init__(self, f, once):
super().__init__(f)
class YM3(YM23):
formatid = 'YM3!'
def __init__(self, f, once):
super().__init__(f)
class YM3b(YM23):
formatid = 'YM3b'
def __init__(self, f, once):
super().__init__(f)
if once:
self.logignoringloopinfo()
else:
self.skip(self.framecount * self.framesize)
loopframe = self.readloopframe()
self.skip(-(self.framecount * self.framesize + 4))
self.loopinfo = LoopInfo(loopframe, self.f.tell() + loopframe)
@singleton
class EternalTTL:
def decr(self):
<|code_end|>
, predict the immediate next line with the help of imports:
from .clock import stclock
from .dac import DigiDrumEffect, NullEffect, PWMEffect, SinusEffect
from .iface import Config, YMFile
from .shapes import makesample5shape
from .ym2149 import PhysicalRegisters
from contextlib import contextmanager
from diapyr import types
from diapyr.util import singleton
from lagoon import lha
import logging, os, shutil, struct, sys, tempfile
and context (classes, functions, sometimes code) from other files:
# Path: pym2149/clock.py
# class ClockInfo:
# def _shapescale(cls, shape):
# def __init__(self, config, platform, ymfile = None):
# def _toneperiodclampor0(self, outrate):
# def _convert(self, freqorperiod, scale):
# def toneperiod(self, freq):
# def noiseperiod(self, freq):
# def envperiod(self, freq, shape):
# def tonefreq(self, period):
# def envfreq(self, period, shape):
#
# Path: pym2149/dac.py
# class DigiDrumEffect:
# 'Like SinusEffect but in addition toneflagreg and noiseflagreg are virtual and we ignore them.'
#
# def __init__(self, sample5shape):
# self.sample5shape = sample5shape
#
# def getshape(self, fixedreg):
# return self.sample5shape
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.rtone))
#
# class NullEffect:
# 'All registers are non-virtual and write directly to chip, the timer does not interfere.'
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.signal))
# if node.levelmodereg.value:
# node.blockbuf.mulbuf(node.chain(node.env))
# else:
# # According to block diagram, the level is already 5-bit when combining with binary signal:
# node.blockbuf.mul(level4to5(node.fixedreg.value))
#
# class PWMEffect(FixedLevelEffect):
# 'Interrupt setup/routine alternates fixed level between fixedreg and zero.'
#
# level4toshape = level4totone5shape
#
# class SinusEffect(FixedLevelEffect):
# 'Interrupt setup/routine sets fixed level to sample value as scaled by fixedreg.'
#
# level4toshape = level4tosinus5shape
#
# Path: pym2149/iface.py
# class Config(lurlene.iface.Config): pass
#
# class YMFile(Prerecorded): pass
#
# Path: pym2149/shapes.py
# def makesample5shape(data, signed, is4bit):
# if is4bit:
# data4 = data
# else:
# if signed:
# data = [(d + 0x80) & 0xff for d in data]
# d0 = min(data)
# data4 = (_amptolevel4(((d - d0) + .5) / 0x100) for d in data)
# return Shape.level4to5(data4, len(data) - 1)
#
# Path: pym2149/ym2149.py
# class PhysicalRegisters:
#
# supportedchannels = 3
# timers = property(lambda self: self.logical.timers)
# levelbase = 0x8
#
# @types(Config, LogicalRegisters)
# def __init__(self, config, logical):
# # XXX: Add reverse wiring?
# # Like the real thing we have 16 registers, this impl ignores the last 2:
# self.R = tuple(Reg() for _ in range(16)) # Assume all incoming values are in [0, 255].
# # We only have registers for the authentic number of channels:
# for c in range(min(self.supportedchannels, config.chipchannels)):
# logical.toneperiods[c].link(TP, self.R[c * 2], self.R[c * 2 + 1])
# logical.toneflags[c].link(MixerFlag(c), self.R[0x7])
# logical.noiseflags[c].link(MixerFlag(self.supportedchannels + c), self.R[0x7])
# logical.fixedlevels[c].link(lambda l: l & 0x0f, self.R[self.levelbase + c])
# logical.levelmodes[c].link(getlevelmode, self.R[self.levelbase + c])
# logical.noiseperiod.link(NP, self.R[0x6])
# logical.envperiod.link(EP, self.R[0xB], self.R[0xC])
# logical.envshape.link(lambda s: s & 0x0f, self.R[0xD])
# for r in self.R:
# r.value = 0
# self.logical = logical
. Output only the next line. | pass |
Given the following code snippet before the placeholder: <|code_start|> self.index = ym.frameindex
self.flags = ym
def applydata(self, chip):
with self.flags.processtimerttls(chip) as timerttls:
for chan, tcr, tdr, effect, ttl in self.updatetimers(chip):
chip.timers[chan].update(tcr, tdr, effect)
timerttls[chan] = ttl
super().applydata(chip)
class Frame5(Frame56):
def updatetimers(self, chip):
if self.data[0x1] & 0x30:
chan = ((self.data[0x1] & 0x30) >> 4) - 1
tcr = (self.data[0x6] & 0xe0) >> 5
tdr = self.data[0xE]
yield chan, tcr, tdr, PWMEffect, FramesTTL(1)
if self.data[0x3] & 0x30:
chan = ((self.data[0x3] & 0x30) >> 4) - 1
sample = self.flags.samples[self.data[0x8 + chan] & 0x1f]
tcr = (self.data[0x8] & 0xe0) >> 5
tdr = self.data[0xF]
yield chan, tcr, tdr, DigiDrumEffect(sample), SampleTTL(chip.timers[chan].repeat)
class Frame6(Frame56):
def updatetimers(self, chip):
for r, rr, rrr in [0x1, 0x6, 0xE], [0x3, 0x8, 0xF]:
if self.data[r] & 0x30:
<|code_end|>
, predict the next line using imports from the current file:
from .clock import stclock
from .dac import DigiDrumEffect, NullEffect, PWMEffect, SinusEffect
from .iface import Config, YMFile
from .shapes import makesample5shape
from .ym2149 import PhysicalRegisters
from contextlib import contextmanager
from diapyr import types
from diapyr.util import singleton
from lagoon import lha
import logging, os, shutil, struct, sys, tempfile
and context including class names, function names, and sometimes code from other files:
# Path: pym2149/clock.py
# class ClockInfo:
# def _shapescale(cls, shape):
# def __init__(self, config, platform, ymfile = None):
# def _toneperiodclampor0(self, outrate):
# def _convert(self, freqorperiod, scale):
# def toneperiod(self, freq):
# def noiseperiod(self, freq):
# def envperiod(self, freq, shape):
# def tonefreq(self, period):
# def envfreq(self, period, shape):
#
# Path: pym2149/dac.py
# class DigiDrumEffect:
# 'Like SinusEffect but in addition toneflagreg and noiseflagreg are virtual and we ignore them.'
#
# def __init__(self, sample5shape):
# self.sample5shape = sample5shape
#
# def getshape(self, fixedreg):
# return self.sample5shape
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.rtone))
#
# class NullEffect:
# 'All registers are non-virtual and write directly to chip, the timer does not interfere.'
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.signal))
# if node.levelmodereg.value:
# node.blockbuf.mulbuf(node.chain(node.env))
# else:
# # According to block diagram, the level is already 5-bit when combining with binary signal:
# node.blockbuf.mul(level4to5(node.fixedreg.value))
#
# class PWMEffect(FixedLevelEffect):
# 'Interrupt setup/routine alternates fixed level between fixedreg and zero.'
#
# level4toshape = level4totone5shape
#
# class SinusEffect(FixedLevelEffect):
# 'Interrupt setup/routine sets fixed level to sample value as scaled by fixedreg.'
#
# level4toshape = level4tosinus5shape
#
# Path: pym2149/iface.py
# class Config(lurlene.iface.Config): pass
#
# class YMFile(Prerecorded): pass
#
# Path: pym2149/shapes.py
# def makesample5shape(data, signed, is4bit):
# if is4bit:
# data4 = data
# else:
# if signed:
# data = [(d + 0x80) & 0xff for d in data]
# d0 = min(data)
# data4 = (_amptolevel4(((d - d0) + .5) / 0x100) for d in data)
# return Shape.level4to5(data4, len(data) - 1)
#
# Path: pym2149/ym2149.py
# class PhysicalRegisters:
#
# supportedchannels = 3
# timers = property(lambda self: self.logical.timers)
# levelbase = 0x8
#
# @types(Config, LogicalRegisters)
# def __init__(self, config, logical):
# # XXX: Add reverse wiring?
# # Like the real thing we have 16 registers, this impl ignores the last 2:
# self.R = tuple(Reg() for _ in range(16)) # Assume all incoming values are in [0, 255].
# # We only have registers for the authentic number of channels:
# for c in range(min(self.supportedchannels, config.chipchannels)):
# logical.toneperiods[c].link(TP, self.R[c * 2], self.R[c * 2 + 1])
# logical.toneflags[c].link(MixerFlag(c), self.R[0x7])
# logical.noiseflags[c].link(MixerFlag(self.supportedchannels + c), self.R[0x7])
# logical.fixedlevels[c].link(lambda l: l & 0x0f, self.R[self.levelbase + c])
# logical.levelmodes[c].link(getlevelmode, self.R[self.levelbase + c])
# logical.noiseperiod.link(NP, self.R[0x6])
# logical.envperiod.link(EP, self.R[0xB], self.R[0xC])
# logical.envshape.link(lambda s: s & 0x0f, self.R[0xD])
# for r in self.R:
# r.value = 0
# self.logical = logical
. Output only the next line. | chan = ((self.data[r] & 0x30) >> 4) - 1 |
Predict the next line for this snippet: <|code_start|> def start(self):
self.startimpl()
for info in self.ym.info:
log.info(info)
self.nominalclock = self.ym.clock
self.pianorollheight = self.updaterate = self.ym.framefreq
def startimpl(self):
self.f = open(self.path, 'rb')
try:
if self.magic == self.f.read(2):
self.ym = self.impls[self.magic + self.f.read(2)](self.f, self.once)
return
except:
self.f.close()
raise
self.f.close()
self.f = UnpackedFile(self.path)
try:
self.ym = self.impls[self.f.read(4)](self.f, self.once)
# return
except:
self.f.close()
raise
def frames(self, chip):
for frame in self.ym:
frame.applydata(chip)
yield
<|code_end|>
with the help of current file imports:
from .clock import stclock
from .dac import DigiDrumEffect, NullEffect, PWMEffect, SinusEffect
from .iface import Config, YMFile
from .shapes import makesample5shape
from .ym2149 import PhysicalRegisters
from contextlib import contextmanager
from diapyr import types
from diapyr.util import singleton
from lagoon import lha
import logging, os, shutil, struct, sys, tempfile
and context from other files:
# Path: pym2149/clock.py
# class ClockInfo:
# def _shapescale(cls, shape):
# def __init__(self, config, platform, ymfile = None):
# def _toneperiodclampor0(self, outrate):
# def _convert(self, freqorperiod, scale):
# def toneperiod(self, freq):
# def noiseperiod(self, freq):
# def envperiod(self, freq, shape):
# def tonefreq(self, period):
# def envfreq(self, period, shape):
#
# Path: pym2149/dac.py
# class DigiDrumEffect:
# 'Like SinusEffect but in addition toneflagreg and noiseflagreg are virtual and we ignore them.'
#
# def __init__(self, sample5shape):
# self.sample5shape = sample5shape
#
# def getshape(self, fixedreg):
# return self.sample5shape
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.rtone))
#
# class NullEffect:
# 'All registers are non-virtual and write directly to chip, the timer does not interfere.'
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.signal))
# if node.levelmodereg.value:
# node.blockbuf.mulbuf(node.chain(node.env))
# else:
# # According to block diagram, the level is already 5-bit when combining with binary signal:
# node.blockbuf.mul(level4to5(node.fixedreg.value))
#
# class PWMEffect(FixedLevelEffect):
# 'Interrupt setup/routine alternates fixed level between fixedreg and zero.'
#
# level4toshape = level4totone5shape
#
# class SinusEffect(FixedLevelEffect):
# 'Interrupt setup/routine sets fixed level to sample value as scaled by fixedreg.'
#
# level4toshape = level4tosinus5shape
#
# Path: pym2149/iface.py
# class Config(lurlene.iface.Config): pass
#
# class YMFile(Prerecorded): pass
#
# Path: pym2149/shapes.py
# def makesample5shape(data, signed, is4bit):
# if is4bit:
# data4 = data
# else:
# if signed:
# data = [(d + 0x80) & 0xff for d in data]
# d0 = min(data)
# data4 = (_amptolevel4(((d - d0) + .5) / 0x100) for d in data)
# return Shape.level4to5(data4, len(data) - 1)
#
# Path: pym2149/ym2149.py
# class PhysicalRegisters:
#
# supportedchannels = 3
# timers = property(lambda self: self.logical.timers)
# levelbase = 0x8
#
# @types(Config, LogicalRegisters)
# def __init__(self, config, logical):
# # XXX: Add reverse wiring?
# # Like the real thing we have 16 registers, this impl ignores the last 2:
# self.R = tuple(Reg() for _ in range(16)) # Assume all incoming values are in [0, 255].
# # We only have registers for the authentic number of channels:
# for c in range(min(self.supportedchannels, config.chipchannels)):
# logical.toneperiods[c].link(TP, self.R[c * 2], self.R[c * 2 + 1])
# logical.toneflags[c].link(MixerFlag(c), self.R[0x7])
# logical.noiseflags[c].link(MixerFlag(self.supportedchannels + c), self.R[0x7])
# logical.fixedlevels[c].link(lambda l: l & 0x0f, self.R[self.levelbase + c])
# logical.levelmodes[c].link(getlevelmode, self.R[self.levelbase + c])
# logical.noiseperiod.link(NP, self.R[0x6])
# logical.envperiod.link(EP, self.R[0xB], self.R[0xC])
# logical.envshape.link(lambda s: s & 0x0f, self.R[0xD])
# for r in self.R:
# r.value = 0
# self.logical = logical
, which may contain function names, class names, or code. Output only the next line. | def stop(self): |
Predict the next line after this snippet: <|code_start|>
class YM2(YM23): # FIXME LATER: Work out format from ST-Sound source, it's not this simple.
formatid = 'YM2!'
def __init__(self, f, once):
super().__init__(f)
class YM3(YM23):
formatid = 'YM3!'
def __init__(self, f, once):
super().__init__(f)
class YM3b(YM23):
formatid = 'YM3b'
def __init__(self, f, once):
super().__init__(f)
if once:
self.logignoringloopinfo()
else:
self.skip(self.framecount * self.framesize)
loopframe = self.readloopframe()
self.skip(-(self.framecount * self.framesize + 4))
self.loopinfo = LoopInfo(loopframe, self.f.tell() + loopframe)
@singleton
<|code_end|>
using the current file's imports:
from .clock import stclock
from .dac import DigiDrumEffect, NullEffect, PWMEffect, SinusEffect
from .iface import Config, YMFile
from .shapes import makesample5shape
from .ym2149 import PhysicalRegisters
from contextlib import contextmanager
from diapyr import types
from diapyr.util import singleton
from lagoon import lha
import logging, os, shutil, struct, sys, tempfile
and any relevant context from other files:
# Path: pym2149/clock.py
# class ClockInfo:
# def _shapescale(cls, shape):
# def __init__(self, config, platform, ymfile = None):
# def _toneperiodclampor0(self, outrate):
# def _convert(self, freqorperiod, scale):
# def toneperiod(self, freq):
# def noiseperiod(self, freq):
# def envperiod(self, freq, shape):
# def tonefreq(self, period):
# def envfreq(self, period, shape):
#
# Path: pym2149/dac.py
# class DigiDrumEffect:
# 'Like SinusEffect but in addition toneflagreg and noiseflagreg are virtual and we ignore them.'
#
# def __init__(self, sample5shape):
# self.sample5shape = sample5shape
#
# def getshape(self, fixedreg):
# return self.sample5shape
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.rtone))
#
# class NullEffect:
# 'All registers are non-virtual and write directly to chip, the timer does not interfere.'
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.signal))
# if node.levelmodereg.value:
# node.blockbuf.mulbuf(node.chain(node.env))
# else:
# # According to block diagram, the level is already 5-bit when combining with binary signal:
# node.blockbuf.mul(level4to5(node.fixedreg.value))
#
# class PWMEffect(FixedLevelEffect):
# 'Interrupt setup/routine alternates fixed level between fixedreg and zero.'
#
# level4toshape = level4totone5shape
#
# class SinusEffect(FixedLevelEffect):
# 'Interrupt setup/routine sets fixed level to sample value as scaled by fixedreg.'
#
# level4toshape = level4tosinus5shape
#
# Path: pym2149/iface.py
# class Config(lurlene.iface.Config): pass
#
# class YMFile(Prerecorded): pass
#
# Path: pym2149/shapes.py
# def makesample5shape(data, signed, is4bit):
# if is4bit:
# data4 = data
# else:
# if signed:
# data = [(d + 0x80) & 0xff for d in data]
# d0 = min(data)
# data4 = (_amptolevel4(((d - d0) + .5) / 0x100) for d in data)
# return Shape.level4to5(data4, len(data) - 1)
#
# Path: pym2149/ym2149.py
# class PhysicalRegisters:
#
# supportedchannels = 3
# timers = property(lambda self: self.logical.timers)
# levelbase = 0x8
#
# @types(Config, LogicalRegisters)
# def __init__(self, config, logical):
# # XXX: Add reverse wiring?
# # Like the real thing we have 16 registers, this impl ignores the last 2:
# self.R = tuple(Reg() for _ in range(16)) # Assume all incoming values are in [0, 255].
# # We only have registers for the authentic number of channels:
# for c in range(min(self.supportedchannels, config.chipchannels)):
# logical.toneperiods[c].link(TP, self.R[c * 2], self.R[c * 2 + 1])
# logical.toneflags[c].link(MixerFlag(c), self.R[0x7])
# logical.noiseflags[c].link(MixerFlag(self.supportedchannels + c), self.R[0x7])
# logical.fixedlevels[c].link(lambda l: l & 0x0f, self.R[self.levelbase + c])
# logical.levelmodes[c].link(getlevelmode, self.R[self.levelbase + c])
# logical.noiseperiod.link(NP, self.R[0x6])
# logical.envperiod.link(EP, self.R[0xB], self.R[0xC])
# logical.envshape.link(lambda s: s & 0x0f, self.R[0xD])
# for r in self.R:
# r.value = 0
# self.logical = logical
. Output only the next line. | class EternalTTL: |
Given the code snippet: <|code_start|> def lword(self):
return self.number(self.lwordstruct)
def readloopframe(self):
loopframe = self.lword()
if loopframe < self.framecount:
return loopframe
self.skip(-4)
loopframe = self.number(self.lwordlestruct)
if loopframe < self.framecount:
log.info('Loop frame apparently little-endian.')
return loopframe
loopframe = 0
log.warning("Cannot interpret loop frame, defaulting to %s.", loopframe)
return loopframe
def skip(self, n):
self.f.seek(n, 1)
def ntstring(self):
start = self.f.tell()
while ord(self.f.read(1)):
pass
textlen = self.f.tell() - 1 - start
self.f.seek(start)
text = self.f.read(textlen).decode()
self.skip(1)
return text
def interleavedframe(self):
<|code_end|>
, generate the next line using the imports in this file:
from .clock import stclock
from .dac import DigiDrumEffect, NullEffect, PWMEffect, SinusEffect
from .iface import Config, YMFile
from .shapes import makesample5shape
from .ym2149 import PhysicalRegisters
from contextlib import contextmanager
from diapyr import types
from diapyr.util import singleton
from lagoon import lha
import logging, os, shutil, struct, sys, tempfile
and context (functions, classes, or occasionally code) from other files:
# Path: pym2149/clock.py
# class ClockInfo:
# def _shapescale(cls, shape):
# def __init__(self, config, platform, ymfile = None):
# def _toneperiodclampor0(self, outrate):
# def _convert(self, freqorperiod, scale):
# def toneperiod(self, freq):
# def noiseperiod(self, freq):
# def envperiod(self, freq, shape):
# def tonefreq(self, period):
# def envfreq(self, period, shape):
#
# Path: pym2149/dac.py
# class DigiDrumEffect:
# 'Like SinusEffect but in addition toneflagreg and noiseflagreg are virtual and we ignore them.'
#
# def __init__(self, sample5shape):
# self.sample5shape = sample5shape
#
# def getshape(self, fixedreg):
# return self.sample5shape
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.rtone))
#
# class NullEffect:
# 'All registers are non-virtual and write directly to chip, the timer does not interfere.'
#
# def putlevel5(self, node):
# node.blockbuf.copybuf(node.chain(node.signal))
# if node.levelmodereg.value:
# node.blockbuf.mulbuf(node.chain(node.env))
# else:
# # According to block diagram, the level is already 5-bit when combining with binary signal:
# node.blockbuf.mul(level4to5(node.fixedreg.value))
#
# class PWMEffect(FixedLevelEffect):
# 'Interrupt setup/routine alternates fixed level between fixedreg and zero.'
#
# level4toshape = level4totone5shape
#
# class SinusEffect(FixedLevelEffect):
# 'Interrupt setup/routine sets fixed level to sample value as scaled by fixedreg.'
#
# level4toshape = level4tosinus5shape
#
# Path: pym2149/iface.py
# class Config(lurlene.iface.Config): pass
#
# class YMFile(Prerecorded): pass
#
# Path: pym2149/shapes.py
# def makesample5shape(data, signed, is4bit):
# if is4bit:
# data4 = data
# else:
# if signed:
# data = [(d + 0x80) & 0xff for d in data]
# d0 = min(data)
# data4 = (_amptolevel4(((d - d0) + .5) / 0x100) for d in data)
# return Shape.level4to5(data4, len(data) - 1)
#
# Path: pym2149/ym2149.py
# class PhysicalRegisters:
#
# supportedchannels = 3
# timers = property(lambda self: self.logical.timers)
# levelbase = 0x8
#
# @types(Config, LogicalRegisters)
# def __init__(self, config, logical):
# # XXX: Add reverse wiring?
# # Like the real thing we have 16 registers, this impl ignores the last 2:
# self.R = tuple(Reg() for _ in range(16)) # Assume all incoming values are in [0, 255].
# # We only have registers for the authentic number of channels:
# for c in range(min(self.supportedchannels, config.chipchannels)):
# logical.toneperiods[c].link(TP, self.R[c * 2], self.R[c * 2 + 1])
# logical.toneflags[c].link(MixerFlag(c), self.R[0x7])
# logical.noiseflags[c].link(MixerFlag(self.supportedchannels + c), self.R[0x7])
# logical.fixedlevels[c].link(lambda l: l & 0x0f, self.R[self.levelbase + c])
# logical.levelmodes[c].link(getlevelmode, self.R[self.levelbase + c])
# logical.noiseperiod.link(NP, self.R[0x6])
# logical.envperiod.link(EP, self.R[0xB], self.R[0xC])
# logical.envshape.link(lambda s: s & 0x0f, self.R[0xD])
# for r in self.R:
# r.value = 0
# self.logical = logical
. Output only the next line. | frame = [None] * self.framesize |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.