Given a 'manager' structure, add self to one or more of its 'buckets'.
979712
def add_to_manager(self, manager):
        
        # Derive version spec allowing us to filter against major/minor buckets
        spec = self.spec or self.default_spec(manager)
        # Only look in appropriate major version/family; if self is an issue
        # declared as living in e.g. >=2, this means we don't even bother
        # looking in the 1.x family.
        families = [Version(str(x)) for x in manager]
        versions = list(spec.filter(families))
        for version in versions:
            family = version.major
            # Within each family, we further limit which bugfix lines match up
            # to what self cares about (ignoring 'unreleased' until later)
            candidates = [
                Version(x)
                for x in manager[family]
                if not x.startswith('unreleased')
            ]
            # Select matching release lines (& stringify)
            buckets = []
            bugfix_buckets = [str(x) for x in spec.filter(candidates)]
            # Add back in unreleased_* as appropriate
            # TODO: probably leverage Issue subclasses for this eventually?
            if self.is_buglike:
                buckets.extend(bugfix_buckets)
                # Don't put into JUST unreleased_bugfix; it implies that this
                # major release/family hasn't actually seen any releases yet
                # and only exists for features to go into.
                if bugfix_buckets:
                    buckets.append('unreleased_bugfix')
            # Obtain list of minor releases to check for "haven't had ANY
            # releases yet" corner case, in which case ALL issues get thrown in
            # unreleased_feature for the first release to consume.
            # NOTE: assumes first release is a minor or major one,
            # but...really? why would your first release be a bugfix one??
            no_releases = not self.minor_releases(manager)
            if self.is_featurelike or self.backported or no_releases:
                buckets.append('unreleased_feature')
            # Now that we know which buckets are appropriate, add ourself to
            # all of them. TODO: or just...do it above...instead...
            for bucket in buckets:
                manager[family][bucket].append(self)
328327
def update_bucket_size(f):
    """"""
    @wraps(f)
    def inner(self, *args, **kwargs):
        res = f(self, *args, **kwargs)
        self.bucket.size += self.file.size
        return res
    return inner
253369
def add_to(self, container):
        '''
        
        '''
        if self.container:
            self.remove_from(self.container)
        container.add(self)
844202
def set_manager(self, manager):
        """"""
        self.manager = manager.deepcopy()
        for task in self:
            task.set_manager(manager)
234087
def add(self, quantity):
        
        newvalue = self._value + quantity
        self.set(newvalue.deg)
1160674
def _add_relations(self, relations):
        """"""
        for k, v in six.iteritems(relations):
            self.d.relate(k, v)
468035
private void addEntry(K key, V value) {
    EntryImpl<K, V> entry = _poolFirst;
    if (entry != null) {
      _poolFirst = entry._after;
      entry._after = null;
    } else { // Pool empty.
      entry = new EntryImpl<K, V>();
    }

    // Setup entry paramters.
    entry._key = key;
    entry._value = value;
    int index = keyHash(key) & _mask;
    entry._index = index;

    // Connects to bucket.
    EntryImpl<K, V> next = _entries[index];
    entry._next = next;
    if (next != null) {
      next._previous = entry;
    }
    _entries[index] = entry;

    // Connects to collection.
    if (_mapLast != null) {
      entry._before = _mapLast;
      _mapLast._after = entry;
    } else {
      _mapFirst = entry;
    }
    _mapLast = entry;

    // Updates size.
    _size++;
    sizeChanged();
  }
1250024
def add_child_to_self( self, tree ):
        '''  '''
        assert isinstance(tree, Tree), \
               '(!) Unexpected type of argument for '+argName+'! Should be Tree.'
        if (not self.children):
            self.children = []
        tree.parent = self
        self.children.append(tree)
555069
def add_dep(self, ):
        
        i = self.dep_tablev.currentIndex()
        item = i.internalPointer()
        if item:
            dep = item.internal_data()
            dep.projects.add(self._project)
            self.deps.append(dep)
            item.set_parent(None)
1132409
def push(self, dir):
        
        self.stack.append(os.getcwd())
        os.chdir(dir or os.getcwd())
137195
def put(self):
        
        return self.manager.put(
            id=self.id,
            name=self.name,
            description=self.description,
            command_to_run=self.command_to_run,
            environment_variables=self.environment_variables,
            required_arguments=self.required_arguments,
            required_arguments_default_values=(
                self.required_arguments_default_values
            ),
            logs_path=self.logs_path,
            results_path=self.results_path,
            container_image=self.container_image,
            container_type=self.container_type,
        )
681344
void addManagementGraph(final JobID jobID, final ManagementGraph managementGraph) {

		synchronized (this.recentManagementGraphs) {
			this.recentManagementGraphs.put(jobID, managementGraph);
		}
	}
1254817
def prepare_buckets(self):
        
        for mdl in self.registry.get_base_models():
            bucket = mdl(super_context).objects.adapter.bucket
            self.buckets[bucket.name] = bucket
544701
def create_bucket(self, name, headers=None):
        
        self.provider.swift_client.put_container(name, headers)
77077
def add(self):
        """"""

        yield self.client.create(self.path)
        yield self.client.create(self.path + "/type", self.name)
        yield self.client.create(self.path + "/state")
        yield self.client.create(self.path + "/machines", "[]")

        log.debug("registered service '%s' at %s." % (self.name, self.path))
131220
protected function addBagDataToSession()
	{
		foreach (array_merge($this->bags, array($this->metaBag)) as $bag)
		{
			$this->put($bag->getStorageKey(), $this->bagData[$bag->getStorageKey()]);
		}
	}
536829
def create(self, name):
    
    return Bucket(name, context=self._context).create(self._project_id)