def run(self, args):
extra_data = self.parse_data(args.data)
repo = api.get_repo(args.repo)
requires = api.get_active_modules()
if not requires:
core.echo("Activate some modules before you save an Environment.")
return
if args.no_versions:
requires = [m.name for m in requires]
else:
requires = [m.qual_name for m in requires]
data = {
"name": args.name,
"requires": requires,
}
data.update(extra_data)
repo.save_environment(
name=data["name"],
data=data,
force=args.force,
)
def run(self, args):
filters = self.parse_filters(args.filters)
core.echo()
found_environments = False
for repo in api.get_repos():
environments = repo.list_environments(filters)
env_names = sorted([env.name for env in environments])
if env_names:
found_environments = True
if repo.name != repo.path:
header = repo.name + " - " + repo.path
else:
header = repo.name
core.echo(core.format_columns(
header,
env_names,
indent=" ",
))
core.echo()
if not found_environments:
core.echo("No Environments are were found.")
core.echo('Use "cpenv env save <name>" to save an Environment.')
def run(self, args):
core.echo()
core.echo(
core.format_section(
"Version Info",
[
("name", cpenv.__name__),
("version", cpenv.__version__),
("url", cpenv.__url__),
("package", paths.parent(cpenv.__file__)),
("path", api.get_module_paths()),
],
))
core.echo()
# List package versions
dependencies = []
try:
import Qt
dependencies.extend([
("Qt.py", Qt.__version__),
("Qt Binding", Qt.__binding__ + "-" + Qt.__binding_version__),
])
except ImportError:
pass
if not dependencies:
return
core.echo(core.format_section("Dependencies", dependencies),
end="\n\n")
def start_progress(self, label, max_size, data):
if "download" in label.lower():
spec = data["module_spec"]
core.echo(" Downloading %s from %s..." %
(spec.qual_name, spec.repo.name))
desc = spec.real_name
elif "upload" in label.lower():
module = data["module"]
to_repo = data["to_repo"]
core.echo(" Uploading %s to %s..." %
(module.qual_name, to_repo.name))
desc = module.real_name
else:
desc = label
style = self.get_bar_style(desc, max_size, data.get("unit", None))
self._bars[label] = tqdm.tqdm(**style)
def run(self, args):
core.echo()
core.echo("Repos in order of resolution:")
for i, repo in enumerate(api.get_repos()):
if repo.path == repo.name:
core.echo(" [{}] {} {}".format(
i,
type(repo).__name__,
repo.path,
))
else:
core.echo(" [{}] {} {} {}".format(
i,
type(repo).__name__,
repo.name,
repo.path,
))
def run(self, args):
core.echo()
if args.env:
return self.run_env(args.module_or_environment)
try:
module_spec = api.resolve([args.module_or_environment])[0]
except ResolveError:
sys.exit(1)
if not isinstance(module_spec.repo, repos.LocalRepo):
core.echo("%s - %s" % (module_spec.qual_name, module_spec.path))
core.echo("Error: Can only edit modules in local repositories.")
sys.exit(1)
editor = os.getenv("CPENV_EDITOR", os.getenv("EDITOR", "subl"))
core.echo("Opening %s in %s." % (module_spec.path, editor))
shell.run(editor, module_spec.path)
def run(self, args):
core.echo()
if args.from_repo:
from_repo = api.get_repo(args.from_repo)
else:
from_repo = core.prompt_for_repo(
api.get_repos(),
"Download from",
default_repo_name="home",
)
if args.to_repo:
to_repo = api.get_repo(args.to_repo)
else:
repos = api.get_repos()
repos.remove(from_repo)
to_repo = core.prompt_for_repo(
repos,
"Upload to",
default_repo_name="home",
)
resolver = Resolver([from_repo])
module_specs = resolver.resolve(args.modules)
core.echo()
choice = core.prompt("Copy these modules to %s?[y/n] " % to_repo.name)
if choice.lower() not in ["y", "yes", "yup"]:
core.echo("Aborted.")
core.exit(1)
core.echo()
copier = Copier(to_repo)
copier.copy(module_specs, args.overwrite)
def run(self, args):
core.echo()
if args.to_repo:
to_repo = api.get_repo(name=args.to_repo)
else:
repos = [r for r in api.get_repos() if isinstance(r, LocalRepo)]
to_repo = core.prompt_for_repo(
repos,
"Choose a repo to localize to",
default_repo_name="home",
)
# Resolve modules
try:
resolved = api.resolve(args.modules)
except ResolveError:
core.exit(1)
# Localize modules from remote repos
remote_modules = [
spec for spec in resolved if not isinstance(spec.repo, LocalRepo)
]
if not len(remote_modules):
core.echo("All modules are already local...")
core.exit()
try:
localizer = Localizer(to_repo)
localizer.localize(
remote_modules,
overwrite=args.overwrite,
)
except Exception as e:
core.echo("Error: " + str(e))
core.exit(1)
def run_env(self, environment):
file = None
repo = False
found_in_remote = False
for repo in api.get_repos():
for env in repo.list_environments():
if env.name == environment:
if isinstance(repo, repos.LocalRepo):
file = env.path
break
else:
repo = repo
found_in_remote = True
if file:
break
if found_in_remote:
core.echo("Error: Can only edit Environments in local repos.")
core.echo("Found %s in repo %s" % (environment, repo.name))
sys.exit(1)
editor = os.getenv("CPENV_EDITOR", os.getenv("EDITOR", "subl"))
core.echo("Opening %s in %s." % (file, editor))
shell.run(editor, file)
def end_localize(self, modules):
core.echo()
def start_localize(self, module_specs):
for spec in module_specs:
if not isinstance(spec.repo, repos.LocalRepo):
core.echo("- Localizing modules...")
core.echo()
return
def end_resolve(self, resolved, unresolved):
core.echo()
if unresolved:
core.echo("Error: Failed to resolve %s" % ", ".join(unresolved))
def run(self, args):
core.echo()
if args.name in ["home", "user", "cwd"]:
core.echo("Error: Can not remove %s repo." % args.name)
repo_config = api.read_config("repos", {})
if args.name not in repo_config:
core.echo("Error: Repo named %s not found." % args.name)
core.exit(1)
core.echo("- Removing repo from config...", end="")
repo_config.pop(args.name)
api.write_config("repos", repo_config)
core.echo("OK!")
core.echo()
def _get_key(self, obj, key):
try:
return eval("obj." + key)
except Exception as e:
core.echo("Error: %s" % e)
sys.exit(1)
def run(self, args):
where = paths.normalize(args.where)
if os.path.isdir(where):
core.echo()
core.echo("Error: Can not create module in existing directory.")
core.exit(1)
default_name, default_version = parse_module_path(where)
core.echo()
core.echo("This command will guide you through creating a new module.")
core.echo()
name = core.prompt(" Module Name [%s]: " % default_name)
version = core.prompt(" Version [%s]: " % default_version.string)
description = core.prompt(" Description []: ")
author = core.prompt(" Author []: ")
email = core.prompt(" Email []: ")
core.echo()
core.echo("- Creating your new Module...", end="")
module = api.create(
where=where,
name=name or default_name,
version=version or default_version.string,
description=description,
author=author,
email=email,
)
core.echo("OK!")
core.echo()
core.echo(" " + module.path)
core.echo()
core.echo("Steps you might take before publishing...")
core.echo()
core.echo(" - Include binaries your module depends on")
core.echo(" - Edit the module.yml file")
core.echo(" - Add variables to the environment section")
core.echo(" - Add other modules to the requires section")
core.echo(" - Add python hooks like post_activate")
core.echo()
def run(self, args):
core.echo()
# Get repo
if args.to_repo:
to_repo = api.get_repo(name=args.to_repo)
else:
to_repo = core.prompt_for_repo(
api.get_repos(),
"Choose a repo to publish to",
default_repo_name="home",
)
# Resolve module
resolver = Resolver(api.get_repos())
module_spec = resolver.resolve([args.module])[0]
core.echo()
# Confirm publication
choice = core.prompt("Publish module to %s?[y/n] " % to_repo.name)
if choice.lower() not in ["y", "yes", "yup"]:
core.echo("Aborted.")
sys.exit(1)
# Publish
module = Module(module_spec.path)
published = to_repo.upload(module, args.overwrite)
core.echo()
core.echo("Activate your module:")
core.echo(" cpenv activate %s" % published.real_name)
core.echo()
def run(self, args):
core.echo()
if args.env:
try:
api.activate_environment(args.modules[0])
except ResolveError as e:
core.echo(str(e))
core.exit(1)
else:
try:
api.activate(args.modules)
except ResolveError:
api.activate_environment(args.modules[0])
except ResolveError:
core.exit(1)
core.echo("- Launching subshell...")
core.echo()
core.echo(' Type "exit" to deactivate.')
core.echo()
shell.launch("[*]")
def run(self, args):
name = args.name
from_repo = api.get_repo(name=args.from_repo)
core.echo()
core.echo("- Removing Environment from %s..." % from_repo.name)
core.echo()
env_removed = False
for env in from_repo.list_environments():
if env.name == name:
env_removed = True
from_repo.remove_environment(env.name)
if env_removed:
core.echo("Successfully removed %s." % name)
else:
core.echo('Could not find Environment "%s".' % name)
core.echo()
def run(self, args):
found_modules = False
core.echo()
active_modules = api.get_active_modules()
if args.requirement:
active_modules = [
m for m in active_modules
if is_partial_match(args.requirement, m)
]
if active_modules:
found_modules = True
core.echo(
core.format_columns(
"[*] Active",
[m.real_name for m in sort_modules(active_modules)],
))
core.echo()
repos = api.get_repos()
if args.repo:
repos = [api.get_repo(args.repo)]
for repo in repos:
if args.requirement:
repo_modules = repo.find(args.requirement)
else:
repo_modules = repo.list()
module_names = []
for module in sort_modules(repo_modules):
if module in active_modules:
module_names.append("* " + module.real_name)
else:
module_names.append(" " + module.real_name)
if module_names:
found_modules = True
if repo.name != repo.path:
header = repo.name + " - " + repo.path
else:
header = repo.name
core.echo(
core.format_columns(
"[ ] " + header,
module_names,
indent=" ",
))
core.echo()
if not found_modules:
core.echo("No modules are available.")
def run(self, args):
core.echo()
if args.from_repo:
from_repo = api.get_repo(name=args.from_repo)
else:
from_repo = core.prompt_for_repo(
api.get_repos(),
"Choose a repo to remove module from",
default_repo_name="home",
)
core.echo("- Finding modules in %s..." % from_repo.name)
core.echo()
modules_to_remove = []
for requirement in args.modules:
module = best_match(requirement, from_repo.find(requirement))
if not module:
core.echo("Error: %s not found..." % requirement)
core.exit(1)
core.echo(" %s - %s" % (module.real_name, module.path))
modules_to_remove.append(module)
core.echo()
choice = core.prompt("Delete these modules?[y/n] ")
if choice.lower() not in ["y", "yes", "yup"]:
core.echo("Aborted.")
core.exit(1)
core.echo()
core.echo("- Removing modules...")
core.echo()
for module in modules_to_remove:
core.echo(" " + module.real_name)
api.remove(module, from_repo)
core.echo()
core.echo("Successfully removed modules.")
core.echo()
def run(self, args):
if args.home:
core.echo(api.get_home_path())
return
if args.cache:
core.echo(api.get_cache_path())
return
# Key mode - print a key's value of a module or repo.
if args.key:
reporter.set_reporter(reporter.Reporter())
if args.repo:
objects = []
for repo_name in args.modules:
repo = api.get_repo(repo_name)
if repo is None:
core.echo("Could not find repo %s" % repo_name)
sys.exit(1)
objects.append(repo)
else:
try:
objects = api.resolve(args.modules)
except ResolveError:
sys.exit(1)
value = self._get_key(objects[0], args.key)
core.echo(value)
return
# Normal mode - resolve repos or modules and show info.
core.echo()
if args.repo:
repos = []
for repo_name in args.modules:
repo = api.get_repo(repo_name)
if repo is None:
core.echo("Could not find repo %s" % repo_name)
sys.exit(1)
repos.append(repo)
for repo in repos:
core.echo(
core.format_section(
repo.name,
[
("name", repo.name),
("path", repo.path),
("type", str(type(repo))),
("type_name", repo.type_name),
],
)
)
core.echo()
return
else:
try:
module_specs = api.resolve(args.modules)
except ResolveError:
sys.exit(1)
core.echo()
for spec in module_specs:
core.echo(
core.format_section(
spec.qual_name,
[(k, str(v)) for k, v in sorted(spec._asdict().items())],
)
)
core.echo()
return
def run(self, args):
config_path = api.get_config_path()
editor = os.getenv("CPENV_EDITOR", os.getenv("EDITOR", "subl"))
core.echo("Opening %s in %s." % (config_path, editor))
shell.run(editor, config_path)
def start_resolve(self, requirements):
core.echo("- Resolving requirements...")
core.echo()
def resolve_requirement(self, requirement, module_spec):
core.echo(" %s - %s" % (module_spec.real_name, module_spec.path))
def run(self, args):
try:
if not args.from_repo:
module_spec = api.resolve([args.module])[0]
else:
from_repo = api.get_repo(args.from_repo)
module_spec = from_repo.find(args.module)[0]
except Exception:
core.echo()
core.echo("Error: Failed to resolve " + args.module)
core.exit(1)
where = paths.normalize(args.where or ".", module_spec.real_name)
if os.path.isdir(where):
core.echo("Error: Directory already exists - " + where)
core.exit(1)
core.echo("- Cloning %s..." % module_spec.real_name)
core.echo()
try:
module = module_spec.repo.download(
module_spec,
where=where,
overwrite=args.overwrite,
)
except Exception as e:
core.echo()
core.echo("Error: " + str(e))
core.exit(1)
core.echo()
core.echo("Navigate to the following folder to make changes:")
core.echo(" " + module.path)
core.echo()
core.echo("Use one of the following commands to publish your changes:")
core.echo(" cpenv publish .")
core.echo(' cpenv publish . --to_repo="repo_name"')
def run(self, args):
# Parse type_args or args that are specific to a given Repo type
repo_kwargs = self.parse_type_args(args.type_args)
repo_type = repo_kwargs.pop("type", args.type)
core.echo()
if repo_type not in repos.registry:
core.echo("Error: %s is not a registered repo type." % args.type)
core.echo("Choose from: " + ", ".join(repos.registry.keys()))
core.exit(1)
if api.get_repo(args.name):
core.echo("Error: Repo named %s already exists." % args.name)
core.exit(1)
repo_cls = repos.registry[repo_type]
repo_kwargs["name"] = args.name
repo_kwargs["priority"] = args.priority
core.echo("- Checking %s args..." % repo_cls.__name__, end="")
try:
repo_cls(**repo_kwargs)
except Exception as e:
core.echo("OOPS!")
core.echo()
core.echo("Error: Failed to initialize %s" % repo_cls.__name__)
core.echo(str(e))
core.exit(1)
core.echo("OK!")
core.echo()
core.echo("- Adding repo to config...", end="")
repo_kwargs["type"] = repo_type
repo_config = api.read_config("repos", {})
repo_config[args.name] = repo_kwargs
api.write_config("repos", repo_config)
core.echo("OK!")
core.echo()