Creates a new project client.
@class Project client provides client-side API to handle projects based on given file client.
@name orion.projectClient.ProjectClient
180019
function ProjectClient(serviceRegistry, fileClient) {
		this.serviceRegistry = serviceRegistry;
		this.fileClient = fileClient;
		this.allProjectHandlersReferences = serviceRegistry.getServiceReferences("orion.project.handler"); //$NON-NLS-0$
		this.allProjectDeployReferences = serviceRegistry.getServiceReferences("orion.project.deploy"); //$NON-NLS-0$
		this._serviceRegistration = serviceRegistry.registerService("orion.project.client", this); //$NON-NLS-0$
		this._launchConfigurationsDir = "launchConfigurations"; //$NON-NLS-0$
	}
1166778
def create_project(self, key, name, description=""):
        
        url = 'rest/api/1.0/projects'
        data = {"key": key,
                "name": name,
                "description": description
                }
        return self.post(url, data=data)
27067
def create_client(self, config_path):
        
        config = ProjectConfig(config_path)
        editor = Editor(self._vim)
        launcher = EnsimeLauncher(self._vim, config)

        if self.using_server_v2:
            client = EnsimeClientV2(editor, launcher)
        else:
            client = EnsimeClientV1(editor, launcher)

        self._create_ticker()

        return client
473857
function createClient() {
	rpc.emit('createClient', 'test', {
		nick : 'simpleircbot',
		user : 'testuser',
		server : 'localhost',
		realname: 'realbot',
		port: 6667,
		secure: false,
		retryCount: 2,
		retryWait: 3000
	});
}
931282
def new
      @project = Project.find params[:project_id]
      @api = @project.apis.new
      @parameters = @api.parameters.build
      @api.success_responses.build
      @api.failure_responses.build
  
      respond_to do |format|
        format.html # new.html.erb
        format.json { render json: @api }
      end
    end
796841
def _create_project(config):
    """"""
    try:
        response = config.pbclient.create_project(config.project['name'],
                                                  config.project['short_name'],
                                                  config.project['description'])
        check_api_error(response)
        return ("Project: %s created!" % config.project['short_name'])
    except exceptions.ConnectionError:
        return("Connection Error! The server %s is not responding" % config.server)
    except (ProjectNotFound, TaskNotFound):
        raise
1050517
function RedisProjectDao(client) {
	this.client = client;
	this.prefix = "omega:";

	console.log('storing projects in: redis://' + this.client.host + ':' + this.client.port + '/' + this.prefix);
}
691563
def create_project(self, name, body=github.GithubObject.NotSet):
        
        assert isinstance(name, (str, unicode)), name
        assert body is github.GithubObject.NotSet or isinstance(body, (str, unicode)), body
        post_parameters = {
            "name": name,
            "body": body,
        }
        import_header = {"Accept": Consts.mediaTypeProjectsPreview}
        if body is not github.GithubObject.NotSet:
            post_parameters['body'] = body
        headers, data = self._requester.requestJsonAndCheck(
            "POST",
            self.url + "/projects",
            headers=import_header,
            input=post_parameters
        )
        return github.Project.Project(self._requester, headers, data, completed=True)
9669
def create_project(self, name, **kwargs):
        
        data = self._wrap_dict("project", kwargs)
        data["customer"]["name"] = name
        return self.post("/projects.json", data=data)
1374024
public Client newClient(String clientName, JaxRsFeatureGroup feature, JaxRsFeatureGroup... moreFeatures) {
        return newBuilder(clientName, feature, moreFeatures).build();
    }
260358
@Override
    public IRundeckProject createFrameworkProjectStrict(final String projectName, final Properties properties) {

        return createFrameworkProjectInt(projectName,properties,true);
    }
783769
def create(self):
        
        logger.info("creating snap7 client")
        self.library.Cli_Create.restype = c_void_p
        self.pointer = S7Object(self.library.Cli_Create())
170963
async function create(name, options, api, env) {
  // Grab the cwd and npmClient off of the environment. We can use these to
  // create the folder for the project and for determining what client to use
  // for npm-related commands
  const { CLI_ENV, cwd, npmClient } = env;
  // We support a couple of options for our `create` command, some only exist
  // during development (like link and linkCli).
  const { link, linkCli, plugins = [], presets = [], skip } = options;
  const root = path.join(cwd, name);

  logger.trace('Creating project:', name, 'at:', root);

  if (await fs.exists(root)) {
    throw new Error(`A folder already exists at \`${root}\``);
  }

  // Create the root directory for the new project
  await fs.ensureDir(root);

  const {
    writePackageJson,
    installDependencies,
    linkDependencies,
  } = await createClient(npmClient, root);
  const packageJson = {
    name,
    private: true,
    license: 'MIT',
    scripts: {},
    dependencies: {},
    devDependencies: {},
    toolkit: {},
  };

  // Write the packageJson to the newly created `root` folder
  await writePackageJson(packageJson);

  const installer = linkCli ? linkDependencies : installDependencies;
  await installer(['@carbon/toolkit']);

  if (CLI_ENV === 'production') {
    clearConsole();
  }

  if (skip) {
    displaySuccess(root, name, npmClient);
    return;
  }

  const toolkit = await which('toolkit', { cwd: root });

  if (presets.length > 0) {
    const args = ['add', ...presets, link && '--link'].filter(Boolean);
    await spawn(toolkit, args, {
      cwd: root,
      stdio: 'inherit',
    });
  }

  if (plugins.length > 0) {
    const args = ['add', ...plugins, link && '--link'].filter(Boolean);
    await spawn(toolkit, args, {
      cwd: root,
      stdio: 'inherit',
    });
  }

  displaySuccess(root, name, npmClient);
}
1355911
def make_client(host, project_name, api_key, create_project):
    
    if host is None:
        raise click.BadParameter('No grano server host is set', param=host)
    if project_name is None:
        raise click.BadParameter('No grano project slug is set',
                                 param=project_name)
    if api_key is None:
        raise click.BadParameter('No grano API key is set', param=api_key)

    client = Grano(api_host=host,
                   api_key=api_key)
    try:
        return client.get(project_name)
    except NotFound:
        if not create_project:
            sys.exit(-1)
        data = {'slug': project_name, 'label': project_name}
        return client.projects.create(data)
522999
function createApi(projectInfo, awsDetails, callback) {
    return appsyncCreate.run(projectInfo, awsDetails).then(()=>{
        if(callback){
            callback()
        }
    })
}
946522
def create_client_for_file(self, filename, is_cython=False):
        """"""
        # Create client
        self.create_new_client(filename=filename, is_cython=is_cython)

        # Don't increase the count of master clients
        self.master_clients -= 1

        # Rename client tab with filename
        client = self.get_current_client()
        client.allow_rename = False
        tab_text = self.disambiguate_fname(filename)
        self.rename_client_tab(client, tab_text)
182157
def instantiate_client(_unused_client, _unused_to_delete):
    """"""

    # [START client_create_default]
    from google.cloud import logging

    client = logging.Client()
    # [END client_create_default]

    credentials = object()
    # [START client_create_explicit]
    from google.cloud import logging

    client = logging.Client(project="my-project", credentials=credentials)