Public: Retrieves a list of available signing groups
557001
def get_signing_groups
      uri = build_uri("/accounts/#{@acct_id}/signing_groups")

      http = initialize_net_http_ssl(uri)
      request = Net::HTTP::Get.new(uri.request_uri, headers({ 'Content-Type' => 'application/json' }))
      JSON.parse(http.request(request).body)
    end
961085
def group_list():
    '''
    
    '''
    ret = {'installed': [],
           'available': [],
           'installed environments': [],
           'available environments': [],
           'available languages': {}}

    section_map = {
        'installed groups:': 'installed',
        'available groups:': 'available',
        'installed environment groups:': 'installed environments',
        'available environment groups:': 'available environments',
        'available language groups:': 'available languages',
    }

    out = __salt__['cmd.run_stdout'](
        [_yum(), 'grouplist', 'hidden'],
        output_loglevel='trace',
        python_shell=False
    )
    key = None
    for line in salt.utils.itertools.split(out, '\n'):
        line_lc = line.lower()
        if line_lc == 'done':
            break

        section_lookup = section_map.get(line_lc)
        if section_lookup is not None and section_lookup != key:
            key = section_lookup
            continue

        # Ignore any administrative comments (plugin info, repo info, etc.)
        if key is None:
            continue

        line = line.strip()
        if key != 'available languages':
            ret[key].append(line)
        else:
            match = re.match(r'(.+) \[(.+)\]', line)
            if match:
                name, lang = match.groups()
                ret[key][line] = {'name': name, 'language': lang}
    return ret
1011810
def get_groups(self, username):
        
        groups = []
        for group in grp.getgrall():
            if username in group.gr_mem:
                groups.append(group.gr_name)

        return groups
136719
def get_committed_signatures(vcs):
    
    committed_path = _get_committed_history_path(vcs)
    known_signatures = []
    if os.path.exists(committed_path):
        with open(committed_path, 'r') as f:
            known_signatures = f.read().split()
    return known_signatures
768709
def group_list(self, params=None):
        ''' 
        '''
        params = params if params else dict()
        return self.request('/v1/firewall/group_list', params, 'GET')
1341502
def get_members_of_group(self, gname):
        
        hostgroup = self.find_by_name(gname)
        if hostgroup:
            return hostgroup.get_hosts()
        return []
1087095
def _api_group_for_type(cls):
    
    _groups = {
        (u"v1beta1", u"Deployment"): u"extensions",
        (u"v1beta1", u"DeploymentList"): u"extensions",
        (u"v1beta1", u"ReplicaSet"): u"extensions",
        (u"v1beta1", u"ReplicaSetList"): u"extensions",
    }
    key = (
        cls.apiVersion,
        cls.__name__.rsplit(u".")[-1],
    )
    group = _groups.get(key, None)
    return group
1223307
def list_security_groups(self, retrieve_all=True, **_params):
        """"""
        return self.list('security_groups', self.security_groups_path,
                         retrieve_all, **_params)
248181
def list_sig_ok(self, signature: str):
        
        list_filename = self.get_list_filename(signature)
        if list_filename not in self.name_cache:
            return False
        for _object_name, sig in Cache.iterate_objects(list_filename):
            if not self.get_object_filename(sig):
                return False
        return True
917960
def _get_options_group(group=None):
    """"""

    #: These expect a hexidecimal keyid as their argument, and can be parsed
    #: with :func:`_is_hex`.
    hex_options = frozenset(['--check-sigs',
                             '--default-key',
                             '--default-recipient',
                             '--delete-keys',
                             '--delete-secret-keys',
                             '--delete-secret-and-public-keys',
                             '--desig-revoke',
                             '--export',
                             '--export-secret-keys',
                             '--export-secret-subkeys',
                             '--fingerprint',
                             '--gen-revoke',
                             '--hidden-encrypt-to',
                             '--hidden-recipient',
                             '--list-key',
                             '--list-keys',
                             '--list-public-keys',
                             '--list-secret-keys',
                             '--list-sigs',
                             '--recipient',
                             '--recv-keys',
                             '--send-keys',
                             '--edit-key',
                             '--sign-key',
                             ])
    #: These options expect value which are left unchecked, though still run
    #: through :func:`_fix_unsafe`.
    unchecked_options = frozenset(['--list-options',
                                   '--passphrase-fd',
                                   '--status-fd',
                                   '--verify-options',
                                   '--command-fd',
                               ])
    #: These have their own parsers and don't really fit into a group
    other_options = frozenset(['--debug-level',
                               '--keyserver',

                           ])
    #: These should have a directory for an argument
    dir_options = frozenset(['--homedir',
                             ])
    #: These expect a keyring or keyfile as their argument
    keyring_options = frozenset(['--keyring',
                                 '--primary-keyring',
                                 '--secret-keyring',
                                 '--trustdb-name',
                                 ])
    #: These expect a filename (or the contents of a file as a string) or None
    #: (meaning that they read from stdin)
    file_or_none_options = frozenset(['--decrypt',
                                      '--decrypt-files',
                                      '--encrypt',
                                      '--encrypt-files',
                                      '--import',
                                      '--verify',
                                      '--verify-files',
                                      '--output',
                                      ])
    #: These options expect a string. see :func:`_check_preferences`.
    pref_options = frozenset(['--digest-algo',
                              '--cipher-algo',
                              '--compress-algo',
                              '--compression-algo',
                              '--cert-digest-algo',
                              '--personal-digest-prefs',
                              '--personal-digest-preferences',
                              '--personal-cipher-prefs',
                              '--personal-cipher-preferences',
                              '--personal-compress-prefs',
                              '--personal-compress-preferences',
                              '--pinentry-mode',
                              '--print-md',
                              '--trust-model',
                              ])
    #: These options expect no arguments
    none_options = frozenset(['--allow-loopback-pinentry',
                              '--always-trust',
                              '--armor',
                              '--armour',
                              '--batch',
                              '--check-sigs',
                              '--check-trustdb',
                              '--clearsign',
                              '--debug-all',
                              '--default-recipient-self',
                              '--detach-sign',
                              '--export',
                              '--export-ownertrust',
                              '--export-secret-keys',
                              '--export-secret-subkeys',
                              '--fingerprint',
                              '--fixed-list-mode',
                              '--gen-key',
                              '--import-ownertrust',
                              '--list-config',
                              '--list-key',
                              '--list-keys',
                              '--list-packets',
                              '--list-public-keys',
                              '--list-secret-keys',
                              '--list-sigs',
                              '--lock-multiple',
                              '--lock-never',
                              '--lock-once',
                              '--no-default-keyring',
                              '--no-default-recipient',
                              '--no-emit-version',
                              '--no-options',
                              '--no-tty',
                              '--no-use-agent',
                              '--no-verbose',
                              '--print-mds',
                              '--quiet',
                              '--sign',
                              '--symmetric',
                              '--throw-keyids',
                              '--use-agent',
                              '--verbose',
                              '--version',
                              '--with-colons',
                              '--yes',
                              ])
    #: These options expect either None or a hex string
    hex_or_none_options = hex_options.intersection(none_options)
    allowed = hex_options.union(unchecked_options, other_options, dir_options,
                                keyring_options, file_or_none_options,
                                pref_options, none_options)

    if group and group in locals().keys():
        return locals()[group]
1279254
def Group(self):
		

		return(clc.v2.Group(id=self.groupId,alias=self.alias,session=self.session))
1309137
def _get_side2KerningGroups(self):
        
        found = {}
        for name, contents in self.items():
            if name.startswith("public.kern2."):
                found[name] = contents
        return found
564801
def get_action_groups(self):
        
        header = BASE_HEADERS.copy()
        header['Cookie'] = self.__cookie

        request = requests.get(BASE_URL + "getActionGroups",
                               headers=header,
                               timeout=10)

        if request.status_code != 200:
            self.__logged_in = False
            self.login()
            self.get_action_groups()
            return

        try:
            result = request.json()
        except ValueError:
            raise Exception(
                "get_action_groups: Not a valid result for ")

        if 'actionGroups' not in result.keys():
            return None

        groups = []

        for group_data in result['actionGroups']:
            group = ActionGroup(group_data)
            groups.append(group)

        return groups
844650
def _get_group_cached_perms(self):
        
        if not self.group:
            return {}
        perms = Permission.objects.filter(
            group=self.group,
        )
        group_permissions = {}
        for perm in perms:
            group_permissions[(
                perm.object_id,
                perm.content_type_id,
                perm.codename,
                perm.approved,
            )] = True
        return group_permissions
1121090
def get_signatures(self):
        
        signature_expr = re.compile(r"^(META-INF/)(.*)(\.RSA|\.EC|\.DSA)$")
        signature_datas = []

        for i in self.get_files():
            if signature_expr.search(i):
                signature_datas.append(self.get_file(i))

        return signature_datas
1216312
def get_inline_signers(signers, sequence)
      signers_array = []
      signers.each do |signer|
        signers_hash = {
          email: signer[:email],
          name: signer[:name],
          recipientId: signer[:recipient_id],
          roleName: signer[:role_name],
          clientUserId: signer[:client_id] || signer[:email],
          requireSignOnPaper: signer[:require_sign_on_paper] || false,
          tabs: {
            textTabs:       get_signer_tabs(signer[:text_tabs]),
            radioGroupTabs: get_radio_signer_tabs(signer[:radio_group_tabs]),
            checkboxTabs:   get_signer_tabs(signer[:checkbox_tabs]),
            numberTabs:     get_signer_tabs(signer[:number_tabs]),
            fullNameTabs:   get_signer_tabs(signer[:fullname_tabs]),
            dateTabs:       get_signer_tabs(signer[:date_tabs]),
            signHereTabs:   get_sign_here_tabs(signer[:sign_here_tabs])
          }
        }
        signers_array << signers_hash
      end
      template_hash = {sequence: sequence, recipients: { signers: signers_array }}
      [template_hash]
    end
772531
def get_signature_names(self):
        
        signature_expr = re.compile(r"^(META-INF/)(.*)(\.RSA|\.EC|\.DSA)$")
        signatures = []

        for i in self.get_files():
            if signature_expr.search(i):
                if "{}.SF".format(i.rsplit(".", 1)[0]) in self.get_files():
                    signatures.append(i)
                else:
                    log.warning("v1 signature file {} missing .SF file - Partial signature!".format(i))

        return signatures