create

Create command module.

create_project(project_name, description, repo_privacy, add_github, github_token, working_directory, home_path, github_org_name, template_repo_url, checkout, name, email, verify_config=True, no_kernel=False)

Create an SSB-project.

Parameters:

Name	Type	Description	Default
project_name	str	project name	required
description	str	project description	required
repo_privacy	RepoPrivacy	repository visibility setting	required
add_github	bool	Create a GitHub repository if true	required
github_token	str	GitHub PAT	required
working_directory	Path	Current working directory	required
home_path	Path	Home Path	required
github_org_name	str	Name of GitHub organization	required
template_repo_url	str	The Cookiecutter template URI.	required
checkout	str | None	The git reference to check against. Supports branches, tags and commit hashes.	required
name	str | None	The project author's name (optional).	required
email	str | None	The project author's email (optional).	required
verify_config	bool	Determines if gitconfig is verified.	True
no_kernel	bool	Determines if a kernel shall be generated or not.	False

Source code in ssb_project_cli/ssb_project/create/create.py

def create_project(  # noqa: C901
    project_name: str,
    description: str,
    repo_privacy: RepoPrivacy,
    add_github: bool,
    github_token: str,
    working_directory: Path,
    home_path: Path,
    github_org_name: str,
    template_repo_url: str,
    checkout: str | None,
    name: str | None,
    email: str | None,
    verify_config: bool = True,
    no_kernel: bool = False,
) -> None:
    """Create an SSB-project.

    Args:
        project_name: project name
        description: project description
        repo_privacy: repository visibility setting
        add_github:  Create a GitHub repository if true
        github_token: GitHub PAT
        working_directory: Current working directory
        home_path: Home Path
        github_org_name: Name of GitHub organization
        template_repo_url: The Cookiecutter template URI.
        checkout: The git reference to check against. Supports branches, tags and commit hashes.
        name: The project author's name (optional).
        email: The project author's email (optional).
        verify_config: Determines if gitconfig is verified.
        no_kernel: Determines if a kernel shall be generated or not.
    """
    is_memory_full()

    if not is_valid_project_name(project_name):
        print("Project name cannot contain uppercase letters.")
        exit(1)

    if not valid_repo_name(project_name):
        print(
            "Invalid repo name: Please choose a valid name. For example: 'my-fantastic-project'"
        )

        exit(1)

    if add_github and not github_token:
        github_token = choose_login(home_path)

    if add_github and not github_token:
        print("Needs GitHub token, please specify with --github-token")
        exit(1)

    if add_github and is_github_repo(github_token, project_name, github_org_name):
        print(
            f"A repo with the name {project_name} already exists on GitHub. Please choose another name."
        )
        exit(1)

    if add_github and description == "":
        description = request_project_description()

    project_directory = working_directory.joinpath(project_name)

    if project_directory.exists():
        print(
            "A project with name {!r} already exists. Please choose another name.".format(
                project_name
            )
        )
        exit(1)

    try:
        create_project_from_template(
            project_name,
            description,
            template_repo_url,
            checkout,
            working_directory,
            name=name,
            email=email,
        )
        build_project(
            project_directory,
            working_directory,
            template_repo_url,
            checkout,
            verify_config,
            no_kernel,
        )

        git_repo_dir = Path(working_directory.joinpath(project_name))
        if add_github:
            print("Creating an empty repo on Github")
            repo_url = create_github(
                github_token, project_name, repo_privacy, description, github_org_name
            )

            print("Creating a local repo, and pushing to Github")
            make_git_repo_and_push(github_token, repo_url, git_repo_dir)

            print("Setting branch protection rules")
            set_branch_protection_rules(github_token, project_name, github_org_name)

            print(f":white_check_mark:\tCreated Github repo. View it here: {repo_url}")
        else:
            make_and_init_git_repo(git_repo_dir)

        print(
            f":white_check_mark:\tCreated project ({project_name}) in the folder {project_directory}"
        )
        print(
            ":tada:\tAll done! Visit the Dapla manual to see how to use your project: https://manual.dapla.ssb.no/ssbproject.html"
        )
    except Exception as e:
        create_error_log(str(e), "create")
        delete_folder(project_directory)
    except (SystemExit, KeyboardInterrupt):
        delete_folder(project_directory)

delete_folder(folder)

Deletes directory if it exists.

Parameters:

Name	Type	Description	Default
folder	Path	Path of folder to delete	required

Source code in ssb_project_cli/ssb_project/create/create.py

def delete_folder(folder: Path) -> None:
    """Deletes directory if it exists.

    Args:
        folder: Path of folder to delete
    """
    if folder.is_dir():
        try:
            rmtree(folder)
        except shutil.Error as e:
            create_error_log(str(e), "delete_dir")

is_memory_full()

Checks whether used memory is greater than 95% and terminates the program if that is the case.

Source code in ssb_project_cli/ssb_project/create/create.py

def is_memory_full() -> None:
    """Checks whether used memory is greater than 95% and terminates the program if that is the case."""
    # get the memory usage information
    virtual_memory = psutil.virtual_memory()
    swap_memory = psutil.swap_memory()

    # calculate the percentage of virtual memory used
    if virtual_memory.total > 0:
        virtual_used_percent = virtual_memory.used / virtual_memory.total * 100

        # check if the percentage of used memory is greater than 95 percent
        if virtual_used_percent > 95:
            print(
                "Remaining free memory is less than 5%. Please free some memory (for example by terminating running programs) before continuing. Terminating."
            )
            exit(1)

    # calculate the percentage of swap memory used
    if swap_memory.total > 0:
        swap_used_percent = swap_memory.used / swap_memory.total * 100

        # check if the percentage of used memory is greater than 95 percent
        if swap_used_percent > 95:
            print(
                "Remaining free memory is less than 5%. Please free some memory (for example by terminating running programs) before continuing. Terminating."
            )
            exit(1)

    # Get the disk usage information for the partition hosting home directories
    if os.path.exists("/home/jovyan/"):
        home_dir = (
            "/home/jovyan/"
            if not running_onprem(JUPYTER_IMAGE_SPEC)
            else "/ssb/bruker/"
        )
        disk_usage = psutil.disk_usage(home_dir)

        # Calculate the percentage of used disk space
        disk_used_percent = disk_usage.used / disk_usage.total * 100

        # Check if the percentage of used disk space is greater than 95 percent
        if disk_used_percent > 95:
            print(
                "Remaining disk space is less than 5%. Please free some disk space before creating a new project. Terminating."
            )
            exit(1)

is_valid_project_name(project_name)

Checks if project name does not contain uppercase letters.

Source code in ssb_project_cli/ssb_project/create/create.py

def is_valid_project_name(project_name: str) -> bool:
    """Checks if project name does not contain uppercase letters."""
    return not any(char.isupper() for char in project_name)