Creates a new analysis group with unique settings for plotting/tabulating etc.
        or switches the active group to the specified name.
978906
def do_group(self, arg):
        
        from copy import deepcopy
        vals = arg.split()
        if len(vals) == 0 or vals[0] not in ["list", "duplicate", "add", "switch", "remove"]:
            self.help_group()
            return

        if vals[0] == "add":
            if vals[1] not in self.args[self.active]:
                self.args[self.active][vals[1]] = self._template_args.copy()
                msg.okay("Created analysis group '{}'.".format(vals[1]))
                self.do_group("switch {}".format(vals[1]))
            else:
                msg.info("Group '{}' already exists. Switching to it.".format(vals[1]))
                self.do_group("switch {}".format(vals[1]))
        elif vals[0] == "switch":
            if vals[1] in self.args[self.active]:
                self.group = vals[1]
                self._set_def_prompt()
            else:
                msg.warn("The group '{}' does not exist.".format(vals[1]))
        elif vals[0] == "duplicate" and len(vals) == 3 and vals[1] in self.args[self.active]:
            self.args[self.active][vals[2]] = deepcopy(self.args[self.active][vals[1]])
            msg.okay("Duplicated analysis group '{}' into '{}'.".format(vals[1], vals[2]))
            self.do_group("switch {}".format(vals[2]))
        elif vals[0] == "list":
            for key in self.args[self.active]:
                msg.info(key)
        elif vals[0] == "remove" and vals[1] in self.args[self.active]:
            del self.args[self.active][vals[1]]
            self.do_group("list")
1201598
def add(name, **kwargs):
    '''
    
    '''
    if not info(name):
        comp_obj = _get_computer_object()
        try:
            new_group = comp_obj.Create('group', name)
            new_group.SetInfo()
            log.info('Successfully created group %s', name)
        except pywintypes.com_error as exc:
            msg = 'Failed to create group {0}. {1}'.format(
                name, win32api.FormatMessage(exc.excepinfo[5]))
            log.error(msg)
            return False
    else:
        log.warning('The group %s already exists.', name)
        return False
    return True
459098
def create_record_set_group(self, name, g_dict):
        """"""
        rs = route53.RecordSetGroup.from_dict(name, g_dict)
        rs = add_hosted_zone_id_if_missing(rs, self.hosted_zone_id)
        rs = self.add_hosted_zone_id_for_alias_target_if_missing(rs)
        return self.template.add_resource(rs)
185887
private void initPatternButtonGroup() {

        m_groupPattern = new CmsRadioButtonGroup();
        m_patternButtons = new HashMap<>();

        createAndAddButton(PatternType.DAILY, Messages.GUI_SERIALDATE_TYPE_DAILY_0);
        m_patternButtons.put(PatternType.NONE, m_patternButtons.get(PatternType.DAILY));
        createAndAddButton(PatternType.WEEKLY, Messages.GUI_SERIALDATE_TYPE_WEEKLY_0);
        createAndAddButton(PatternType.MONTHLY, Messages.GUI_SERIALDATE_TYPE_MONTHLY_0);
        createAndAddButton(PatternType.YEARLY, Messages.GUI_SERIALDATE_TYPE_YEARLY_0);
        // createAndAddButton(PatternType.INDIVIDUAL, Messages.GUI_SERIALDATE_TYPE_INDIVIDUAL_0);

        m_groupPattern.addValueChangeHandler(new ValueChangeHandler<String>() {

            public void onValueChange(ValueChangeEvent<String> event) {

                if (handleChange()) {
                    String value = event.getValue();
                    if (value != null) {
                        m_controller.setPattern(value);
                    }
                }
            }
        });

    }
634145
def rename(self, **kwargs):
        ''''''
        for old, new in kwargs.iteritems():
            if old in self.groups:
                self.groups[new] = self.groups[old]
                del self.groups[old]
330894
def add_new_header_groups(self, groups):
        
        already_present = []
        for group in groups:
            col_names = self.dm[self.dm['group'] == group].index
            for col in col_names:
                if col not in self.grid.col_labels:
                    col_number = self.grid.add_col(col)
                    # add to appropriate headers list
                    # add drop down menus for user-added column
                    if col in self.contribution.vocab.vocabularies:
                        self.drop_down_menu.add_drop_down(col_number, col)
                    elif col in self.contribution.vocab.suggested:
                        self.drop_down_menu.add_drop_down(col_number, col)
                    elif col in ['specimen', 'sample', 'site', 'location',
                                 'specimens', 'samples', 'sites']:
                        self.drop_down_menu.add_drop_down(col_number, col)
                    elif col == 'experiments':
                        self.drop_down_menu.add_drop_down(col_number, col)
                    if col == "method_codes":
                        self.drop_down_menu.add_method_drop_down(col_number, col)
                else:
                    already_present.append(col)
        return already_present
289389
def create_group(groupname, gid, system=True):
    
    sudo(addgroup(groupname, gid, system))
244416
def CreateGroup(self, GroupName):
        
        groups = self.CustomGroups
        self._DoCommand('CREATE GROUP %s' % tounicode(GroupName))
        for g in self.CustomGroups:
            if g not in groups and g.DisplayName == GroupName:
                return g
        raise SkypeError(0, 'Group creating failed')
1245084
function Group(options) {
    this.name = options.name
    this.axis = options.axis
    this.id = this.name + '-' + this.axis
    this.waypoints = []
    this.clearTriggerQueues()
    groups[this.axis][this.name] = this
  }
392698
def groups_rename(self, room_id, name, **kwargs):
        """"""
        return self.__call_api_post('groups.rename', roomId=room_id, name=name, kwargs=kwargs)
862551
def group_create(self, data, **kwargs):
        ""
        api_path = "/api/v2/groups.json"
        return self.call(api_path, method="POST", data=data, **kwargs)
292116
function (group) {
            var options = this.options,
              formatOption = options.format,
              str = formatOption ?
                format(formatOption, this) :
                options.formatter.call(this);  // format the text in the label

            // Change the text to reflect the new total and set visibility to hidden in case the serie is hidden
            if (this.label) {
                this.label.attr({text: str, visibility: HIDDEN});
                // Create new label
            } else {
                this.label =
                  this.axis.chart.renderer.text(str, null, null, options.useHTML)		// dummy positions, actual position updated with setOffset method in columnseries
                    .css(options.style)				// apply style
                    .attr({
                        align: this.textAlign,				// fix the text-anchor
                        rotation: options.rotation,	// rotation
                        visibility: HIDDEN					// hidden until setOffset is called
                    })
                    .add(group);							// add to the labels-group
            }
        }
1086980
def create_group(self, name):
        
        self.project_service.set_auth(self._token_project)
        return self.project_service.create_group(name)
694799
function() {
		this._groups = [];
		var group_labels = this.timescale.getGroupLabels();

		if (group_labels) {
			this.options.has_groups = true;
			for (var i = 0; i < group_labels.length; i++) {
				this._createGroup(group_labels[i]);
			}
		}

	}
55798
def group_create(auth=None, **kwargs):
    '''
    
    '''
    cloud = get_operator_cloud(auth)
    kwargs = _clean_kwargs(keep_name=True, **kwargs)
    return cloud.create_group(**kwargs)
521013
def _set_group_selection(self):
        
        grp = self.grouper
        if not (self.as_index and
                getattr(grp, 'groupings', None) is not None and
                self.obj.ndim > 1 and
                self._group_selection is None):
            return

        ax = self.obj._info_axis
        groupers = [g.name for g in grp.groupings
                    if g.level is None and g.in_axis]

        if len(groupers):
            # GH12839 clear selected obj cache when group selection changes
            self._group_selection = ax.difference(Index(groupers),
                                                  sort=False).tolist()
            self._reset_cache('_selected_obj')
208797
function buildContainerGroups() {
            let container = svg
                .append('g')
                  .classed('container-group', true)
                  .attr('transform', `translate(${margin.left}, ${margin.top})`);

            container
                .append('g').classed('grid-lines-group', true);
            container
                .append('g').classed('chart-group', true);
            container
                .append('g').classed('axis-group', true);
            container
                .append('g').classed('metadata-group', true);

            if (hasTitle()) {
                container.selectAll('.chart-group')
                  .attr('transform', `translate(${legendSpacing}, 0)`);
            }
        }