sentence1
stringlengths 52
3.87M
| sentence2
stringlengths 1
47.2k
| label
stringclasses 1
value |
|---|---|---|
def write_byte(self, byte):
"""Write one byte."""
self.payload[self.pos] = byte
self.pos = self.pos + 1
|
Write one byte.
|
entailment
|
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
|
Write n number of bytes to this packet.
|
entailment
|
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
|
Read a byte.
|
entailment
|
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
|
Read 2 bytes.
|
entailment
|
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
|
Read count number of bytes.
|
entailment
|
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
|
Read string.
|
entailment
|
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
|
Pop an event from event_list.
|
entailment
|
def mid_generate(self):
"""Generate mid. TODO : check."""
self.last_mid += 1
if self.last_mid == 0:
self.last_mid += 1
return self.last_mid
|
Generate mid. TODO : check.
|
entailment
|
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
|
Enqueue packet to out_packet queue.
|
entailment
|
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
|
Write packet to network.
|
entailment
|
def packet_read(self):
"""Read packet from network."""
bytes_received = 0
if self.sock == NC.INVALID_SOCKET:
return NC.ERR_NO_CONN
if self.in_packet.command == 0:
ba_data, errnum, errmsg = nyamuk_net.read(self.sock, 1)
if errnum == 0 and len(ba_data) == 1:
bytes_received += 1
byte = ba_data[0]
self.in_packet.command = byte
if self.as_broker:
if self.bridge is None and self.state == NC.CS_NEW and (byte & 0xF0) != NC.CMD_CONNECT:
print "RETURN ERR_PROTOCOL"
return NC.ERR_PROTOCOL, bytes_received
else:
if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:
return NC.ERR_SUCCESS, bytes_received
elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:
return NC.ERR_CONN_LOST, bytes_received
else:
evt = event.EventNeterr(errnum, errmsg)
self.push_event(evt)
return NC.ERR_UNKNOWN, bytes_received
if not self.in_packet.have_remaining:
loop_flag = True
while loop_flag:
ba_data, errnum, errmsg = nyamuk_net.read(self.sock, 1)
if errnum == 0 and len(ba_data) == 1:
byte = ba_data[0]
bytes_received += 1
self.in_packet.remaining_count += 1
if self.in_packet.remaining_count > 4:
return NC.ERR_PROTOCOL, bytes_received
self.in_packet.remaining_length += (byte & 127) * self.in_packet.remaining_mult
self.in_packet.remaining_mult *= 128
else:
if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:
return NC.ERR_SUCCESS, bytes_received
elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:
return NC.ERR_CONN_LOST, bytes_received
else:
evt = event.EventNeterr(errnum, errmsg)
self.push_event(evt)
return NC.ERR_UNKNOWN, bytes_received
if (byte & 128) == 0:
loop_flag = False
if self.in_packet.remaining_length > 0:
self.in_packet.payload = bytearray(self.in_packet.remaining_length)
if self.in_packet.payload is None:
return NC.ERR_NO_MEM, bytes_received
self.in_packet.to_process = self.in_packet.remaining_length
self.in_packet.have_remaining = True
if self.in_packet.to_process > 0:
ba_data, errnum, errmsg = nyamuk_net.read(self.sock, self.in_packet.to_process)
if errnum == 0 and len(ba_data) > 0:
readlen = len(ba_data)
bytes_received += readlen
for idx in xrange(0, readlen):
self.in_packet.payload[self.in_packet.pos] = ba_data[idx]
self.in_packet.pos += 1
self.in_packet.to_process -= 1
else:
if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:
return NC.ERR_SUCCESS, bytes_received
elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:
return NC.ERR_CONN_LOST, bytes_received
else:
evt = event.EventNeterr(errnum, errmsg)
self.push_event(evt)
return NC.ERR_UNKNOWN, bytes_received
#all data for this packet is read
self.in_packet.pos = 0
ret = self.packet_handle()
self.in_packet.packet_cleanup()
self.last_msg_in = time.time()
return ret, bytes_received
|
Read packet from network.
|
entailment
|
def socket_close(self):
"""Close our socket."""
if self.sock != NC.INVALID_SOCKET:
self.sock.close()
self.sock = NC.INVALID_SOCKET
|
Close our socket.
|
entailment
|
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
|
Build PUBLISH packet.
|
entailment
|
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)
|
Send simple mqtt commands.
|
entailment
|
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
|
The actual public IP of this host.
|
entailment
|
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")
|
Get the current IP Tor is using.
:returns str
:raises TorIpError
|
entailment
|
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
|
Try to obtain new a usable TOR IP.
:returns bool
:raises TorIpError
|
entailment
|
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
|
Check if the current Tor's IP is usable.
:argument current_ip: current Tor IP
:type current_ip: str
:returns bool
|
entailment
|
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]
|
Handle registering and releasing used Tor IPs.
:argument current_ip: current Tor IP
:type current_ip: str
|
entailment
|
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)
|
Change Tor's IP.
|
entailment
|
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
|
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.
|
entailment
|
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
|
Returns a processed request or raises an exception
|
entailment
|
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
|
Tries to get the link form DAPI or the mirror
|
entailment
|
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
|
Remove the API URL from the link if it is there
|
entailment
|
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)
|
Returns a dictionary from requested link
|
entailment
|
def _unpaginated(what):
'''Returns a dictionary with all <what>, unpaginated'''
page = data(what)
results = page['results']
count = page['count']
while page['next']:
page = data(page['next'])
results += page['results']
count += page['count']
return {'results': results, 'count': count}
|
Returns a dictionary with all <what>, unpaginated
|
entailment
|
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))
|
Returns a dictionary with the search results
|
entailment
|
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
|
Formats a list of users available on Dapi
|
entailment
|
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
|
Formats a list of metadaps available on Dapi
|
entailment
|
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
|
Return data for dap of given or latest version.
|
entailment
|
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
|
Formats information about given DAP from DAPI in a human readable form to list of lines
|
entailment
|
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
|
Formaqts information about the given local DAP in a human readable form to list of lines
|
entailment
|
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))
|
Formats information about an installed DAP in a human readable form to list of lines
|
entailment
|
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
|
Formats all installed DAPs in a human readable form to list of lines
|
entailment
|
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
|
Get Assistants and Snippets for a given DAP name on a given path
|
entailment
|
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)
|
Formats the results of a search
|
entailment
|
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
|
Returns a set of all installed daps
Either in the given location or in all of them
|
entailment
|
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
|
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
|
entailment
|
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)
|
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
|
entailment
|
def install_dap_from_path(path, update=False, update_allpaths=False, first=True,
force=False, nodeps=False, reinstall=False, __ui__=''):
'''Installs a dap from a given path'''
will_uninstall = False
dap_obj = dapi.Dap(path)
name = dap_obj.meta['package_name']
if name in get_installed_daps():
if not update and not reinstall:
raise DapiLocalError(
'DAP {name} is already installed. '
'Run `da pkg list` to see it\'s location, or use --reinstall to ignore this check.'
.format(name=name))
elif not update_allpaths and name in get_installed_daps(_install_path()):
will_uninstall = True
elif update_allpaths and name in get_installed_daps():
will_uninstall = True
if update and update_allpaths:
install_locations = []
for pair in get_installed_daps_detailed()[name]:
install_locations.append(pair['location'])
else:
install_locations = [_install_path()]
# This should not happen unless someone did it on purpose
for location in install_locations:
if os.path.isfile(location):
raise DapiLocalError(
'{i} is a file, not a directory.'.format(i=_install_path()))
_dir = tempfile.mkdtemp()
old_level = logger.getEffectiveLevel()
logger.setLevel(logging.ERROR)
ok = dapi.DapChecker.check(dap_obj)
logger.setLevel(old_level)
if not ok:
raise DapiLocalError('The DAP you want to install has errors, not installing.')
installed = []
if first:
if not force and not _is_supported_here(dap_obj.meta):
raise DapiLocalError(
'{0} is not supported on this platform (use --force to suppress this check)'.
format(name))
deps = set()
if 'dependencies' in dap_obj.meta and not nodeps:
for dep in dap_obj.meta['dependencies']:
dep = _strip_version_from_dependency(dep)
if dep not in get_installed_daps():
deps |= _get_all_dependencies_of(dep, force=force)
for dep in deps:
if dep not in get_installed_daps():
installed += install_dap(dep, first=False, __ui__=__ui__)
dap_obj.extract(_dir)
if will_uninstall:
uninstall_dap(name, allpaths=update_allpaths, __ui__=__ui__)
_dapdir = os.path.join(_dir, name + '-' + dap_obj.meta['version'])
if not os.path.isdir(_install_path()):
os.makedirs(_install_path())
os.mkdir(os.path.join(_dapdir, 'meta'))
os.rename(os.path.join(_dapdir, 'meta.yaml'),
os.path.join(_dapdir, 'meta', name + '.yaml'))
for location in install_locations:
for f in glob.glob(_dapdir + '/*'):
dst = os.path.join(location, os.path.basename(f))
if os.path.isdir(f):
if not os.path.exists(dst):
os.mkdir(dst)
for src_dir, dirs, files in os.walk(f):
dst_dir = src_dir.replace(f, dst)
if not os.path.exists(dst_dir):
os.mkdir(dst_dir)
for file_ in files:
src_file = os.path.join(src_dir, file_)
dst_file = os.path.join(dst_dir, file_)
shutil.copyfile(src_file, dst_file)
else:
shutil.copyfile(f, dst)
try:
shutil.rmtree(_dir)
except:
pass
return [name] + installed
|
Installs a dap from a given path
|
entailment
|
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()
|
For given dependency string, return only the package name
|
entailment
|
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
|
Gets the installed version of the given dap or None if not installed
Searches in all dirs by default, otherwise in the given one
|
entailment
|
def _get_dependencies_of(name, location=None):
'''
Returns list of first level dependencies of the given installed dap
or dap from Dapi if not installed
If a location is specified, this only checks for dap installed in that path
and return [] if the dap is not located there
'''
if not location:
detailed_dap_list = get_installed_daps_detailed()
if name not in detailed_dap_list:
return _get_api_dependencies_of(name)
location = detailed_dap_list[name][0]['location']
meta = '{d}/meta/{dap}.yaml'.format(d=location, dap=name)
try:
data = yaml.load(open(meta), Loader=Loader)
except IOError:
return []
return data.get('dependencies', [])
|
Returns list of first level dependencies of the given installed dap
or dap from Dapi if not installed
If a location is specified, this only checks for dap installed in that path
and return [] if the dap is not located there
|
entailment
|
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])
|
Returns list of dependencies of the given dap from Dapi recursively
|
entailment
|
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', [])
|
Returns list of first level dependencies of the given dap from Dapi
|
entailment
|
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
|
Install a dap from dapi
If update is True, it will remove previously installed daps of the same name
|
entailment
|
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')
|
Returns list of strings with dependency metadata from Dapi
|
entailment
|
def create_frame(self):
"""
This function creates a frame
"""
frame = Gtk.Frame()
frame.set_shadow_type(Gtk.ShadowType.IN)
return frame
|
This function creates a frame
|
entailment
|
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
|
Function creates box. Based on orientation
it can be either HORIZONTAL or VERTICAL
|
entailment
|
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
|
Function creates a button with lave.
If assistant is specified then text is aligned
|
entailment
|
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
|
The function creates a image from name defined in image_name
|
entailment
|
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
|
The function creates a button with image
|
entailment
|
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
|
The function creates a checkbutton with label
|
entailment
|
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
|
Function creates a checkbox with his name
|
entailment
|
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
|
Function creates an Entry with corresponding text
|
entailment
|
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
|
Function creates a link button with corresponding text and
URI reference
|
entailment
|
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
|
This is generalized method for creating Gtk.Button
|
entailment
|
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
|
Function creates a menu item with an image
|
entailment
|
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
|
The function is used for creating lable with HTML text
|
entailment
|
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
|
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
|
entailment
|
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
|
Add button that opens the window for installing more assistants
|
entailment
|
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
|
The function creates a menu item
and assigns signal like select and button-press-event for
manipulation with menu_item. sub_assistant and path
|
entailment
|
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
|
Function generates menu from based on ass parameter
|
entailment
|
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)
|
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
|
entailment
|
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
|
Function creates a scrolled window with layout manager
|
entailment
|
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
|
Function creates a Gtk Grid with spacing
and homogeous tags
|
entailment
|
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
|
Function creates a notebook
|
entailment
|
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
|
Function creates a message dialog with text
and relevant buttons
|
entailment
|
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
|
Function creates a question dialog with title text
and second_text
|
entailment
|
def execute_dialog(self, title):
"""
Function executes a dialog
"""
msg_dlg = self.create_message_dialog(title)
msg_dlg.run()
msg_dlg.destroy()
return
|
Function executes a dialog
|
entailment
|
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
|
Function creates a file chooser dialog with title text
|
entailment
|
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
|
Function creates an alignment
|
entailment
|
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
|
Function creates a text view with wrap_mode
and justification
|
entailment
|
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
|
Function creates a tree_view with model
|
entailment
|
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)
|
Function creates a CellRendererText with title
|
entailment
|
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)
|
Function creates a CellRendererCombo with title, model
|
entailment
|
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
|
Function creates a clipboard
|
entailment
|
def run_command(cls,
cmd_str,
log_level=logging.DEBUG,
ignore_sigint=False,
output_callback=None,
as_user=None,
log_secret=False,
env=None):
"""Runs a command from string, e.g. "cp foo bar"
Args:
cmd_str: the command to run as string
log_level: level at which to log command output (DEBUG by default)
ignore_sigint: should we ignore sigint during this command (False by default)
output_callback: function that gets called with every line of output as argument
as_user: run as specified user (the best way to do this will be deduced by DA)
runs as current user if as_user == None
log_secret: if True, the command invocation will only be logged as
"LOGGING PREVENTED FOR SECURITY REASONS", no output will be logged
env: if not None, pass to subprocess as shell environment; else use
original DevAssistant environment
"""
# run format processors on cmd_str
for name, cmd_proc in cls.command_processors.items():
cmd_str = cmd_proc(cmd_str)
# TODO: how to do cd with as_user?
if as_user and not cmd_str.startswith('cd '):
cmd_str = cls.format_for_another_user(cmd_str, as_user)
cls.log(log_level, cmd_str, 'cmd_call', log_secret)
if cmd_str.startswith('cd '):
# special-case cd to behave like shell cd and stay in the directory
try:
directory = cmd_str[3:]
# delete any quotes, os.chdir doesn't split words like sh does
if directory[0] == directory[-1] == '"':
directory = directory[1:-1]
os.chdir(directory)
except OSError as e:
raise exceptions.ClException(cmd_str, 1, six.text_type(e))
return ''
stdin_pipe = None
stdout_pipe = subprocess.PIPE
stderr_pipe = subprocess.STDOUT
preexec_fn = cls.ignore_sigint if ignore_sigint else None
env = os.environ if env is None else env
proc = subprocess.Popen(cmd_str,
stdin=stdin_pipe,
stdout=stdout_pipe,
stderr=stderr_pipe,
shell=True,
preexec_fn=preexec_fn,
env=env)
# register process to cls.subprocesses
cls.subprocesses[proc.pid] = proc
stdout = []
while proc.poll() is None:
try:
output = proc.stdout.readline().decode(utils.defenc)
if output:
output = output.strip()
stdout.append(output)
cls.log(log_level, output, 'cmd_out', log_secret)
if output_callback:
output_callback(output)
except IOError as e:
if e.errno == errno.EINTR: # Interrupted system call in Python 2.6
sys.stderr.write('Can\'t interrupt this process!\n')
else:
raise e
# remove process from cls.subprocesses
cls.subprocesses.pop(proc.pid)
# add a newline to the end - if there is more output in output_rest, we'll be appending
# it line by line; if there's no more output, we strip anyway
stdout = '\n'.join(stdout) + '\n'
# there may be some remains not read after exiting the previous loop
output_rest = proc.stdout.read().strip().decode(utils.defenc)
# we want to log lines separately, not as one big chunk
output_rest_lines = output_rest.splitlines()
for i, l in enumerate(output_rest_lines):
cls.log(log_level, l, 'cmd_out', log_secret)
# add newline for every line - for last line, only add it if it was originally present
if i != len(output_rest_lines) - 1 or output_rest.endswith('\n'):
l += '\n'
stdout += l
if output_callback:
output_callback(l)
# log return code always on debug level
cls.log(logging.DEBUG, proc.returncode, 'cmd_retcode', log_secret)
stdout = stdout.strip()
if proc.returncode == 0:
return stdout
else:
raise exceptions.ClException(cmd_str,
proc.returncode,
stdout)
|
Runs a command from string, e.g. "cp foo bar"
Args:
cmd_str: the command to run as string
log_level: level at which to log command output (DEBUG by default)
ignore_sigint: should we ignore sigint during this command (False by default)
output_callback: function that gets called with every line of output as argument
as_user: run as specified user (the best way to do this will be deduced by DA)
runs as current user if as_user == None
log_secret: if True, the command invocation will only be logged as
"LOGGING PREVENTED FOR SECURITY REASONS", no output will be logged
env: if not None, pass to subprocess as shell environment; else use
original DevAssistant environment
|
entailment
|
def ask_for_password(cls, ui, prompt='Provide your password:', **options):
"""Returns the password typed by user as a string or None if user cancels the request
(e.g. presses Ctrl + D on commandline or presses Cancel in GUI.
"""
# optionally set title, that may be used by some helpers like zenity
return cls.get_appropriate_helper(ui).ask_for_password(prompt,
title=options.get('title', prompt))
|
Returns the password typed by user as a string or None if user cancels the request
(e.g. presses Ctrl + D on commandline or presses Cancel in GUI.
|
entailment
|
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)
|
Returns True if user agrees, False otherwise
|
entailment
|
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)
|
Ask user for written input with prompt
|
entailment
|
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)
|
Used by cli to add this as an argument to argparse parser.
Args:
parser: parser to add this argument to
|
entailment
|
def get_gui_hint(self, hint):
"""Returns the value for specified gui hint (or a sensible default value,
if this argument doesn't specify the hint).
Args:
hint: name of the hint to get value for
Returns:
value of the hint specified in yaml or a sensible default
"""
if hint == 'type':
# 'self.kwargs.get('nargs') == 0' is there for default_iff_used, which may
# have nargs: 0, so that it works similarly to 'store_const'
if self.kwargs.get('action') == 'store_true' or self.kwargs.get('nargs') == 0:
return 'bool'
# store_const is represented by checkbox, but computes default differently
elif self.kwargs.get('action') == 'store_const':
return 'const'
return self.gui_hints.get('type', 'str')
elif hint == 'default':
hint_type = self.get_gui_hint('type')
hint_default = self.gui_hints.get('default', None)
arg_default = self.kwargs.get('default', None)
preserved_value = None
if 'preserved' in self.kwargs:
preserved_value = config_manager.get_config_value(self.kwargs['preserved'])
if hint_type == 'path':
if preserved_value is not None:
default = preserved_value
elif hint_default is not None:
default = hint_default.replace('$(pwd)', utils.get_cwd_or_homedir())
else:
default = arg_default or '~'
return os.path.abspath(os.path.expanduser(default))
elif hint_type == 'bool':
return hint_default or arg_default or False
elif hint_type == 'const':
return hint_default or arg_default
else:
if hint_default == '$(whoami)':
hint_default = getpass.getuser()
return preserved_value or hint_default or arg_default or ''
|
Returns the value for specified gui hint (or a sensible default value,
if this argument doesn't specify the hint).
Args:
hint: name of the hint to get value for
Returns:
value of the hint specified in yaml or a sensible default
|
entailment
|
def construct_arg(cls, name, params):
"""Construct an argument from name, and params (dict loaded from assistant/snippet).
"""
use_snippet = params.pop('use', None)
if use_snippet:
# if snippet is used, take this parameter from snippet and update
# it with current params, if any
try:
problem = None
snippet = yaml_snippet_loader.YamlSnippetLoader.get_snippet_by_name(use_snippet)
# this works much like snippet.args.pop(arg_name).update(arg_params),
# but unlike it, this actually returns the updated dict
params = dict(snippet.args.pop(name), **params)
# if there is SnippetNotFoundException, just let it be raised
except KeyError: # snippet doesn't have the requested argument
problem = 'Couldn\'t find arg {arg} in snippet {snip}.'.\
format(arg=name, snip=snippet.name)
raise exceptions.ExecutionException(problem)
if 'flags' not in params:
msg = 'Couldn\'t find "flags" in arg {arg}'.format(arg=name)
raise exceptions.ExecutionException(msg)
return cls(name, *params.pop('flags'), **params)
|
Construct an argument from name, and params (dict loaded from assistant/snippet).
|
entailment
|
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
|
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
|
entailment
|
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>,
[(<Subassistant 1>, [...]),
(<Subassistant 2>, [...])]
)]
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
|
Returns a tree-like structure representing the assistant hierarchy going down
from this assistant to leaf assistants.
For example: [(<This Assistant>,
[(<Subassistant 1>, [...]),
(<Subassistant 2>, [...])]
)]
Returns:
a tree-like structure (see above) representing assistant hierarchy going down
from this assistant to leaf assistants
|
entailment
|
def get_selected_subassistant_path(self, **kwargs):
"""Recursively searches self._tree - has format of (Assistant: [list_of_subassistants]) -
for specific path from first to last selected subassistants.
Args:
kwargs: arguments containing names of the given assistants in form of
subassistant_0 = 'name', subassistant_1 = 'another_name', ...
Returns:
list of subassistants objects from tree sorted from first to last
"""
path = [self]
previous_subas_list = None
currently_searching = self.get_subassistant_tree()[1]
# len(path) - 1 always points to next subassistant_N, so we can use it to control iteration
while settings.SUBASSISTANT_N_STRING.format(len(path) - 1) in kwargs and \
kwargs[settings.SUBASSISTANT_N_STRING.format(len(path) - 1)]:
for sa, subas_list in currently_searching:
if sa.name == kwargs[settings.SUBASSISTANT_N_STRING.format(len(path) - 1)]:
currently_searching = subas_list
path.append(sa)
break # sorry if you shed a tear ;)
if subas_list == previous_subas_list:
raise exceptions.AssistantNotFoundException(
'No assistant {n} after path {p}.'.format(
n=kwargs[settings.SUBASSISTANT_N_STRING.format(len(path) - 1)],
p=path))
previous_subas_list = subas_list
return path
|
Recursively searches self._tree - has format of (Assistant: [list_of_subassistants]) -
for specific path from first to last selected subassistants.
Args:
kwargs: arguments containing names of the given assistants in form of
subassistant_0 = 'name', subassistant_1 = 'another_name', ...
Returns:
list of subassistants objects from tree sorted from first to last
|
entailment
|
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
|
Returns True if this assistant was run as last in path, False otherwise.
|
entailment
|
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
|
Loads yaml files from all given directories.
Args:
directories: list of directories to search
Returns:
dict of {fullpath: loaded_yaml_structure}
|
entailment
|
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
|
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
|
entailment
|
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
|
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
|
entailment
|
def _run_path_dependencies(self, parsed_args):
"""Installs dependencies from the leaf assistant.
Raises:
devassistant.exceptions.DependencyException with a cause if something goes wrong
"""
deps = self.path[-1].dependencies(parsed_args)
lang.Command('dependencies', deps, parsed_args).run()
|
Installs dependencies from the leaf assistant.
Raises:
devassistant.exceptions.DependencyException with a cause if something goes wrong
|
entailment
|
def run(self):
"""Runs all errors, dependencies and run methods of all *Assistant objects in self.path.
Raises:
devassistant.exceptions.ExecutionException with a cause if something goes wrong
"""
error = None
# run 'pre_run', 'logging', 'dependencies' and 'run'
try: # serve as a central place for error logging
self._logging(self.parsed_args)
if 'deps_only' not in self.parsed_args:
self._run_path_run('pre', self.parsed_args)
self._run_path_dependencies(self.parsed_args)
if 'deps_only' not in self.parsed_args:
self._run_path_run('', self.parsed_args)
except exceptions.ExecutionException as e:
error = self._log_if_not_logged(e)
if isinstance(e, exceptions.YamlError): # if there's a yaml error, just shut down
raise e
# in any case, run post_run
try: # serve as a central place for error logging
self._run_path_run('post', self.parsed_args)
except exceptions.ExecutionException as e:
error = self._log_if_not_logged(e)
# exitfuncs are run all regardless of exceptions; if there is an exception in one
# of them, this function will raise it at the end
try:
utils.run_exitfuncs()
except exceptions.ExecutionException as e:
error = self._log_if_not_logged(e)
if error:
raise error
|
Runs all errors, dependencies and run methods of all *Assistant objects in self.path.
Raises:
devassistant.exceptions.ExecutionException with a cause if something goes wrong
|
entailment
|
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])
|
Return the maximum length of the provided strings that have a nice
variant in DapFormatter._nice_strings
|
entailment
|
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 ''
|
Format the line with DAPI user rating and number of votes
|
entailment
|
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
|
Return all information from a given meta dictionary in a list of lines
|
entailment
|
def _format_files(cls, files, kind):
'''Format the list of files (e. g. assistants or snippets'''
lines = []
if files:
lines.append('The following {kind} are contained in this DAP:'.format(kind=kind.title()))
for f in files:
lines.append('* ' + strip_prefix(f, kind).replace(os.path.sep, ' ').strip())
return lines
else:
return ['No {kind} are contained in this DAP'.format(kind=kind.title())]
|
Format the list of files (e. g. assistants or snippets
|
entailment
|
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
|
Return formatted assistants from the given list in human readable form.
|
entailment
|
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
|
Formats supported platforms in human readable form
|
entailment
|
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
|
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
|
entailment
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.