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 dump(self):
"""Print packet content.""" |
print "-----MqttPkt------"
print "command = ", self.command
print "have_remaining = ", self.have_remaining
print "remaining_count = ", self.remaining_count
print "mid = ", self.mid
print "remaining_mult = ", self.remaining_mult
print "remaining_length = ", self.remaining_length
print "packet_length = ", self.packet_length
print "to_process = ", self.to_process
print "pos = ", self.pos
print "payload = ", self.payload
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 alloc(self):
"""from _mosquitto_packet_alloc.""" |
byte = 0
remaining_bytes = bytearray(5)
i = 0
remaining_length = self.remaining_length
self.payload = None
self.remaining_count = 0
loop_flag = True
#self.dump()
while loop_flag:
byte = remaining_length % 128
remaining_length = remaining_length / 128
if remaining_length > 0:
byte = byte | 0x80
remaining_bytes[self.remaining_count] = byte
self.remaining_count += 1
if not (remaining_length > 0 and self.remaining_count < 5):
loop_flag = False
if self.remaining_count == 5:
return NC.ERR_PAYLOAD_SIZE
self.packet_length = self.remaining_length + 1 + self.remaining_count
self.payload = bytearray(self.packet_length)
self.payload[0] = self.command
i = 0
while i < self.remaining_count:
self.payload[i+1] = remaining_bytes[i]
i += 1
self.pos = 1 + self.remaining_count
return NC.ERR_SUCCESS |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def connect_build(self, nyamuk, keepalive, clean_session, retain = 0, dup = 0, version = 3):
"""Build packet for CONNECT command.""" |
will = 0; will_topic = None
byte = 0
client_id = utf8encode(nyamuk.client_id)
username = utf8encode(nyamuk.username) if nyamuk.username is not None else None
password = utf8encode(nyamuk.password) if nyamuk.password is not None else None
#payload len
payload_len = 2 + len(client_id)
if nyamuk.will is not None:
will = 1
will_topic = utf8encode(nyamuk.will.topic)
payload_len = payload_len + 2 + len(will_topic) + 2 + nyamuk.will.payloadlen
if username is not None:
payload_len = payload_len + 2 + len(username)
if password != None:
payload_len = payload_len + 2 + len(password)
self.command = NC.CMD_CONNECT
self.remaining_length = 12 + payload_len
rc = self.alloc()
if rc != NC.ERR_SUCCESS:
return rc
#var header
self.write_string(getattr(NC, 'PROTOCOL_NAME_{0}'.format(version)))
self.write_byte( getattr(NC, 'PROTOCOL_VERSION_{0}'.format(version)))
byte = (clean_session & 0x1) << 1
if will:
byte = byte | ((nyamuk.will.retain & 0x1) << 5) | ((nyamuk.will.qos & 0x3) << 3) | ((will & 0x1) << 2)
if nyamuk.username is not None:
byte = byte | 0x1 << 7
if nyamuk.password is not None:
byte = byte | 0x1 << 6
self.write_byte(byte)
self.write_uint16(keepalive)
#payload
self.write_string(client_id)
if will:
self.write_string(will_topic)
self.write_string(nyamuk.will.payload)
if username is not None:
self.write_string(username)
if password is not None:
self.write_string(password)
nyamuk.keep_alive = keepalive
return NC.ERR_SUCCESS |
<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_string(self, string):
"""Write a string to this packet.""" |
self.write_uint16(len(string))
self.write_bytes(string, len(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_uint16(self, word):
"""Write 2 bytes.""" |
self.write_byte(nyamuk_net.MOSQ_MSB(word))
self.write_byte(nyamuk_net.MOSQ_LSB(word)) |
<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_byte(self, byte):
"""Write one byte.""" |
self.payload[self.pos] = byte
self.pos = self.pos + 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 write_bytes(self, data, n):
"""Write n number of bytes to this packet.""" |
for pos in xrange(0, n):
self.payload[self.pos + pos] = data[pos]
self.pos += 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 read_byte(self):
"""Read a byte.""" |
if self.pos + 1 > self.remaining_length:
return NC.ERR_PROTOCOL, None
byte = self.payload[self.pos]
self.pos += 1
return NC.ERR_SUCCESS, byte |
<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_uint16(self):
"""Read 2 bytes.""" |
if self.pos + 2 > self.remaining_length:
return NC.ERR_PROTOCOL
msb = self.payload[self.pos]
self.pos += 1
lsb = self.payload[self.pos]
self.pos += 1
word = (msb << 8) + lsb
return NC.ERR_SUCCESS, word |
<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_bytes(self, count):
"""Read count number of bytes.""" |
if self.pos + count > self.remaining_length:
return NC.ERR_PROTOCOL, None
ba = bytearray(count)
for x in xrange(0, count):
ba[x] = self.payload[self.pos]
self.pos += 1
return NC.ERR_SUCCESS, ba |
<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_string(self):
"""Read string.""" |
rc, length = self.read_uint16()
if rc != NC.ERR_SUCCESS:
return rc, None
if self.pos + length > self.remaining_length:
return NC.ERR_PROTOCOL, None
ba = bytearray(length)
if ba is None:
return NC.ERR_NO_MEM, None
for x in xrange(0, length):
ba[x] = self.payload[self.pos]
self.pos += 1
return NC.ERR_SUCCESS, ba |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def pop_event(self):
"""Pop an event from event_list.""" |
if len(self.event_list) > 0:
evt = self.event_list.pop(0)
return evt
return None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def packet_queue(self, pkt):
"""Enqueue packet to out_packet queue.""" |
pkt.pos = 0
pkt.to_process = pkt.packet_length
self.out_packet.append(pkt)
return NC.ERR_SUCCESS |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def packet_write(self):
"""Write packet to network.""" |
bytes_written = 0
if self.sock == NC.INVALID_SOCKET:
return NC.ERR_NO_CONN, bytes_written
while len(self.out_packet) > 0:
pkt = self.out_packet[0]
write_length, status = nyamuk_net.write(self.sock, pkt.payload)
if write_length > 0:
pkt.to_process -= write_length
pkt.pos += write_length
bytes_written += write_length
if pkt.to_process > 0:
return NC.ERR_SUCCESS, bytes_written
else:
if status == errno.EAGAIN or status == errno.EWOULDBLOCK:
return NC.ERR_SUCCESS, bytes_written
elif status == errno.ECONNRESET:
return NC.ERR_CONN_LOST, bytes_written
else:
return NC.ERR_UNKNOWN, bytes_written
"""
if pkt.command & 0xF6 == NC.CMD_PUBLISH and self.on_publish is not None:
self.in_callback = True
self.on_publish(pkt.mid)
self.in_callback = False
"""
#next
del self.out_packet[0]
#free data (unnecessary)
self.last_msg_out = time.time()
return NC.ERR_SUCCESS, bytes_written |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def socket_close(self):
"""Close our socket.""" |
if self.sock != NC.INVALID_SOCKET:
self.sock.close()
self.sock = NC.INVALID_SOCKET |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def build_publish_pkt(self, mid, topic, payload, qos, retain, dup):
"""Build PUBLISH packet.""" |
pkt = MqttPkt()
payloadlen = len(payload)
packetlen = 2 + len(topic) + payloadlen
if qos > 0:
packetlen += 2
pkt.mid = mid
pkt.command = NC.CMD_PUBLISH | ((dup & 0x1) << 3) | (qos << 1) | retain
pkt.remaining_length = packetlen
ret = pkt.alloc()
if ret != NC.ERR_SUCCESS:
return ret, None
#variable header : Topic String
pkt.write_string(topic)
if qos > 0:
pkt.write_uint16(mid)
#payloadlen
if payloadlen > 0:
pkt.write_bytes(payload, payloadlen)
return NC.ERR_SUCCESS, pkt |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def send_simple_command(self, cmd):
"""Send simple mqtt commands.""" |
pkt = MqttPkt()
pkt.command = cmd
pkt.remaining_length = 0
ret = pkt.alloc()
if ret != NC.ERR_SUCCESS:
return ret
return self.packet_queue(pkt) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def real_ip(self):
""" The actual public IP of this host. """ |
if self._real_ip is None:
response = get(ICANHAZIP)
self._real_ip = self._get_response_text(response)
return self._real_ip |
<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_current_ip(self):
""" Get the current IP Tor is using. :returns str :raises TorIpError """ |
response = get(ICANHAZIP, proxies={"http": self.local_http_proxy})
if response.ok:
return self._get_response_text(response)
raise TorIpError("Failed to get the current Tor IP") |
<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_new_ip(self):
""" Try to obtain new a usable TOR IP. :returns bool :raises TorIpError """ |
attempts = 0
while True:
if attempts == self.new_ip_max_attempts:
raise TorIpError("Failed to obtain a new usable Tor IP")
attempts += 1
try:
current_ip = self.get_current_ip()
except (RequestException, TorIpError):
self._obtain_new_ip()
continue
if not self._ip_is_usable(current_ip):
self._obtain_new_ip()
continue
self._manage_used_ips(current_ip)
break
return current_ip |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _ip_is_usable(self, current_ip):
""" Check if the current Tor's IP is usable. :argument current_ip: current Tor IP :type current_ip: str :returns bool """ |
# Consider IP addresses only.
try:
ipaddress.ip_address(current_ip)
except ValueError:
return False
# Never use real IP.
if current_ip == self.real_ip:
return False
# Do dot allow IP reuse.
if not self._ip_is_safe(current_ip):
return False
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 _manage_used_ips(self, current_ip):
""" Handle registering and releasing used Tor IPs. :argument current_ip: current Tor IP :type current_ip: str """ |
# Register current IP.
self.used_ips.append(current_ip)
# Release the oldest registred IP.
if self.reuse_threshold:
if len(self.used_ips) > self.reuse_threshold:
del self.used_ips[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 _obtain_new_ip(self):
""" Change Tor's IP. """ |
with Controller.from_port(
address=self.tor_address, port=self.tor_port
) as controller:
controller.authenticate(password=self.tor_password)
controller.signal(Signal.NEWNYM)
# Wait till the IP 'settles in'.
sleep(0.5) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_local_subsection(command_dict):
"""Returns True if command dict is "local subsection", meaning that it is "if", "else" or "for" (not a real call, but calls run_section recursively.""" |
for local_com in ['if ', 'for ', 'else ']:
if list(command_dict.keys())[0].startswith(local_com):
return True
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 _process_req_txt(req):
'''Returns a processed request or raises an exception'''
if req.status_code == 404:
return ''
if req.status_code != 200:
raise DapiCommError('Response of the server was {code}'.format(code=req.status_code))
return req.text |
<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_from_dapi_or_mirror(link):
'''Tries to get the link form DAPI or the mirror'''
exception = False
try:
req = requests.get(_api_url() + link, timeout=5)
except requests.exceptions.RequestException:
exception = True
attempts = 1
while exception or str(req.status_code).startswith('5'):
if attempts > 5:
raise DapiCommError('Could not connect to the API endpoint, sorry.')
exception = False
try:
# Every second attempt, use the mirror
req = requests.get(_api_url(attempts % 2) + link, timeout=5*attempts)
except requests.exceptions.RequestException:
exception = True
attempts += 1
return req |
<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_api_url_from_link(link):
'''Remove the API URL from the link if it is there'''
if link.startswith(_api_url()):
link = link[len(_api_url()):]
if link.startswith(_api_url(mirror=True)):
link = link[len(_api_url(mirror=True)):]
return link |
<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(link):
'''Returns a dictionary from requested link'''
link = _remove_api_url_from_link(link)
req = _get_from_dapi_or_mirror(link)
return _process_req(req) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def search(q, **kwargs):
'''Returns a dictionary with the search results'''
data = {'q': q}
for key, value in kwargs.items():
if value:
if type(value) == bool:
data[key] = 'on'
else:
data[key] = value
return _unpaginated('search/?' + urlencode(data)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def format_users():
'''Formats a list of users available on Dapi'''
lines = []
u = users()
count = u['count']
if not count:
raise DapiCommError('Could not find any users on DAPI.')
for user in u['results']:
line = user['username']
if user['full_name']:
line += ' (' + user['full_name'] + ')'
lines.append(line)
return lines |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def format_daps(simple=False, skip_installed=False):
'''Formats a list of metadaps available on Dapi'''
lines= []
m = metadaps()
if not m['count']:
logger.info('Could not find any daps')
return
for mdap in sorted(m['results'], key=lambda mdap: mdap['package_name']):
if skip_installed and mdap['package_name'] in get_installed_daps():
continue
if simple:
logger.info(mdap['package_name'])
else:
for line in _format_dap_with_description(mdap):
lines.append(line)
return lines |
<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_metadap_dap(name, version=''):
'''Return data for dap of given or latest version.'''
m = metadap(name)
if not m:
raise DapiCommError('DAP {dap} not found.'.format(dap=name))
if not version:
d = m['latest_stable'] or m['latest']
if d:
d = data(d)
else:
d = dap(name, version)
if not d:
raise DapiCommError(
'DAP {dap} doesn\'t have version {version}.'.format(dap=name, version=version))
return m, d |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def format_dap_from_dapi(name, version='', full=False):
'''Formats information about given DAP from DAPI in a human readable form to list of lines'''
lines = []
m, d = _get_metadap_dap(name, version)
if d:
# Determining label width
labels = BASIC_LABELS + ['average_rank'] # average_rank comes from m, not d
if full:
labels.extend(EXTRA_LABELS)
label_width = dapi.DapFormatter.calculate_offset(labels)
# Metadata
lines += dapi.DapFormatter.format_meta_lines(d, labels=labels, offset=label_width)
lines.append(dapi.DapFormatter.format_dapi_score(m, offset=label_width))
if 'assistants' in d:
# Assistants
assistants = sorted([a for a in d['assistants'] if a.startswith('assistants')])
lines.append('')
for line in dapi.DapFormatter.format_assistants_lines(assistants):
lines.append(line)
# Snippets
if full:
snippets = sorted([a for a in d['assistants'] if a.startswith('snippets')])
lines.append('')
lines += dapi.DapFormatter.format_snippets(snippets)
# Supported platforms
if d.get('supported_platforms', ''):
lines.append('')
lines += dapi.DapFormatter.format_platforms(d['supported_platforms'])
lines.append('')
return lines |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def format_local_dap(dap, full=False, **kwargs):
'''Formaqts information about the given local DAP in a human readable form to list of lines'''
lines = []
# Determining label width
label_width = dapi.DapFormatter.calculate_offset(BASIC_LABELS)
# Metadata
lines.append(dapi.DapFormatter.format_meta(dap.meta, labels=BASIC_LABELS,
offset=label_width, **kwargs))
# Assistants
lines.append('')
lines.append(dapi.DapFormatter.format_assistants(dap.assistants))
# Snippets
if full:
lines.append('')
lines.append(dapi.DapFormatter.format_snippets(dap.snippets))
# Supported platforms
if 'supported_platforms' in dap.meta:
lines.append('')
lines.append(dapi.DapFormatter.format_platforms(dap.meta['supported_platforms']))
lines.append()
return lines |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def format_installed_dap(name, full=False):
'''Formats information about an installed DAP in a human readable form to list of lines'''
dap_data = get_installed_daps_detailed().get(name)
if not dap_data:
raise DapiLocalError('DAP "{dap}" is not installed, can not query for info.'.format(dap=name))
locations = [os.path.join(data['location'], '') for data in dap_data]
for location in locations:
dap = dapi.Dap(None, fake=True, mimic_filename=name)
meta_path = os.path.join(location, 'meta', name + '.yaml')
with open(meta_path, 'r') as fh:
dap.meta = dap._load_meta(fh)
dap.files = _get_assistants_snippets(location, name)
dap._find_bad_meta()
format_local_dap(dap, full=full, custom_location=os.path.dirname(location)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def format_installed_dap_list(simple=False):
'''Formats all installed DAPs in a human readable form to list of lines'''
lines = []
if simple:
for pkg in sorted(get_installed_daps()):
lines.append(pkg)
else:
for pkg, instances in sorted(get_installed_daps_detailed().items()):
versions = []
for instance in instances:
location = utils.unexpanduser(instance['location'])
version = instance['version']
if not versions: # if this is the first
version = utils.bold(version)
versions.append('{v}:{p}'.format(v=version, p=location))
pkg = utils.bold(pkg)
lines.append('{pkg} ({versions})'.format(pkg=pkg, versions=' '.join(versions)))
return lines |
<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_assistants_snippets(path, name):
'''Get Assistants and Snippets for a given DAP name on a given path'''
result = []
subdirs = {'assistants': 2, 'snippets': 1} # Values used for stripping leading path tokens
for loc in subdirs:
for root, dirs, files in os.walk(os.path.join(path, loc)):
for filename in [utils.strip_prefix(os.path.join(root, f), path) for f in files]:
stripped = os.path.sep.join(filename.split(os.path.sep)[subdirs[loc]:])
if stripped.startswith(os.path.join(name, '')) or stripped == name + '.yaml':
result.append(os.path.join('fakeroot', filename))
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def format_search(q, **kwargs):
'''Formats the results of a search'''
m = search(q, **kwargs)
count = m['count']
if not count:
raise DapiCommError('Could not find any DAP packages for your query.')
return
for mdap in m['results']:
mdap = mdap['content_object']
return _format_dap_with_description(mdap) |
<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_installed_daps(location=None, skip_distro=False):
'''Returns a set of all installed daps
Either in the given location or in all of them'''
if location:
locations = [location]
else:
locations = _data_dirs()
s = set()
for loc in locations:
if skip_distro and loc == DISTRO_DIRECTORY:
continue
g = glob.glob('{d}/meta/*.yaml'.format(d=loc))
for meta in g:
s.add(meta.split('/')[-1][:-len('.yaml')])
return 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 get_installed_daps_detailed():
'''Returns a dictionary with all installed daps and their versions and locations
First version and location in the dap's list is the one that is preferred'''
daps = {}
for loc in _data_dirs():
s = get_installed_daps(loc)
for dap in s:
if dap not in daps:
daps[dap] = []
daps[dap].append({'version': get_installed_version_of(dap, loc), 'location': loc})
return daps |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def download_dap(name, version='', d='', directory=''):
'''Download a dap to a given or temporary directory
Return a path to that file together with information if the directory should be later deleted
'''
if not d:
m, d = _get_metadap_dap(name, version)
if directory:
_dir = directory
else:
_dir = tempfile.mkdtemp()
try:
url = d['download']
except TypeError:
raise DapiCommError('DAP {dap} has no version to download.'.format(dap=name))
filename = url.split('/')[-1]
path = os.path.join(_dir, filename)
urllib.request.urlretrieve(url, path)
dapisum = d['sha256sum']
downloadedsum = hashlib.sha256(open(path, 'rb').read()).hexdigest()
if dapisum != downloadedsum:
os.remove(path)
raise DapiLocalError(
'DAP {dap} has incorrect sha256sum (DAPI: {dapi}, downloaded: {downloaded})'.
format(dap=name, dapi=dapisum, downloaded=downloadedsum))
return path, not bool(directory) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def _strip_version_from_dependency(dep):
'''For given dependency string, return only the package name'''
usedmark = ''
for mark in '< > ='.split():
split = dep.split(mark)
if len(split) > 1:
usedmark = mark
break
if usedmark:
return split[0].strip()
else:
return dep.strip() |
<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_installed_version_of(name, location=None):
'''Gets the installed version of the given dap or None if not installed
Searches in all dirs by default, otherwise in the given one'''
if location:
locations = [location]
else:
locations = _data_dirs()
for loc in locations:
if name not in get_installed_daps(loc):
continue
meta = '{d}/meta/{dap}.yaml'.format(d=loc, dap=name)
data = yaml.load(open(meta), Loader=Loader)
return str(data['version'])
return None |
<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_all_dependencies_of(name, deps=set(), force=False):
'''Returns list of dependencies of the given dap from Dapi recursively'''
first_deps = _get_api_dependencies_of(name, force=force)
for dep in first_deps:
dep = _strip_version_from_dependency(dep)
if dep in deps:
continue
# we do the following not to resolve the dependencies of already installed daps
if dap in get_installed_daps():
continue
deps |= _get_all_dependencies_of(dep, deps)
return deps | set([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 _get_api_dependencies_of(name, version='', force=False):
'''Returns list of first level dependencies of the given dap from Dapi'''
m, d = _get_metadap_dap(name, version=version)
# We need the dependencies to install the dap,
# if the dap is unsupported, raise an exception here
if not force and not _is_supported_here(d):
raise DapiLocalError(
'{0} is not supported on this platform (use --force to suppress this check).'.
format(name))
return d.get('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 install_dap(name, version='', update=False, update_allpaths=False, first=True,
force=False, nodeps=False, reinstall=False, __ui__=''):
'''Install a dap from dapi
If update is True, it will remove previously installed daps of the same name'''
m, d = _get_metadap_dap(name, version)
if update:
available = d['version']
current = get_installed_version_of(name)
if not current:
raise DapiLocalError('Cannot update not yet installed DAP.')
if dapver.compare(available, current) <= 0:
return []
path, remove_dir = download_dap(name, d=d)
ret = install_dap_from_path(path, update=update, update_allpaths=update_allpaths, first=first,
force=force, nodeps=nodeps, reinstall=reinstall, __ui__=__ui__)
try:
if remove_dir:
shutil.rmtree(os.dirname(path))
else:
os.remove(path)
except:
pass
return ret |
<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_dependency_metadata():
'''Returns list of strings with dependency metadata from Dapi'''
link = os.path.join(_api_url(), 'meta.txt')
return _process_req_txt(requests.get(link)).split('\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 create_frame(self):
""" This function creates a frame """ |
frame = Gtk.Frame()
frame.set_shadow_type(Gtk.ShadowType.IN)
return frame |
<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_box(self, orientation=Gtk.Orientation.HORIZONTAL, spacing=0):
""" Function creates box. Based on orientation it can be either HORIZONTAL or VERTICAL """ |
h_box = Gtk.Box(orientation=orientation, spacing=spacing)
h_box.set_homogeneous(False)
return h_box |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def button_with_label(self, description, assistants=None):
""" Function creates a button with lave. If assistant is specified then text is aligned """ |
btn = self.create_button()
label = self.create_label(description)
if assistants is not None:
h_box = self.create_box(orientation=Gtk.Orientation.VERTICAL)
h_box.pack_start(label, False, False, 0)
label_ass = self.create_label(
assistants, justify=Gtk.Justification.LEFT
)
label_ass.set_alignment(0, 0)
h_box.pack_start(label_ass, False, False, 12)
btn.add(h_box)
else:
btn.add(label)
return btn |
<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_image(self, image_name=None, scale_ratio=1, window=None):
""" The function creates a image from name defined in image_name """ |
size = 48 * scale_ratio
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(image_name, -1, size, True)
image = Gtk.Image()
# Creating the cairo surface is necessary for proper scaling on HiDPI
try:
surface = Gdk.cairo_surface_create_from_pixbuf(pixbuf, scale_ratio, window)
image.set_from_surface(surface)
# Fallback for GTK+ older than 3.10
except AttributeError:
image.set_from_pixbuf(pixbuf)
return 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 button_with_image(self, description, image=None, sensitive=True):
""" The function creates a button with image """ |
btn = self.create_button()
btn.set_sensitive(sensitive)
h_box = self.create_box()
try:
img = self.create_image(image_name=image,
scale_ratio=btn.get_scale_factor(),
window=btn.get_window())
except: # Older GTK+ than 3.10
img = self.create_image(image_name=image)
h_box.pack_start(img, False, False, 12)
label = self.create_label(description)
h_box.pack_start(label, False, False, 0)
btn.add(h_box)
return btn |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def checkbutton_with_label(self, description):
""" The function creates a checkbutton with label """ |
act_btn = Gtk.CheckButton(description)
align = self.create_alignment()
act_btn.add(align)
return align |
<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_checkbox(self, name, margin=10):
""" Function creates a checkbox with his name """ |
chk_btn = Gtk.CheckButton(name)
chk_btn.set_margin_right(margin)
return chk_btn |
<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_entry(self, text="", sensitive="False"):
""" Function creates an Entry with corresponding text """ |
text_entry = Gtk.Entry()
text_entry.set_sensitive(sensitive)
text_entry.set_text(text)
return text_entry |
<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_link_button(self, text="None", uri="None"):
""" Function creates a link button with corresponding text and URI reference """ |
link_btn = Gtk.LinkButton(uri, text)
return link_btn |
<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_button(self, style=Gtk.ReliefStyle.NORMAL):
""" This is generalized method for creating Gtk.Button """ |
btn = Gtk.Button()
btn.set_relief(style)
return btn |
<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_image_menu_item(self, text, image_name):
""" Function creates a menu item with an image """ |
menu_item = Gtk.ImageMenuItem(text)
img = self.create_image(image_name)
menu_item.set_image(img)
return menu_item |
<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_label(self, name, justify=Gtk.Justification.CENTER, wrap_mode=True, tooltip=None):
""" The function is used for creating lable with HTML text """ |
label = Gtk.Label()
name = name.replace('|', '\n')
label.set_markup(name)
label.set_justify(justify)
label.set_line_wrap(wrap_mode)
if tooltip is not None:
label.set_has_tooltip(True)
label.connect("query-tooltip", self.parent.tooltip_queries, tooltip)
return label |
<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_button(self, grid_lang, ass, row, column):
""" The function is used for creating button with all features like signal on tooltip and signal on clicked The function does not have any menu. Button is add to the Gtk.Grid on specific row and column """ |
#print "gui_helper add_button"
image_name = ass[0].icon_path
label = "<b>" + ass[0].fullname + "</b>"
if not image_name:
btn = self.button_with_label(label)
else:
btn = self.button_with_image(label, image=ass[0].icon_path)
#print "Dependencies button",ass[0]._dependencies
if ass[0].description:
btn.set_has_tooltip(True)
btn.connect("query-tooltip",
self.parent.tooltip_queries,
self.get_formatted_description(ass[0].description)
)
btn.connect("clicked", self.parent.btn_clicked, ass[0].name)
if row == 0 and column == 0:
grid_lang.add(btn)
else:
grid_lang.attach(btn, column, row, 1, 1)
return btn |
<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_install_button(self, grid_lang, row, column):
""" Add button that opens the window for installing more assistants """ |
btn = self.button_with_label('<b>Install more...</b>')
if row == 0 and column == 0:
grid_lang.add(btn)
else:
grid_lang.attach(btn, column, row, 1, 1)
btn.connect("clicked", self.parent.install_btn_clicked)
return btn |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def menu_item(self, sub_assistant, path):
""" The function creates a menu item and assigns signal like select and button-press-event for manipulation with menu_item. sub_assistant and path """ |
if not sub_assistant[0].icon_path:
menu_item = self.create_menu_item(sub_assistant[0].fullname)
else:
menu_item = self.create_image_menu_item(
sub_assistant[0].fullname, sub_assistant[0].icon_path
)
if sub_assistant[0].description:
menu_item.set_has_tooltip(True)
menu_item.connect("query-tooltip",
self.parent.tooltip_queries,
self.get_formatted_description(sub_assistant[0].description),
)
menu_item.connect("select", self.parent.sub_menu_select, path)
menu_item.connect("button-press-event", self.parent.sub_menu_pressed)
menu_item.show()
return menu_item |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def generate_menu(self, ass, text, path=None, level=0):
""" Function generates menu from based on ass parameter """ |
menu = self.create_menu()
for index, sub in enumerate(sorted(ass[1], key=lambda y: y[0].fullname.lower())):
if index != 0:
text += "|"
text += "- " + sub[0].fullname
new_path = list(path)
if level == 0:
new_path.append(ass[0].name)
new_path.append(sub[0].name)
menu_item = self.menu_item(sub, new_path)
if sub[1]:
# If assistant has subassistants
(sub_menu, txt) = self.generate_menu(sub, text, new_path, level=level + 1)
menu_item.set_submenu(sub_menu)
menu.append(menu_item)
return menu, text |
<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_submenu(self, grid_lang, ass, row, column):
""" The function is used for creating button with menu and submenu. Also signal on tooltip and signal on clicked are specified Button is add to the Gtk.Grid """ |
text = "Available subassistants:\n"
# Generate menus
path = []
(menu, text) = self.generate_menu(ass, text, path=path)
menu.show_all()
if ass[0].description:
description = self.get_formatted_description(ass[0].description) + "\n\n"
else:
description = ""
description += text.replace('|', '\n')
image_name = ass[0].icon_path
lbl_text = "<b>" + ass[0].fullname + "</b>"
if not image_name:
btn = self.button_with_label(lbl_text)
else:
btn = self.button_with_image(lbl_text, image=image_name)
btn.set_has_tooltip(True)
btn.connect("query-tooltip",
self.parent.tooltip_queries,
description
)
btn.connect_object("event", self.parent.btn_press_event, menu)
if row == 0 and column == 0:
grid_lang.add(btn)
else:
grid_lang.attach(btn, column, row, 1, 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 create_scrolled_window(self, layout_manager, horizontal=Gtk.PolicyType.NEVER, vertical=Gtk.PolicyType.ALWAYS):
""" Function creates a scrolled window with layout manager """ |
scrolled_window = Gtk.ScrolledWindow()
scrolled_window.add(layout_manager)
scrolled_window.set_policy(horizontal, vertical)
return scrolled_window |
<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_gtk_grid(self, row_spacing=6, col_spacing=6, row_homogenous=False, col_homogenous=True):
""" Function creates a Gtk Grid with spacing and homogeous tags """ |
grid_lang = Gtk.Grid()
grid_lang.set_column_spacing(row_spacing)
grid_lang.set_row_spacing(col_spacing)
grid_lang.set_border_width(12)
grid_lang.set_row_homogeneous(row_homogenous)
grid_lang.set_column_homogeneous(col_homogenous)
return grid_lang |
<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_notebook(self, position=Gtk.PositionType.TOP):
""" Function creates a notebook """ |
notebook = Gtk.Notebook()
notebook.set_tab_pos(position)
notebook.set_show_border(True)
return notebook |
<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_message_dialog(self, text, buttons=Gtk.ButtonsType.CLOSE, icon=Gtk.MessageType.WARNING):
""" Function creates a message dialog with text and relevant buttons """ |
dialog = Gtk.MessageDialog(None,
Gtk.DialogFlags.DESTROY_WITH_PARENT,
icon,
buttons,
text
)
return dialog |
<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_question_dialog(self, text, second_text):
""" Function creates a question dialog with title text and second_text """ |
dialog = self.create_message_dialog(
text, buttons=Gtk.ButtonsType.YES_NO, icon=Gtk.MessageType.QUESTION
)
dialog.format_secondary_text(second_text)
response = dialog.run()
dialog.destroy()
return 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 execute_dialog(self, title):
""" Function executes a dialog """ |
msg_dlg = self.create_message_dialog(title)
msg_dlg.run()
msg_dlg.destroy()
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 create_file_chooser_dialog(self, text, parent, name=Gtk.STOCK_OPEN):
""" Function creates a file chooser dialog with title text """ |
text = None
dialog = Gtk.FileChooserDialog(
text, parent,
Gtk.FileChooserAction.SELECT_FOLDER,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, name, Gtk.ResponseType.OK)
)
response = dialog.run()
if response == Gtk.ResponseType.OK:
text = dialog.get_filename()
dialog.destroy()
return text |
<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_alignment(self, x_align=0, y_align=0, x_scale=0, y_scale=0):
""" Function creates an alignment """ |
align = Gtk.Alignment()
align.set(x_align, y_align, x_scale, y_scale)
return align |
<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_textview(self, wrap_mode=Gtk.WrapMode.WORD_CHAR, justify=Gtk.Justification.LEFT, visible=True, editable=True):
""" Function creates a text view with wrap_mode and justification """ |
text_view = Gtk.TextView()
text_view.set_wrap_mode(wrap_mode)
text_view.set_editable(editable)
if not editable:
text_view.set_cursor_visible(False)
else:
text_view.set_cursor_visible(visible)
text_view.set_justification(justify)
return text_view |
<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_tree_view(self, model=None):
""" Function creates a tree_view with model """ |
tree_view = Gtk.TreeView()
if model is not None:
tree_view.set_model(model)
return tree_view |
<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_cell_renderer_text(self, tree_view, title="title", assign=0, editable=False):
""" Function creates a CellRendererText with title """ |
renderer = Gtk.CellRendererText()
renderer.set_property('editable', editable)
column = Gtk.TreeViewColumn(title, renderer, text=assign)
tree_view.append_column(column) |
<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_cell_renderer_combo(self, tree_view, title="title", assign=0, editable=False, model=None, function=None):
"""' Function creates a CellRendererCombo with title, model """ |
renderer_combo = Gtk.CellRendererCombo()
renderer_combo.set_property('editable', editable)
if model:
renderer_combo.set_property('model', model)
if function:
renderer_combo.connect("edited", function)
renderer_combo.set_property("text-column", 0)
renderer_combo.set_property("has-entry", False)
column = Gtk.TreeViewColumn(title, renderer_combo, text=assign)
tree_view.append_column(column) |
<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_clipboard(self, text, selection=Gdk.SELECTION_CLIPBOARD):
""" Function creates a clipboard """ |
clipboard = Gtk.Clipboard.get(selection)
clipboard.set_text('\n'.join(text), -1)
clipboard.store()
return clipboard |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def ask_for_confirm_with_message(cls, ui, prompt='Do you agree?', message='', **options):
"""Returns True if user agrees, False otherwise""" |
return cls.get_appropriate_helper(ui).ask_for_confirm_with_message(prompt, message) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def ask_for_input_with_prompt(cls, ui, prompt='', **options):
"""Ask user for written input with prompt""" |
return cls.get_appropriate_helper(ui).ask_for_input_with_prompt(prompt=prompt, **options) |
<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_argument_to(self, parser):
"""Used by cli to add this as an argument to argparse parser. Args: parser: parser to add this argument to """ |
from devassistant.cli.devassistant_argparse import DefaultIffUsedActionFactory
if isinstance(self.kwargs.get('action', ''), list):
# see documentation of DefaultIffUsedActionFactory to see why this is necessary
if self.kwargs['action'][0] == 'default_iff_used':
self.kwargs['action'] = DefaultIffUsedActionFactory.generate_action(
self.kwargs['action'][1])
# In cli 'preserved' is not supported.
# It needs to be removed because it is unknown for argparse.
self.kwargs.pop('preserved', None)
try:
parser.add_argument(*self.flags, **self.kwargs)
except Exception as ex:
problem = "Error while adding argument '{name}': {error}".\
format(name=self.name, error=repr(ex))
raise exceptions.ExecutionException(problem) |
<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_subassistants(self):
"""Return list of instantiated subassistants. Usually, this needs not be overriden in subclasses, you should just override get_subassistant_classes Returns: list of instantiated subassistants """ |
if not hasattr(self, '_subassistants'):
self._subassistants = []
# we want to know, if type(self) defines 'get_subassistant_classes',
# we don't want to inherit it from superclass (would cause recursion)
if 'get_subassistant_classes' in vars(type(self)):
for a in self.get_subassistant_classes():
self._subassistants.append(a())
return self._subassistants |
<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_subassistant_tree(self):
"""Returns a tree-like structure representing the assistant hierarchy going down from this assistant to leaf assistants. For example: [(<This Assistant>, )] Returns: a tree-like structure (see above) representing assistant hierarchy going down from this assistant to leaf assistants """ |
if '_tree' not in dir(self):
subassistant_tree = []
subassistants = self.get_subassistants()
for subassistant in subassistants:
subassistant_tree.append(subassistant.get_subassistant_tree())
self._tree = (self, subassistant_tree)
return self._tree |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_run_as_leaf(self, **kwargs):
"""Returns True if this assistant was run as last in path, False otherwise.""" |
# find the last subassistant_N
i = 0
while i < len(kwargs): # len(kwargs) is maximum of subassistant_N keys
if settings.SUBASSISTANT_N_STRING.format(i) in kwargs:
leaf_name = kwargs[settings.SUBASSISTANT_N_STRING.format(i)]
i += 1
return self.name == leaf_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 load_all_yamls(cls, directories):
"""Loads yaml files from all given directories. Args: directories: list of directories to search Returns: dict of {fullpath: loaded_yaml_structure} """ |
yaml_files = []
loaded_yamls = {}
for d in directories:
if d.startswith('/home') and not os.path.exists(d):
os.makedirs(d)
for dirname, subdirs, files in os.walk(d):
yaml_files.extend(map(lambda x: os.path.join(dirname, x),
filter(lambda x: x.endswith('.yaml'), files)))
for f in yaml_files:
loaded_yamls[f] = cls.load_yaml_by_path(f)
return loaded_yamls |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def load_yaml_by_relpath(cls, directories, rel_path, log_debug=False):
"""Load a yaml file with path that is relative to one of given directories. Args: directories: list of directories to search name: relative path of the yaml file to load log_debug: log all messages as debug Returns: tuple (fullpath, loaded yaml structure) or None if not found """ |
for d in directories:
if d.startswith(os.path.expanduser('~')) and not os.path.exists(d):
os.makedirs(d)
possible_path = os.path.join(d, rel_path)
if os.path.exists(possible_path):
loaded = cls.load_yaml_by_path(possible_path, log_debug=log_debug)
if loaded is not None:
return (possible_path, cls.load_yaml_by_path(possible_path))
return None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def load_yaml_by_path(cls, path, log_debug=False):
"""Load a yaml file that is at given path, if the path is not a string, it is assumed it's a file-like object""" |
try:
if isinstance(path, six.string_types):
return yaml.load(open(path, 'r'), Loader=Loader) or {}
else:
return yaml.load(path, Loader=Loader) or {}
except (yaml.scanner.ScannerError, yaml.parser.ParserError) as e:
log_level = logging.DEBUG if log_debug else logging.WARNING
logger.log(log_level, 'Yaml error in {path} (line {ln}, column {col}): {err}'.
format(path=path,
ln=e.problem_mark.line,
col=e.problem_mark.column,
err=e.problem))
return None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def calculate_offset(cls, labels):
'''Return the maximum length of the provided strings that have a nice
variant in DapFormatter._nice_strings'''
used_strings = set(cls._nice_strings.keys()) & set(labels)
return max([len(cls._nice_strings[s]) for s in used_strings]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def format_dapi_score(cls, meta, offset):
'''Format the line with DAPI user rating and number of votes'''
if 'average_rank' and 'rank_count' in meta:
label = (cls._nice_strings['average_rank'] + ':').ljust(offset + 2)
score = cls._format_field(meta['average_rank'])
votes = ' ({num} votes)'.format(num=meta['rank_count'])
return label + score + votes
else:
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 format_meta_lines(cls, meta, labels, offset, **kwargs):
'''Return all information from a given meta dictionary in a list of lines'''
lines = []
# Name and underline
name = meta['package_name']
if 'version' in meta:
name += '-' + meta['version']
if 'custom_location' in kwargs:
name += ' ({loc})'.format(loc=kwargs['custom_location'])
lines.append(name)
lines.append(len(name)*'=')
lines.append('')
# Summary
lines.extend(meta['summary'].splitlines())
lines.append('')
# Description
if meta.get('description', ''):
lines.extend(meta['description'].splitlines())
lines.append('')
# Other metadata
data = []
for item in labels:
if meta.get(item, '') != '': # We want to process False and 0
label = (cls._nice_strings[item] + ':').ljust(offset + 2)
data.append(label + cls._format_field(meta[item]))
lines.extend(data)
return lines |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def format_assistants_lines(cls, assistants):
'''Return formatted assistants from the given list in human readable form.'''
lines = cls._format_files(assistants, 'assistants')
# Assistant help
if assistants:
lines.append('')
assistant = strip_prefix(random.choice(assistants), 'assistants').replace(os.path.sep, ' ').strip()
if len(assistants) == 1:
strings = ['After you install this DAP, you can find help about the Assistant',
'by running "da {a} -h" .']
else:
strings = ['After you install this DAP, you can find help, for example about the Assistant',
'"{a}", by running "da {a} -h".']
lines.extend([l.format(a=assistant) for l in strings])
return lines |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def format_platforms(cls, platforms):
'''Formats supported platforms in human readable form'''
lines = []
if platforms:
lines.append('This DAP is only supported on the following platforms:')
lines.extend([' * ' + platform for platform in platforms])
return lines |
<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(cls, dap, network=False, yamls=True, raises=False, logger=logger):
'''Checks if the dap is valid, reports problems
Parameters:
network -- whether to run checks that requires network connection
output -- where to write() problems, might be None
raises -- whether to raise an exception immediately after problem is detected'''
dap._check_raises = raises
dap._problematic = False
dap._logger = logger
problems = list()
problems += cls.check_meta(dap)
problems += cls.check_no_self_dependency(dap)
problems += cls.check_topdir(dap)
problems += cls.check_files(dap)
if yamls:
problems += cls.check_yamls(dap)
if network:
problems += cls.check_name_not_on_dapi(dap)
for problem in problems:
dap._report_problem(problem.message, problem.level)
del dap._check_raises
return not dap._problematic |
<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_meta(cls, dap):
'''Check the meta.yaml in the dap.
Return a list of DapProblems.'''
problems = list()
# Check for non array-like metadata
for datatype in (Dap._required_meta | Dap._optional_meta) - Dap._array_meta:
if not dap._isvalid(datatype):
msg = datatype + ' is not valid (or required and unspecified)'
problems.append(DapProblem(msg))
# Check for the array-like metadata
for datatype in Dap._array_meta:
ok, bads = dap._arevalid(datatype)
if not ok:
if not bads:
msg = datatype + ' is not a valid non-empty list'
problems.append(DapProblem(msg))
else:
for bad in bads:
msg = bad + ' in ' + datatype + ' is not valid or is a duplicate'
problems.append(DapProblem(msg))
# Check that there is no unknown metadata
leftovers = set(dap.meta.keys()) - (Dap._required_meta | Dap._optional_meta)
if leftovers:
msg = 'Unknown metadata: ' + str(leftovers)
problems.append(DapProblem(msg))
# Check that package_name is not longer than 200 characters
if len(dap.meta.get('package_name', '')) > 200:
msg = 'Package name is too long. It must not exceed 200 characters.'
problems.append(DapProblem(msg))
return problems |
<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_topdir(cls, dap):
'''Check that everything is in the correct top-level directory.
Return a list of DapProblems'''
problems = list()
dirname = os.path.dirname(dap._meta_location)
if not dirname:
msg = 'meta.yaml is not in top-level directory'
problems.append(DapProblem(msg))
else:
for path in dap.files:
if not path.startswith(dirname):
msg = path + ' is outside of ' + dirname + ' top-level directory'
problems.append(DapProblem(msg))
if dap.meta['package_name'] and dap.meta['version']:
desired_dirname = dap._dirname()
desired_filename = desired_dirname + '.dap'
if dirname and dirname != desired_dirname:
msg = 'Top-level directory with meta.yaml is not named ' + desired_dirname
problems.append(DapProblem(msg))
if dap.basename != desired_filename:
msg = 'The dap filename is not ' + desired_filename
problems.append(DapProblem(msg))
return problems |
<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_no_self_dependency(cls, dap):
'''Check that the package does not depend on itself.
Return a list of problems.'''
problems = list()
if 'package_name' in dap.meta and 'dependencies' in dap.meta:
dependencies = set()
for dependency in dap.meta['dependencies']:
if 'dependencies' in dap._badmeta and dependency in dap._badmeta['dependencies']:
continue
# No version specified
if not re.search(r'[<=>]', dependency):
dependencies.add(dependency)
# Version specified
for mark in ['==', '>=', '<=', '<', '>']:
dep = dependency.split(mark)
if len(dep) == 2:
dependencies.add(dep[0].strip())
break
if dap.meta['package_name'] in dependencies:
msg = 'Depends on dap with the same name as itself'
problems.append(DapProblem(msg))
return problems |
<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_name_not_on_dapi(cls, dap):
'''Check that the package_name is not registered on Dapi.
Return list of problems.'''
problems = list()
if dap.meta['package_name']:
from . import dapicli
d = dapicli.metadap(dap.meta['package_name'])
if d:
problems.append(DapProblem('This dap name is already registered on Dapi',
level=logging.WARNING))
return problems |
<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_yamls(cls, dap):
'''Check that all assistants and snippets are valid.
Return list of DapProblems.'''
problems = list()
for yaml in dap.assistants_and_snippets:
path = yaml + '.yaml'
parsed_yaml = YamlLoader.load_yaml_by_path(dap._get_file(path, prepend=True))
if parsed_yaml:
try:
yaml_checker.check(path, parsed_yaml)
except YamlError as e:
problems.append(DapProblem(exc_as_decoded_string(e), level=logging.ERROR))
else:
problems.append(DapProblem('Empty YAML ' + path, level=logging.WARNING))
return problems |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def _strip_leading_dirname(self, path):
'''Strip leading directory name from the given path'''
return os.path.sep.join(path.split(os.path.sep)[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 assistants(self):
'''Get all assistants in this DAP'''
return [strip_suffix(f, '.yaml') for f in self._stripped_files if self._assistants_pattern.match(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 snippets(self):
'''Get all snippets in this DAP'''
return [strip_suffix(f, '.yaml') for f in self._stripped_files if self._snippets_pattern.match(f)] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.