Create a group by given group parameter

        :param name: str
        :return: New group params
345724
def create_group(self, name):
        
        url = 'rest/api/2/group'
        data = {'name': name}

        return self.post(url, data=data)
612513
def group_list(**kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('group:list', **{
        'storage': ctx.repo.create_secure_service('storage'),
    })
955328
def create_groups(self, *names, **kwargs):
        """"""
        return tuple(self.create_group(name, **kwargs) for name in names)
1085689
def create_group(self, trigger):
        
        data = self._serialize_object(trigger)
        return Trigger(self._post(self._service_url(['triggers', 'groups']), data))
1081862
def create_group(self, **kwargs):
        
        response = self.__requester.request(
            'POST',
            'groups',
            _kwargs=combine_kwargs(**kwargs)
        )
        return Group(self.__requester, response.json())
831678
def cli(ctx, group_id, new_name):
    
    return ctx.gi.groups.update_group(group_id, new_name)
1267094
def create_group_groups(self, description=None, is_public=None, join_level=None, name=None, storage_quota_mb=None):
        
        path = {}
        data = {}
        params = {}

        # OPTIONAL - name
        """The name of the group"""
        if name is not None:
            data["name"] = name

        # OPTIONAL - description
        """A description of the group"""
        if description is not None:
            data["description"] = description

        # OPTIONAL - is_public
        """whether the group is public (applies only to community groups)"""
        if is_public is not None:
            data["is_public"] = is_public

        # OPTIONAL - join_level
        """no description"""
        if join_level is not None:
            self._validate_enum(join_level, ["parent_context_auto_join", "parent_context_request", "invitation_only"])
            data["join_level"] = join_level

        # OPTIONAL - storage_quota_mb
        """The allowed file storage for the group, in megabytes. This parameter is
        ignored if the caller does not have the manage_storage_quotas permission."""
        if storage_quota_mb is not None:
            data["storage_quota_mb"] = storage_quota_mb

        self.logger.debug("POST /api/v1/groups with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("POST", "/api/v1/groups".format(**path), data=data, params=params, single_item=True)
912765
def add_user_to_group(self, group_name, user_name):
        
        params = {'GroupName' : group_name,
                  'UserName' : user_name}
        return self.get_response('AddUserToGroup', params)
293081
def create_securitygroup(self, name=None, description=None):
        

        create_dict = {'name': name, 'description': description}
        return self.security_group.createObject(create_dict)
679900
def groups(self, group_type=None, filters=None, params=None):
        
        group = self._tcex.ti.group(group_type)
        for g in self.tc_requests.groups_from_tag(group, self.name, filters=filters, params=params):
            yield g
1077294
def _get_pgroup(name, array):
    ''''''
    pgroup = None
    for temp in array.list_pgroups():
        if temp['name'] == name:
            pgroup = temp
            break
    return pgroup
239263
private Composite getOrCreateGroup(Object parent, String name) {
		if (groups.containsKey(name)) {
			return groups.get(name);
		}
		Composite group = new Composite(name);
		mapWidget.getVectorContext().drawGroup(parent, group);
		groups.put(name, group);
		return group;
	}
1041966
def add_parameter_to_group(self, parameter, group_name):
        
        groups = self.metadata \
            .setdefault("AWS::CloudFormation::Interface", {}) \
            .setdefault("ParameterGroups", [])

        if isinstance(parameter, BaseAWSObject):
            parameter = parameter.title

        # Check if group_name already exists
        existing_group = None
        for group in groups:
            if group["Label"]["default"] == group_name:
                existing_group = group
                break

        if existing_group is None:
            existing_group = {
                "Label": {"default": group_name},
                "Parameters": [],
            }
            groups.append(existing_group)

        existing_group["Parameters"].append(parameter)

        return group_name
532644
public static BoxGroup.Info createGroup(BoxAPIConnection api, String name) {
        return createGroup(api, name, null, null, null, null, null);
    }
823937
public CreateGroupResponse createGroup(String name) {
        CreateGroupResponse response;
        BeanUtil.requireNonNull(name, "name is null");
        LOG.debug("创建分组.....");
        String url = BASE_API_URL + "cgi-bin/groups/create?access_token=#";
        Map<String, Object> param = new HashMap<String, Object>();
        Map<String, Object> group = new HashMap<String, Object>();
        group.put("name", name);
        param.put("group", group);
        BaseResponse r = executePost(url, JSONUtil.toJson(param));
        String resultJson = isSuccess(r.getErrcode()) ? r.getErrmsg() : r.toJsonString();
        response = JSONUtil.toBean(resultJson, CreateGroupResponse.class);
        return response;
    }
581984
def creategroup(self, name, path, **kwargs):
        
        data = {'name': name, 'path': path}

        if kwargs:
            data.update(kwargs)

        request = requests.post(
            self.groups_url, data=data, headers=self.headers,
            verify=self.verify_ssl, auth=self.auth, timeout=self.timeout)

        if request.status_code == 201:
            return request.json()
        else:
            msg = request.json()['message']
            raise exceptions.HttpError(msg)
1174492
@RequestMapping(value = "api/group", method = RequestMethod.POST)
    public
    @ResponseBody
    HashMap<String, Object> createNewGroup(Model model,
                                           @RequestParam(value = "name", required = true) String groupName) {
        logger.info("groupname={}", groupName);
        pathOverrideService.addGroup(groupName);
        return Utils.getJQGridJSON(pathOverrideService.findAllGroups(), "groups");
    }