_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q6700 | PipAccelerator.initialize_directories | train | def initialize_directories(self):
"""Automatically create local directories required by pip-accel."""
makedirs(self.config.source_index)
makedirs(self.config.eggs_cache) | python | {
"resource": ""
} |
q6701 | PipAccelerator.clean_source_index | train | def clean_source_index(self):
"""
Cleanup broken symbolic links in the local source distribution index.
The purpose of this method requires some context to understand. Let me
preface this by stating that I realize I'm probably overcomplicating
things, but I like to preserve forw... | python | {
"resource": ""
} |
q6702 | PipAccelerator.install_from_arguments | train | def install_from_arguments(self, arguments, **kw):
"""
Download, unpack, build and install the specified requirements.
This function is a simple wrapper for :func:`get_requirements()`,
:func:`install_requirements()` and :func:`cleanup_temporary_directories()`
that implements the... | python | {
"resource": ""
} |
q6703 | PipAccelerator.get_requirements | train | def get_requirements(self, arguments, max_retries=None, use_wheels=False):
"""
Use pip to download and unpack the requested source distribution archives.
:param arguments: The command line arguments to ``pip install ...`` (a
list of strings).
:param max_retries... | python | {
"resource": ""
} |
q6704 | PipAccelerator.unpack_source_dists | train | def unpack_source_dists(self, arguments, use_wheels=False):
"""
Find and unpack local source distributions and discover their metadata.
:param arguments: The command line arguments to ``pip install ...`` (a
list of strings).
:param use_wheels: Whether pip and p... | python | {
"resource": ""
} |
q6705 | PipAccelerator.download_source_dists | train | def download_source_dists(self, arguments, use_wheels=False):
"""
Download missing source distributions.
:param arguments: The command line arguments to ``pip install ...`` (a
list of strings).
:param use_wheels: Whether pip and pip-accel are allowed to use whe... | python | {
"resource": ""
} |
q6706 | PipAccelerator.transform_pip_requirement_set | train | def transform_pip_requirement_set(self, requirement_set):
"""
Transform pip's requirement set into one that `pip-accel` can work with.
:param requirement_set: The :class:`pip.req.RequirementSet` object
reported by pip.
:returns: A list of :class:`pip_acce... | python | {
"resource": ""
} |
q6707 | PipAccelerator.clear_build_directory | train | def clear_build_directory(self):
"""Clear the build directory where pip unpacks the source distribution archives."""
stat = os.stat(self.build_directory)
shutil.rmtree(self.build_directory)
os.makedirs(self.build_directory, stat.st_mode) | python | {
"resource": ""
} |
q6708 | PipAccelerator.cleanup_temporary_directories | train | def cleanup_temporary_directories(self):
"""Delete the build directories and any temporary directories created by pip."""
while self.build_directories:
shutil.rmtree(self.build_directories.pop())
for requirement in self.reported_requirements:
requirement.remove_temporary_... | python | {
"resource": ""
} |
q6709 | DownloadLogFilter.filter | train | def filter(self, record):
"""Change the severity of selected log records."""
if isinstance(record.msg, basestring):
message = record.msg.lower()
if all(kw in message for kw in self.KEYWORDS):
record.levelname = 'DEBUG'
record.levelno = logging.DEBU... | python | {
"resource": ""
} |
q6710 | main | train | def main():
"""The command line interface for the ``pip-accel`` program."""
arguments = sys.argv[1:]
# If no arguments are given, the help text of pip-accel is printed.
if not arguments:
usage()
sys.exit(0)
# If no install subcommand is given we pass the command line straight
# t... | python | {
"resource": ""
} |
q6711 | LocalCacheBackend.get | train | def get(self, filename):
"""
Check if a distribution archive exists in the local cache.
:param filename: The filename of the distribution archive (a string).
:returns: The pathname of a distribution archive on the local file
system or :data:`None`.
"""
... | python | {
"resource": ""
} |
q6712 | LocalCacheBackend.put | train | def put(self, filename, handle):
"""
Store a distribution archive in the local cache.
:param filename: The filename of the distribution archive (a string).
:param handle: A file-like object that provides access to the
distribution archive.
"""
file... | python | {
"resource": ""
} |
q6713 | MultiEmailField.to_python | train | def to_python(self, value):
"Normalize data to a list of strings."
# Return None if no input was given.
if not value:
return []
return [v.strip() for v in value.splitlines() if v != ""] | python | {
"resource": ""
} |
q6714 | MultiEmailWidget.prep_value | train | def prep_value(self, value):
""" Prepare value before effectively render widget """
if value in MULTI_EMAIL_FIELD_EMPTY_VALUES:
return ""
elif isinstance(value, six.string_types):
return value
elif isinstance(value, list):
return "\n".join(value)
... | python | {
"resource": ""
} |
q6715 | tagged | train | def tagged(*tags: Tags) -> Callable:
global GREENSIM_TAG_ATTRIBUTE
"""
Decorator for adding a label to the process.
These labels are applied to any child Processes produced by event
"""
def hook(event: Callable):
def wrapper(*args, **kwargs):
event(*args, **kwargs)
se... | python | {
"resource": ""
} |
q6716 | select | train | def select(*signals: Signal, **kwargs) -> List[Signal]:
"""
Allows the current process to wait for multiple concurrent signals. Waits until one of the signals turns on, at
which point this signal is returned.
:param timeout:
If this parameter is not ``None``, it is taken as a delay at the end o... | python | {
"resource": ""
} |
q6717 | Simulator.add_in | train | def add_in(self, delay: float, fn_process: Callable, *args: Any, **kwargs: Any) -> 'Process':
"""
Adds a process to the simulation, which is made to start after the given delay in simulated time.
See method add() for more details.
"""
process = Process(self, fn_process, self._gr... | python | {
"resource": ""
} |
q6718 | Simulator.add_at | train | def add_at(self, moment: float, fn_process: Callable, *args: Any, **kwargs: Any) -> 'Process':
"""
Adds a process to the simulation, which is made to start at the given exact time on the simulated clock. Note
that times in the past when compared to the current moment on the simulated clock are f... | python | {
"resource": ""
} |
q6719 | Simulator.step | train | def step(self) -> None:
"""
Runs a single event of the simulation.
"""
event = heappop(self._events)
self._ts_now = event.timestamp or self._ts_now
event.execute(self) | python | {
"resource": ""
} |
q6720 | Simulator.stop | train | def stop(self) -> None:
"""
Stops the running simulation once the current event is done executing.
"""
if self.is_running:
if _logger is not None:
self._log(INFO, "stop", __now=self.now())
self._is_running = False | python | {
"resource": ""
} |
q6721 | Simulator._clear | train | def _clear(self) -> None:
"""
Resets the internal state of the simulator, and sets the simulated clock back to 0.0. This discards all
outstanding events and tears down hanging process instances.
"""
for _, event, _, _ in self.events():
if hasattr(event, "__self__") an... | python | {
"resource": ""
} |
q6722 | Process.current | train | def current() -> 'Process':
"""
Returns the instance of the process that is executing at the current moment.
"""
curr = greenlet.getcurrent()
if not isinstance(curr, Process):
raise TypeError("Current greenlet does not correspond to a Process instance.")
retur... | python | {
"resource": ""
} |
q6723 | Signal.turn_on | train | def turn_on(self) -> "Signal":
"""
Turns on the signal. If processes are waiting, they are all resumed. This may be invoked from any code.
Remark that while processes are simultaneously resumed in simulated time, they are effectively resumed in the
sequence corresponding to the queue di... | python | {
"resource": ""
} |
q6724 | Signal.turn_off | train | def turn_off(self) -> "Signal":
"""
Turns off the signal. This may be invoked from any code.
"""
if _logger is not None:
self._log(INFO, "turn-off")
self._is_on = False
return self | python | {
"resource": ""
} |
q6725 | Signal.wait | train | def wait(self, timeout: Optional[float] = None) -> None:
"""
Makes the current process wait for the signal. If it is closed, it will join the signal's queue.
:param timeout:
If this parameter is not ``None``, it is taken as a delay at the end of which the process times out, and
... | python | {
"resource": ""
} |
q6726 | Resource.take | train | def take(self, num_instances: int = 1, timeout: Optional[float] = None) -> None:
"""
The current process reserves a certain number of instances. If there are not enough instances available, the
process is made to join a queue. When this method returns, the process holds the instances it has requ... | python | {
"resource": ""
} |
q6727 | Resource.release | train | def release(self, num_instances: int = 1) -> None:
"""
The current process releases instances it has previously taken. It may thus release less than it has taken.
These released instances become free. If the total number of free instances then satisfy the request of the top
process of th... | python | {
"resource": ""
} |
q6728 | capture_print | train | def capture_print(file_dest_maybe: Optional[IO] = None):
"""Progress capture that writes updated metrics to an interactive terminal."""
file_dest: IO = file_dest_maybe or sys.stderr
def _print_progress(progress_min: float, rt_remaining: float, _mc: MeasureComparison) -> None:
nonlocal file_dest
... | python | {
"resource": ""
} |
q6729 | calcTm | train | def calcTm(seq, mv_conc=50, dv_conc=0, dntp_conc=0.8, dna_conc=50,
max_nn_length=60, tm_method='santalucia',
salt_corrections_method='santalucia'):
''' Return the tm of `seq` as a float.
'''
tm_meth = _tm_methods.get(tm_method)
if tm_meth is None:
raise ValueError('{} is no... | python | {
"resource": ""
} |
q6730 | _parse_ntthal | train | def _parse_ntthal(ntthal_output):
''' Helper method that uses regex to parse ntthal output. '''
parsed_vals = re.search(_ntthal_re, ntthal_output)
return THERMORESULT(
True, # Structure found
float(parsed_vals.group(1)), # dS
float(parsed_vals.group(2)), ... | python | {
"resource": ""
} |
q6731 | calcThermo | train | def calcThermo(seq1, seq2, calc_type='ANY', mv_conc=50, dv_conc=0,
dntp_conc=0.8, dna_conc=50, temp_c=37, max_loop=30,
temp_only=False):
""" Main subprocess wrapper for calls to the ntthal executable.
Returns a named tuple with tm, ds, dh, and dg values or None if no
struc... | python | {
"resource": ""
} |
q6732 | calcHairpin | train | def calcHairpin(seq, mv_conc=50, dv_conc=0, dntp_conc=0.8, dna_conc=50,
temp_c=37, max_loop=30, temp_only=False):
''' Return a namedtuple of the dS, dH, dG, and Tm of any hairpin struct
present.
'''
return calcThermo(seq, seq, 'HAIRPIN', mv_conc, dv_conc, dntp_conc,
... | python | {
"resource": ""
} |
q6733 | calcHeterodimer | train | def calcHeterodimer(seq1, seq2, mv_conc=50, dv_conc=0, dntp_conc=0.8,
dna_conc=50, temp_c=37, max_loop=30, temp_only=False):
''' Return a tuple of the dS, dH, dG, and Tm of any predicted heterodimer.
'''
return calcThermo(seq1, seq2, 'ANY', mv_conc, dv_conc, dntp_conc,
... | python | {
"resource": ""
} |
q6734 | designPrimers | train | def designPrimers(p3_args, input_log=None, output_log=None, err_log=None):
''' Return the raw primer3_core output for the provided primer3 args.
Returns an ordered dict of the boulderIO-format primer3 output file
'''
sp = subprocess.Popen([pjoin(PRIMER3_HOME, 'primer3_core')],
... | python | {
"resource": ""
} |
q6735 | makeExecutable | train | def makeExecutable(fp):
''' Adds the executable bit to the file at filepath `fp`
'''
mode = ((os.stat(fp).st_mode) | 0o555) & 0o7777
setup_log.info("Adding executable bit to %s (mode is now %o)", fp, mode)
os.chmod(fp, mode) | python | {
"resource": ""
} |
q6736 | calcHairpin | train | def calcHairpin(seq, mv_conc=50.0, dv_conc=0.0, dntp_conc=0.8, dna_conc=50.0,
temp_c=37, max_loop=30):
''' Calculate the hairpin formation thermodynamics of a DNA sequence.
**Note that the maximum length of `seq` is 60 bp.** This is a cap suggested
by the Primer3 team as the longest reasona... | python | {
"resource": ""
} |
q6737 | calcEndStability | train | def calcEndStability(seq1, seq2, mv_conc=50, dv_conc=0, dntp_conc=0.8,
dna_conc=50, temp_c=37, max_loop=30):
''' Calculate the 3' end stability of DNA sequence `seq1` against DNA
sequence `seq2`.
**Note that at least one of the two sequences must by <60 bp in length.**
This is a ca... | python | {
"resource": ""
} |
q6738 | designPrimers | train | def designPrimers(seq_args, global_args=None, misprime_lib=None,
mishyb_lib=None, debug=False):
''' Run the Primer3 design process.
If the global args have been previously set (either by a pervious
`designPrimers` call or by a `setGlobals` call), `designPrimers` may be
called with seq... | python | {
"resource": ""
} |
q6739 | GradeBook.unravel_sections | train | def unravel_sections(section_data):
"""Unravels section type dictionary into flat list of sections with
section type set as an attribute.
Args:
section_data(dict): Data return from py:method::get_sections
Returns:
list: Flat list of sections with ``sectionType``... | python | {
"resource": ""
} |
q6740 | GradeBook.unravel_staff | train | def unravel_staff(staff_data):
"""Unravels staff role dictionary into flat list of staff
members with ``role`` set as an attribute.
Args:
staff_data(dict): Data return from py:method::get_staff
Returns:
list: Flat list of staff members with ``role`` set to
... | python | {
"resource": ""
} |
q6741 | GradeBook.get_gradebook_id | train | def get_gradebook_id(self, gbuuid):
"""Return gradebookid for a given gradebook uuid.
Args:
gbuuid (str): gradebook uuid, i.e. ``STELLAR:/project/gbngtest``
Raises:
PyLmodUnexpectedData: No gradebook id returned
requests.RequestException: Exception connectio... | python | {
"resource": ""
} |
q6742 | GradeBook.get_options | train | def get_options(self, gradebook_id):
"""Get options for gradebook.
Get options dictionary for a gradebook. Options include gradebook
attributes.
Args:
gradebook_id (str): unique identifier for gradebook, i.e. ``2314``
Returns:
An example return value ... | python | {
"resource": ""
} |
q6743 | GradeBook.get_assignments | train | def get_assignments(
self,
gradebook_id='',
simple=False,
max_points=True,
avg_stats=False,
grading_stats=False
):
"""Get assignments for a gradebook.
Return list of assignments for a given gradebook,
specified by a py:... | python | {
"resource": ""
} |
q6744 | GradeBook.get_assignment_by_name | train | def get_assignment_by_name(self, assignment_name, assignments=None):
"""Get assignment by name.
Get an assignment by name. It works by retrieving all assignments
and returning the first assignment with a matching name. If the
optional parameter ``assignments`` is provided, it uses this
... | python | {
"resource": ""
} |
q6745 | GradeBook.create_assignment | train | def create_assignment( # pylint: disable=too-many-arguments
self,
name,
short_name,
weight,
max_points,
due_date_str,
gradebook_id='',
**kwargs
):
"""Create a new assignment.
Create a new assignment. By... | python | {
"resource": ""
} |
q6746 | GradeBook.set_grade | train | def set_grade(
self,
assignment_id,
student_id,
grade_value,
gradebook_id='',
**kwargs
):
"""Set numerical grade for student and assignment.
Set a numerical grade for for a student and assignment. Additional
options
... | python | {
"resource": ""
} |
q6747 | GradeBook.multi_grade | train | def multi_grade(self, grade_array, gradebook_id=''):
"""Set multiple grades for students.
Set multiple student grades for a gradebook. The grades are passed
as a list of dictionaries.
Each grade dictionary in ``grade_array`` must contain a
``studentId`` and a ``assignmentId``.... | python | {
"resource": ""
} |
q6748 | GradeBook.get_sections | train | def get_sections(self, gradebook_id='', simple=False):
"""Get the sections for a gradebook.
Return a dictionary of types of sections containing a list of that
type for a given gradebook. Specified by a gradebookid.
If simple=True, a list of dictionaries is provided for each
se... | python | {
"resource": ""
} |
q6749 | GradeBook.get_section_by_name | train | def get_section_by_name(self, section_name):
"""Get a section by its name.
Get a list of sections for a given gradebook,
specified by a gradebookid.
Args:
section_name (str): The section's name.
Raises:
requests.RequestException: Exception connection er... | python | {
"resource": ""
} |
q6750 | GradeBook.get_students | train | def get_students(
self,
gradebook_id='',
simple=False,
section_name='',
include_photo=False,
include_grade_info=False,
include_grade_history=False,
include_makeup_grades=False
):
"""Get students for a gradebook.
... | python | {
"resource": ""
} |
q6751 | GradeBook.get_student_by_email | train | def get_student_by_email(self, email, students=None):
"""Get a student based on an email address.
Calls ``self.get_students()`` to get list of all students,
if not passed as the ``students`` parameter.
Args:
email (str): student email
students (list): dictionary... | python | {
"resource": ""
} |
q6752 | GradeBook.spreadsheet2gradebook | train | def spreadsheet2gradebook(
self,
csv_file,
email_field=None,
approve_grades=False,
use_max_points_column=False,
max_points_column=None,
normalize_column=None
):
"""Upload grade spreadsheet to gradebook.
Upload grade... | python | {
"resource": ""
} |
q6753 | GradeBook.get_staff | train | def get_staff(self, gradebook_id, simple=False):
"""Get staff list for gradebook.
Get staff list for the gradebook specified. Optionally, return
a less detailed list by specifying ``simple = True``.
If simple=True, return a list of dictionaries, one dictionary
for each member. ... | python | {
"resource": ""
} |
q6754 | Membership.get_group | train | def get_group(self, uuid=None):
"""Get group data based on uuid.
Args:
uuid (str): optional uuid. defaults to self.cuuid
Raises:
PyLmodUnexpectedData: No data was returned.
requests.RequestException: Exception connection error
Returns:
d... | python | {
"resource": ""
} |
q6755 | Membership.get_group_id | train | def get_group_id(self, uuid=None):
"""Get group id based on uuid.
Args:
uuid (str): optional uuid. defaults to self.cuuid
Raises:
PyLmodUnexpectedData: No group data was returned.
requests.RequestException: Exception connection error
Returns:
... | python | {
"resource": ""
} |
q6756 | Membership.get_membership | train | def get_membership(self, uuid=None):
"""Get membership data based on uuid.
Args:
uuid (str): optional uuid. defaults to self.cuuid
Raises:
PyLmodUnexpectedData: No data was returned.
requests.RequestException: Exception connection error
Returns:
... | python | {
"resource": ""
} |
q6757 | Membership.email_has_role | train | def email_has_role(self, email, role_name, uuid=None):
"""Determine if an email is associated with a role.
Args:
email (str): user email
role_name (str): user role
uuid (str): optional uuid. defaults to self.cuuid
Raises:
PyLmodUnexpectedData: Un... | python | {
"resource": ""
} |
q6758 | Membership.get_course_id | train | def get_course_id(self, course_uuid):
"""Get course id based on uuid.
Args:
uuid (str): course uuid, i.e. /project/mitxdemosite
Raises:
PyLmodUnexpectedData: No course data was returned.
requests.RequestException: Exception connection error
Returns:... | python | {
"resource": ""
} |
q6759 | Membership.get_course_guide_staff | train | def get_course_guide_staff(self, course_id=''):
"""Get the staff roster for a course.
Get a list of staff members for a given course,
specified by a course id.
Args:
course_id (int): unique identifier for course, i.e. ``2314``
Raises:
requests.RequestEx... | python | {
"resource": ""
} |
q6760 | Base._data_to_json | train | def _data_to_json(data):
"""Convert to json if it isn't already a string.
Args:
data (str): data to convert to json
"""
if type(data) not in [str, unicode]:
data = json.dumps(data)
return data | python | {
"resource": ""
} |
q6761 | Base._url_format | train | def _url_format(self, service):
"""Generate URL from urlbase and service.
Args:
service (str): The endpoint service to use, i.e. gradebook
Returns:
str: URL to where the request should be made
"""
base_service_url = '{base}{service}'.format(
b... | python | {
"resource": ""
} |
q6762 | Base.rest_action | train | def rest_action(self, func, url, **kwargs):
"""Routine to do low-level REST operation, with retry.
Args:
func (callable): API function to call
url (str): service URL endpoint
kwargs (dict): addition parameters
Raises:
requests.RequestException: E... | python | {
"resource": ""
} |
q6763 | Base.get | train | def get(self, service, params=None):
"""Generic GET operation for retrieving data from Learning Modules API.
.. code-block:: python
gbk.get('students/{gradebookId}', params=params, gradebookId=gbid)
Args:
service (str): The endpoint service to use, i.e. gradebook
... | python | {
"resource": ""
} |
q6764 | Base.post | train | def post(self, service, data):
"""Generic POST operation for sending data to Learning Modules API.
Data should be a JSON string or a dict. If it is not a string,
it is turned into a JSON string for the POST body.
Args:
service (str): The endpoint service to use, i.e. grade... | python | {
"resource": ""
} |
q6765 | Base.delete | train | def delete(self, service):
"""Generic DELETE operation for Learning Modules API.
Args:
service (str): The endpoint service to use, i.e. gradebook
Raises:
requests.RequestException: Exception connection error
ValueError: Unable to decode response content
... | python | {
"resource": ""
} |
q6766 | raw_connection_from | train | def raw_connection_from(engine_or_conn):
"""Extract a raw_connection and determine if it should be automatically closed.
Only connections opened by this package will be closed automatically.
"""
if hasattr(engine_or_conn, 'cursor'):
return engine_or_conn, False
if hasattr(engine_or_conn, 'c... | python | {
"resource": ""
} |
q6767 | makedirs | train | def makedirs(name, mode=0o777, exist_ok=False):
"""cheapo replacement for py3 makedirs with support for exist_ok
"""
if os.path.exists(name):
if not exist_ok:
raise FileExistsError("File exists: " + name)
else:
os.makedirs(name, mode) | python | {
"resource": ""
} |
q6768 | fetch_in_thread | train | def fetch_in_thread(sr, nsa):
"""fetch a sequence in a thread
"""
def fetch_seq(q, nsa):
pid, ppid = os.getpid(), os.getppid()
q.put((pid, ppid, sr[nsa]))
q = Queue()
p = Process(target=fetch_seq, args=(q, nsa))
p.start()
pid, ppid, seq = q.get()
p.join()
asse... | python | {
"resource": ""
} |
q6769 | Application.run | train | def run(self):
"""Run install process."""
try:
self.linux.verify_system_status()
except InstallSkipError:
Log.info('Install skipped.')
return
work_dir = tempfile.mkdtemp(suffix='-rpm-py-installer')
Log.info("Created working directory '{0}'".fo... | python | {
"resource": ""
} |
q6770 | RpmPy.download_and_install | train | def download_and_install(self):
"""Download and install RPM Python binding."""
if self.is_installed_from_bin:
try:
self.installer.install_from_rpm_py_package()
return
except RpmPyPackageNotFoundError as e:
Log.warn('RPM Py Package n... | python | {
"resource": ""
} |
q6771 | RpmPyVersion.git_branch | train | def git_branch(self):
"""Git branch name."""
info = self.info
return 'rpm-{major}.{minor}.x'.format(
major=info[0], minor=info[1]) | python | {
"resource": ""
} |
q6772 | SetupPy.add_patchs_to_build_without_pkg_config | train | def add_patchs_to_build_without_pkg_config(self, lib_dir, include_dir):
"""Add patches to remove pkg-config command and rpm.pc part.
Replace with given library_path: lib_dir and include_path: include_dir
without rpm.pc file.
"""
additional_patches = [
{
... | python | {
"resource": ""
} |
q6773 | SetupPy.apply_and_save | train | def apply_and_save(self):
"""Apply replaced words and patches, and save setup.py file."""
patches = self.patches
content = None
with open(self.IN_PATH) as f_in:
# As setup.py.in file size is 2.4 KByte.
# it's fine to read entire content.
content = f_i... | python | {
"resource": ""
} |
q6774 | Downloader.download_and_expand | train | def download_and_expand(self):
"""Download and expand RPM Python binding."""
top_dir_name = None
if self.git_branch:
# Download a source by git clone.
top_dir_name = self._download_and_expand_by_git()
else:
# Download a source from the arcihve URL.
... | python | {
"resource": ""
} |
q6775 | Installer._make_lib_file_symbolic_links | train | def _make_lib_file_symbolic_links(self):
"""Make symbolic links for lib files.
Make symbolic links from system library files or downloaded lib files
to downloaded source library files.
For example, case: Fedora x86_64
Make symbolic links
from
a. /usr/lib64/l... | python | {
"resource": ""
} |
q6776 | Installer._copy_each_include_files_to_include_dir | train | def _copy_each_include_files_to_include_dir(self):
"""Copy include header files for each directory to include directory.
Copy include header files
from
rpm/
rpmio/*.h
lib/*.h
build/*.h
sign/*.h
to
rp... | python | {
"resource": ""
} |
q6777 | Installer._rpm_py_has_popt_devel_dep | train | def _rpm_py_has_popt_devel_dep(self):
"""Check if the RPM Python binding has a depndency to popt-devel.
Search include header files in the source code to check it.
"""
found = False
with open('../include/rpm/rpmlib.h') as f_in:
for line in f_in:
if re... | python | {
"resource": ""
} |
q6778 | FedoraInstaller.install_from_rpm_py_package | train | def install_from_rpm_py_package(self):
"""Run install from RPM Python binding RPM package."""
self._download_and_extract_rpm_py_package()
# Find ./usr/lib64/pythonN.N/site-packages/rpm directory.
# A binary built by same version Python with used Python is target
# for the safe i... | python | {
"resource": ""
} |
q6779 | Linux.get_instance | train | def get_instance(cls, python, rpm_path, **kwargs):
"""Get OS object."""
linux = None
if Cmd.which('apt-get'):
linux = DebianLinux(python, rpm_path, **kwargs)
else:
linux = FedoraLinux(python, rpm_path, **kwargs)
return linux | python | {
"resource": ""
} |
q6780 | Python.python_lib_rpm_dirs | train | def python_lib_rpm_dirs(self):
"""Both arch and non-arch site-packages directories."""
libs = [self.python_lib_arch_dir, self.python_lib_non_arch_dir]
def append_rpm(path):
return os.path.join(path, 'rpm')
return map(append_rpm, libs) | python | {
"resource": ""
} |
q6781 | Rpm.version | train | def version(self):
"""RPM vesion string."""
stdout = Cmd.sh_e_out('{0} --version'.format(self.rpm_path))
rpm_version = stdout.split()[2]
return rpm_version | python | {
"resource": ""
} |
q6782 | Rpm.is_system_rpm | train | def is_system_rpm(self):
"""Check if the RPM is system RPM."""
sys_rpm_paths = [
'/usr/bin/rpm',
# On CentOS6, system RPM is installed in this directory.
'/bin/rpm',
]
matched = False
for sys_rpm_path in sys_rpm_paths:
if self.rpm_p... | python | {
"resource": ""
} |
q6783 | Rpm.is_package_installed | train | def is_package_installed(self, package_name):
"""Check if the RPM package is installed."""
if not package_name:
raise ValueError('package_name required.')
installed = True
try:
Cmd.sh_e('{0} --query {1} --quiet'.format(self.rpm_path,
... | python | {
"resource": ""
} |
q6784 | FedoraRpm.is_downloadable | train | def is_downloadable(self):
"""Return if rpm is downloadable by the package command.
Check if dnf or yum plugin package exists.
"""
is_plugin_avaiable = False
if self.is_dnf:
is_plugin_avaiable = self.is_package_installed(
'dnf-plugins... | python | {
"resource": ""
} |
q6785 | FedoraRpm.download | train | def download(self, package_name):
"""Download given package."""
if not package_name:
ValueError('package_name required.')
if self.is_dnf:
cmd = 'dnf download {0}.{1}'.format(package_name, self.arch)
else:
cmd = 'yumdownloader {0}.{1}'.format(package_na... | python | {
"resource": ""
} |
q6786 | FedoraRpm.extract | train | def extract(self, package_name):
"""Extract given package."""
for cmd in ['rpm2cpio', 'cpio']:
if not Cmd.which(cmd):
message = '{0} command not found. Install {0}.'.format(cmd)
raise InstallError(message)
pattern = '{0}*{1}.rpm'.format(package_name, ... | python | {
"resource": ""
} |
q6787 | Cmd.sh_e | train | def sh_e(cls, cmd, **kwargs):
"""Run the command. It behaves like "sh -e".
It raises InstallError if the command failed.
"""
Log.debug('CMD: {0}'.format(cmd))
cmd_kwargs = {
'shell': True,
}
cmd_kwargs.update(kwargs)
env = os.environ.copy()
... | python | {
"resource": ""
} |
q6788 | Cmd.sh_e_out | train | def sh_e_out(cls, cmd, **kwargs):
"""Run the command. and returns the stdout."""
cmd_kwargs = {
'stdout': subprocess.PIPE,
}
cmd_kwargs.update(kwargs)
return cls.sh_e(cmd, **cmd_kwargs)[0] | python | {
"resource": ""
} |
q6789 | Cmd.cd | train | def cd(cls, directory):
"""Change directory. It behaves like "cd directory"."""
Log.debug('CMD: cd {0}'.format(directory))
os.chdir(directory) | python | {
"resource": ""
} |
q6790 | Cmd.pushd | train | def pushd(cls, new_dir):
"""Change directory, and back to previous directory.
It behaves like "pushd directory; something; popd".
"""
previous_dir = os.getcwd()
try:
new_ab_dir = None
if os.path.isabs(new_dir):
new_ab_dir = new_dir
... | python | {
"resource": ""
} |
q6791 | Cmd.which | train | def which(cls, cmd):
"""Return an absolute path of the command.
It behaves like "which command".
"""
abs_path_cmd = None
if sys.version_info >= (3, 3):
abs_path_cmd = shutil.which(cmd)
else:
abs_path_cmd = find_executable(cmd)
return abs_p... | python | {
"resource": ""
} |
q6792 | Cmd.curl_remote_name | train | def curl_remote_name(cls, file_url):
"""Download file_url, and save as a file name of the URL.
It behaves like "curl -O or --remote-name".
It raises HTTPError if the file_url not found.
"""
tar_gz_file_name = file_url.split('/')[-1]
if sys.version_info >= (3, 2):
... | python | {
"resource": ""
} |
q6793 | Cmd.tar_extract | train | def tar_extract(cls, tar_comp_file_path):
"""Extract tar.gz or tar bz2 file.
It behaves like
- tar xzf tar_gz_file_path
- tar xjf tar_bz2_file_path
It raises tarfile.ReadError if the file is broken.
"""
try:
with contextlib.closing(tarfile.open(ta... | python | {
"resource": ""
} |
q6794 | Cmd.find | train | def find(cls, searched_dir, pattern):
"""Find matched files.
It does not include symbolic file in the result.
"""
Log.debug('find {0} with pattern: {1}'.format(searched_dir, pattern))
matched_files = []
for root_dir, dir_names, file_names in os.walk(searched_dir,
... | python | {
"resource": ""
} |
q6795 | Utils.version_str2tuple | train | def version_str2tuple(cls, version_str):
"""Version info.
tuple object. ex. ('4', '14', '0', 'rc1')
"""
if not isinstance(version_str, str):
ValueError('version_str invalid instance.')
version_info_list = re.findall(r'[0-9a-zA-Z]+', version_str)
def convert_... | python | {
"resource": ""
} |
q6796 | install_rpm_py | train | def install_rpm_py():
"""Install RPM Python binding."""
python_path = sys.executable
cmd = '{0} install.py'.format(python_path)
exit_status = os.system(cmd)
if exit_status != 0:
raise Exception('Command failed: {0}'.format(cmd)) | python | {
"resource": ""
} |
q6797 | _get_bgzip_version | train | def _get_bgzip_version(exe):
"""return bgzip version as string"""
p = subprocess.Popen([exe, "-h"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True)
output = p.communicate()
version_line = output[0].splitlines()[1]
version = re.match(r"(?:Version:|bgzip \(htslib\))\s+(\d+\.... | python | {
"resource": ""
} |
q6798 | _find_bgzip | train | def _find_bgzip():
"""return path to bgzip if found and meets version requirements, else exception"""
missing_file_exception = OSError if six.PY2 else FileNotFoundError
min_bgzip_version = ".".join(map(str, min_bgzip_version_info))
exe = os.environ.get("SEQREPO_BGZIP_PATH", which("bgzip") or "/usr/bin/b... | python | {
"resource": ""
} |
q6799 | SeqRepo.translate_alias | train | def translate_alias(self, alias, namespace=None, target_namespaces=None, translate_ncbi_namespace=None):
"""given an alias and optional namespace, return a list of all other
aliases for same sequence
"""
if translate_ncbi_namespace is None:
translate_ncbi_namespace = self.t... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.