sentence1 stringlengths 52 3.87M | sentence2 stringlengths 1 47.2k | label stringclasses 1
value |
|---|---|---|
def lte(max_value):
"""
Validates that a field value is less than or equal to the
value given to this validator.
"""
def validate(value):
if value > max_value:
return e("{} is not less than or equal to {}", value, max_value)
return validate | Validates that a field value is less than or equal to the
value given to this validator. | entailment |
def gt(gt_value):
"""
Validates that a field value is greater than the
value given to this validator.
"""
def validate(value):
if value <= gt_value:
return e("{} is not greater than {}", value, gt_value)
return validate | Validates that a field value is greater than the
value given to this validator. | entailment |
def lt(lt_value):
"""
Validates that a field value is less than the
value given to this validator.
"""
def validate(value):
if value >= lt_value:
return e("{} is not less than {}", value, lt_value)
return validate | Validates that a field value is less than the
value given to this validator. | entailment |
def between(min_value, max_value):
"""
Validates that a field value is between the two values
given to this validator.
"""
def validate(value):
if value < min_value:
return e("{} is not greater than or equal to {}",
value, min_value)
if value > max_value:
... | Validates that a field value is between the two values
given to this validator. | entailment |
def length(min=None, max=None):
"""
Validates that a field value's length is between the bounds given to this
validator.
"""
def validate(value):
if min and len(value) < min:
return e("{} does not have a length of at least {}", value, min)
if max and len(value) > max:
... | Validates that a field value's length is between the bounds given to this
validator. | entailment |
def match(pattern):
"""
Validates that a field value matches the regex given to this validator.
"""
regex = re.compile(pattern)
def validate(value):
if not regex.match(value):
return e("{} does not match the pattern {}", value, pattern)
return validate | Validates that a field value matches the regex given to this validator. | entailment |
def is_email():
"""
Validates that a fields value is a valid email address.
"""
email = (
ur'(?!^\.)' # No dot at start
ur'(?!.*\.@)' # No dot before at sign
ur'(?!.*@\.)' # No dot after at sign
ur'(?!.*\.$)' # No dot at the end
ur'(?!.*\.\.)' # No dou... | Validates that a fields value is a valid email address. | entailment |
def is_url():
"""
Validates that a fields value is a valid URL.
"""
# Stolen from Django
regex = re.compile(
r'^(?:http|ftp)s?://' # http:// or https://
r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' #domain...
r'localhost|' #localhost...... | Validates that a fields value is a valid URL. | entailment |
def each_item(*validators):
"""
A wrapper which applies the given validators to each item in a field
value of type `list`.
Example usage in a Schema:
"my_list_field": {"type": Array(int), "validates": each_item(lte(10))}
"""
def validate(value):
for item in value:
for v... | A wrapper which applies the given validators to each item in a field
value of type `list`.
Example usage in a Schema:
"my_list_field": {"type": Array(int), "validates": each_item(lte(10))} | entailment |
def distinct():
"""
Validates that all items in the given field list value are distinct,
i.e. that the list contains no duplicates.
"""
def validate(value):
for i, item in enumerate(value):
if item in value[i+1:]:
return e("{} is not a distinct set of values", val... | Validates that all items in the given field list value are distinct,
i.e. that the list contains no duplicates. | entailment |
def apply_defaults(self, instance):
"""Applies the defaults described by the this schema to the given
document instance as appropriate. Defaults are only applied to
fields which are currently unset."""
for field, spec in self.doc_spec.iteritems():
field_type = spec['type']
... | Applies the defaults described by the this schema to the given
document instance as appropriate. Defaults are only applied to
fields which are currently unset. | entailment |
def validate(self, instance):
"""Validates the given document against this schema. Raises a
ValidationException if there are any failures."""
errors = {}
self._validate_instance(instance, errors)
if len(errors) > 0:
raise ValidationException(errors) | Validates the given document against this schema. Raises a
ValidationException if there are any failures. | entailment |
def _verify(self, path_prefix=None):
"""Verifies that this schema's doc spec is valid and makes sense."""
for field, spec in self.doc_spec.iteritems():
path = self._append_path(path_prefix, field)
# Standard dict-based spec
if isinstance(spec, dict):
... | Verifies that this schema's doc spec is valid and makes sense. | entailment |
def _verify_field_spec(self, spec, path):
"""Verifies a given field specification is valid, recursing into nested schemas if required."""
# Required should be a boolean
if 'required' in spec and not isinstance(spec['required'], bool):
raise SchemaFormatException("{} required declara... | Verifies a given field specification is valid, recursing into nested schemas if required. | entailment |
def _verify_type(self, spec, path):
"""Verify that the 'type' in the spec is valid"""
field_type = spec['type']
if isinstance(field_type, Schema):
# Nested documents cannot have validation
if not set(spec.keys()).issubset(set(['type', 'required', 'nullable', 'default']))... | Verify that the 'type' in the spec is valid | entailment |
def _verify_default(self, spec, path):
"""Verifies that the default specified in the given spec is valid."""
field_type = spec['type']
default = spec['default']
# If it's a function there's nothing we can really do except assume its valid
if callable(default):
return... | Verifies that the default specified in the given spec is valid. | entailment |
def _verify_validates(self, spec, path):
"""Verify thats the 'validates' argument is valid."""
validates = spec['validates']
if isinstance(validates, list):
for validator in validates:
self._verify_validator(validator, path)
else:
self._verify_val... | Verify thats the 'validates' argument is valid. | entailment |
def _verify_validator(self, validator, path):
"""Verifies that a given validator associated with the field at the given path is legitimate."""
# Validator should be a function
if not callable(validator):
raise SchemaFormatException("Invalid validations for {}", path)
# Vali... | Verifies that a given validator associated with the field at the given path is legitimate. | entailment |
def _validate_instance(self, instance, errors, path_prefix=''):
"""Validates that the given instance of a document conforms to the given schema's
structure and validations. Any validation errors are added to the given errors
collection. The caller should assume the instance is considered valid i... | Validates that the given instance of a document conforms to the given schema's
structure and validations. Any validation errors are added to the given errors
collection. The caller should assume the instance is considered valid if the
errors collection is empty when this method returns. | entailment |
def _validate_value(self, value, field_spec, path, errors):
"""Validates that the given field value is valid given the associated
field spec and path. Any validation failures are added to the given errors
collection."""
# Check if the value is None and add an error if the field is not n... | Validates that the given field value is valid given the associated
field spec and path. Any validation failures are added to the given errors
collection. | entailment |
def load_config(path=None, defaults=None):
"""
Loads and parses an INI style configuration file using Python's built-in
configparser module. If path is specified, load it.
If ``defaults`` (a list of strings) is given, try to load each entry as a
file, without throwing any error if the operation fail... | Loads and parses an INI style configuration file using Python's built-in
configparser module. If path is specified, load it.
If ``defaults`` (a list of strings) is given, try to load each entry as a
file, without throwing any error if the operation fails.
If ``defaults`` is not given, the following loca... | entailment |
def as_dict(config):
"""
Converts a ConfigParser object into a dictionary.
The resulting dictionary has sections as keys which point to a dict of the
sections options as key => value pairs.
"""
settings = defaultdict(lambda: {})
for section in config.sections():
for key, val in conf... | Converts a ConfigParser object into a dictionary.
The resulting dictionary has sections as keys which point to a dict of the
sections options as key => value pairs. | entailment |
def initialize(self, timeouts):
""" Bind or connect the nanomsg socket to some address """
# Bind or connect to address
if self.bind is True:
self.socket.bind(self.address)
else:
self.socket.connect(self.address)
# Set send and recv timeouts
self... | Bind or connect the nanomsg socket to some address | entailment |
def _set_timeouts(self, timeouts):
""" Set socket timeouts for send and receive respectively """
(send_timeout, recv_timeout) = (None, None)
try:
(send_timeout, recv_timeout) = timeouts
except TypeError:
raise EndpointError(
'`timeouts` must be a... | Set socket timeouts for send and receive respectively | entailment |
def send(self, payload):
""" Encode and sign (optional) the send through socket """
payload = self.encode(payload)
payload = self.sign(payload)
self.socket.send(payload) | Encode and sign (optional) the send through socket | entailment |
def receive(self, decode=True):
""" Receive from socket, authenticate and decode payload """
payload = self.socket.recv()
payload = self.verify(payload)
if decode:
payload = self.decode(payload)
return payload | Receive from socket, authenticate and decode payload | entailment |
def sign(self, payload):
""" Sign payload using the supplied authenticator """
if self.authenticator:
return self.authenticator.signed(payload)
return payload | Sign payload using the supplied authenticator | entailment |
def verify(self, payload):
""" Verify payload authenticity via the supplied authenticator """
if not self.authenticator:
return payload
try:
self.authenticator.auth(payload)
return self.authenticator.unsigned(payload)
except AuthenticatorInvalidSignatu... | Verify payload authenticity via the supplied authenticator | entailment |
def decode(self, payload):
""" Decode payload """
try:
return self.encoder.decode(payload)
except Exception as exception:
raise DecodeError(str(exception)) | Decode payload | entailment |
def encode(self, payload):
""" Encode payload """
try:
return self.encoder.encode(payload)
except Exception as exception:
raise EncodeError(str(exception)) | Encode payload | entailment |
def start(self):
""" Start and listen for calls """
if threading.current_thread().name == 'MainThread':
signal.signal(signal.SIGINT, self.stop)
logging.info('Started on {}'.format(self.address))
while True:
self.process() | Start and listen for calls | entailment |
def stop(self, dummy_signum=None, dummy_frame=None):
""" Shutdown process (this method is also a signal handler) """
logging.info('Shutting down ...')
self.socket.close()
sys.exit(0) | Shutdown process (this method is also a signal handler) | entailment |
def get_summary(list_all=[], **kwargs):
''' summarize the report data
@param list_all: a list which save the report data
@param kwargs: such as
show_all: True/False report show all status cases
proj_name: project name
home_pag... | summarize the report data
@param list_all: a list which save the report data
@param kwargs: such as
show_all: True/False report show all status cases
proj_name: project name
home_page: home page url | entailment |
def add_report_data(list_all=[], module_name="TestModule", **kwargs):
''' add report data to a list
@param list_all: a list which save the report data
@param module_name: test set name or test module name
@param kwargs: such as
case_name: testcase name
... | add report data to a list
@param list_all: a list which save the report data
@param module_name: test set name or test module name
@param kwargs: such as
case_name: testcase name
status: test result, Pass or Fail
resp_teste... | entailment |
def parse(self, subscription):
""" Fetch the function registered for a certain subscription """
for name in self.methods:
tag = bytes(name.encode('utf-8'))
if subscription.startswith(tag):
fun = self.methods.get(name)
message = subscription[len(ta... | Fetch the function registered for a certain subscription | entailment |
def subscribe(self, tag, fun, description=None):
""" Subscribe to something and register a function """
self.methods[tag] = fun
self.descriptions[tag] = description
self.socket.set_string_option(nanomsg.SUB, nanomsg.SUB_SUBSCRIBE, tag) | Subscribe to something and register a function | entailment |
def process(self):
""" Receive a subscription from the socket and process it """
subscription = None
result = None
try:
subscription = self.socket.recv()
except AuthenticateError as exception:
logging.error(
'Subscriber error while authe... | Receive a subscription from the socket and process it | entailment |
def build_payload(self, tag, message):
""" Encode, sign payload(optional) and attach subscription tag """
message = self.encode(message)
message = self.sign(message)
payload = bytes(tag.encode('utf-8')) + message
return payload | Encode, sign payload(optional) and attach subscription tag | entailment |
def publish(self, tag, message):
""" Publish a message down the socket """
payload = self.build_payload(tag, message)
self.socket.send(payload) | Publish a message down the socket | entailment |
def start_service(addr, n, authenticator):
""" Start a service """
s = Subscriber(addr, authenticator=authenticator)
def do_something(line):
pass
s.subscribe('test', do_something)
started = time.time()
for _ in range(n):
s.process()
s.socket.close()
duration = time.ti... | Start a service | entailment |
def bench(client, n):
""" Benchmark n requests """
items = list(range(n))
# Time client publish operations
# ------------------------------
started = time.time()
for i in items:
client.publish('test', i)
duration = time.time() - started
print('Publisher client stats:')
util... | Benchmark n requests | entailment |
def get_webpack(request, name='DEFAULT'):
"""
Get the Webpack object for a given webpack config.
Called at most once per request per config name.
"""
if not hasattr(request, '_webpack_map'):
request._webpack_map = {}
wp = request._webpack_map.get(name)
if wp is None:
wp = re... | Get the Webpack object for a given webpack config.
Called at most once per request per config name. | entailment |
def includeme(config):
""" Add pyramid_webpack methods and config to the app """
settings = config.registry.settings
root_package_name = config.root_package.__name__
config.registry.webpack = {
'DEFAULT': WebpackState(settings, root_package_name)
}
for extra_config in aslist(settings.get... | Add pyramid_webpack methods and config to the app | entailment |
def _get_setting(self, setting, default=None, name=None, inherit=True):
""" Helper function to fetch settings, inheriting from the base """
if name is None:
name = self.name
if name == 'DEFAULT':
return self._settings.get('webpack.{0}'.format(setting), default)
el... | Helper function to fetch settings, inheriting from the base | entailment |
def load_stats(self, cache=None, wait=None):
""" Load and cache the webpack-stats file """
if cache is None:
cache = not self.debug
if wait is None:
wait = self.debug
if not cache or self._stats is None:
self._stats = self._load_stats()
sta... | Load and cache the webpack-stats file | entailment |
def _load_stats(self):
""" Load the webpack-stats file """
for attempt in range(0, 3):
try:
with self.stats_file.open() as f:
return json.load(f)
except ValueError:
# If we failed to parse the JSON, it's possible that the
... | Load the webpack-stats file | entailment |
def _chunk_filter(self, extensions):
""" Create a filter from the extensions and ignore files """
if isinstance(extensions, six.string_types):
extensions = extensions.split()
def _filter(chunk):
""" Exclusion filter """
name = chunk['name']
if ext... | Create a filter from the extensions and ignore files | entailment |
def _add_url(self, chunk):
""" Add a 'url' property to a chunk and return it """
if 'url' in chunk:
return chunk
public_path = chunk.get('publicPath')
if public_path:
chunk['url'] = public_path
else:
fullpath = posixpath.join(self.state.static_... | Add a 'url' property to a chunk and return it | entailment |
def get_bundle(self, bundle_name, extensions=None):
""" Get all the chunks contained in a bundle """
if self.stats.get('status') == 'done':
bundle = self.stats.get('chunks', {}).get(bundle_name, None)
if bundle is None:
raise KeyError('No such bundle {0!r}.'.forma... | Get all the chunks contained in a bundle | entailment |
def _unique_names():
"""Generates unique sequences of bytes.
"""
characters = ("abcdefghijklmnopqrstuvwxyz"
"0123456789")
characters = [characters[i:i + 1] for i in irange(len(characters))]
rng = random.Random()
while True:
letters = [rng.choice(characters) for i in ira... | Generates unique sequences of bytes. | entailment |
def escape_queue(s):
"""Escapes the path to a queue, e.g. preserves ~ at the begining.
"""
if isinstance(s, PosixPath):
s = unicode_(s)
elif isinstance(s, bytes):
s = s.decode('utf-8')
if s.startswith('~/'):
return '~/' + shell_escape(s[2:])
else:
return shell_esc... | Escapes the path to a queue, e.g. preserves ~ at the begining. | entailment |
def parse_ssh_destination(destination):
"""Parses the SSH destination argument.
"""
match = _re_ssh.match(destination)
if not match:
raise InvalidDestination("Invalid destination: %s" % destination)
user, password, host, port = match.groups()
info = {}
if user:
info['username... | Parses the SSH destination argument. | entailment |
def _ssh_client(self):
"""Gets an SSH client to connect with.
"""
ssh = paramiko.SSHClient()
ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(paramiko.RejectPolicy())
return ssh | Gets an SSH client to connect with. | entailment |
def _connect(self):
"""Connects via SSH.
"""
ssh = self._ssh_client()
logger.debug("Connecting with %s",
', '.join('%s=%r' % (k, v if k != "password" else "***")
for k, v in iteritems(self.destination)))
ssh.connect(**self.desti... | Connects via SSH. | entailment |
def get_client(self):
"""Gets the SSH client.
This will check that the connection is still alive first, and reconnect
if necessary.
"""
if self._ssh is None:
self._connect()
return self._ssh
else:
try:
chan = self._ssh.... | Gets the SSH client.
This will check that the connection is still alive first, and reconnect
if necessary. | entailment |
def _call(self, cmd, get_output):
"""Calls a command through the SSH connection.
Remote stderr gets printed to this program's stderr. Output is captured
and may be returned.
"""
server_err = self.server_logger()
chan = self.get_client().get_transport().open_session()
... | Calls a command through the SSH connection.
Remote stderr gets printed to this program's stderr. Output is captured
and may be returned. | entailment |
def check_call(self, cmd):
"""Calls a command through SSH.
"""
ret, _ = self._call(cmd, False)
if ret != 0: # pragma: no cover
raise RemoteCommandFailure(command=cmd, ret=ret) | Calls a command through SSH. | entailment |
def check_output(self, cmd):
"""Calls a command through SSH and returns its output.
"""
ret, output = self._call(cmd, True)
if ret != 0: # pragma: no cover
raise RemoteCommandFailure(command=cmd, ret=ret)
logger.debug("Output: %r", output)
return output | Calls a command through SSH and returns its output. | entailment |
def _resolve_queue(self, queue, depth=0, links=None):
"""Finds the location of tej's queue directory on the server.
The `queue` set when constructing this `RemoteQueue` might be relative
to the home directory and might contain ``~user`` placeholders. Also,
each queue may in fact be a li... | Finds the location of tej's queue directory on the server.
The `queue` set when constructing this `RemoteQueue` might be relative
to the home directory and might contain ``~user`` placeholders. Also,
each queue may in fact be a link to another path (a file containing
the string ``tejdir... | entailment |
def _get_queue(self):
"""Gets the actual location of the queue, or None.
"""
if self._queue is None:
self._links = []
queue, depth = self._resolve_queue(self.queue, links=self._links)
if queue is None and depth > 0:
raise QueueLinkBroken
... | Gets the actual location of the queue, or None. | entailment |
def setup(self, links=None, force=False, only_links=False):
"""Installs the runtime at the target location.
This will not replace an existing installation, unless `force` is True.
After installation, creates links to this installation at the specified
locations.
"""
if ... | Installs the runtime at the target location.
This will not replace an existing installation, unless `force` is True.
After installation, creates links to this installation at the specified
locations. | entailment |
def _setup(self):
"""Actually installs the runtime.
"""
# Expands ~user in queue
if self.queue.path[0:1] == b'/':
queue = self.queue
else:
if self.queue.path[0:1] == b'~':
output = self.check_output('echo %s' %
... | Actually installs the runtime. | entailment |
def submit(self, job_id, directory, script=None):
"""Submits a job to the queue.
If the runtime is not there, it will be installed. If it is a broken
chain of links, error.
"""
if job_id is None:
job_id = '%s_%s_%s' % (Path(directory).unicodename,
... | Submits a job to the queue.
If the runtime is not there, it will be installed. If it is a broken
chain of links, error. | entailment |
def status(self, job_id):
"""Gets the status of a previously-submitted job.
"""
check_jobid(job_id)
queue = self._get_queue()
if queue is None:
raise QueueDoesntExist
ret, output = self._call('%s %s' % (
shell_escape(queue / ... | Gets the status of a previously-submitted job. | entailment |
def download(self, job_id, files, **kwargs):
"""Downloads files from server.
"""
check_jobid(job_id)
if not files:
return
if isinstance(files, string_types):
files = [files]
directory = False
recursive = kwargs.pop('recursive', True)
... | Downloads files from server. | entailment |
def kill(self, job_id):
"""Kills a job on the server.
"""
check_jobid(job_id)
queue = self._get_queue()
if queue is None:
raise QueueDoesntExist
ret, output = self._call('%s %s' % (
shell_escape(queue / 'commands/kill'),
... | Kills a job on the server. | entailment |
def list(self):
"""Lists the jobs on the server.
"""
queue = self._get_queue()
if queue is None:
raise QueueDoesntExist
output = self.check_output('%s' %
shell_escape(queue / 'commands/list'))
job_id, info = None, None
... | Lists the jobs on the server. | entailment |
def multi_substitution(*substitutions):
"""
Take a sequence of pairs specifying substitutions, and create
a function that performs those substitutions.
>>> multi_substitution(('foo', 'bar'), ('bar', 'baz'))('foo')
'baz'
"""
substitutions = itertools.starmap(substitution, substitutions)
# compose function appli... | Take a sequence of pairs specifying substitutions, and create
a function that performs those substitutions.
>>> multi_substitution(('foo', 'bar'), ('bar', 'baz'))('foo')
'baz' | entailment |
def simple_html_strip(s):
r"""
Remove HTML from the string `s`.
>>> str(simple_html_strip(''))
''
>>> print(simple_html_strip('A <bold>stormy</bold> day in paradise'))
A stormy day in paradise
>>> print(simple_html_strip('Somebody <!-- do not --> tell the truth.'))
Somebody tell the truth.
>>> print(simpl... | r"""
Remove HTML from the string `s`.
>>> str(simple_html_strip(''))
''
>>> print(simple_html_strip('A <bold>stormy</bold> day in paradise'))
A stormy day in paradise
>>> print(simple_html_strip('Somebody <!-- do not --> tell the truth.'))
Somebody tell the truth.
>>> print(simple_html_strip('What about<br... | entailment |
def remove_prefix(text, prefix):
"""
Remove the prefix from the text if it exists.
>>> remove_prefix('underwhelming performance', 'underwhelming ')
'performance'
>>> remove_prefix('something special', 'sample')
'something special'
"""
null, prefix, rest = text.rpartition(prefix)
return rest | Remove the prefix from the text if it exists.
>>> remove_prefix('underwhelming performance', 'underwhelming ')
'performance'
>>> remove_prefix('something special', 'sample')
'something special' | entailment |
def remove_suffix(text, suffix):
"""
Remove the suffix from the text if it exists.
>>> remove_suffix('name.git', '.git')
'name'
>>> remove_suffix('something special', 'sample')
'something special'
"""
rest, suffix, null = text.partition(suffix)
return rest | Remove the suffix from the text if it exists.
>>> remove_suffix('name.git', '.git')
'name'
>>> remove_suffix('something special', 'sample')
'something special' | entailment |
def common_prefix(s1, s2):
"""
Return the common prefix of two lines.
"""
index = min(len(s1), len(s2))
while s1[:index] != s2[:index]:
index -= 1
return s1[:index] | Return the common prefix of two lines. | entailment |
def _get_graph(self, ctx, bundle, extensions, caller=None):
""" Run a graph and render the tag contents for each output """
request = ctx.get('request')
if request is None:
request = get_current_request()
if ':' in bundle:
config_name, bundle = bundle.split(':')
... | Run a graph and render the tag contents for each output | entailment |
def activate(lancet, method, project):
"""Switch to this project."""
with taskstatus("Looking up project") as ts:
if method == "key":
func = get_project_keys
elif method == "dir":
func = get_project_keys
for key, project_path in func(lancet):
if key.l... | Switch to this project. | entailment |
def workon(ctx, issue_id, new, base_branch):
"""
Start work on a given issue.
This command retrieves the issue from the issue tracker, creates and checks
out a new aptly-named branch, puts the issue in the configured active,
status, assigns it to you and starts a correctly linked Harvest timer.
... | Start work on a given issue.
This command retrieves the issue from the issue tracker, creates and checks
out a new aptly-named branch, puts the issue in the configured active,
status, assigns it to you and starts a correctly linked Harvest timer.
If a branch with the same name as the one to be created... | entailment |
def time(lancet, issue):
"""
Start an Harvest timer for the given issue.
This command takes care of linking the timer with the issue tracker page
for the given issue. If the issue is not passed to command it's taken
from currently active branch.
"""
issue = get_issue(lancet, issue)
wit... | Start an Harvest timer for the given issue.
This command takes care of linking the timer with the issue tracker page
for the given issue. If the issue is not passed to command it's taken
from currently active branch. | entailment |
def pause(ctx):
"""
Pause work on the current issue.
This command puts the issue in the configured paused status and stops the
current Harvest timer.
"""
lancet = ctx.obj
paused_status = lancet.config.get("tracker", "paused_status")
# Get the issue
issue = get_issue(lancet)
# ... | Pause work on the current issue.
This command puts the issue in the configured paused status and stops the
current Harvest timer. | entailment |
def resume(ctx):
"""
Resume work on the currently active issue.
The issue is retrieved from the currently active branch name.
"""
lancet = ctx.obj
username = lancet.tracker.whoami()
active_status = lancet.config.get("tracker", "active_status")
# Get the issue
issue = get_issue(lan... | Resume work on the currently active issue.
The issue is retrieved from the currently active branch name. | entailment |
def ssh(lancet, print_cmd, environment):
"""
SSH into the given environment, based on the dploi configuration.
"""
namespace = {}
with open(lancet.config.get('dploi', 'deployment_spec')) as fh:
code = compile(fh.read(), 'deployment.py', 'exec')
exec(code, {}, namespace)
config ... | SSH into the given environment, based on the dploi configuration. | entailment |
def _setup_helper():
"""Print the shell integration code."""
base = os.path.abspath(os.path.dirname(__file__))
helper = os.path.join(base, "helper.sh")
with open(helper) as fh:
click.echo(fh.read()) | Print the shell integration code. | entailment |
def _commands(ctx):
"""Prints a list of commands for shell completion hooks."""
ctx = ctx.parent
ctx.show_hidden_subcommands = False
main = ctx.command
for subcommand in main.list_commands(ctx):
cmd = main.get_command(ctx, subcommand)
if cmd is None:
continue
hel... | Prints a list of commands for shell completion hooks. | entailment |
def _arguments(ctx, command_name=None):
"""Prints a list of arguments for shell completion hooks.
If a command name is given, returns the arguments for that subcommand.
The command name has to refer to a command; aliases are not supported.
"""
ctx = ctx.parent
main = ctx.command
if command_... | Prints a list of arguments for shell completion hooks.
If a command name is given, returns the arguments for that subcommand.
The command name has to refer to a command; aliases are not supported. | entailment |
def _autocomplete(ctx, shell):
"""Print the shell autocompletion code."""
if not shell:
shell = os.environ.get("SHELL", "")
shell = os.path.basename(shell).lower()
if not shell:
click.secho(
"Your shell could not be detected, please pass its name "
"as the arg... | Print the shell autocompletion code. | entailment |
def raisefrom(exc_type, message, exc):
# type: (Any, str, BaseException) -> None
"""Call Python 3 raise from or emulate it for Python 2
Args:
exc_type (Any): Type of Exception
message (str): Error message to display
exc (BaseException): original exception
Returns:
None
... | Call Python 3 raise from or emulate it for Python 2
Args:
exc_type (Any): Type of Exception
message (str): Error message to display
exc (BaseException): original exception
Returns:
None | entailment |
def init_runner(self, parser, tracers, projinfo):
''' initial some instances for preparing to run test case
@note: should not override
@param parser: instance of TestCaseParser
@param tracers: dict type for the instance of Tracer. Such as {"":tracer_obj} or {"192.168.0.1:5555":trace... | initial some instances for preparing to run test case
@note: should not override
@param parser: instance of TestCaseParser
@param tracers: dict type for the instance of Tracer. Such as {"":tracer_obj} or {"192.168.0.1:5555":tracer_obj1, "192.168.0.2:5555":tracer_obj2}
@param proj_i... | entailment |
def _run_grid_multiprocess(self, func, iterables):
''' running case with mutil process to support selenium grid-mode(multiple web) and appium grid-mode(multiple devices).
@param func: function object
@param iterables: iterable objects
'''
multiprocessing.freeze_support()
... | running case with mutil process to support selenium grid-mode(multiple web) and appium grid-mode(multiple devices).
@param func: function object
@param iterables: iterable objects | entailment |
def _run_grid_multithread(self, func, iterables):
''' running case with mutil process to support selenium grid-mode(multiple web) and appium grid-mode(multiple devices).
@param func: function object
@param iterables: iterable objects
'''
f = lambda x: threading.... | running case with mutil process to support selenium grid-mode(multiple web) and appium grid-mode(multiple devices).
@param func: function object
@param iterables: iterable objects | entailment |
def init_project_env(subject='Automation', proj_path = None, sysencoding = "utf-8", debug = False):
''' Set the environment for pyrunner '''
# if sysencoding:
# set_sys_encode(sysencoding)
if not proj_path:
try:
executable_file_path = os.path.dirname(os.... | Set the environment for pyrunner | entailment |
def seqfy(strs):
''' 序列化 字符串--->实际效果是，为字符串，添加行号，返回字符串
Sampe usage:
strs = ["", None, u"First-line\nSecond-line\nThird-line", u"没有换行符"]
for s in strs:
print "---"
result = seqfy(s)
print result
print unseqfy(result)
'''
if no... | 序列化 字符串--->实际效果是，为字符串，添加行号，返回字符串
Sampe usage:
strs = ["", None, u"First-line\nSecond-line\nThird-line", u"没有换行符"]
for s in strs:
print "---"
result = seqfy(s)
print result
print unseqfy(result) | entailment |
def stepfy(strs):
''' 步骤化 字符串 --->实际效果是, 依据 序列化的字符串，转换为 Step_%s_info 的字典， 返回字典
Sample usage:
test_strs = [
"",
None,
u"First-line\nSecond-line\nThird-line",
u'1.First-line\n2.Second-line\n3.Third-line\n',
u'3.没有换行符',
u'3.有换行符\n',
"asdfasd... | 步骤化 字符串 --->实际效果是, 依据 序列化的字符串，转换为 Step_%s_info 的字典， 返回字典
Sample usage:
test_strs = [
"",
None,
u"First-line\nSecond-line\nThird-line",
u'1.First-line\n2.Second-line\n3.Third-line\n',
u'3.没有换行符',
u'3.有换行符\n',
"asdfasdfsdf",
"1.asdf... | entailment |
def map_function(func_str, fw_action_addtion=None,bw_action_addtion=None, alias_func=None):
''' Sample usage:
print map_function('set',alias_func = "ini_items");# -> ini_items
print map_function('set',fw_action_addtion="action_steps_",bw_action_addtion="_for_upd",alias_func = "ini_items"); # -> a... | Sample usage:
print map_function('set',alias_func = "ini_items");# -> ini_items
print map_function('set',fw_action_addtion="action_steps_",bw_action_addtion="_for_upd",alias_func = "ini_items"); # -> action_steps_ini_items_for_upd
print map_function('set(a=1,b=2,c=Test())',"action_steps_","_f... | entailment |
def until_cmd(listcmd, end_expects=None, save2logfile=None, coding = encoding):
''' 执行系统命令,并等待执行完
@param listcmd: 执行的命令，列表格式
@param end_expects: 命令执行结束，在输出的最后一行，正则搜素期望值，并设置 结果标志
@param save2logfile: 设置执行过程，保存的日志
@param coding: 设置输出编码
'''
... | 执行系统命令,并等待执行完
@param listcmd: 执行的命令，列表格式
@param end_expects: 命令执行结束，在输出的最后一行，正则搜素期望值，并设置 结果标志
@param save2logfile: 设置执行过程，保存的日志
@param coding: 设置输出编码 | entailment |
def until(method, timeout = 30, message=''):
"""Calls the method until the return value is not False."""
end_time = time.time() + timeout
while True:
try:
value = method()
if value:
return value
except:
... | Calls the method until the return value is not False. | entailment |
def _check_format(file_path, content):
""" check testcase format if valid
"""
if not content:
# testcase file content is empty
err_msg = u"Testcase file content is empty: {}".format(file_path)
raise p_exception.FileFormatError(err_msg)
elif no... | check testcase format if valid | entailment |
def _load_yaml_file(yaml_file):
""" load yaml file and check file content format
"""
with io.open(yaml_file, 'r', encoding='utf-8') as stream:
yaml_content = yaml.load(stream)
FileUtils._check_format(yaml_file, yaml_content)
return yaml_content | load yaml file and check file content format | entailment |
def _load_json_file(json_file):
""" load json file and check file content format
"""
with io.open(json_file, encoding='utf-8') as data_file:
try:
json_content = json.load(data_file)
except p_exception.JSONDecodeError:
err_msg = u"JSO... | load json file and check file content format | entailment |
def _load_csv_file(csv_file):
""" load csv file and check file content format
@param
csv_file: csv file path
e.g. csv file content:
username,password
test1,111111
test2,222222
test3,333333
@return
... | load csv file and check file content format
@param
csv_file: csv file path
e.g. csv file content:
username,password
test1,111111
test2,222222
test3,333333
@return
list of parameter, each paramete... | entailment |
def force_delete_file(file_path):
''' force delete a file '''
if os.path.isfile(file_path):
try:
os.remove(file_path)
return file_path
except:
return FileSystemUtils.add_unique_postfix(file_path)
else:
... | force delete a file | entailment |
def mkzip(source_dir, output_filename):
'''Usage:
p = r'D:\auto\env\ttest\ins\build\lib\rock4\softtest\support'
mkzip(os.path.join(p, "appiumroot"),os.path.join(p, "appiumroot.zip"))
unzip(os.path.join(p, "appiumroot.zip"),os.path.join(p, "appiumroot2"))
'''
... | Usage:
p = r'D:\auto\env\ttest\ins\build\lib\rock4\softtest\support'
mkzip(os.path.join(p, "appiumroot"),os.path.join(p, "appiumroot.zip"))
unzip(os.path.join(p, "appiumroot.zip"),os.path.join(p, "appiumroot2")) | entailment |
def get_imported_module_from_file(file_path):
""" import module from python file path and return imported module
"""
if p_compat.is_py3:
imported_module = importlib.machinery.SourceFileLoader('module_name', file_path).load_module()
elif p_compat.is_py2:
impo... | import module from python file path and return imported module | entailment |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.