Create a subgroup.

        Creates a new empty subgroup under the outcome group with the given title
        and description.
769754
def create_subgroup_global(self, id, title, description=None, vendor_guid=None):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - id
        """ID"""
        path["id"] = id

        # REQUIRED - title
        """The title of the new outcome group."""
        data["title"] = title

        # OPTIONAL - description
        """The description of the new outcome group."""
        if description is not None:
            data["description"] = description

        # OPTIONAL - vendor_guid
        """A custom GUID for the learning standard"""
        if vendor_guid is not None:
            data["vendor_guid"] = vendor_guid

        self.logger.debug("POST /api/v1/global/outcome_groups/{id}/subgroups with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("POST", "/api/v1/global/outcome_groups/{id}/subgroups".format(**path), data=data, params=params, single_item=True)
1031832
private static <PS, SEG, S> ToSemigroup<Paragraph<PS, SEG, S>, Summary> summaryProvider() {
        return new ToSemigroup<Paragraph<PS, SEG, S>, Summary>() {

            @Override
            public Summary apply(Paragraph<PS, SEG, S> p) {
                return new Summary(1, p.length());
            }

            @Override
            public Summary reduce(Summary left, Summary right) {
                return new Summary(
                        left.paragraphCount + right.paragraphCount,
                        left.charCount + right.charCount);
            }
        };

    }
673276
function createGroup() {

  var aGroup = {
    name: unique('Administrators')
  };

  return application.createGroup(aGroup, function(err, createdGroup) {
    if (err) throw err;
    group = createdGroup;

    return addAccountToGroup(); //next quickstart step
  });
}
1079980
def createGroup(self, group, vendorSpecific=None):
        
        response = self.createGroupResponse(group, vendorSpecific)
        return self._read_boolean_response(response)
645877
private void addGroup(List<Token> group, List<List<Token>> groups) {

    if(group.isEmpty()) return;

    // remove trailing tokens that should be ignored
    while(!group.isEmpty() && IGNORED_TRAILING_TOKENS.contains(
        group.get(group.size() - 1).getType())) {
      group.remove(group.size() - 1);
    }

    // if the group still has some tokens left, we'll add it to our list of groups
    if(!group.isEmpty()) {
      groups.add(group);
    }
  }
1052725
def group_membership_create(self, data, **kwargs):
        ""
        api_path = "/api/v2/group_memberships.json"
        return self.call(api_path, method="POST", data=data, **kwargs)
381411
public void createGroup(String name, boolean isPrivate) {
		LinkedMultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
		params.set("name",name);
		params.set("private", String.valueOf(isPrivate));
		restTemplate.postForEntity(buildUri("groups"), params, String.class);
	}
40971
@NotNull
    @ObjectiveCName("createGroupWithTitle:withAvatar:withUids:")
    public Promise<Integer> createGroup(String title, String avatarDescriptor, int[] uids) {
        return modules.getGroupsModule().createGroup(title, avatarDescriptor, uids);
    }
1077848
def add_subgroup(label, &proc)
      columns = ActiveScaffold::DataStructures::ActionColumns.new
      columns.label = label
      columns.action = action
      columns.configure(&proc)
      exclude columns.collect_columns
      add columns
    end
450299
public ApiResponse createGroup(String groupPath, String groupTitle, String groupName){
        Map<String, Object> data = new HashMap<String, Object>();
        data.put("type", "group");
        data.put("path", groupPath);
        
        if (groupTitle != null) {
            data.put("title", groupTitle);
        }
        
        if(groupName != null){
            data.put("name", groupName);
        }
        
        return apiRequest(HttpMethod.POST, null, data,  organizationId, applicationId, "groups");
    }
979047
def create_dataset(
            self, group, chunk_size, compression=None, compression_opts=None):
        """"""
        group.attrs['format'] = self.dformat
        super(Features, self)._create_dataset(
            group, chunk_size, compression, compression_opts)

        # TODO attribute declared outside __init__ is not safe. Used
        # because Labels.create_dataset need it.
        if chunk_size != 'auto':
            self.nb_per_chunk = nb_per_chunk(
                self.dtype.itemsize, self.dim, chunk_size)
        else:
            self.nb_per_chunk = 'auto'
675626
def new(self, grp_id, branch_id):
        
        new = copy.copy(self)
        new.orig = new
        new.src_group_id = grp_id
        new.source_id = branch_id
        new.idx_set = build_idx_set(branch_id, self.start_date)
        with h5py.File(self.source_file, "r") as hdf5:
            new.start = 0
            new.stop = len(hdf5[new.idx_set["mag"]])
        return new
1149698
def create_secgroup(self, name, description):
        
        return self.ec2.create_security_group(name, description)
        log.debug("... created group %s" % name)
1231299
def create
      @group = Group.new(group_params)

      respond_to do |format|
        if @group.save
          format.html { redirect_to @group, notice: 'Group was successfully created.' }
          format.json { render :show, status: :created, location: @group }
        else
          format.html { render :new }
          format.json { render json: @group.errors, status: :unprocessable_entity }
        end
      end
    end
738996
def createGroupResponse(self, group, vendorSpecific=None):
        
        mmp_dict = {'group': ('group.xml', group.toxml('utf-8'))}
        return self.POST('groups', fields=mmp_dict, headers=vendorSpecific)
948533
def add_group(id, description=None):
    

    if not description:
        description = id
    data = {
        'description': description
    }
    acl_url = urljoin(_acl_url(), 'groups/{}'.format(id))
    try:
        r = http.put(acl_url, json=data)
        assert r.status_code == 201
    except DCOSHTTPException as e:
        if e.response.status_code != 409:
            raise
289389
def create_group(groupname, gid, system=True):
    
    sudo(addgroup(groupname, gid, system))