code: def create_project(
      name: str,
      *,
      key: Optional[str] = None,
      workspace: Optional[str] = None,
      visibility: str = ProjectVisibility.PRIVATE,
      description: Optional[str] = None,
      api_token: Optional[str] = None,
  ) -> str:
      """Creates a new project in a Neptune workspace.
  
      Args:
          name: The name for the project in Neptune. Can contain letters and hyphens. For example, "classification".
              If you leave out the workspace argument, include the workspace name here,
              in the form "workspace-name/project-name". For example, "ml-team/classification".
          key: Project identifier. Must contain 1-10 upper case letters or numbers (at least one letter).
              For example, "CLS2". If you leave it out, Neptune generates a project key for you.
          workspace: Name of your Neptune workspace.
              If None, it will be parsed from the name argument.
          visibility: Level of privacy for the project. Options:
              - "pub": Public. Anyone on the internet can see it.
              - "priv": Private. Only users specifically assigned to the project can access it. Requires a plan with
                  project-level access control.
              - "workspace" (team workspaces only): Accessible to all workspace members.
              If None, it will be set to "priv".
          description: Project description.
              If None, it will be left empty.
          api_token: Account's API token.
              If None, the value of the NEPTUNE_API_TOKEN environment variable is used.
              Note: To keep your token secure, use the NEPTUNE_API_TOKEN environment variable rather than placing your
              API token in plain text in your source code.
  
      Returns:
          The name of the new project you created.
  
      Example:
          >>> from neptune import management
          >>> management.create_project(
          ...     workspace="ml-team",
          ...     name="classification",
          ...     key="CLS",
          ...     visibility="pub",
          ... )
          'ml-team/classification'
  
      You may also want to check the management API reference:
      https://docs.neptune.ai/api/management
      """
      verify_type("name", name, str)
      verify_type("key", key, (str, type(None)))
      verify_type("workspace", workspace, (str, type(None)))
      verify_type("visibility", visibility, str)
      verify_type("description", description, (str, type(None)))
      verify_type("api_token", api_token, (str, type(None)))
  
      backend_client = _get_backend_client(api_token=api_token)
      workspace, name = extract_project_and_workspace(
          name=name, workspace=workspace
      )
      project_qualified_name = f"{workspace}/{name}"
      workspace_id = _get_workspace_id(backend_client, workspace)
  
      params = {
          "projectToCreate": {
              "name": name,
              "description": description,
              "projectKey": key,
              "organizationId": workspace_id,
              "visibility": ProjectVisibilityDTO.from_str(
                  visibility
              ).value,
          },
          **DEFAULT_REQUEST_KWARGS,
      }
  
      project_response = _create_project(
          backend_client, project_qualified_name, params
      )
  
      return normalize_project_name(
          name=project_response.result.name,
          workspace=project_response.result.organizationName,
      )
  
imports: import os
  from typing import Dict, Iterable, List, Optional, Union
  from bravado.exception import HTTPBadRequest, HTTPConflict, HTTPForbidden, HTTPNotFound, HTTPUnprocessableEntity
  from neptune.common.backends.utils import with_api_exceptions_handler
  from neptune.common.envs import API_TOKEN_ENV_NAME
  from neptune.internal.backends.hosted_client import DEFAULT_REQUEST_KWARGS, create_backend_client, create_http_client_with_auth, create_leaderboard_client
  from neptune.internal.backends.swagger_client_wrapper import SwaggerClientWrapper
  from neptune.internal.backends.utils import parse_validation_errors, ssl_verify
  from neptune.internal.credentials import Credentials
  from neptune.internal.id_formats import QualifiedName
  from neptune.internal.utils import verify_collection_type, verify_type
  from neptune.internal.utils.iteration import get_batches
  from neptune.internal.utils.logger import logger
  from neptune.management.exceptions import AccessRevokedOnDeletion, AccessRevokedOnMemberRemoval, AccessRevokedOnServiceAccountRemoval, BadRequestException, ProjectAlreadyExists, ProjectNotFound, ServiceAccountAlreadyHasAccess, ServiceAccountNotExistsOrWithoutAccess, ServiceAccountNotFound, UserAlreadyHasAccess, UserAlreadyInvited, UserNotExistsOrWithoutAccess, WorkspaceNotFound, WorkspaceOrUserNotFound
  from neptune.management.internal.dto import ProjectMemberRoleDTO, ProjectVisibilityDTO, ServiceAccountDTO, WorkspaceMemberRoleDTO
  from neptune.management.internal.types import ProjectVisibility
  from neptune.management.internal.utils import WorkspaceMemberRole, extract_project_and_workspace, normalize_project_name
label_desc: Use image node_id 7 for calling a global function with example usage: create_project(name) and returns: normalize_project_name