Get tasks from registry by its tag

		:param registry_tag: any hash-able object
		:return: Return task (if :attr:`.WTaskRegistryStorage.__multiple_tasks_per_tag__` is not True) or \
		list of tasks
193808
def tasks_by_tag(self, registry_tag):
		
		if registry_tag not in self.__registry.keys():
			return None
		tasks = self.__registry[registry_tag]
		return tasks if self.__multiple_tasks_per_tag__ is True else tasks[0]
626844
def pull_tag_dict(data):
    
    # If there are tags, set them to a normal dict, vs. a list of dicts:
    tags = data.pop('Tags', {}) or {}
    if tags:
        proper_tags = {}
        for tag in tags:
            proper_tags[tag['Key']] = tag['Value']

        tags = proper_tags

    return tags
679039
def get_tasks(self, list_id, completed=False):
        '''  '''
        return tasks_endpoint.get_tasks(self, list_id, completed=completed)
792806
def check_existing_vr_tag(self):
        
        primary_images = get_primary_images(self.workflow)

        if not primary_images:
            return

        vr_image = None
        for image in primary_images:
            if '-' in image.tag:
                vr_image = image
                break
        if not vr_image:
            return

        should_fail = False
        for registry_name, registry in self.registries.items():
            pullspec = vr_image.copy()
            pullspec.registry = registry_name
            insecure = registry.get('insecure', False)
            secret = registry.get('secret', None)

            manifest_list = get_manifest_list(pullspec, registry_name, insecure, secret)

            if manifest_list:
                self.log.error("Primary tag already exists in registry: %s", pullspec)
                should_fail = True

        if should_fail:
            raise RuntimeError("Primary tag already exists in registry")
709579
def _get_tag(repo, name):
    '''
    
    '''
    try:
        return [x for x in _all_tags(repo) if x[0] == name][0]
    except IndexError:
        return False
1307464
def tags
      runner.tag_lists[decision_task.workflow_execution] ||= begin
        collision = 0
        begin
          decision_task.workflow_execution.tags
        rescue => e
          collision += 1 if collision < 10
          max_slot_delay = 2**collision - 1
          sleep(slot_time * rand(0 .. max_slot_delay))
          retry
        end
      end
    end
933741
def get_for_tag(self, tag):
        
        tag_filter = {'tag': tag}

        if isinstance(tag, six.integer_types):
            tag_filter = {'tag_id': tag}
        elif isinstance(tag, str):
            tag_filter = {'tag__slug': tag}

        return self.filter(id__in=[
            entry_tag.entry_id
            for entry_tag
            in EntryTag.objects.filter(**tag_filter)
        ])
868776
def list_tags(context, id):
    

    result = job.list_tags(context, id)
    utils.format_output(result, context.format)
101150
def plugin_info_by_tag(tag, opts={})
      matches = Fluent::Engine.root_agent.event_router.instance_variable_get(:@match_rules)
      matches.each { |rule|
        if rule.match?(tag)
          if rule.collector.is_a?(Fluent::Plugin::Output) || rule.collector.is_a?(Fluent::Output)
            return get_monitor_info(rule.collector, opts)
          end
        end
      }
      nil
    end
401823
def get_tags(model, trigger_id):
    
    # get the data of this trigger
    trigger = model.objects.get(trigger_id=trigger_id)

    tags = ''
    if trigger.tag:
        # is there several tag ?
        tags = ["#" + tag.strip() for tag in trigger.tag.split(',')]
        tags = str(','.join(tags)) if isinstance(tags, list) else tags
        tags = ' ' + tags
    return tags
304813
def add_tag(self, task, params={}, **options): 
        
        path = "/tasks/%s/addTag" % (task)
        return self.client.post(path, params, **options)
632595
def tag_helper(tag, items, locked=True, remove=False):
    
    if not isinstance(items, list):
        items = [items]
    data = {}
    if not remove:
        for i, item in enumerate(items):
            tagname = '%s[%s].tag.tag' % (tag, i)
            data[tagname] = item
    if remove:
        tagname = '%s[].tag.tag-' % tag
        data[tagname] = ','.join(items)
    data['%s.locked' % tag] = 1 if locked else 0
    return data
247649
def query_tags(tags, hrefs=nil, timeout=120)
      cmd = { :name => :query_tags, :tags => tags }
      cmd[:hrefs] = hrefs unless hrefs.nil? || hrefs.empty?
      response = blocking_request(cmd, timeout)
      begin
        result = OperationResult.from_results(load(response, "Unexpected response #{response.inspect}"))
        raise TagError.new("Query tags failed: #{result.content}") unless result.success?
        return result.content
      rescue
        raise TagError.new("Query tags failed: #{response.inspect}")
      end
    end
298411
def remove_tag_and_push_registries(tag_and_push_registries, version):
        
        registries = [uri
                      for uri, regdict in tag_and_push_registries.items()
                      if regdict['version'] == version]
        for registry in registries:
            logger.info("removing %s registry: %s", version, registry)
            del tag_and_push_registries[registry]
36518
public CollectionRequest<Task> getTasksWithTag(String tag) {
    
        String path = String.format("/tags/%s/tasks", tag);
        return new CollectionRequest<Task>(this, Task.class, path, "GET");
    }
279937
def gather_registries() -> Tuple[Dict, Mapping, Mapping]:
    
    id2devices = copy.copy(_id2devices)
    registry = copy.copy(_registry)
    selection = copy.copy(_selection)
    dict_ = globals()
    dict_['_id2devices'] = {}
    dict_['_registry'] = {Node: {}, Element: {}}
    dict_['_selection'] = {Node: {}, Element: {}}
    return id2devices, registry, selection
774214
def get_all_tags_of_invoice(self, invoice_id):
        
        return self._iterate_through_pages(
            get_function=self.get_tags_of_invoice_per_page,
            resource=INVOICE_TAGS,
            **{'invoice_id': invoice_id}
        )