def explicit_namespace_works_correctly(self):
# Regression-ish test re #288
ns = Collection.from_module(load('integration'))
expect(
'print_foo',
out='foo\n',
program=Program(namespace=ns),
)
def _site(name, build_help):
_path = join('sites', name)
# TODO: turn part of from_module into .clone(), heh.
self = sys.modules[__name__]
coll = Collection.from_module(self, name=name, config={
'sphinx': {
'source': _path,
'target': join(_path, '_build')
}
})
coll['build'].__doc__ = build_help
return coll
def _site(name, help_part):
_path = join("sites", name)
# TODO: turn part of from_module into .clone(), heh.
self = sys.modules[__name__]
coll = Collection.from_module(
self,
name=name,
config={"sphinx": {"source": _path, "target": join(_path, "_build")}},
)
coll.__doc__ = "Tasks for building {}".format(help_part)
coll["build"].__doc__ = "Build {}".format(help_part)
return coll
def setup_from_tasks(
globals_dict, main_package=None,
settings_module_name=None, **kwargs):
"""
This is the function you must call from your :xfile:`tasks.py` file
in order to activate the tasks defined by atelier.
"""
if '__file__' not in globals_dict:
raise Exception(
"No '__file__' in %r. "
"First parameter to must be `globals()`" % globals_dict)
tasks_file = Path(globals_dict['__file__'])
if not tasks_file.exists():
raise Exception("No such file: %s" % tasks_file)
# print("20180428 setup_from_tasks() : {}".format(root_dir))
from atelier.invlib import tasks
from atelier.projects import get_project_from_tasks
prj = get_project_from_tasks(tasks_file.parent)
atelier.current_project = prj
if kwargs:
prj.config.update(kwargs)
if settings_module_name is not None:
os.environ['DJANGO_SETTINGS_MODULE'] = settings_module_name
from django.conf import settings
prj.config.update(
languages=[lng.name for lng in settings.SITE.languages])
if isinstance(main_package, six.string_types):
main_package = import_module(main_package)
if main_package:
prj.set_main_package(main_package)
self = Collection.from_module(tasks)
prj.set_namespace(self)
return self
def _load(self, name):
mod, _ = self.loader.load(name)
return Collection.from_module(mod)
from invoke import Collection
from inv import cf, client, monitoring
# https://code.visualstudio.com/docs/python/debugging#_attach-to-a-local-script
# import ptvsd
# print("Waiting for debugger attach")
# ptvsd.enable_attach(address=('localhost', 5678), redirect_output=True)
# ptvsd.wait_for_attach()
# breakpoint()
ns = Collection(cf, client, monitoring)
HERE = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..'))
WHEELHOUSE_PATH = os.environ.get('WHEELHOUSE')
CONSTRAINTS_PATH = os.path.join(HERE, 'requirements', 'constraints.txt')
try:
__import__('rednose')
except ImportError:
TEST_CMD = 'nosetests'
else:
TEST_CMD = 'nosetests --rednose'
ns = Collection()
try:
from admin import tasks as admin_tasks
ns.add_collection(Collection.from_module(admin_tasks), name='admin')
except ImportError:
pass
def task(*args, **kwargs):
"""Behaves the same way as invoke.task. Adds the task
to the root namespace.
"""
if len(args) == 1 and callable(args[0]):
new_task = invoke.task(args[0])
ns.add_task(new_task)
return new_task
def decorator(f):
new_task = invoke.task(f, *args, **kwargs)
ns.add_task(new_task)
from invoke import Collection
from . import main, copy, mp3, meta
namespace = Collection.from_module(main)
for mod in (copy, mp3, meta):
namespace.add_collection(mod)
from invoke import Collection from tasks import countries ns = Collection() ns.add_collection(Collection.from_module(countries))
@task
def clean(ctx):
"""Clean up release artifacts."""
if RELEASE_DIR.is_dir():
try:
shutil.rmtree(str(RELEASE_DIR))
except (OSError, shutil.Error) as e:
logging.warning("Error while cleaning release dir: %s", e)
else:
RELEASE_DIR.mkdir()
# Task setup
ns = Collection()
ns.add_task(all_, default=True)
ns.add_task(clean)
# Import every task from submodules directly into the root task namespace
# (without creating silly qualified names like `release.fpm.deb`
# instead of just `release.deb`).
submodules = [f.stem for f in Path(__file__).parent.glob('*.py')
if f.name != '__init__.py']
this_module = __import__('tasks.release', fromlist=submodules)
for mod_name in submodules:
module = getattr(this_module, mod_name)
collection = Collection.from_module(module)
for task_name in collection.task_names:
task = getattr(module, task_name)
ns.add_task(task)
def core_arg_parse_result_defaults_to_None(self):
ok_(Executor(collection=Collection()).core is None)
def can_grant_access_to_core_arg_parse_result(self):
c = ParserContext()
ok_(Executor(collection=Collection(), core=c).core is c)
def uses_blank_config_by_default(self):
e = Executor(collection=Collection())
assert isinstance(e.config, Config)
def allows_collection_and_config(self):
coll = Collection()
conf = Config()
e = Executor(collection=coll, config=conf)
assert e.collection is coll
assert e.config is conf
)
exit(-1)
with ctx.cd(os.environ["ESP32_OPENOCD"]):
ctx.run(
"bin/openocd -s share/openocd/scripts "
"-f interface/ftdi/esp32_devkitj_v1.cfg -f board/esp-wroom-32.cfg",
pty=True,
)
@task
def esp32_app_gdb(ctx, gdb=None, reset=False):
"""Launches xtensa-gdb with app elf and connects to openocd gdb server"""
if gdb is None:
gdb = OPENOCD_GDB_PORT_DEFAULT
with ctx.cd(ESP32_TEST_APP_ROOT):
gdb_cmd = gdb_build_cmd(
"", ESP32_TEST_APP_ELF, gdb, gdb_prefix="xtensa-esp32-elf-", reset=reset
)
ctx.run(gdb_cmd, pty=True)
ns = Collection("esp32")
ns.add_task(esp32_console, name="console")
ns.add_task(esp32_openocd, name="gdbserver")
ns.add_task(esp32_app_build, name="build")
ns.add_task(esp32_app_clean, name="clean")
ns.add_task(esp32_app_flash, name="flash")
ns.add_task(esp32_app_gdb, name="app-gdb")
ns.add_task(esp32_app_menuconfig, name="app-menuconfig")
from invoke import Collection from invoke_commands import docs, clean, sonar, test, release, misc, django # from rajk_appman import invoke_rajk as rajk ns = Collection() ns.add_collection(Collection.from_module(release)) ns.add_collection(Collection.from_module(docs)) ns.add_collection(Collection.from_module(clean)) ns.add_collection(Collection.from_module(sonar)) ns.add_collection(Collection.from_module(test)) ns.add_collection(Collection.from_module(misc)) ns.add_collection(Collection.from_module(django)) # ns.add_collection(Collection.from_module(rajk), name="rajk")
# Copy MSVC runtime libraries into the dist folder
redist = r'%VS100COMNTOOLS%..\..\VC\redist\x86\Microsoft.VC100.CRT'
redist = os.path.expandvars(redist)
libs = glob.glob(os.path.join(redist, 'msvc?100.dll'))
if not libs:
print("Warning: Could not copy CRT libraries. Expect deployment problems.",
file=sys.stderr)
return
BUILDDIR = 'dist\\MapsEvolved-win32'
for lib in libs:
shutil.copy(lib, BUILDDIR)
zipname = shutil.make_archive(BUILDDIR, 'zip', BUILDDIR)
print("Successfully created Windows binary distribution.",
file=sys.stderr)
@ctask
def doxygen(ctx):
"""Generate documentation for pymaplib_cpp"""
try:
doxygen = mev_build_utils.find_executable('doxygen')
except ValueError:
logger.error("Could not find doxygen executable. Is it installed?")
sys.exit(2)
ctx.run([doxygen, 'Doxyfile'], cwd='docs')
ns = Collection(*[obj for obj in vars().values() if isinstance(obj, Task)])
ns.add_collection(Collection.from_module(tasks_thirdparty), 'third-party')
ns.add_collection(Collection.from_module(tasks_sip), 'sip')
ns.configure({'run': { 'runner': mev_build_utils.LightInvokeRunner }})
from invoke import Collection from tasks import build, docker, lint, server, test ns = Collection() ns.add_collection(Collection.from_module(build)) ns.add_collection(Collection.from_module(docker)) ns.add_collection(Collection.from_module(lint)) ns.add_collection(Collection.from_module(server)) ns.add_collection(Collection.from_module(test))
from invoke import task, Exit, Collection, Responder
from fabric import Connection
from fabric.transfer import Transfer
from patchwork.files import append
import os
from . import desktop
from . import utility
ns = Collection()
d = Collection("desktop")
d.add_collection(desktop)
d.add_collection(desktop.install)
d.add_collection(desktop.conf)
ns.add_collection(d)
ns.add_collection(utility)
}),
'ex6-1': ('bizkit.application', {
'BIZKIT_APP': 'greeting_persist'
}),
}
@task(name="run")
def run_example(ctx, ex):
if not ex.startswith('ex'):
ex = 'ex' + ex
if ex not in RUNNERS:
print(f"No such example: {ex}")
return
os.chdir(ex)
wsgi_app, env = RUNNERS[ex]
env['PYTHONPATH'] = '.'
ctx.run(f'twist --log-format text web --wsgi {wsgi_app} --port tcp:8080',
env=env,
echo=True)
slides = Collection("slides")
slides.add_task(start_slides, "start")
slides.add_task(stop_slides, "stop")
ns = Collection()
ns.add_collection(slides)
ns.add_task(run_example)
from invoke import ctask, Collection
@ctask
def go(c):
c.run('false') # Ensures a kaboom if mocking fails
ns = Collection(go)
ns.configure({'run': {'echo': True}})
import pathlib
import sys
from invoke import Collection
from tasks.root import *
ns = Collection.from_module(sys.modules[__name__])
collections = [
'assets',
'analysis',
'deploy',
'dictionary',
'exports',
'fonts',
'jsdata',
'log',
'newrelic',
'search',
'test',
'textdata',
'tmp',
'travis',
]
for collection in collections:
exec('from tasks import {} as module'.format(collection))
ns.add_collection(module)
from invoke import Collection
from invocations import docs, travis, checks
from invocations.packaging import release
ns = Collection(release, docs, travis, checks.blacken)
ns.configure(
{
"packaging": {
"sign": True,
"wheel": True,
"changelog_file": "docs/changelog.rst",
}
}
)
from os.path import join
from invoke import Collection
from invocations import docs as _docs, testing
d = 'sites'
# Usage doc/API site (published as docs.paramiko.org)
path = join(d, 'docs')
docs = Collection.from_module(_docs, name='docs', config={
'sphinx.source': path,
'sphinx.target': join(path, '_build'),
})
# Main/about/changelog site ((www.)?paramiko.org)
path = join(d, 'www')
www = Collection.from_module(_docs, name='www', config={
'sphinx.source': path,
'sphinx.target': join(path, '_build'),
})
ns = Collection(testing.test, docs=docs, www=www)
from aws_infrastructure.tasks import compose_collection
import aws_infrastructure.tasks.library.vpc
import aws_infrastructure.tasks.library.terraform
from invoke import Collection
CONFIG_KEY = 'vpc'
TERRAFORM_BIN = './bin/terraform.exe'
TERRAFORM_DIR = './terraform/vpc'
ns = Collection('vpc')
ns_vpc = aws_infrastructure.tasks.library.vpc.create_tasks(
config_key=CONFIG_KEY,
terraform_bin=TERRAFORM_BIN,
terraform_dir=TERRAFORM_DIR,
)
compose_collection(
ns,
ns_vpc,
sub=False,
exclude=aws_infrastructure.tasks.library.terraform.exclude_without_state(
terraform_dir=TERRAFORM_DIR,
exclude=[
"destroy", # Prevent destroy
'init',
'output',
],
exclude_without_state=[
'destroy',
]))
import sys
from invoke import Collection
# -- TASK-LIBRARY:
from . import _tasklet_cleanup as clean
from . import test
from . import release
# -----------------------------------------------------------------------------
# TASKS:
# -----------------------------------------------------------------------------
# None
# -----------------------------------------------------------------------------
# TASK CONFIGURATION:
# -----------------------------------------------------------------------------
namespace = Collection()
namespace.add_task(clean.clean)
namespace.add_task(clean.clean_all)
namespace.add_collection(Collection.from_module(test))
namespace.add_collection(Collection.from_module(release))
# -- INJECT: clean configuration into this namespace
namespace.configure(clean.namespace.configuration())
if sys.platform.startswith("win"):
# -- OVERRIDE SETTINGS: For platform=win32, ... (Windows)
from ._compat_shutil import which
run_settings = dict(echo=True, pty=False, shell=which("cmd"))
namespace.configure({"run": run_settings})
# For full license text, see the LICENSE file in the repo root
# or https://opensource.org/licenses/BSD-3-Clause
import sys
import os
import logging
from invoke import task, Collection, UnexpectedExit, Failure
sys.path.append(
os.path.abspath(
os.path.join(os.path.dirname(__file__), os.path.pardir + "/cloudsplaining/")
)
)
logger = logging.getLogger(__name__)
# Create the necessary collections (namespaces)
ns = Collection()
test = Collection("test")
ns.add_collection(test)
integration = Collection("integration")
ns.add_collection(integration)
unit = Collection("unit")
ns.add_collection(unit)
build = Collection("build")
ns.add_collection(build)
docs = Collection("docs")
ns.add_collection(docs)
"You need to modify this call before being able to use it")
from aml_compute import TFExperimentCLI
exp = TFExperimentCLI("<YOUR-EXPERIMENT-NAME>")
run = exp.submit_local(
os.path.join(_BASE_PATH, "src"),
"<YOUR-TRAINING-SCRIPT>",
{
"--training_data_path": "/data/train",
"--validation_data_path": "/data/validation",
"--epochs": "1",
"--data_type": "images",
"--data-format": "channels_first",
},
dependencies_file="TensorFlow_imagenet/environment_gpu.yml",
docker_args=["-v", f"{env_values['data']}:/data"],
wait_for_completion=True,
)
print(run)
remote_collection = Collection("remote")
remote_collection.add_task(submit_images, "images")
remote_collection.add_task(submit_remote, "synthetic")
local_collection = Collection("local")
local_collection.add_task(submit_images_local, "images")
local_collection.add_task(submit_local, "synthetic")
submit_collection = Collection("submit", local_collection, remote_collection)
namespace = Collection("tf_experiment", submit_collection)
from os import mkdir
from os.path import join
from shutil import rmtree, copytree
from invoke import Collection, ctask as task
from invocations import docs as _docs
from invocations.packaging import publish
d = 'sites'
# Usage doc/API site (published as docs.paramiko.org)
docs_path = join(d, 'docs')
docs_build = join(docs_path, '_build')
docs = Collection.from_module(_docs,
name='docs',
config={
'sphinx.source': docs_path,
'sphinx.target': docs_build,
})
# Main/about/changelog site ((www.)?paramiko.org)
www_path = join(d, 'www')
www = Collection.from_module(_docs,
name='www',
config={
'sphinx.source': www_path,
'sphinx.target': join(www_path, '_build'),
})
# Until we move to spec-based testing
@task
from spec import eq_
from invoke import task, Collection
@task
def mytask(c):
eq_(c.hooray, 'yaml')
ns = Collection(mytask)
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from invoke import task, Collection
from vultr import Vultr
from .query import query
@task(name='list',
help={
'criteria':
'Filter queried data. Example usage: ' + '"{\'family\': \'ubuntu\'}"'
})
def os_list(ctx, criteria=''):
"""
Retrieve a list of available operating systems
"""
return query(ctx, lambda x: Vultr(x).os.list(), criteria)
os_coll = Collection()
os_coll.add_task(os_list)
def explicit_namespace_works_correctly(self):
# Regression-ish test re #288
ns = Collection.from_module(load("integration"))
expect("print-foo", out="foo\n", program=Program(namespace=ns))
from invoke import Collection, task, call
from package import module
@task
def top_pre():
pass
@task(call(top_pre))
def toplevel():
pass
ns = Collection(module, toplevel)
from . import core as _core
from invoke import Collection as _Collection, task as _task
ns = _Collection.from_module(_core)
def task(*args, **kwargs):
if not kwargs and len(args) == 1 and callable(args[0]):
task = _task(args[0])
ns.add_task(task)
else:
def decorator(func):
task = _task(func)
ns.add_task(task)
return task
return decorator
from invoke import Collection from tasks import k8s from tasks import metrics from tasks import istio from tasks import dashboard from tasks import httpbin from tasks import domain from tasks import namespace ns = Collection() ns.add_collection(k8s) ns.add_collection(metrics) ns.add_collection(istio) ns.add_collection(dashboard, name='dash') ns.add_collection(httpbin) ns.add_collection(domain) ns.add_collection(namespace, name="ns")
#!/usr/bin/env python3 """Command line tasks to build and deploy the ACW Battle Data.""" from invoke import Collection from . import data, misc ns = Collection(misc.clean, misc.doc, misc.deploy, misc.check_tables) ns.add_task(data.build, name='build', default=True) ns.add_collection(Collection.from_module(data))
#!/usr/bin/env python # -*- coding: utf-8 -*- from __future__ import absolute_import from invoke import Collection from . import demo from . import image from . import email from thread_learn import queue_ctrl_c ns = Collection() # must be ns? ns.add_collection(Collection.from_module(demo)) ns.add_collection(Collection.from_module(image)) ns.add_collection(Collection.from_module(email)) ns.add_collection(Collection.from_module(queue_ctrl_c))
def main():
program = Program(namespace=Collection.from_module(sys.modules[__name__]),
version='0.1.0')
program.run()
import os.path
from invoke import Collection
from app import create_app
from task import db as database, misc, pkg, assets
from task.db import get_project_root
_project_root = get_project_root(__file__)
_app = create_app(os.getenv('ENV') or 'default')
ns = Collection.from_module(misc)
ns.configure({'config': _app.config, 'project_root': _project_root})
ns.add_collection(Collection.from_module(database))
ns.add_collection(Collection.from_module(pkg))
ns.add_collection(Collection.from_module(assets))
@task(help={"dest": "Destination directory to save docs"})
def save(ctx, dest="docs.html", format="html"):
"""Save/update docs under destination directory."""
print("STEP: Generate docs in HTML format")
build(ctx, builder=format)
print("STEP: Save docs under %s/" % dest)
source_dir = Path(ctx.config.sphinx.destdir) / format
Path(dest).rmtree_p()
source_dir.copytree(dest)
# -- POST-PROCESSING: Polish up.
for part in [".buildinfo", ".doctrees"]:
partpath = Path(dest) / part
if partpath.isdir():
partpath.rmtree_p()
elif partpath.exists():
partpath.remove_p()
# -----------------------------------------------------------------------------
# TASK CONFIGURATION:
# -----------------------------------------------------------------------------
namespace = Collection(clean, linkcheck, browse, save)
namespace.add_task(build, default=True)
namespace.configure({"sphinx": {"sourcedir": "docs", "destdir": "build/docs"}})
# -- ADD CLEANUP TASK:
cleanup_tasks.add_task(clean, "clean_docs")
cleanup_tasks.configure(namespace.configuration())
from invoke import Collection, Program from guilder import tasks namespace = Collection.from_module(tasks) program = Program(namespace=namespace, version='0.1')
def _load(self, name):
mod, _ = self.loader.load(name)
return Collection.from_module(mod)
_setup.require_invoke_minversion(INVOKE_MINVERSION) # ----------------------------------------------------------------------------- # IMPORTS: # ----------------------------------------------------------------------------- from invoke import Collection # -- TASK-LIBRARY: from . import clean from . import docs from . import test # ----------------------------------------------------------------------------- # TASKS: # ----------------------------------------------------------------------------- # None # ----------------------------------------------------------------------------- # TASK CONFIGURATION: # ----------------------------------------------------------------------------- namespace = Collection() namespace.add_task(clean.clean) namespace.add_task(clean.clean_all) namespace.add_collection(Collection.from_module(docs)) namespace.add_collection(Collection.from_module(test)) # -- INJECT: clean configuration into this namespace namespace.configure(clean.namespace.configuration())
from invocations import docs
from invocations.testing import test
from invocations.packaging import vendorize, release
from invoke import task, run, Collection
@task
def doctree():
run("tree -Ca -I \".git|*.pyc|*.swp|dist|*.egg-info|_static|_build\" docs")
docs = Collection.from_module(docs)
docs.add_task(doctree, 'tree')
ns = Collection(test, vendorize, release, docs)
# http://www.pyinvoke.org #################################################################################################### from invoke import task, Collection # import sys #################################################################################################### # PYSPICE_SOURCE_PATH = Path(__file__).resolve().parent #################################################################################################### from . import anaconda from . import clean from . import doc from . import git from . import ngspice from . import release from . import test ns = Collection() ns.add_collection(Collection.from_module(anaconda)) ns.add_collection(Collection.from_module(clean)) ns.add_collection(Collection.from_module(doc)) ns.add_collection(Collection.from_module(git)) ns.add_collection(Collection.from_module(ngspice)) ns.add_collection(Collection.from_module(release)) ns.add_collection(Collection.from_module(test))
if not ctx.config.build_configs_map:
build_configs_map = make_build_configs_map(ctx.config.build_configs)
ctx.config.build_configs_map = build_configs_map
print("cmake_generator: %s" % ctx.config.cmake_generator)
cmake_build_show_build_configs(ctx.config.build_configs)
cmake_build_show_projects(ctx.config.projects)
pprint(ctx.config, indent=4)
print("-------------------------")
pprint(dict(ctx.config), indent=4)
# -----------------------------------------------------------------------------
# TASK CONFIGURATION:
# -----------------------------------------------------------------------------
namespace = Collection(redo, init, test, clean, reinit, rebuild, config)
namespace.add_task(build, default=True)
namespace.add_task(install)
namespace.add_task(pack)
namespace.add_task(configure)
# pylint: disable=line-too-long
TASKS_CONFIG_DEFAULTS = {
"cmake_generator": None,
"cmake_toolchain": None,
"cmake_install_prefix": None,
"cmake_defines": None,
"build_dir_schema": "build.{BUILD_CONFIG}",
"build_config": BUILD_CONFIG_DEFAULT,
"build_configs": [],
):
"""Test local deployment in Minikube."""
chart = chart or ctx.helm.chart
values = values or ctx.helm.values
utils.check_path(chart)
utils.check_path(values)
cmd = f"helm install {release} {chart} --values {values} "
cmd += f"--create-namespace --namespace {namespace} --kube-context {context}"
if dry_run:
cmd += " --dry-run --debug"
ctx.run(cmd)
@task
def push(ctx, chart=None, repo=None):
"""Push Helm chart to a remote registry."""
chart = chart or ctx.helm.chart
repo = repo or ctx.helm.repo
utils.check_path(chart)
ctx.run(f"helm dependency update {chart}")
ctx.run(f"helm cm-push {chart} {repo}")
ns = Collection("helm")
ns.configure(CONFIG)
ns.add_task(login)
ns.add_task(install)
ns.add_task(lint)
ns.add_task(test)
ns.add_task(push)
from invocations import docs as _docs, packaging
from invoke import Collection
# TODO: move this & paramiko's copy of same into Alabaster?
d = 'sites'
# Usage doc/API site (published as docs.paramiko.org)
docs_path = join(d, 'docs')
docs = Collection.from_module(_docs, name='docs', config={
'sphinx': {
'source': docs_path,
'target': join(docs_path, '_build')
}
})
# Main/about/changelog site ((www.)?paramiko.org)
www_path = join(d, 'www')
www = Collection.from_module(_docs, name='www', config={
'sphinx': {
'source': www_path,
'target': join(www_path, '_build')
}
})
ns = Collection(docs=docs, www=www, release=packaging)
run = exp.submit_local(
os.path.join(_BASE_PATH, "src"),
"resnet_main.py",
{
"--training_data_path": "/data/tfrecords/train",
"--validation_data_path": "/data/tfrecords/validation",
"--epochs": epochs,
"--data_type": "tfrecords",
"--data-format": "channels_first",
},
dependencies_file="TensorFlow_imagenet/environment_gpu.yml",
docker_args=["-v", f"{env_values['DATA']}:/data"],
wait_for_completion=True,
)
print(run)
remote_collection = Collection("remote")
remote_collection.add_task(submit_images, "images")
remote_collection.add_task(submit_tfrecords, "tfrecords")
remote_collection.add_task(submit_synthetic, "synthetic")
local_collection = Collection("local")
local_collection.add_task(submit_images_local, "images")
local_collection.add_task(submit_tfrecords_local, "tfrecords")
local_collection.add_task(submit_synthetic_local, "synthetic")
submit_collection = Collection("submit", local_collection, remote_collection)
namespace = Collection("tf_imagenet", submit_collection)
from . import test
from . import release
# -----------------------------------------------------------------------------
# TASKS:
# -----------------------------------------------------------------------------
# None
# -----------------------------------------------------------------------------
# TASK CONFIGURATION:
# -----------------------------------------------------------------------------
namespace = Collection()
# DISABLED: namespace.add_task(clean.clean)
# DISABLED: namespace.add_task(clean.clean_all)
namespace.add_collection(Collection.from_module(cleanup), name="cleanup")
namespace.add_collection(Collection.from_module(docs))
namespace.add_collection(Collection.from_module(test))
namespace.add_collection(Collection.from_module(release))
cleanup.cleanup_tasks.add_task(cleanup.clean_python)
cleanup.cleanup_tasks.add_task(cleanup.clean_python)
# -- INJECT: clean configuration into this namespace
namespace.configure(cleanup.namespace.configuration())
if sys.platform.startswith("win"):
# -- OVERRIDE SETTINGS: For platform=win32, ... (Windows)
from ._compat_shutil import which
run_settings = dict(echo=True, pty=False, shell=which("cmd"))
namespace.configure({"run": run_settings})
else:
Examples:
>>> is_truthy('yes')
True
Args:
arg (str): Truthy string (True values are y, yes, t, true, on and 1; false values are n, no,
f, false, off and 0. Raises ValueError if val is anything else.
"""
if isinstance(arg, bool):
return arg
return bool(strtobool(arg))
# Use pyinvoke configuration for default values, see http://docs.pyinvoke.org/en/stable/concepts/configuration.html
# Variables may be overwritten in invoke.yml or by the environment variables INVOKE_NAUTOBOT_xxx
namespace = Collection("nautobot")
namespace.configure({
"nautobot": {
"project_name":
"nautobot",
"python_ver":
"3.6",
"local":
False,
"compose_dir":
os.path.join(os.path.dirname(__file__), "development/"),
"compose_files": [
"docker-compose.yml",
"docker-compose.dev.yml",
],
"docker_image_names_main": [
from invoke import Collection import watch ns = Collection() ns.add_collection(Collection.from_module(watch))
# TASKS
# ---------------------------------------------------------------------------
# MAYBE: echo=False):
@task(help={
"args": "Command line args for behave",
"format": "Formatter to use",
})
def behave_test(ctx, args="", format=""): # pylint: disable=redefined-builtin
"""Run behave tests."""
format = format or ctx.behave_test.format
options = ctx.behave_test.options or ""
args = args or ctx.behave_test.args
behave = "{python} bin/behave".format(python=sys.executable)
ctx.run("{behave} -f {format} {options} {args}".format(
behave=behave, format=format, options=options, args=args), pty=USE_PTY)
# ---------------------------------------------------------------------------
# TASK MANAGEMENT / CONFIGURATION
# ---------------------------------------------------------------------------
# namespace.add_task(behave_test, default=True)
namespace = Collection()
namespace.add_task(behave_test, default=True)
namespace.configure({
"behave_test": {
"args": "",
"format": "progress2",
"options": "", # -- NOTE: Overide in configfile "invoke.yaml"
},
})
# ----------------------------------------------------------------------------- # IMPORTS: # ----------------------------------------------------------------------------- from invoke import Collection # -- TASK-LIBRARY: from . import clean from . import docs from . import test # ----------------------------------------------------------------------------- # TASKS: # ----------------------------------------------------------------------------- # None # ----------------------------------------------------------------------------- # TASK CONFIGURATION: # ----------------------------------------------------------------------------- namespace = Collection() namespace.add_task(clean.clean) namespace.add_task(clean.clean_all) namespace.add_task(test.behave, "behave_test") namespace.add_collection(Collection.from_module(docs)) namespace.add_collection(Collection.from_module(test)) # -- INJECT: clean configuration into this namespace namespace.configure(clean.namespace.configuration()) namespace.configure(test.namespace.configuration())
#!/usr/bin/env python from invoke import Collection from .pullrequests import PullRequestCollection from .repository import RepoCollection BitbucketCollection = Collection() BitbucketCollection.add_collection(PullRequestCollection, 'request') BitbucketCollection.add_collection(RepoCollection, 'repo')
