text_prompt
stringlengths 157
13.1k
| code_prompt
stringlengths 7
19.8k
⌀ |
|---|---|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def addChildren(self, child_ids):
"""Add children to current workitem :param child_ids: a :class:`list` contains the children workitem id/number (integer or equivalent string) """
|
if not hasattr(child_ids, "__iter__"):
error_msg = "Input parameter 'child_ids' is not iterable"
self.log.error(error_msg)
raise exception.BadValue(error_msg)
self.log.debug("Try to add children <Workitem %s> to current "
"<Workitem %s>",
child_ids,
self)
self._addChildren(child_ids)
self.log.info("Successfully add children <Workitem %s> to current "
"<Workitem %s>",
child_ids,
self)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def removeParent(self):
"""Remove the parent workitem from current workitem Notice: for a certain workitem, no more than one parent workitem can be added and specified """
|
self.log.debug("Try to remove the parent workitem from current "
"<Workitem %s>",
self)
headers = copy.deepcopy(self.rtc_obj.headers)
headers["Content-Type"] = self.OSLC_CR_JSON
req_url = "".join([self.url,
"?oslc_cm.properties=com.ibm.team.workitem.",
"linktype.parentworkitem.parent"])
parent_tag = ("rtc_cm:com.ibm.team.workitem.linktype."
"parentworkitem.parent")
parent_original = {parent_tag: []}
self.put(req_url,
verify=False,
proxies=self.rtc_obj.proxies,
headers=headers,
data=json.dumps(parent_original))
self.log.info("Successfully remove the parent workitem of current "
"<Workitem %s>",
self)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def removeChild(self, child_id):
"""Remove a child from current workitem :param child_id: the child workitem id/number (integer or equivalent string) """
|
self.log.debug("Try to remove a child <Workitem %s> from current "
"<Workitem %s>",
child_id,
self)
self._removeChildren([child_id])
self.log.info("Successfully remove a child <Workitem %s> from "
"current <Workitem %s>",
child_id,
self)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def removeChildren(self, child_ids):
"""Remove children from current workitem :param child_ids: a :class:`list` contains the children workitem id/number (integer or equivalent string) """
|
if not hasattr(child_ids, "__iter__"):
error_msg = "Input parameter 'child_ids' is not iterable"
self.log.error(error_msg)
raise exception.BadValue(error_msg)
self.log.debug("Try to remove children <Workitem %s> from current "
"<Workitem %s>",
child_ids,
self)
self._removeChildren(child_ids)
self.log.info("Successfully remove children <Workitem %s> from "
"current <Workitem %s>",
child_ids,
self)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def addAttachment(self, filepath):
"""Upload attachment to a workitem :param filepath: the attachment file path :return: the :class:`rtcclient.models.Attachment` object :rtype: rtcclient.models.Attachment """
|
proj_id = self.contextId
fa = self.rtc_obj.getFiledAgainst(self.filedAgainst,
projectarea_id=proj_id)
fa_id = fa.url.split("/")[-1]
headers = copy.deepcopy(self.rtc_obj.headers)
if headers.__contains__("Content-Type"):
headers.__delitem__("Content-Type")
filename = os.path.basename(filepath)
fileh = open(filepath, "rb")
files = {"attach": (filename, fileh, "application/octet-stream")}
params = {"projectId": proj_id,
"multiple": "true",
"category": fa_id}
req_url = "".join([self.rtc_obj.url,
"/service/com.ibm.team.workitem.service.",
"internal.rest.IAttachmentRestService/"])
resp = self.post(req_url,
verify=False,
headers=headers,
proxies=self.rtc_obj.proxies,
params=params,
files=files)
raw_data = xmltodict.parse(resp.content)
json_body = json.loads(raw_data["html"]["body"]["textarea"])
attachment_info = json_body["files"][0]
return self._add_attachment_link(attachment_info)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def list_containers(active=True, defined=True, as_object=False, config_path=None):
""" List the containers on the system. """
|
if config_path:
if not os.path.exists(config_path):
return tuple()
try:
entries = _lxc.list_containers(active=active, defined=defined,
config_path=config_path)
except ValueError:
return tuple()
else:
try:
entries = _lxc.list_containers(active=active, defined=defined)
except ValueError:
return tuple()
if as_object:
return tuple([Container(name, config_path) for name in entries])
else:
return entries
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def attach_run_command(cmd):
""" Run a command when attaching Please do not call directly, this will execvp the command. This is to be used in conjunction with the attach method of a container. """
|
if isinstance(cmd, tuple):
return _lxc.attach_run_command(cmd)
elif isinstance(cmd, list):
return _lxc.attach_run_command((cmd[0], cmd))
else:
return _lxc.attach_run_command((cmd, [cmd]))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def arch_to_personality(arch):
""" Determine the process personality corresponding to the architecture """
|
if isinstance(arch, bytes):
arch = unicode(arch)
return _lxc.arch_to_personality(arch)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_device_net(self, name, destname=None):
""" Add network device to running container. """
|
if not self.running:
return False
if os.path.exists("/sys/class/net/%s/phy80211/name" % name):
with open("/sys/class/net/%s/phy80211/name" % name) as fd:
phy = fd.read().strip()
if subprocess.call(['iw', 'phy', phy, 'set', 'netns',
str(self.init_pid)]) != 0:
return False
if destname:
def rename_interface(args):
old, new = args
return subprocess.call(['ip', 'link', 'set',
'dev', old, 'name', new])
return self.attach_wait(rename_interface, (name, destname),
namespaces=(CLONE_NEWNET)) == 0
return True
if not destname:
destname = name
if not os.path.exists("/sys/class/net/%s/" % name):
return False
return subprocess.call(['ip', 'link', 'set',
'dev', name,
'netns', str(self.init_pid),
'name', destname]) == 0
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def append_config_item(self, key, value):
""" Append 'value' to 'key', assuming 'key' is a list. If 'key' isn't a list, 'value' will be set as the value of 'key'. """
|
return _lxc.Container.set_config_item(self, key, value)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create(self, template=None, flags=0, args=()):
""" Create a new rootfs for the container. "template" if passed must be a valid template name. "flags" (optional) is an integer representing the optional create flags to be passed. "args" (optional) is a tuple of arguments to pass to the template. It can also be provided as a dict. """
|
if isinstance(args, dict):
template_args = []
for item in args.items():
template_args.append("--%s" % item[0])
template_args.append("%s" % item[1])
else:
template_args = args
if template:
return _lxc.Container.create(self, template=template,
flags=flags,
args=tuple(template_args))
else:
return _lxc.Container.create(self, flags=flags,
args=tuple(template_args))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def clone(self, newname, config_path=None, flags=0, bdevtype=None, bdevdata=None, newsize=0, hookargs=()):
""" Clone the current container. """
|
args = {}
args['newname'] = newname
args['flags'] = flags
args['newsize'] = newsize
args['hookargs'] = hookargs
if config_path:
args['config_path'] = config_path
if bdevtype:
args['bdevtype'] = bdevtype
if bdevdata:
args['bdevdata'] = bdevdata
if _lxc.Container.clone(self, **args):
return Container(newname, config_path=config_path)
else:
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_cgroup_item(self, key):
""" Returns the value for a given cgroup entry. A list is returned when multiple values are set. """
|
value = _lxc.Container.get_cgroup_item(self, key)
if value is False:
return False
else:
return value.rstrip("\n")
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_config_item(self, key):
""" Returns the value for a given config key. A list is returned when multiple values are set. """
|
value = _lxc.Container.get_config_item(self, key)
if value is False:
return False
elif value.endswith("\n"):
return value.rstrip("\n").split("\n")
else:
return value
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_keys(self, key=None):
""" Returns a list of valid sub-keys. """
|
if key:
value = _lxc.Container.get_keys(self, key)
else:
value = _lxc.Container.get_keys(self)
if value is False:
return False
elif value.endswith("\n"):
return value.rstrip("\n").split("\n")
else:
return value
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_ips(self, interface=None, family=None, scope=None, timeout=0):
""" Get a tuple of IPs for the container. """
|
kwargs = {}
if interface:
kwargs['interface'] = interface
if family:
kwargs['family'] = family
if scope:
kwargs['scope'] = scope
ips = None
timeout = int(os.environ.get('LXC_GETIP_TIMEOUT', timeout))
while not ips:
ips = _lxc.Container.get_ips(self, **kwargs)
if timeout == 0:
break
timeout -= 1
time.sleep(1)
return ips
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def rename(self, new_name):
""" Rename the container. On success, returns the new Container object. On failure, returns False. """
|
if _lxc.Container.rename(self, new_name):
return Container(new_name)
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_config_item(self, key, value):
""" Set a config key to a provided value. The value can be a list for the keys supporting multiple values. """
|
try:
old_value = self.get_config_item(key)
except KeyError:
old_value = None
# Get everything to unicode with python2
if isinstance(value, str):
value = value.decode()
elif isinstance(value, list):
for i in range(len(value)):
if isinstance(value[i], str):
value[i] = value[i].decode()
# Check if it's a list
def set_key(key, value):
self.clear_config_item(key)
if isinstance(value, list):
for entry in value:
if not _lxc.Container.set_config_item(self, key, entry):
return False
else:
_lxc.Container.set_config_item(self, key, value)
set_key(key, value)
new_value = self.get_config_item(key)
# loglevel is special and won't match the string we set
if key == "lxc.loglevel":
new_value = value
if (isinstance(value, unicode) and isinstance(new_value, unicode) and
value == new_value):
return True
elif (isinstance(value, list) and isinstance(new_value, list) and
set(value) == set(new_value)):
return True
elif (isinstance(value, unicode) and isinstance(new_value, list) and
set([value]) == set(new_value)):
return True
elif old_value:
set_key(key, old_value)
return False
else:
self.clear_config_item(key)
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wait(self, state, timeout=-1):
""" Wait for the container to reach a given state or timeout. """
|
if isinstance(state, str):
state = state.upper()
return _lxc.Container.wait(self, state, timeout)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def render(self, template, **kwargs):
"""Renders the template :param template: The template to render. The template is actually a file, which is usually generated by :class:`rtcclient.template.Templater.getTemplate` and can also be modified by user accordingly. :param kwargs: The `kwargs` dict is used to fill the template. These two parameter are mandatory: * description * title Some of below parameters (which may not be included in some customized workitem type ) are mandatory if `keep` (parameter in :class:`rtcclient.template.Templater.getTemplate`) is set to `False`; Optional for otherwise. * teamArea (Team Area) * ownedBy (Owned By) * plannedFor(Planned For) * severity(Severity) * priority(Priority) * filedAgainst(Filed Against) Actually all these needed keywords/attributes/fields can be retrieved by :class:`rtcclient.template.Templater.listFields` :return: the :class:`string` object :rtype: string """
|
try:
temp = self.environment.get_template(template)
return temp.render(**kwargs)
except AttributeError:
err_msg = "Invalid value for 'template'"
self.log.error(err_msg)
raise exception.BadValue(err_msg)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def listFields(self, template):
"""List all the attributes to be rendered from the template file :param template: The template to render. The template is actually a file, which is usually generated by :class:`rtcclient.template.Templater.getTemplate` and can also be modified by user accordingly. :return: a :class:`set` contains all the needed attributes :rtype: set """
|
try:
temp_source = self.environment.loader.get_source(self.environment,
template)
return self.listFieldsFromSource(temp_source)
except AttributeError:
err_msg = "Invalid value for 'template'"
self.log.error(err_msg)
raise exception.BadValue(err_msg)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def listFieldsFromSource(self, template_source):
"""List all the attributes to be rendered directly from template source :param template_source: the template source (usually represents the template content in string format) :return: a :class:`set` contains all the needed attributes :rtype: set """
|
ast = self.environment.parse(template_source)
return jinja2.meta.find_undeclared_variables(ast)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
|
def _get_file(self):
'''
return an opened tempfile pointer that can be used
http://docs.python.org/2/library/tempfile.html
'''
f = tempfile.NamedTemporaryFile(delete=False)
self.tmp_files.add(f.name)
return f
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_args(self, executable, *args):
"""compile all the executable and the arguments, combining with common arguments to create a full batch of command args"""
|
args = list(args)
args.insert(0, executable)
if self.username:
args.append("--username={}".format(self.username))
if self.host:
args.append("--host={}".format(self.host))
if self.port:
args.append("--port={}".format(self.port))
args.append(self.dbname)
#args.extend(other_args)
return args
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_outfile_path(self, table):
"""return the path for a file we can use to back up the table"""
|
self.outfile_count += 1
outfile = os.path.join(self.directory, '{:03d}_{}.sql.gz'.format(self.outfile_count, table))
return outfile
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _run_queries(self, queries, *args, **kwargs):
"""run the queries queries -- list -- the queries to run return -- string -- the results of the query? """
|
# write out all the commands to a temp file and then have psql run that file
f = self._get_file()
for q in queries:
f.write("{};\n".format(q))
f.close()
psql_args = self._get_args('psql', '-X', '-f {}'.format(f.name))
return self._run_cmd(' '.join(psql_args), *args, **kwargs)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _restore_auto_increment(self, table):
"""restore the auto increment value for the table to what it was previously"""
|
query, seq_table, seq_column, seq_name = self._get_auto_increment_info(table)
if query:
queries = [query, "select nextval('{}')".format(seq_name)]
return self._run_queries(queries)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_auto_increment_info(self, table):
"""figure out the the autoincrement value for the given table"""
|
query = ''
seq_table = ''
seq_column = ''
seq_name = ''
find_query = "\n".join([
"SELECT",
" t.relname as related_table,",
" a.attname as related_column,",
" s.relname as sequence_name",
"FROM pg_class s",
"JOIN pg_depend d ON d.objid = s.oid",
"JOIN pg_class t ON d.objid = s.oid AND d.refobjid = t.oid",
"JOIN pg_attribute a ON (d.refobjid, d.refobjsubid) = (a.attrelid, a.attnum)",
"JOIN pg_namespace n ON n.oid = s.relnamespace",
"WHERE",
" s.relkind = 'S'",
"AND",
" n.nspname = 'public'",
"AND",
" t.relname = '{}'".format(table)
])
pipe = self._run_queries([find_query], popen_kwargs={'stdout': subprocess.PIPE})
stdout, stderr = pipe.communicate()
if stdout:
try:
m = re.findall('^\s*(\S+)\s*\|\s*(\S+)\s*\|\s*(\S+)\s*$', stdout, flags=re.MULTILINE)
seq_table, seq_column, seq_name = m[1]
# http://www.postgresql.org/docs/9.2/static/functions-sequence.html
# http://www.postgresql.org/docs/9.2/static/functions-conditional.html
query = "\n".join([
"SELECT",
" setval('{}',".format(seq_name.strip()),
" coalesce(max({}), 1),".format(seq_column.strip()),
" max({}) IS NOT null)".format(seq_column.strip()),
"FROM \"{}\"".format(seq_table.strip())
])
except IndexError:
query = ''
return query, seq_table, seq_column, seq_name
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def restore(self):
"""use the self.directory to restore a db NOTE -- this will only restore a database dumped with one of the methods of this class """
|
sql_files = []
for root, dirs, files in os.walk(self.directory):
for f in files:
if f.endswith(".sql.gz"):
path = os.path.join(self.directory, f)
self._run_cmd(["gunzip", path])
sql_files.append(f.rstrip(".gz"))
elif f.endswith('.sql'):
sql_files.append(f)
sql_files.sort() # we want to go in the order the tables were dumped
r = re.compile('\d{3,}_([^\.]+)')
for f in sql_files:
path = os.path.join(self.directory, f)
m = r.match(f)
if m:
table = m.group(1)
logger.info('------- restoring table {}'.format(table))
#psql_args = self._get_args('psql', '-X', '--echo-queries', '-f {}'.format(path))
psql_args = self._get_args('psql', '-X', '--quiet', '--file={}'.format(path))
self._run_cmd(psql_args)
logger.info('------- restored table {}'.format(table))
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_env(self):
"""this returns an environment dictionary we want to use to run the command this will also create a fake pgpass file in order to make it possible for the script to be passwordless"""
|
if hasattr(self, 'env'): return self.env
# create a temporary pgpass file
pgpass = self._get_file()
# format: http://www.postgresql.org/docs/9.2/static/libpq-pgpass.html
pgpass.write('*:*:*:{}:{}\n'.format(self.username, self.password).encode("utf-8"))
pgpass.close()
self.env = dict(os.environ)
self.env['PGPASSFILE'] = pgpass.name
# we want to assure a consistent environment
if 'PGOPTIONS' in self.env: del self.env['PGOPTIONS']
return self.env
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_response(**kwargs):
"""Get a template response Use kwargs to add things to the dictionary """
|
if 'code' not in kwargs:
kwargs['code'] = 200
if 'headers' not in kwargs:
kwargs['headers'] = dict()
if 'version' not in kwargs:
kwargs['version'] = 'HTTP/1.1'
return dict(**kwargs)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _write_transport(self, string):
"""Convenience function to write to the transport"""
|
if isinstance(string, str): # we need to convert to bytes
self.transport.write(string.encode('utf-8'))
else:
self.transport.write(string)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _write_response(self, response):
"""Write the response back to the client Arguments: response -- the dictionary containing the response. """
|
status = '{} {} {}\r\n'.format(response['version'],
response['code'],
responses[response['code']])
self.logger.debug("Responding status: '%s'", status.strip())
self._write_transport(status)
if 'body' in response and 'Content-Length' not in response['headers']:
response['headers']['Content-Length'] = len(response['body'])
response['headers']['Date'] = datetime.utcnow().strftime(
"%a, %d %b %Y %H:%M:%S +0000")
for (header, content) in response['headers'].items():
self.logger.debug("Sending header: '%s: %s'", header, content)
self._write_transport('{}: {}\r\n'.format(header, content))
self._write_transport('\r\n')
if 'body' in response:
self._write_transport(response['body'])
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def connection_made(self, transport):
"""Called when the connection is made"""
|
self.logger.info('Connection made at object %s', id(self))
self.transport = transport
self.keepalive = True
if self._timeout:
self.logger.debug('Registering timeout event')
self._timout_handle = self._loop.call_later(
self._timeout, self._handle_timeout)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def connection_lost(self, exception):
"""Called when the connection is lost or closed. The argument is either an exception object or None. The latter means a regular EOF is received, or the connection was aborted or closed by this side of the connection. """
|
if exception:
self.logger.exception('Connection lost!')
else:
self.logger.info('Connection lost')
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def data_received(self, data):
"""Process received data from the socket Called when we receive data """
|
self.logger.debug('Received data: %s', repr(data))
try:
request = self._parse_headers(data)
self._handle_request(request)
except InvalidRequestError as e:
self._write_response(e.get_http_response())
if not self.keepalive:
if self._timeout_handle:
self._timeout_handle.cancel()
self.transport.close()
if self._timeout and self._timeout_handle:
self.logger.debug('Delaying timeout event')
self._timeout_handle.cancel()
self._timout_handle = self._loop.call_later(
self._timeout, self._handle_timeout)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_request_uri(self, request):
"""Parse the request URI into something useful Server MUST accept full URIs (5.1.2)"""
|
request_uri = request['target']
if request_uri.startswith('/'): # eg. GET /index.html
return (request.get('Host', 'localhost').split(':')[0],
request_uri[1:])
elif '://' in request_uri: # eg. GET http://rded.nl
locator = request_uri.split('://', 1)[1]
host, path = locator.split('/', 1)
return (host.split(':')[0], path)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _handle_request(self, request):
"""Process the headers and get the file"""
|
# Check if this is a persistent connection.
if request['version'] == 'HTTP/1.1':
self.keepalive = not request.get('Connection') == 'close'
elif request['version'] == 'HTTP/1.0':
self.keepalive = request.get('Connection') == 'Keep-Alive'
# Check if we're getting a sane request
if request['method'] not in ('GET'):
raise InvalidRequestError(501, 'Method not implemented')
if request['version'] not in ('HTTP/1.0', 'HTTP/1.1'):
raise InvalidRequestError(
505, 'Version not supported. Supported versions are: {}, {}'
.format('HTTP/1.0', 'HTTP/1.1'))
host, location = self._get_request_uri(request)
# We must ignore the Host header if a host is specified in GET
if host is None:
host = request.get('Host')
# Check if this request is intended for this webserver
if host is not None and not host == self.host:
self.logger.info('Got a request for unknown host %s', host)
raise InvalidRequestError(404, "We don't serve this host")
filename = os.path.join(self.folder, unquote(location))
self.logger.debug('trying to serve %s', filename)
if os.path.isdir(filename):
filename = os.path.join(filename, 'index.html')
if not os.path.isfile(filename):
raise InvalidRequestError(404, 'Not Found')
# Start response with version
response = _get_response(version=request['version'])
# timeout negotiation
match = re.match(r'timeout=(\d+)', request.get('Keep-Alive', ''))
if match is not None:
requested_timeout = int(match.group(1))
if requested_timeout < self._timeout:
self._timeout = requested_timeout
# tell the client our timeout
if self.keepalive:
response['headers'][
'Keep-Alive'] = 'timeout={}'.format(self._timeout)
# Set Content-Type
response['headers']['Content-Type'] = mimetypes.guess_type(
filename)[0] or 'text/plain'
# Generate E-tag
sha1 = hashlib.sha1()
with open(filename, 'rb') as fp:
response['body'] = fp.read()
sha1.update(response['body'])
etag = sha1.hexdigest()
# Create 304 response if if-none-match matches etag
if request.get('If-None-Match') == '"{}"'.format(etag):
# 304 responses shouldn't contain many headers we might already
# have added.
response = _get_response(code=304)
response['headers']['Etag'] = '"{}"'.format(etag)
self._write_response(response)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_http_response(self):
"""Get this exception as an HTTP response suitable for output"""
|
return _get_response(
code=self.code,
body=str(self),
headers={
'Content-Type': 'text/plain'
}
)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _start_server(bindaddr, port, hostname, folder):
"""Starts an asyncio server"""
|
import asyncio
from .httpserver import HttpProtocol
loop = asyncio.get_event_loop()
coroutine = loop.create_server(lambda: HttpProtocol(hostname, folder),
bindaddr,
port)
server = loop.run_until_complete(coroutine)
print('Starting server on {}'.format(server.sockets[0].getsockname()))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run(argv=None):
# pragma: no cover """Run the HTTP server Usage: httpserver [options] [<folder>] Options:: -h,--host=<hostname> What host name to serve (default localhost) -a,--bindaddress=<address> Address to bind to (default 127.0.0.1) -p,--port=<port> Port to listen on (default 8080) -v,--verbose Increase verbosity to INFO messages -d,--debug Increase verbosity to DEBUG messages --help Print this help message --version Print the version To serve /path/to/www on all (ipv4) addresses for host myserver on port 80:: httpserver -a 0.0.0.0 -p 80 -h myserver /path/to/www """
|
import sys
import os
import docopt
import textwrap
# Check for the version
if not sys.version_info >= (3, 4):
print('This python version is not supported. Please use python 3.4')
exit(1)
argv = argv or sys.argv[1:]
# remove some RST formatting
docblock = run.__doc__.replace('::', ':')
args = docopt.docopt(textwrap.dedent(docblock), argv)
if args['--version']:
print("httpserver version {} by {}".format(
__version__,
__author__))
exit(0)
# Set up logging
level = logging.WARNING
if args['--verbose']:
level = logging.INFO
if args['--debug']:
level = logging.DEBUG
logging.basicConfig(level=level)
logger = logging.getLogger('run method')
logger.debug('CLI args: %s' % args)
bindaddr = args['--bindaddress'] or '127.0.0.1'
port = args['--port'] or '8080'
folder = args['<folder>'] or os.getcwd()
hostname = args['--host'] or 'localhost'
_start_server(bindaddr, port, hostname, folder)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def reading(self):
"""Open url and read """
|
try:
# testing proxy
proxies = {}
try:
proxies["http_proxy"] = os.environ['http_proxy']
except KeyError:
pass
try:
proxies["https_proxy"] = os.environ['https_proxy']
except KeyError:
pass
if len(proxies) != 0:
proxy = urllib2.ProxyHandler(proxies)
opener = urllib2.build_opener(proxy)
urllib2.install_opener(opener)
# end testing
f = urllib2.urlopen(self.link)
return f.read()
except (urllib2.URLError, ValueError):
print("\n{0}Can't read the file '{1}'{2}".format(
self.meta.color["RED"], self.link.split("/")[-1],
self.meta.color["ENDC"]))
return " "
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def repos(self):
"""View or enabled or disabled repositories """
|
def_cnt, cus_cnt = 0, 0
print("")
self.msg.template(78)
print("{0}{1}{2}{3}{4}{5}{6}".format(
"| Repo id", " " * 2,
"Repo URL", " " * 44,
"Default", " " * 3,
"Status"))
self.msg.template(78)
for repo_id, repo_URL in sorted(self.all_repos.iteritems()):
status, COLOR = "disabled", self.meta.color["RED"]
default = "yes"
if len(repo_URL) > 49:
repo_URL = repo_URL[:48] + "~"
if repo_id in self.meta.repositories:
def_cnt += 1
status, COLOR = "enabled", self.meta.color["GREEN"]
if repo_id not in self.meta.default_repositories:
cus_cnt += 1
default = "no"
print(" {0}{1}{2}{3}{4}{5}{6}{7:>8}{8}".format(
repo_id, " " * (9 - len(repo_id)),
repo_URL, " " * (52 - len(repo_URL)),
default, " " * (8 - len(default)),
COLOR, status, self.meta.color["ENDC"]))
print("\nRepositories summary")
print("=" * 79)
print("{0}{1}/{2} enabled default repositories and {3} custom.".format(
self.meta.color["GREY"], def_cnt, len(self.all_repos), cus_cnt))
print("Edit the file '/etc/slpkg/repositories.conf' for enable "
"and disable default\nrepositories or run 'slpkg "
"repo-enable' command.\n{0}".format(self.meta.color["ENDC"]))
raise SystemExit()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def view(self):
"""View slpkg config file """
|
print("") # new line at start
conf_args = [
"RELEASE",
"SLACKWARE_VERSION",
"COMP_ARCH",
"BUILD_PATH",
"PACKAGES",
"PATCHES",
"CHECKMD5",
"DEL_ALL",
"DEL_BUILD",
"SBO_BUILD_LOG",
"MAKEFLAGS",
"DEFAULT_ANSWER",
"REMOVE_DEPS_ANSWER",
"SKIP_UNST",
"RSL_DEPS",
"DEL_DEPS",
"USE_COLORS",
"DOWNDER",
"DOWNDER_OPTIONS",
"SLACKPKG_LOG",
"ONLY_INSTALLED",
"PRG_BAR",
"EDITOR",
"NOT_DOWNGRADE"
]
read_conf = Utils().read_file(self.config_file)
for line in read_conf.splitlines():
if not line.startswith("#") and line.split("=")[0] in conf_args:
print("{0}".format(line))
else:
print("{0}{1}{2}".format(self.meta.color["CYAN"], line,
self.meta.color["ENDC"]))
print("")
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def edit(self):
"""Edit configuration file """
|
subprocess.call("{0} {1}".format(self.meta.editor,
self.config_file), shell=True)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def reset(self):
"""Reset slpkg.conf file with default values """
|
shutil.copy2(self.config_file + ".orig", self.config_file)
if filecmp.cmp(self.config_file + ".orig", self.config_file):
print("{0}The reset was done{1}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"]))
else:
print("{0}Reset failed{1}".format(self.meta.color["RED"],
self.meta.color["ENDC"]))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get(self):
"""Return sbo arch """
|
if self.arch.startswith("i") and self.arch.endswith("86"):
self.arch = self.x86
elif self.meta.arch.startswith("arm"):
self.arch = self.arm
return self.arch
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def case_sensitive(self, lst):
"""Create dictionary from list with key in lower case and value with default """
|
dictionary = {}
for pkg in lst:
dictionary[pkg.lower()] = pkg
return dictionary
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove_dbs(self, double):
"""Remove double item from list """
|
one = []
for dup in double:
if dup not in one:
one.append(dup)
return one
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_file(self, registry):
"""Returns reading file """
|
with open(registry, "r") as file_txt:
read_file = file_txt.read()
file_txt.close()
return read_file
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def package_name(self, PACKAGES_TXT):
"""Returns list with all the names of packages repository """
|
packages = []
for line in PACKAGES_TXT.splitlines():
if line.startswith("PACKAGE NAME:"):
packages.append(split_package(line[14:].strip())[0])
return packages
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def check_downloaded(self, path, maybe_downloaded):
"""Check if files downloaded and return downloaded packages """
|
downloaded = []
for pkg in maybe_downloaded:
if os.path.isfile(path + pkg):
downloaded.append(pkg)
return downloaded
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def dependencies(self, deps_dict):
"""Generate graph file with depenndencies map tree """
|
try:
import pygraphviz as pgv
except ImportError:
graph_easy, comma = "", ""
if (self.image == "ascii" and
not os.path.isfile("/usr/bin/graph-easy")):
comma = ","
graph_easy = " graph-easy"
print("Require 'pygraphviz{0}{1}': Install with 'slpkg -s sbo "
"pygraphviz{1}'".format(comma, graph_easy))
raise SystemExit()
if self.image != "ascii":
self.check_file()
try:
G = pgv.AGraph(deps_dict)
G.layout(prog="fdp")
if self.image == "ascii":
G.write("{0}.dot".format(self.image))
self.graph_easy()
G.draw(self.image)
except IOError:
raise SystemExit()
if os.path.isfile(self.image):
print("Graph image file '{0}' created".format(self.image))
raise SystemExit()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def check_file(self):
"""Check for file format and type """
|
try:
image_type = ".{0}".format(self.image.split(".")[1])
if image_type not in self.file_format:
print("Format: '{0}' not recognized. Use one of "
"them:\n{1}".format(self.image.split(".")[1],
", ".join(self.file_format)))
raise SystemExit()
except IndexError:
print("slpkg: Error: Image file suffix missing")
raise SystemExit()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def graph_easy(self):
"""Draw ascii diagram. graph-easy perl module require """
|
if not os.path.isfile("/usr/bin/graph-easy"):
print("Require 'graph-easy': Install with 'slpkg -s sbo "
"graph-easy'")
self.remove_dot()
raise SystemExit()
subprocess.call("graph-easy {0}.dot".format(self.image), shell=True)
self.remove_dot()
raise SystemExit()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove_dot(self):
"""Remove .dot files """
|
if os.path.isfile("{0}.dot".format(self.image)):
os.remove("{0}.dot".format(self.image))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def alien_filter(packages, sizes):
"""This filter avoid list double packages from alien repository """
|
cache, npkg, nsize = [], [], []
for p, s in zip(packages, sizes):
name = split_package(p)[0]
if name not in cache:
cache.append(name)
npkg.append(p)
nsize.append(s)
return npkg, nsize
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def upgrade(self, flag):
"""Upgrade Slackware binary packages with new """
|
for pkg in self.binary:
try:
subprocess.call("upgradepkg {0} {1}".format(flag, pkg),
shell=True)
check = pkg[:-4].split("/")[-1]
if os.path.isfile(self.meta.pkg_path + check):
print("Completed!\n")
else:
raise SystemExit()
except subprocess.CalledProcessError:
self._not_found("Can't upgrade", self.binary, pkg)
raise SystemExit(1)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove(self, flag, extra):
"""Remove Slackware binary packages """
|
self.flag = flag
self.extra = extra
self.dep_path = self.meta.log_path + "dep/"
dependencies, rmv_list = [], []
self.removed = self._view_removed()
if not self.removed:
print("") # new line at end
else:
msg = "package"
if len(self.removed) > 1:
msg = msg + "s"
try:
if self.meta.default_answer in ["y", "Y"]:
remove_pkg = self.meta.default_answer
else:
remove_pkg = raw_input(
"\nAre you sure to remove {0} {1} [y/N]? ".format(
str(len(self.removed)), msg))
except EOFError:
print("") # new line at exit
raise SystemExit()
if remove_pkg in ["y", "Y"]:
self._check_if_used(self.binary)
for rmv in self.removed:
# If package build and install with "slpkg -s sbo <package>"
# then look log file for dependencies in /var/log/slpkg/dep,
# read and remove all else remove only the package.
if (os.path.isfile(self.dep_path + rmv) and
self.meta.del_deps in ["on", "ON"] or
os.path.isfile(self.dep_path + rmv) and
"--deps" in self.extra):
dependencies = self._view_deps(self.dep_path, rmv)
if dependencies and self._rmv_deps_answer() in ["y",
"Y"]:
rmv_list += self._rmv_deps(dependencies, rmv)
else:
rmv_list += self._rmv_pkg(rmv)
else:
rmv_list += self._rmv_pkg(rmv)
# Prints all removed packages
self._reference_rmvs(rmv_list)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _rmv_deps_answer(self):
"""Remove dependencies answer """
|
if self.meta.remove_deps_answer in ["y", "Y"]:
remove_dep = self.meta.remove_deps_answer
else:
try:
remove_dep = raw_input(
"\nRemove dependencies (maybe used by "
"other packages) [y/N]? ")
print("")
except EOFError:
print("") # new line at exit
raise SystemExit()
return remove_dep
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_removed(self):
"""Manage removed packages by extra options """
|
removed, packages = [], []
if "--tag" in self.extra:
for pkg in find_package("", self.meta.pkg_path):
for tag in self.binary:
if pkg.endswith(tag):
removed.append(split_package(pkg)[0])
packages.append(pkg)
if not removed:
self.msg.pkg_not_found("", "'tag'", "Can't remove", "\n")
raise SystemExit(1)
else:
for pkg in self.binary:
name = GetFromInstalled(pkg).name()
ver = GetFromInstalled(pkg).version()
package = find_package("{0}{1}{2}".format(
name, ver, self.meta.sp), self.meta.pkg_path)
if pkg and name == pkg:
removed.append(pkg)
packages.append(package[0])
else:
self.msg.pkg_not_found("", pkg, "Can't remove", "\n")
raise SystemExit(1)
return removed, packages
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _view_removed(self):
"""View packages before removed """
|
print("\nPackages with name matching [ {0}{1}{2} ]\n".format(
self.meta.color["CYAN"], ", ".join(self.binary),
self.meta.color["ENDC"]))
removed, packages = self._get_removed()
if packages and "--checklist" in self.extra:
removed = []
text = "Press 'spacebar' to unchoose packages from the remove"
backtitle = "{0} {1}".format(self.meta.__all__,
self.meta.__version__)
status = True
pkgs = DialogUtil(packages, text, " Remove ", backtitle,
status).checklist()
if pkgs:
for rmv in pkgs:
removed.append(split_package(rmv)[0])
self.meta.default_answer = "y"
else:
for rmv, pkg in zip(removed, packages):
print("[ {0}delete{1} ] --> {2}".format(
self.meta.color["RED"], self.meta.color["ENDC"], pkg))
self._sizes(pkg)
self._calc_sizes()
self._remove_summary()
return removed
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _calc_sizes(self):
"""Package size calculation """
|
if self.size > 1024:
self.unit = "Mb"
self.size = (self.size / 1024)
if self.size > 1024:
self.unit = "Gb"
self.size = (self.size / 1024)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _remove_summary(self):
"""Removed packge size summary """
|
if self.size > 0:
print("\nRemoved summary")
print("=" * 79)
print("{0}Size of removed packages {1} {2}.{3}".format(
self.meta.color["GREY"], round(self.size, 2), self.unit,
self.meta.color["ENDC"]))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _view_deps(self, path, package):
"""View dependencies before remove """
|
self.size = 0
packages = []
dependencies = (Utils().read_file(path + package)).splitlines()
for dep in dependencies:
if GetFromInstalled(dep).name():
ver = GetFromInstalled(dep).version()
packages.append(dep + ver)
else:
dependencies.remove(dep)
if packages:
if "--checklist" in self.extra:
deps, dependencies = [], []
text = "Found dependencies for the package {0}".format(package)
backtitle = "{0} {1}".format(self.meta.__all__,
self.meta.__version__)
status = True
deps = DialogUtil(packages, text, " Remove ", backtitle,
status).checklist()
for d in deps:
dependencies.append("-".join(d.split("-")[:-1]))
self.meta.remove_deps_answer = "y"
else:
print("") # new line at start
self.msg.template(78)
print("| Found dependencies for the package {0}:".format(
package))
self.msg.template(78)
for pkg in packages:
find = find_package(pkg + self.meta.sp, self.meta.pkg_path)
self._sizes(find[0])
print("| {0}{1}{2}".format(self.meta.color["RED"], pkg,
self.meta.color["ENDC"]))
self.msg.template(78)
self._calc_sizes()
print("| {0}Size of removed dependencies {1} {2}{3}".format(
self.meta.color["GREY"], round(self.size, 2), self.unit,
self.meta.color["ENDC"]))
self.msg.template(78)
return dependencies
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _removepkg(self, package):
"""removepkg Slackware command """
|
try:
subprocess.call("removepkg {0} {1}".format(self.flag, package),
shell=True)
if os.path.isfile(self.dep_path + package):
os.remove(self.dep_path + package) # remove log
except subprocess.CalledProcessError as er:
print(er)
raise SystemExit()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _rmv_pkg(self, package):
"""Remove one signle package """
|
removes = []
if GetFromInstalled(package).name() and package not in self.skip:
ver = GetFromInstalled(package).version()
removes.append(package + ver)
self._removepkg(package)
return removes
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _skip_remove(self):
"""Skip packages from remove """
|
if "--checklist" not in self.extra:
self.msg.template(78)
print("| Insert packages to exception remove:")
self.msg.template(78)
try:
self.skip = raw_input(" > ").split()
except EOFError:
print("")
raise SystemExit()
for s in self.skip:
if s in self.removed:
self.removed.remove(s)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _check_if_used(self, removes):
"""Check package if dependencies for another package before removed"""
|
if "--check-deps" in self.extra:
package, dependency, pkg_dep = [], [], []
for pkg in find_package("", self.dep_path):
deps = Utils().read_file(self.dep_path + pkg)
for rmv in removes:
if GetFromInstalled(rmv).name() and rmv in deps.split():
pkg_dep.append(
"{0} is dependency of the package --> {1}".format(
rmv, pkg))
package.append(pkg)
dependency.append(rmv)
if package:
if "--checklist" in self.extra:
text = ("Press 'spacebar' to choose packages for the remove"
" exception")
backtitle = "{0} {1}".format(self.meta.__all__,
self.meta.__version__)
status = False
choose = DialogUtil(pkg_dep, text, " !!! WARNING !!! ",
backtitle, status).checklist()
for pkg in choose:
self.skip.append(pkg.split()[0])
else:
self.msg.template(78)
print("| {0}{1}{2}".format(
self.meta.color["RED"], " " * 30 + "!!! WARNING !!!",
self.meta.color["ENDC"]))
self.msg.template(78)
for p, d in zip(package, dependency):
print("| {0}{1}{2} is dependency of the package --> "
"{3}{4}{5}".format(self.meta.color["YELLOW"], d,
self.meta.color["ENDC"],
self.meta.color["GREEN"], p,
self.meta.color["ENDC"]))
self.msg.template(78)
self._skip_remove()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _reference_rmvs(self, removes):
"""Prints all removed packages """
|
print("")
self.msg.template(78)
msg_pkg = "package"
if len(removes) > 1:
msg_pkg = "packages"
print("| Total {0} {1} removed".format(len(removes), msg_pkg))
self.msg.template(78)
for pkg in removes:
if not GetFromInstalled(pkg).name():
print("| Package {0} removed".format(pkg))
else:
print("| Package {0} not found".format(pkg))
self.msg.template(78)
print("")
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def find(self, flag):
"""Find installed Slackware packages """
|
matching, pkg_cache, match_cache = 0, "", ""
print("\nPackages with matching name [ {0}{1}{2} ]\n".format(
self.meta.color["CYAN"], ", ".join(self.binary),
self.meta.color["ENDC"]))
for pkg in self.binary:
for match in find_package("", self.meta.pkg_path):
if "--case-ins" in flag:
pkg_cache = pkg.lower()
match_cache = match.lower()
else:
pkg_cache = pkg
match_cache = match
if pkg_cache in match_cache:
matching += 1
self._sizes(match)
print("[ {0}installed{1} ] [ {2} ] - {3}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"],
self.file_size, match))
if matching == 0:
message = "Can't find"
self.msg.pkg_not_found("", ", ".join(self.binary), message, "\n")
raise SystemExit(1)
else:
self._calc_sizes()
print("\nFound summary")
print("=" * 79)
print("{0}Total found {1} matching packages.{2}".format(
self.meta.color["GREY"], matching, self.meta.color["ENDC"]))
print("{0}Size of installed packages {1} {2}.{3}\n".format(
self.meta.color["GREY"], round(self.size, 2), self.unit,
self.meta.color["ENDC"]))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _sizes(self, package):
"""Package size summary """
|
data = Utils().read_file(self.meta.pkg_path + package)
for line in data.splitlines():
if line.startswith("UNCOMPRESSED PACKAGE SIZE:"):
digit = float((''.join(re.findall(
"[-+]?\d+[\.]?\d*[eE]?[-+]?\d*", line[26:]))))
self.file_size = line[26:].strip()
if "M" in line[26:]:
self.size += digit * 1024
else:
self.size += digit
break
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def display(self):
"""Print the Slackware packages contents """
|
for pkg in self.binary:
name = GetFromInstalled(pkg).name()
ver = GetFromInstalled(pkg).version()
find = find_package("{0}{1}{2}".format(name, ver, self.meta.sp),
self.meta.pkg_path)
if find:
package = Utils().read_file(
self.meta.pkg_path + "".join(find))
print(package)
else:
message = "Can't dislpay"
if len(self.binary) > 1:
bol = eol = ""
else:
bol = eol = "\n"
self.msg.pkg_not_found(bol, pkg, message, eol)
raise SystemExit(1)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def package_list(self, repo, name, INDEX, installed):
"""List with the installed packages """
|
tty_size = os.popen("stty size", "r").read().split()
row = int(tty_size[0]) - 2
try:
all_installed_names = []
index, page, pkg_list = 0, row, []
r = self.list_lib(repo)
pkg_list = self.list_greps(repo, r)[0]
all_installed_names = self.list_of_installed(repo, name)
print("")
for pkg in sorted(pkg_list):
pkg = self._splitting_packages(pkg, repo, name)
if installed:
if repo == "sbo":
if pkg in all_installed_names:
pkg = ("{0}{1}{2}".format(self.meta.color["GREEN"],
pkg,
self.meta.color["ENDC"]))
else:
if pkg in all_installed_names:
pkg = ("{0}{1}{2}".format(self.meta.color["GREEN"],
pkg,
self.meta.color["ENDC"]))
if INDEX:
index += 1
pkg = self.list_color_tag(pkg)
print("{0}{1}:{2} {3}".format(
self.meta.color["GREY"], index,
self.meta.color["ENDC"], pkg))
if index == page:
read = raw_input("\nPress {0}Enter{1} to "
"continue... ".format(
self.meta.color["CYAN"],
self.meta.color["ENDC"]))
if read in ["Q", "q"]:
break
print("") # new line after page
page += row
else:
print(pkg)
print("") # new line at end
except EOFError:
print("") # new line at exit
raise SystemExit()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _splitting_packages(self, pkg, repo, name):
"""Return package name from repositories """
|
if name and repo != "sbo":
pkg = split_package(pkg)[0]
elif not name and repo != "sbo":
pkg = pkg[:-4]
return pkg
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def list_lib(self, repo):
"""Return package lists """
|
packages = ""
if repo == "sbo":
if (os.path.isfile(
self.meta.lib_path + "{0}_repo/SLACKBUILDS.TXT".format(
repo))):
packages = Utils().read_file(self.meta.lib_path + "{0}_repo/"
"SLACKBUILDS.TXT".format(repo))
else:
if (os.path.isfile(
self.meta.lib_path + "{0}_repo/PACKAGES.TXT".format(repo))):
packages = Utils().read_file(self.meta.lib_path + "{0}_repo/"
"PACKAGES.TXT".format(repo))
return packages
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def list_color_tag(self, pkg):
"""Tag with color installed packages """
|
name = GetFromInstalled(pkg).name()
find = name + self.meta.sp
if pkg.endswith(".txz") or pkg.endswith(".tgz"):
find = pkg[:-4]
if find_package(find, self.meta.pkg_path):
pkg = "{0}{1}{2}".format(self.meta.color["GREEN"], pkg,
self.meta.color["ENDC"])
return pkg
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def list_of_installed(self, repo, name):
"""Return installed packages """
|
all_installed_names = []
all_installed_packages = find_package("", self.meta.pkg_path)
for inst in all_installed_packages:
if repo == "sbo" and inst.endswith("_SBo"):
name = split_package(inst)[0]
all_installed_names.append(name)
else:
if name:
all_installed_names.append(split_package(inst)[0])
else:
all_installed_names.append(inst)
return all_installed_names
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def rlw_filter(name, location, size, unsize):
"""Filter rlw repository data """
|
arch = _meta_.arch
if arch.startswith("i") and arch.endswith("86"):
arch = "i486"
(fname, flocation, fsize, funsize) = ([] for i in range(4))
for n, l, s, u in zip(name, location, size, unsize):
loc = l.split("/")
if arch == loc[-1]:
fname.append(n)
flocation.append(l)
fsize.append(s)
funsize.append(u)
return [fname, flocation, fsize, funsize]
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def alien_filter(name, location, size, unsize):
"""Fix to avoid packages include in slackbuilds folder """
|
(fname, flocation, fsize, funsize) = ([] for i in range(4))
for n, l, s, u in zip(name, location, size, unsize):
if "slackbuilds" != l:
fname.append(n)
flocation.append(l)
fsize.append(s)
funsize.append(u)
return [fname, flocation, fsize, funsize]
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def rested_filter(name, location, size, unsize):
"""Filter Alien"s repository data """
|
ver = slack_ver()
if _meta_.slack_rel == "current":
ver = "current"
path_pkg = "pkg"
if _meta_.arch == "x86_64":
path_pkg = "pkg64"
(fname, flocation, fsize, funsize) = ([] for i in range(4))
for n, l, s, u in zip(name, location, size, unsize):
if path_pkg == l.split("/")[-2] and ver == l.split("/")[-1]:
fname.append(n)
flocation.append(l)
fsize.append(s)
funsize.append(u)
return [fname, flocation, fsize, funsize]
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_deps(self):
"""Grap package requirements from repositories """
|
if self.repo == "rlw":
dependencies = {}
rlw_deps = Utils().read_file(_meta_.conf_path + "rlworkman.deps")
for line in rlw_deps.splitlines():
if line and not line.startswith("#"):
pkgs = line.split(":")
dependencies[pkgs[0]] = pkgs[1]
if self.name in dependencies.keys():
return dependencies[self.name].split()
else:
return ""
else:
PACKAGES_TXT = Utils().read_file("{0}{1}_repo/PACKAGES.TXT".format(
_meta_.lib_path, self.repo))
for line in PACKAGES_TXT.splitlines():
if line.startswith("PACKAGE NAME:"):
pkg_name = split_package(line[14:].strip())[0]
if line.startswith("PACKAGE REQUIRED:"):
if pkg_name == self.name:
if line[18:].strip():
return self._req_fix(line)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _req_fix(self, line):
"""Fix slacky and salix requirements because many dependencies splitting with "," and others with "|" """
|
deps = []
for dep in line[18:].strip().split(","):
dep = dep.split("|")
if self.repo == "slacky":
if len(dep) > 1:
for d in dep:
deps.append(d.split()[0])
dep = "".join(dep)
deps.append(dep.split()[0])
else:
if len(dep) > 1:
for d in dep:
deps.append(d)
deps.append(dep[0])
return deps
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run(self):
"""print .new configuration files """
|
self.find_new()
for n in self.news:
print("{0}".format(n))
print("")
self.msg.template(78)
print("| Installed {0} new configuration files:".format(
len(self.news)))
self.msg.template(78)
self.choices()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def choices(self):
"""Menu options for new configuration files """
|
print("| {0}K{1}{2}eep the old and .new files, no changes".format(
self.red, self.endc, self.br))
print("| {0}O{1}{2}verwrite all old configuration files with new "
"ones".format(self.red, self.endc, self.br))
print("| The old files will be saved with suffix .old")
print("| {0}R{1}{2}emove all .new files".format(
self.red, self.endc, self.br))
print("| {0}P{1}{2}rompt K, O, R, D, M option for each single "
"file".format(self.red, self.endc, self.br))
print("| {0}Q{1}{2}uit from menu".format(self.red, self.endc, self.br))
self.msg.template(78)
try:
choose = raw_input("\nWhat would you like to do [K/O/R/P/Q]? ")
except EOFError:
print("")
raise SystemExit()
print("")
if choose in ("K", "k"):
self.keep()
elif choose in ("O", "o"):
self.overwrite_all()
elif choose in ("R", "r"):
self.remove_all()
elif choose in ("P", "p"):
self.prompt()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def question(self, n):
"""Choose what do to file by file """
|
print("")
prompt_ask = raw_input("{0} [K/O/R/D/M/Q]? ".format(n))
print("")
if prompt_ask in ("K", "k"):
self.keep()
elif prompt_ask in ("O", "o"):
self._overwrite(n)
elif prompt_ask in ("R", "r"):
self._remove(n)
elif prompt_ask in ("D", "d"):
self.diff(n)
self.i -= 1
elif prompt_ask in ("M", "m"):
self.merge(n)
elif prompt_ask in ("Q", "q", "quit"):
self.quit()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _remove(self, n):
"""Remove one single file """
|
if os.path.isfile(n):
os.remove(n)
if not os.path.isfile(n):
print("File '{0}' removed".format(n))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _overwrite(self, n):
"""Overwrite old file with new and keep file with suffix .old """
|
if os.path.isfile(n[:-4]):
shutil.copy2(n[:-4], n[:-4] + ".old")
print("Old file {0} saved as {1}.old".format(
n[:-4].split("/")[-1], n[:-4].split("/")[-1]))
if os.path.isfile(n):
shutil.move(n, n[:-4])
print("New file {0} overwrite as {1}".format(
n.split("/")[-1], n[:-4].split("/")[-1]))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def diff(self, n):
"""Print the differences between the two files """
|
if os.path.isfile(n[:-4]):
diff1 = Utils().read_file(n[:-4]).splitlines()
if os.path.isfile(n):
diff2 = Utils().read_file(n).splitlines()
lines, l, c = [], 0, 0
for a, b in itertools.izip_longest(diff1, diff2):
l += 1
if a != b:
for s1, s2 in itertools.izip_longest(str(a), str(b)):
c += 1
if s1 != s2:
break
print("@@ -{0},{1} +{2},{3} @@\n".format(l, c, l, c))
for line in lines[-3:]:
print("{0}".format(line))
if a is None:
a = ""
print("{0}{1}{2}{3}".format(self.red, "-", self.endc, a))
if b is None:
b = ""
print("{0}{1}{2}{3}".format(self.green, "+", self.endc, b))
lines = []
c = 0
else:
lines.append(a)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def merge(self, n):
"""Merge new file into old """
|
if os.path.isfile(n[:-4]):
old = Utils().read_file(n[:-4]).splitlines()
if os.path.isfile(n):
new = Utils().read_file(n).splitlines()
with open(n[:-4], "w") as out:
for l1, l2 in itertools.izip_longest(old, new):
if l1 is None:
l1 = ""
if l2 is None:
l2 = ""
if l1 != l2:
out.write(l2 + "\n")
else:
out.write(l1 + "\n")
print("The file {0} merged in file {1}".format(
n.split("/")[-1], n[:-4].split("/")[-1]))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def status_bar(self):
"""Top view bar status """
|
print("")
self.msg.template(78)
print("| Repository Status")
self.msg.template(78)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run(self):
"""Run and check if new in ChangeLog.txt """
|
if (self.repo in self.meta.default_repositories and
self.repo in self.meta.repositories):
try:
self.check = self.all_repos[self.repo]()
except OSError:
usage(self.repo)
raise SystemExit()
elif self.repo in self.meta.repositories:
self.check = self._init.custom(self.repo)
else:
usage(self.repo)
raise SystemExit()
self.status_bar()
self.status()
self.print_status(self.repo)
self.summary()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def md5(source):
"""Return MD5 Checksum """
|
# fix passing char '+' from source
source = source.replace("%2B", "+")
with open(source) as file_to_check:
data = file_to_check.read()
return hashlib.md5(data).hexdigest()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run(self):
"""Run tracking dependencies """
|
self.msg.resolving()
self.repositories()
if self.find_pkg:
self.dependencies_list.reverse()
self.requires = Utils().dimensional_list(self.dependencies_list)
self.dependencies = Utils().remove_dbs(self.requires)
if self.dependencies == []:
self.dependencies = ["No dependencies"]
if "--graph=" in self.flag:
self.deps_tree()
self.msg.done()
pkg_len = len(self.name) + 24
print("") # new line at start
self.msg.template(pkg_len)
print("| Package {0}{1}{2} dependencies :".format(
self.cyan, self.name, self.endc))
self.msg.template(pkg_len)
print("\\")
print(" +---{0}[ Tree of dependencies ]{1}".format(self.yellow,
self.endc))
index = 0
for pkg in self.dependencies:
if "--check-deps" in self.flag:
used = self.check_used(pkg)
self.deps_used(pkg, used)
used = "{0} {1}{2}{3}".format(
"is dependency -->", self.cyan,
", ".join(used), self.endc)
else:
used = ""
index += 1
installed = ""
if find_package(pkg + self.meta.sp, self.meta.pkg_path):
if self.meta.use_colors in ["off", "OFF"]:
installed = "* "
print(" |")
print(" {0}{1}: {2}{3}{4} {5}{6}".format(
"+--", index, self.green, pkg,
self.endc, installed, used))
else:
print(" |")
print(" {0}{1}: {2}{3}{4} {5}".format(
"+--", index, self.red, pkg,
self.endc, installed))
if self.meta.use_colors in ["off", "OFF"]:
print("\n * = Installed\n")
else:
print("") # new line at end
if "--graph=" in self.flag:
self.graph()
else:
self.msg.done()
print("\nNo package was found to match\n")
raise SystemExit(1)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def repositories(self):
"""Get dependencies by repositories """
|
if self.repo == "sbo":
self.sbo_case_insensitive()
self.find_pkg = sbo_search_pkg(self.name)
if self.find_pkg:
self.dependencies_list = Requires(self.flag).sbo(self.name)
else:
PACKAGES_TXT = Utils().read_file(
self.meta.lib_path + "{0}_repo/PACKAGES.TXT".format(self.repo))
self.names = Utils().package_name(PACKAGES_TXT)
self.bin_case_insensitive()
self.find_pkg = search_pkg(self.name, self.repo)
if self.find_pkg:
self.black = BlackList().packages(self.names, self.repo)
self.dependencies_list = Dependencies(
self.repo, self.black).binary(self.name, self.flag)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def sbo_case_insensitive(self):
"""Matching packages distinguish between uppercase and lowercase for sbo repository """
|
if "--case-ins" in self.flag:
data = SBoGrep(name="").names()
data_dict = Utils().case_sensitive(data)
for key, value in data_dict.iteritems():
if key == self.name.lower():
self.name = value
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def check_used(self, pkg):
"""Check if dependencies used """
|
used = []
dep_path = self.meta.log_path + "dep/"
logs = find_package("", dep_path)
for log in logs:
deps = Utils().read_file(dep_path + log)
for dep in deps.splitlines():
if pkg == dep:
used.append(log)
return used
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def deps_tree(self):
"""Package dependencies image map file """
|
dependencies = self.dependencies + [self.name]
if self.repo == "sbo":
for dep in dependencies:
deps = Requires(flag="").sbo(dep)
if dep not in self.deps_dict.values():
self.deps_dict[dep] = Utils().dimensional_list(deps)
else:
for dep in dependencies:
deps = Dependencies(self.repo, self.black).binary(dep, flag="")
if dep not in self.deps_dict.values():
self.deps_dict[dep] = Utils().dimensional_list(deps)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def deps_used(self, pkg, used):
"""Create dependencies dictionary """
|
if find_package(pkg + self.meta.sp, self.meta.pkg_path):
if pkg not in self.deps_dict.values():
self.deps_dict[pkg] = used
else:
self.deps_dict[pkg] += used
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def version(self):
"""Return version from installed packages """
|
if self.find:
return self.meta.sp + split_package(self.find)[1]
return ""
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.