code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
fields = []
if asm_format:
indexed_operand = set(['name', 'local', 'compare', 'free'])
# Column: Source code line number
if lineno_width:
if self.starts_line is not None:
if asm_format:
lineno_fmt = "%%%dd:\n" % lineno_... | def disassemble(self, lineno_width=3,
mark_as_current=False,
asm_format=False,
show_bytes=False) | Format instruction details for inclusion in disassembly output
*lineno_width* sets the width of the line number field (0 omits it)
*mark_as_current* inserts a '-->' marker arrow as part of the line | 3.015571 | 3.046255 | 0.989927 |
while tb.tb_next:
tb = tb.tb_next
return cls(tb.tb_frame.f_code, current_offset=tb.tb_lasti) | def from_traceback(cls, tb) | Construct a Bytecode from the given traceback | 3.139473 | 2.981538 | 1.052971 |
co = self.codeobj
if self.current_offset is not None:
offset = self.current_offset
else:
offset = -1
output = StringIO()
self.disassemble_bytes(co.co_code, varnames=co.co_varnames,
names=co.co_names, constants=co.co_... | def dis(self, asm_format=False, show_bytes=False) | Return a formatted view of the bytecode operations. | 2.95033 | 2.782181 | 1.060438 |
co = get_code_object(x)
cell_names = co.co_cellvars + co.co_freevars
linestarts = dict(self.opc.findlinestarts(co))
if first_line is not None:
line_offset = first_line - co.co_firstlineno
else:
line_offset = 0
return get_instructions_bytes... | def get_instructions(self, x, first_line=None) | Iterator for the opcodes in methods, functions or code
Generates a series of Instruction named tuples giving the details of
each operations in the supplied code.
If *first_line* is not None, it indicates the line number that should
be reported for the first source line in the disassemb... | 2.846259 | 3.225609 | 0.882394 |
if PYTHON3:
byte_increments = code.co_lnotab[0::2]
line_increments = code.co_lnotab[1::2]
else:
byte_increments = [ord(c) for c in code.co_lnotab[0::2]]
line_increments = [ord(c) for c in code.co_lnotab[1::2]]
lastlineno = None
lineno = code.co_firstlineno
addr ... | def findlinestarts(code, dup_lines=False) | Find the offsets in a byte code which are start of lines in the source.
Generate pairs (offset, lineno) as described in Python/compile.c. | 2.114147 | 2.045027 | 1.033799 |
offsets = []
for offset, op, arg in unpack_opargs_wordcode(code, opc):
if arg is not None:
if op in opc.JREL_OPS:
jump_offset = offset + 2 + arg
elif op in opc.JABS_OPS:
jump_offset = arg
else:
continue
... | def get_jump_targets(code, opc) | Returns a list of instruction offsets in the supplied bytecode
which are the targets of some sort of jump instruction. | 3.718266 | 3.388372 | 1.09736 |
offset2prev = {}
prev_offset = -1
for offset, op, arg in unpack_opargs_wordcode(code, opc):
if prev_offset >= 0:
prev_list = offset2prev.get(offset, [])
prev_list.append(prev_offset)
offset2prev[offset] = prev_list
prev_offset = offset
if op i... | def get_jump_target_maps(code, opc) | Returns a dictionary where the key is an offset and the values are
a list of instruction offsets which can get run before that
instruction. This includes jump instructions as well as non-jump
instructions. Therefore, the keys of the dictionary are reachible
instructions. The values of the dictionary may... | 2.579139 | 2.432834 | 1.060138 |
if isinstance(python_version, float):
major = int(python_version)
minor = int(((python_version - major) + 0.05) * 10)
python_version = (major, minor)
return _StdApi(python_version, variant) | def make_std_api(python_version=sys.version_info, variant=VARIANT) | Generate an object which can be used in the same way as the python
standard dis module. The difference is that the generated 'module' can be
used to disassemble byte / word code from a different python version than
the version of the interpreter under which we are running.
:param python_version: Genera... | 3.044444 | 3.81734 | 0.79753 |
return _show_code(x, self.opc.version, file) | def show_code(self, x, file=None) | Print details of methods, functions, or code to *file*.
If *file* is not provided, the output is printed on stdout. | 18.631386 | 28.393917 | 0.656175 |
self._print(self.Bytecode(x).dis(), file) | def dis(self, x=None, file=None) | Disassemble classes, methods, functions, generators, or code.
With no argument, disassemble the last traceback. | 27.975307 | 20.413025 | 1.370464 |
if tb is None:
try:
tb = sys.last_traceback
except AttributeError:
raise RuntimeError("no last traceback to disassemble")
while tb.tb_next: tb = tb.tb_next
self.disassemble(tb.tb_frame.f_code, tb.tb_lasti, file=file) | def distb(self, tb=None, file=None) | Disassemble a traceback (default: last traceback). | 2.591325 | 2.126756 | 1.21844 |
return self.disco(code, lasti, file) | def disassemble(self, code, lasti=-1, file=None) | Disassemble a code object. | 7.487426 | 6.502685 | 1.151436 |
return _disco(self.python_version, code, timestamp=0,
out=file, is_pypy=self.is_pypy, header=False) | def disco(self, code, lasti=-1, file=None) | Disassemble a code object. | 12.370123 | 11.205572 | 1.103926 |
return self.Bytecode(x).get_instructions(x, first_line) | def get_instructions(self, x, first_line=None) | Iterator for the opcodes in methods, functions or code
Generates a series of Instruction named tuples giving the details of
each operations in the supplied code.
If *first_line* is not None, it indicates the line number that should
be reported for the first source line in the disassemb... | 9.844019 | 10.879174 | 0.90485 |
DELTA = 0x9e3779b9
n = len(v)
rounds = 6 + 52//n
sum = (rounds*DELTA)
y = v[0]
while sum != 0:
e = (sum >> 2) & 3
for p in range(n-1, -1, -1):
z = v[(n + p - 1) % n]
v[p] = (v[p] - MX(z, y, sum, key, p, e)) & 0xffffffff
y = v[p]
su... | def tea_decipher(v, key) | Tiny Decryption Algorithm decription (TEA)
See https://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm | 4.201798 | 4.215447 | 0.996762 |
a = self.load_int()
b = self.load_int()
key = get_keys(a, b)
padsize = (b + 15) & ~0xf
intsize = padsize/4
data = self.bufstr[self.bufpos:self.bufpos+padsize]
# print("%d: %d (%d=%d)" % (self.bufpos, b, padsize, len(data)))
data = list(struct.unpack('<%dL' % intsize, data))
tea_... | def load_code(self) | Returns a Python code object like xdis.unmarshal.load_code(),
but in we decrypt the data in self.bufstr.
That is:
* calculate the TEA key,
* decrypt self.bufstr
* create and return a Python code-object | 2.714541 | 2.534447 | 1.071058 |
um = xmarshal._FastUnmarshaller(s)
um.dispatch[xmarshal.TYPE_CODE] = load_code
return um.load() | def loads(s) | xdis.marshal.load() but with its dispatch load_code() function replaced
with our decoding version. | 19.212606 | 9.540247 | 2.013848 |
cls = protocol_map.get(name)
if not cls:
raise ValueError('Unsupported protocol "%s".' % name)
return cls | def get_protocol_from_name(name) | Returns the protocol class for the protocol with the given name.
:type name: str
:param name: The name of the protocol.
:rtype: Protocol
:return: The protocol class. | 3.742326 | 4.534064 | 0.82538 |
cls = protocol_map.get(name)
if not cls:
raise ValueError('Unsupported protocol "%s".' % name)
return cls(**kwargs) | def create_protocol(name, **kwargs) | Returns an instance of the protocol with the given name.
:type name: str
:param name: The name of the protocol.
:rtype: Protocol
:return: An instance of the protocol. | 3.093619 | 3.88482 | 0.796335 |
host = to_host(host, default_protocol=default_protocol)
protocol = host.get_protocol()
conn = create_protocol(protocol, **kwargs)
if protocol == 'pseudo':
filename = host.get_address()
conn.device.add_commands_from_file(filename)
return conn | def prepare(host, default_protocol='telnet', **kwargs) | Creates an instance of the protocol by either parsing the given
URL-formatted hostname using :class:`Exscript.util.url`, or according to
the options of the given :class:`Exscript.Host`.
:type host: str or Host
:param host: A URL-formatted hostname or a :class:`Exscript.Host` instance.
:type defau... | 5.203897 | 7.21487 | 0.721274 |
host = to_host(host)
conn = prepare(host, default_protocol, **kwargs)
account = host.get_account()
conn.connect(host.get_address(), host.get_tcp_port())
if account is not None:
conn.login(account)
return conn | def connect(host, default_protocol='telnet', **kwargs) | Like :class:`prepare()`, but also connects to the host by calling
:class:`Protocol.connect()`. If the URL or host contain any login info, this
function also logs into the host using :class:`Protocol.login()`.
:type host: str or Host
:param host: A URL-formatted hostname or a :class:`Exscript.Host` obj... | 4.044531 | 4.997929 | 0.809241 |
hashnum = 0
for h in thehash:
hashnum <<= 8
hashnum |= ord(bytes([h]))
return hashnum | def _long_from_raw(thehash) | Fold to a long, a digest supplied as a string. | 4.085284 | 4.167863 | 0.980187 |
if len(password) not in list(range(4, 64)):
raise ValueError('passphrase length')
if len(seed) not in list(range(1, 17)):
raise ValueError('seed length')
for x in seed:
if not x in _VALIDSEEDCHARACTERS:
raise ValueError('seed composition')
if sequence < 0:
... | def otp(password, seed, sequence) | Calculates a one-time password hash using the given password, seed, and
sequence number and returns it.
Uses the MD4/sixword algorithm as supported by TACACS+ servers.
:type password: str
:param password: A password.
:type seed: str
:param seed: A cryptographic seed.
:type sequence: int
... | 4.023088 | 3.883417 | 1.035966 |
if isinstance(string, Protocol):
string = string.response
return _first_match(string, re.compile(regex, flags)) | def first_match(string, regex, flags=re.M) | Matches the given string against the given regex.
- If no match is found and the regular expression has zero or one
groups, this function returns None.
- If no match is found and the regular expression has more than one
group, this function returns a tuple of None. The number of elements
... | 6.537038 | 5.879942 | 1.111752 |
if isinstance(string, Protocol):
string = string.response
compiled = re.compile(regex, flags)
results = []
if compiled.groups <= 1:
for line in string.split('\n'):
match = _first_match(line, compiled)
if match is None:
continue
res... | def any_match(string, regex, flags=re.M) | Matches the given string against the given regex.
- If no match is found, this function returns an empty list.
- If a match is found and the regular expression has no groups,
a list of matching lines returned.
- If a match is found and the regular expression has one group,
a list of... | 2.682902 | 2.47708 | 1.083091 |
sys.stdout.flush()
sys.stderr.flush()
# UNIX double-fork magic. We need to fork before any threads are
# created.
pid = os.fork()
if pid > 0:
# Exit first parent.
sys.exit(0)
# Decouple from parent environment.
os.chdir('/')
os.setsid()
os.umask(0)
# N... | def daemonize() | Forks and daemonizes the current process. Does not automatically track
the process id; to do this, use :class:`Exscript.util.pidutil`. | 2.551119 | 2.836895 | 0.899264 |
self.exc_info = exc_info
self.did_end = True
self.write(format_exception(*self.exc_info)) | def aborted(self, exc_info) | Called by a logger to log an exception. | 5.91113 | 5.1662 | 1.144193 |
if keytype is None:
try:
key = RSAKey.from_private_key_file(filename)
keytype = 'rsa'
except SSHException as e:
try:
key = DSSKey.from_private_key_file(filename)
keytype = 'dss'
... | def from_file(filename, password='', keytype=None) | Returns a new PrivateKey instance with the given attributes.
If keytype is None, we attempt to automatically detect the type.
:type filename: string
:param filename: The key file name.
:type password: string
:param password: The key password.
:type keytype: string
... | 2.32359 | 2.340901 | 0.992605 |
theip = ip
if theip.startswith('::'):
theip = '0' + theip
if theip.endswith('::'):
theip += '0'
segments = theip.split(':')
if len(segments) == 1:
raise ValueError('no colons in ipv6 address: ' + repr(ip))
fill = 8 - len(segments)
if fill < 0:
raise Value... | def normalize_ip(ip) | Transform the address into a standard, fixed-length form, such as:
1234:0:01:02:: -> 1234:0000:0001:0002:0000:0000:0000:0000
1234::A -> 1234:0000:0000:0000:0000:0000:0000:000a
:type ip: string
:param ip: An IP address.
:rtype: string
:return: The normalized IP. | 2.426972 | 2.489334 | 0.974948 |
theip = normalize_ip(ip)
segments = ['%x' % int(s, 16) for s in theip.split(':')]
# Find the longest consecutive sequence of zeroes.
seq = {0: 0}
start = None
count = 0
for n, segment in enumerate(segments):
if segment != '0':
start = None
count = 0
... | def clean_ip(ip) | Cleans the ip address up, useful for removing leading zeros, e.g.::
1234:0:01:02:: -> 1234:0:1:2::
1234:0000:0000:0000:0000:0000:0000:000A -> 1234::a
1234:0000:0000:0000:0001:0000:0000:0000 -> 1234:0:0:0:1::
0000:0000:0000:0000:0001:0000:0000:0000 -> ::1:0:0:0
:type ip: string
... | 3.066605 | 3.013411 | 1.017652 |
if '/' in prefix:
network, pfxlen = prefix.split('/')
else:
network = prefix
pfxlen = default_length
return network, int(pfxlen) | def parse_prefix(prefix, default_length=128) | Splits the given IP prefix into a network address and a prefix length.
If the prefix does not have a length (i.e., it is a simple IP address),
it is presumed to have the given default length.
:type prefix: string
:param prefix: An IP mask.
:type default_length: long
:param default_length: The... | 2.997637 | 3.196667 | 0.937738 |
try:
uri = Url.from_string(uri, self.protocol)
except ValueError:
raise ValueError('Hostname parse error: ' + repr(uri))
hostname = uri.hostname or ''
name = uri.path and hostname + uri.path or hostname
self.set_protocol(uri.protocol)
self... | def set_uri(self, uri) | Defines the protocol, hostname/address, TCP port number, username,
and password from the given URL. The hostname may be URL formatted,
so the following formats are all valid:
- myhostname
- myhostname.domain
- ssh:hostname
- ssh:hostname.domain
... | 3.481796 | 3.574874 | 0.973963 |
url = Url()
url.protocol = self.get_protocol()
url.hostname = self.get_address()
url.port = self.get_tcp_port()
url.vars = dict((k, to_list(v))
for (k, v) in list(self.get_all().items())
if isinstance(v, str) or isinstance(... | def get_uri(self) | Returns a URI formatted representation of the host, including all
of it's attributes except for the name. Uses the
address, not the name of the host to build the URI.
:rtype: str
:return: A URI. | 3.564108 | 3.751315 | 0.950096 |
return {'hostname': self.get_name(),
'address': self.get_address(),
'protocol': self.get_protocol(),
'port': self.get_tcp_port()} | def get_dict(self) | Returns a dict containing the host's attributes. The following
keys are contained:
- hostname
- address
- protocol
- port
:rtype: dict
:return: The resulting dictionary. | 4.341832 | 3.178512 | 1.365995 |
if is_ip(address):
self.address = clean_ip(address)
else:
self.address = address | def set_address(self, address) | Set the address of the remote host the is contacted, without
changing hostname, username, password, protocol, and TCP port
number.
This is the actual address that is used to open the connection.
:type address: string
:param address: A hostname or IP name. | 4.549494 | 8.162968 | 0.557333 |
if name not in ('debug', 'verify_fingerprint', 'driver'):
raise TypeError('No such option: ' + repr(name))
if self.options is None:
self.options = {}
self.options[name] = value | def set_option(self, name, value) | Defines a (possibly protocol-specific) option for the host.
Possible options include:
verify_fingerprint: bool
:type name: str
:param name: The option name.
:type value: object
:param value: The option value. | 4.66095 | 4.727184 | 0.985989 |
if self.options is None:
return default
return self.options.get(name, default) | def get_option(self, name, default=None) | Returns the value of the given option if it is defined, returns
the given default value otherwise.
:type name: str
:param name: The option name.
:type default: object
:param default: A default value. | 3.071775 | 4.629937 | 0.663459 |
if tcp_port is None:
self.tcp_port = None
return
self.tcp_port = int(tcp_port) | def set_tcp_port(self, tcp_port) | Defines the TCP port number.
:type tcp_port: int
:param tcp_port: The TCP port number. | 2.484341 | 3.961488 | 0.627123 |
if self.vars is None:
self.vars = {}
self.vars[name] = value | def set(self, name, value) | Stores the given variable/value in the object for later retrieval.
:type name: string
:param name: The name of the variable.
:type value: object
:param value: The value of the variable. | 3.528001 | 4.749774 | 0.742772 |
if self.vars is None:
self.vars = {}
if name in self.vars:
self.vars[name].append(value)
else:
self.vars[name] = [value] | def append(self, name, value) | Appends the given value to the list variable with the given name.
:type name: string
:param name: The name of the variable.
:type value: object
:param value: The appended value. | 2.085771 | 2.271843 | 0.918096 |
if self.vars is None:
self.vars = {}
if name not in self.vars:
self.vars[name] = value | def set_default(self, name, value) | Like set(), but only sets the value if the variable is not already
defined.
:type name: string
:param name: The name of the variable.
:type value: object
:param value: The value of the variable. | 2.818553 | 3.196395 | 0.881791 |
if self.vars is None:
return default
return self.vars.get(name, default) | def get(self, name, default=None) | Returns the value of the given variable, or the given default
value if the variable is not defined.
:type name: string
:param name: The name of the variable.
:type default: object
:param default: The default value.
:rtype: object
:return: The value of the vari... | 3.789001 | 4.62639 | 0.818997 |
return [crypt.otp(password[0], seed[0], int(seq)) for seq in seqs] | def otp(scope, password, seed, seqs) | Calculates a one-time password hash using the given password, seed, and
sequence number and returns it.
Uses the md4/sixword algorithm as supported by TACACS+ servers.
:type password: string
:param password: A password.
:type seed: string
:param seed: A username.
:type seqs: int
:par... | 7.030788 | 11.428149 | 0.615217 |
labels = obj.__dict__.setdefault('_labels', dict())
labels[name] = kwargs
return obj | def add_label(obj, name, **kwargs) | Labels an object such that it can later be checked with
:class:`get_label()`.
:type obj: object
:param obj: The object that is labeled.
:type name: str
:param name: A label.
:type kwargs: dict
:param kwargs: Optional values to store with the label.
:rtype: object
:return: The la... | 4.909735 | 8.001673 | 0.613589 |
labels = obj.__dict__.get('_labels')
if labels is None:
return None
return labels.get(name) | def get_label(obj, name) | Checks whether an object has the given label attached (see
:class:`add_label()`) and returns the associated options.
:type obj: object
:param obj: The object to check for the label.
:type name: str
:param name: A label.
:rtype: dict or None
:return: The optional values if the label is at... | 3.42223 | 5.463501 | 0.62638 |
labels = src.__dict__.get('_labels')
if labels is None:
return
dst.__dict__['_labels'] = labels.copy() | def copy_labels(src, dst) | Copies all labels of one object to another object.
:type src: object
:param src: The object to check read the labels from.
:type dst: object
:param dst: The object into which the labels are copied. | 3.442514 | 4.943199 | 0.696414 |
return thetype, ex, ''.join(traceback.format_exception(thetype, ex, tb)) | def serializeable_exc_info(thetype, ex, tb) | Since traceback objects can not be pickled, this function manipulates
exception info tuples before they are passed accross process
boundaries. | 3.056282 | 3.658335 | 0.83543 |
if isinstance(tb, str):
return tb
return ''.join(traceback.format_exception(thetype, ex, tb)) | def format_exception(thetype, ex, tb) | This function is a drop-in replacement for Python's
traceback.format_exception().
Since traceback objects can not be pickled, Exscript is forced to
manipulate them before they are passed accross process boundaries.
This leads to the fact the Python's traceback.format_exception()
no longer works for... | 3.190575 | 3.574295 | 0.892645 |
def decorated(*args, **kwargs):
warnings.warn('Call to deprecated function %s.' % func.__name__,
category=DeprecationWarning,
stacklevel=2)
return func(*args, **kwargs)
decorated.__name__ = func.__name__
decorated.__doc__ = func.__doc__
de... | def deprecated(func) | A decorator for marking functions as deprecated. Results in
a printed warning message when the function is used. | 1.429326 | 1.508909 | 0.947258 |
@wraps(func)
def wrapped(self, *args, **kwargs):
try:
rlock = self._sync_lock
except AttributeError:
from multiprocessing import RLock
rlock = self.__dict__.setdefault('_sync_lock', RLock())
with rlock:
return func(self, *args, **kwarg... | def synchronized(func) | Decorator for synchronizing method access. | 2.429868 | 2.461241 | 0.987253 |
@wraps(func)
def wrapped(*args, **kwargs):
arg = repr(args) + ' ' + repr(kwargs)
sys.stdout.write('Entering ' + func.__name__ + arg + '\n')
try:
result = func(*args, **kwargs)
except:
sys.stdout.write('Traceback caught:\n')
sys.stdout.writ... | def debug(func) | Decorator that prints a message whenever a function is entered or left. | 2.205639 | 2.402356 | 0.918115 |
parser_args = {'strip_command': strip_command}
return _run(conn, None, string, parser_args, **kwargs) | def eval(conn, string, strip_command=True, **kwargs) | Compiles the given template and executes it on the given
connection.
Raises an exception if the compilation fails.
if strip_command is True, the first line of each response that is
received after any command sent by the template is stripped. For
example, consider the following template::
l... | 4.82034 | 7.570827 | 0.636699 |
parser_args = {'strip_command': strip_command}
with open(filename, 'r') as fp:
return _run(conn, filename, fp.read(), parser_args, **kwargs) | def eval_file(conn, filename, strip_command=True, **kwargs) | Convenience wrapper around eval() that reads the template from a file
instead.
:type conn: Exscript.protocols.Protocol
:param conn: The connection on which to run the template.
:type filename: string
:param filename: The name of the template file.
:type strip_command: bool
:param strip_c... | 3.486811 | 5.143904 | 0.677853 |
with open(filename, 'r') as fp:
return _run(conn, None, fp.read(), {'no_prompt': True}, **kwargs) | def paste_file(conn, filename, **kwargs) | Convenience wrapper around paste() that reads the template from a file
instead.
:type conn: Exscript.protocols.Protocol
:param conn: The connection on which to run the template.
:type filename: string
:param filename: The name of the template file.
:type kwargs: dict
:param kwargs: Varia... | 6.483876 | 7.695888 | 0.842512 |
result = string.split('%')
for i, item in enumerate(result[1:]):
i += 1
try:
result[i] = _HEXTOCHR[item[:2]] + item[2:]
except KeyError:
result[i] = '%' + item
except UnicodeDecodeError:
result[i] = chr(int(item[:2], 16)) + item[2:]
re... | def _unquote(string) | _unquote('abc%20def') -> 'abc def'. | 2.5848 | 2.678927 | 0.964864 |
# Extract the query part from the URL.
querystring = urlparse(url)[4]
# Split the query into name/value pairs.
pairs = [s2 for s1 in querystring.split('&') for s2 in s1.split(';')]
# Split the name/value pairs.
result = OrderedDefaultDict(list)
for name_value in pairs:
pair = ... | def _urlparse_qs(url) | Parse a URL query string and return the components as a dictionary.
Based on the cgi.parse_qs method.This is a utility function provided
with urlparse so that users need not use cgi module for
parsing the url query string.
Arguments:
:type url: str
:param url: URL with query string to be pars... | 2.397112 | 2.537404 | 0.94471 |
if url is None:
raise TypeError('Expected string but got' + type(url))
# Extract the protocol name from the URL.
result = Url()
match = re.match(r'(\w+)://', url)
if match:
result.protocol = match.group(1)
else:
result.protoco... | def from_string(url, default_protocol='telnet') | Parses the given URL and returns an URL object. There are some
differences to Python's built-in URL parser:
- It is less strict, many more inputs are accepted. This is
necessary to allow for passing a simple hostname as a URL.
- You may specify a default protocol that is used when the... | 3.157187 | 3.082275 | 1.024304 |
self._check_if_ready()
self.debug = debug
self.main_loop.debug = debug | def set_debug(self, debug=1) | Set the debug level.
:type debug: int
:param debug: The debug level. | 7.391458 | 9.203486 | 0.803115 |
if max_threads is None:
raise TypeError('max_threads must not be None.')
self._check_if_ready()
self.collection.set_max_working(max_threads) | def set_max_threads(self, max_threads) | Set the maximum number of concurrent threads.
:type max_threads: int
:param max_threads: The number of threads. | 6.277554 | 8.442465 | 0.743569 |
self._check_if_ready()
return self.main_loop.enqueue(function, name, times, data) | def enqueue(self, function, name=None, times=1, data=None) | Appends a function to the queue for execution. The times argument
specifies the number of attempts if the function raises an exception.
If the name argument is None it defaults to whatever id(function)
returns.
:type function: callable
:param function: The function that is exec... | 5.412575 | 8.883924 | 0.609255 |
self._check_if_ready()
return self.main_loop.enqueue_or_ignore(function, name, times, data) | def enqueue_or_ignore(self, function, name=None, times=1, data=None) | Like enqueue(), but does nothing if a function with the same name
is already in the queue.
Returns a job id if a new job was added, returns None otherwise.
:type function: callable
:param function: The function that is executed.
:type name: str
:param name: Stored in J... | 4.254085 | 6.443289 | 0.660235 |
self._check_if_ready()
return self.main_loop.priority_enqueue(function,
name,
force_start,
times,
data) | def priority_enqueue(self,
function,
name=None,
force_start=False,
times=1,
data=None) | Like :class:`enqueue()`, but adds the given function at the top of the
queue.
If force_start is True, the function is immediately started even when
the maximum number of concurrent threads is already reached.
:type function: callable
:param function: The function that is execut... | 3.623824 | 6.435713 | 0.56308 |
self._check_if_ready()
self.collection.stop()
self.collection.wait()
self.main_loop.join()
self.main_loop = None
self.collection.clear()
if restart:
self.collection.start()
self._init() | def shutdown(self, restart=True) | Stop the execution of enqueued jobs, and wait for all running
jobs to complete. This method is synchronous and returns as soon
as all jobs are terminated (i.e. all threads are stopped).
If restart is True, the workqueue is restarted and paused,
so you may fill it with new jobs.
... | 4.690849 | 4.996322 | 0.93886 |
self._check_if_ready()
self.collection.stop()
self.main_loop.join()
self.main_loop = None
self.collection.clear() | def destroy(self) | Like shutdown(), but does not restart the queue and does not
wait for already started jobs to complete. | 7.514287 | 6.379337 | 1.17791 |
conn = scope.get('__connection__')
user = user[0]
if user is None:
conn.app_authenticate()
else:
account = Account(user, password[0])
conn.app_authenticate(account)
return True | def authenticate_user(scope, user=[None], password=[None]) | Like authenticate(), but logs in using the given user and password.
If a user and password are not given, the function uses the same
user and password that were used at the last login attempt; it is
an error if no such attempt was made before.
:type user: string
:param user: A username.
:type ... | 4.814486 | 7.174276 | 0.671076 |
conn = scope.get('__connection__')
password = password[0]
if password is None:
conn.app_authorize()
else:
account = Account('', password)
conn.app_authorize(account)
return True | def authorize(scope, password=[None]) | Looks for a password prompt on the current connection
and enters the given password.
If a password is not given, the function uses the same
password that was used at the last login attempt; it is
an error if no such attempt was made before.
:type password: string
:param password: A password. | 6.725494 | 9.783983 | 0.687398 |
conn = scope.get('__connection__')
password = password[0]
if password is None:
conn.auto_app_authorize()
else:
account = Account('', password)
conn.auto_app_authorize(account)
return True | def auto_authorize(scope, password=[None]) | Executes a command on the remote host that causes an authorization
procedure to be started, then authorizes using the given password
in the same way in which authorize() works.
Depending on the detected operating system of the remote host the
following commands are started:
- on IOS, the "enable"... | 6.060185 | 9.670261 | 0.626683 |
conn = scope.get('__connection__')
conn.close(1)
scope.define(__response__=conn.response)
return True | def close(scope) | Closes the existing connection with the remote host. This function is
rarely used, as normally Exscript closes the connection automatically
when the script has completed. | 15.264446 | 14.654441 | 1.041626 |
conn = scope.get('__connection__')
response = []
for line in data:
conn.send(line)
conn.expect_prompt()
response += conn.response.split('\n')[1:]
scope.define(__response__=response)
return True | def exec_(scope, data) | Sends the given data to the remote host and waits until the host
has responded with a prompt.
If the given data is a list of strings, each item is sent, and
after each item a prompt is expected.
This function also causes the response of the command to be stored
in the built-in __response__ variable... | 6.72926 | 5.907128 | 1.139176 |
conn = scope.get('__connection__')
response = []
for line in data:
conn.execute(line)
response += conn.response.split('\n')[1:]
scope.define(__response__=response)
return True | def execline(scope, data) | Like exec(), but appends a newline to the command in data before sending
it.
:type data: string
:param data: The data that is sent. | 6.998491 | 10.062191 | 0.695524 |
conn = scope.get('__connection__')
for line in data:
conn.send(line)
return True | def send(scope, data) | Like exec(), but does not wait for a response of the remote host after
sending the command.
:type data: string
:param data: The data that is sent. | 9.173071 | 11.868782 | 0.772874 |
conn = scope.get('__connection__')
conn.expect(prompt)
scope.define(__response__=conn.response)
return True | def wait_for(scope, prompt) | Waits until the response of the remote host contains the given pattern.
:type prompt: regex
:param prompt: The prompt pattern. | 13.780628 | 23.21549 | 0.593596 |
conn = scope.get('__connection__')
conn.set_prompt(prompt)
return True | def set_prompt(scope, prompt=None) | Defines the pattern that is recognized at any future time when Exscript
needs to wait for a prompt.
In other words, whenever Exscript waits for a prompt, it searches the
response of the host for the given pattern and continues as soon as the
pattern is found.
Exscript waits for a prompt whenever it... | 6.75598 | 17.675442 | 0.382224 |
conn = scope.get('__connection__')
conn.set_error_prompt(error_re)
return True | def set_error(scope, error_re=None) | Defines a pattern that, whenever detected in the response of the remote
host, causes an error to be raised.
In other words, whenever Exscript waits for a prompt, it searches the
response of the host for the given pattern and raises an error if the
pattern is found.
:type error_re: regex
:para... | 8.299741 | 15.088782 | 0.55006 |
conn = scope.get('__connection__')
conn.set_timeout(int(timeout[0]))
return True | def set_timeout(scope, timeout) | Defines the time after which Exscript fails if it does not receive a
prompt from the remote host.
:type timeout: int
:param timeout: The timeout in seconds. | 7.299356 | 13.971321 | 0.522453 |
if prompt:
thehandler = self._create_autoprompt_handler(handler)
else:
thehandler = handler
self.commands.add(command, thehandler) | def add_command(self, command, handler, prompt=True) | Registers a command.
The command may be either a string (which is then automatically
compiled into a regular expression), or a pre-compiled regular
expression object.
If the given response handler is a string, it is sent as the
response to any command that matches the given reg... | 5.056115 | 8.12862 | 0.622014 |
if autoprompt:
deco = self._create_autoprompt_handler
else:
deco = None
self.commands.add_from_file(filename, deco) | def add_commands_from_file(self, filename, autoprompt=True) | Wrapper around add_command_handler that reads the handlers from the
file with the given name. The file is a Python script containing
a list named 'commands' of tuples that map command names to
handlers.
:type filename: str
:param filename: The name of the file containing the tu... | 5.010313 | 7.255003 | 0.690601 |
self.logged_in = False
if self.login_type == self.LOGIN_TYPE_PASSWORDONLY:
self.prompt_stage = self.PROMPT_STAGE_PASSWORD
elif self.login_type == self.LOGIN_TYPE_NONE:
self.prompt_stage = self.PROMPT_STAGE_CUSTOM
else:
self.prompt_stage = sel... | def init(self) | Init or reset the virtual device.
:rtype: str
:return: The initial response of the virtual device. | 3.741465 | 3.964061 | 0.943847 |
echo = self.echo and command or ''
if not self.logged_in:
return echo + '\n' + self._get_prompt()
response = self.commands.eval(command)
if response is None:
return echo + '\n' + self._get_prompt()
return echo + response | def do(self, command) | "Executes" the given command on the virtual device, and returns
the response.
:type command: str
:param command: The command to be executed.
:rtype: str
:return: The response of the virtual device. | 4.779776 | 6.226686 | 0.767627 |
if history is None:
history = InputHistory()
if not doverh or default is None:
default = history.get(key, str(default))
while True:
if default is None:
value = input('%s: ' % message)
else:
value = input('%s [%s]: ' % (message, default)) or defaul... | def prompt(key,
message,
default=None,
doverh=True,
strip=True,
check=None,
history=None) | Prompt the user for input. This function is similar to Python's built
in raw_input, with the following differences:
- You may specify a default value that is returned if the user
presses "enter" without entering anything.
- The user's input is recorded in a config file, and offered
... | 2.303517 | 2.701199 | 0.852776 |
def _validate(string):
if not os.path.isfile(string):
return 'File not found. Please enter a filename.'
return prompt(key, message, default, True, _validate, history) | def get_filename(key, message, default=None, history=None) | Like :meth:`prompt`, but only accepts the name of an existing file
as an input.
:type key: str
:param key: The key under which to store the input in the :class:`InputHistory`.
:type message: str
:param message: The user prompt.
:type default: str|None
:param default: The offered default ... | 5.984743 | 6.36265 | 0.940605 |
# Read username and password.
try:
env_user = getpass.getuser()
except KeyError:
env_user = ''
if prompt is None:
prompt = "Please enter your user name"
if env_user is None or env_user == '':
user = input('%s: ' % prompt)
else:
user = input('%s [%s]: ... | def get_user(prompt=None) | Prompts the user for his login name, defaulting to the USER environment
variable. Returns a string containing the username.
May throw an exception if EOF is given by the user.
:type prompt: str|None
:param prompt: The user prompt or the default one if None.
:rtype: string
:return: A username. | 2.687161 | 2.923007 | 0.919314 |
if not self.parser:
return default
try:
return self.parser.get(self.section, key)
except (configparser.NoSectionError, configparser.NoOptionError):
return default | def get(self, key, default=None) | Returns the input with the given key from the section that was
passed to the constructor. If either the section or the key
are not found, the default value is returned.
:type key: str
:param key: The key for which to return a value.
:type default: str|object
:param def... | 2.352576 | 2.755628 | 0.853735 |
if value is None:
return None
self.parser.set(self.section, key, value)
# Unfortunately ConfigParser attempts to write a string to the file
# object, and NamedTemporaryFile uses binary mode. So we nee to create
# the tempfile, and then re-open it.
w... | def set(self, key, value) | Saves the input with the given key in the section that was
passed to the constructor. If either the section or the key
are not found, they are created.
Does nothing if the given value is None.
:type key: str
:param key: The key for which to define a value.
:type value... | 3.867229 | 3.892935 | 0.993397 |
if not self.needs_lock:
return
with self.synclock:
while not self.lock.acquire(False):
self.synclock.wait()
if signal:
self.acquired_event(self)
self.synclock.notify_all() | def acquire(self, signal=True) | Locks the account.
Method has no effect if the constructor argument `needs_lock`
wsa set to False.
:type signal: bool
:param signal: Whether to emit the acquired_event signal. | 4.737247 | 3.930407 | 1.205282 |
if not self.needs_lock:
return
with self.synclock:
self.lock.release()
if signal:
self.released_event(self)
self.synclock.notify_all() | def release(self, signal=True) | Unlocks the account.
Method has no effect if the constructor argument `needs_lock`
wsa set to False.
:type signal: bool
:param signal: Whether to emit the released_event signal. | 6.043377 | 4.448798 | 1.358429 |
self.name = name
self.changed_event.emit(self) | def set_name(self, name) | Changes the name of the account.
:type name: string
:param name: The account name. | 7.219174 | 21.932402 | 0.329156 |
self.password = password
self.changed_event.emit(self) | def set_password(self, password) | Changes the password of the account.
:type password: string
:param password: The account password. | 9.222653 | 21.698845 | 0.42503 |
self.authorization_password = password
self.changed_event.emit(self) | def set_authorization_password(self, password) | Changes the authorization password of the account.
:type password: string
:param password: The new authorization password. | 8.791244 | 27.070679 | 0.324752 |
account = AccountProxy(parent)
account.host = host
if account.acquire():
return account
return None | def for_host(parent, host) | Returns a new AccountProxy that has an account acquired. The
account is chosen based on what the connected AccountManager
selects for the given host. | 10.688583 | 5.526274 | 1.934139 |
account = AccountProxy(parent)
account.account_hash = account_hash
if account.acquire():
return account
return None | def for_account_hash(parent, account_hash) | Returns a new AccountProxy that acquires the account with the
given hash, if such an account is known to the account manager.
It is an error if the account manager does not have such an
account. | 7.022598 | 4.5391 | 1.547134 |
if self.host:
self.parent.send(('acquire-account-for-host', self.host))
elif self.account_hash:
self.parent.send(('acquire-account-from-hash', self.account_hash))
else:
self.parent.send(('acquire-account'))
response = self.parent.recv()
... | def acquire(self) | Locks the account. Returns True on success, False if the account
is thread-local and must not be locked. | 3.525294 | 3.271873 | 1.077454 |
self.parent.send(('release-account', self.account_hash))
response = self.parent.recv()
if isinstance(response, Exception):
raise response
if response != 'ok':
raise ValueError('unexpected response: ' + repr(response)) | def release(self) | Unlocks the account. | 5.532064 | 4.702555 | 1.176396 |
for account in self.accounts:
if account.__hash__() == account_hash:
return account
return None | def get_account_from_hash(self, account_hash) | Returns the account with the given hash, or None if no such
account is included in the account pool. | 3.44392 | 3.047923 | 1.129924 |
with self.unlock_cond:
for account in to_list(accounts):
account.acquired_event.listen(self._on_account_acquired)
account.released_event.listen(self._on_account_released)
self.accounts.add(account)
self.unlocked_accounts.append... | def add_account(self, accounts) | Adds one or more account instances to the pool.
:type accounts: Account|list[Account]
:param accounts: The account to be added. | 3.654446 | 3.90702 | 0.935354 |
for account in to_list(accounts):
if account not in self.accounts:
msg = 'attempt to remove unknown account %s' % account
raise Exception(msg)
if account not in self.unlocked_accounts:
raise Exception('account %s should be unlocked... | def _remove_account(self, accounts) | :type accounts: Account|list[Account]
:param accounts: The accounts to be removed. | 2.880281 | 2.958169 | 0.97367 |
with self.unlock_cond:
for owner in self.owner2account:
self.release_accounts(owner)
self._remove_account(self.accounts.copy())
self.unlock_cond.notify_all() | def reset(self) | Removes all accounts. | 9.188091 | 7.855379 | 1.169656 |
for account in self.accounts:
if account.get_name() == name:
return account
return None | def get_account_from_name(self, name) | Returns the account with the given name.
:type name: string
:param name: The name of the account. | 2.841901 | 5.343966 | 0.531796 |
with self.unlock_cond:
if len(self.accounts) == 0:
raise ValueError('account pool is empty')
if account:
# Specific account requested.
while account not in self.unlocked_accounts:
self.unlock_cond.wait()
... | def acquire_account(self, account=None, owner=None) | Waits until an account becomes available, then locks and returns it.
If an account is not passed, the next available account is returned.
:type account: Account
:param account: The account to be acquired, or None.
:type owner: object
:param owner: An optional descriptor for th... | 3.040798 | 2.959404 | 1.027504 |
with self.unlock_cond:
for account in self.owner2account[owner]:
self.account2owner.pop(account)
account.release(False)
self.unlocked_accounts.append(account)
self.owner2account.pop(owner)
self.unlock_cond.notify_all() | def release_accounts(self, owner) | Releases all accounts that were acquired by the given owner.
:type owner: object
:param owner: The owner descriptor as passed to acquire_account(). | 3.650701 | 4.505167 | 0.810336 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.