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')
_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')