Given the identity return a HPEManager object

        :param identity: The identity of the Manager resource
        :returns: The Manager object
778672
def get_manager(self, identity):
        
        return manager.HPEManager(self._conn, identity,
                                  redfish_version=self.redfish_version)
963795
def identity(self):
        
        if hasattr(self._identity, 'get_identity'):
            return self._identity.get_identity(self._environ)
        return self._identity(self._environ)
691588
def get_identity(self, processor, user, sp_config):
        
        sp_mapping = sp_config.get('attribute_mapping', {'username': 'username'})
        return processor.create_identity(user, sp_mapping, **sp_config.get('extra_config', {}))
572662
def get(identity_id = '', service = '')
      fail BadParametersError, 'identity_id is required' if identity_id.empty?
      fail BadParametersError, 'service is required' if service.empty?

      DataSift.request(:GET, "account/identity/#{identity_id}/limit/#{service}", @config)
    end
63795
def get_identity(user):
    
    identity = Identity(user.id)

    if hasattr(user, 'id'):
        identity.provides.add(UserNeed(user.id))

    for role in getattr(user, 'roles', []):
        identity.provides.add(RoleNeed(role.name))

    identity.user = user
    return identity
493712
def get_identities(self, item):
        
        identities = []

        field = self.get_field_author()
        identities.append(self.get_sh_identity(item, field))

        return identities
1239830
def run(self, *args):
        
        params = self.parser.parse_args(args)

        identifier = params.identifier
        identity = params.identity

        code = self.remove(identifier, identity)

        return code
864551
function Client(identity) {
  if (!(this instanceof Client)) {
    return new Client(identity);
  }

  assert(identity instanceof Identity, 'Invalid identity supplied');

  this._identity = identity;
  this._podhost = utils.getPodHostFromUserID(this._identity.userID);
  this._baseUrl = 'https://' + this._podhost;
  this._pubkey = this._identity._publicKeyArmored;
}
817689
def mapIdentity(self, primarySubject, secondarySubject, vendorSpecific=None):
        
        response = self.mapIdentityResponse(
            primarySubject, secondarySubject, vendorSpecific
        )
        return self._read_boolean_response(response)
227151
def get(self, resource_manager, identities):
        
        m = self.resolve(resource_manager.resource_type)
        params = {}
        client_filter = False

        # Try to formulate server side query
        if m.filter_name:
            if m.filter_type == 'list':
                params[m.filter_name] = identities
            elif m.filter_type == 'scalar':
                assert len(identities) == 1, "Scalar server side filter"
                params[m.filter_name] = identities[0]
        else:
            client_filter = True

        resources = self.filter(resource_manager, **params)
        if client_filter:
            # This logic was added to prevent the issue from:
            # https://github.com/capitalone/cloud-custodian/issues/1398
            if all(map(lambda r: isinstance(r, six.string_types), resources)):
                resources = [r for r in resources if r in identities]
            else:
                resources = [r for r in resources if r[m.id] in identities]

        return resources
1279597
def create_context(id_type=None, env=None, username=None, password=None,
        tenant_id=None, tenant_name=None, api_key=None, verify_ssl=None):
    
    if env:
        set_environment(env)
    return _create_identity(id_type=id_type, username=username,
            password=password, tenant_id=tenant_id, tenant_name=tenant_name,
            api_key=api_key, verify_ssl=verify_ssl, return_context=True)
791245
def get_id_generator(self, name):
        
        atomic_long = self.get_atomic_long(ID_GENERATOR_ATOMIC_LONG_PREFIX + name)
        return self.proxy.get_or_create(ID_GENERATOR_SERVICE, name, atomic_long=atomic_long)
974261
def manager(self, obj):
        """"""
        manager = getattr(obj, _MANAGER_ATTR, None)
        if manager is None:
            manager = AttachmentsManager()
            setattr(obj.__class__, _MANAGER_ATTR, manager)

        return manager
1061920
def create_or_bind_with_claims(self, source_identity):
        
        content = self._serialize.body(source_identity, 'Identity')
        response = self._send(http_method='PUT',
                              location_id='90ddfe71-171c-446c-bf3b-b597cd562afd',
                              version='5.0-preview.1',
                              content=content)
        return self._deserialize('Identity', response)
639979
function Identity(userID, passphrase, keyPair) {
  if (!(this instanceof Identity)) {
    return new Identity(userID, passphrase, keyPair);
  }

  assert(typeof userID === 'string', 'Invalid userID supplied');
  assert(typeof passphrase === 'string', 'Invalid passphrase supplied');

  this._publicKeyArmored = keyPair.publicKey.toString();
  this._privateKeyArmored = keyPair.privateKey.toString();

  this.userID = userID;
  this.publicKey = pgp.key.readArmored(this._publicKeyArmored).keys[0];
  this.privateKey = pgp.key.readArmored(this._privateKeyArmored).keys[0];

  assert(this.privateKey.decrypt(passphrase), 'Failed to decrypt private key');
}
998831
def assignee(self):
        
        if self.api and self.assignee_id:
            return self.api._get_user(self.assignee_id)
157181
def get_user_identity(cls, instance_config):
        
        user = instance_config.get('user')

        if not (
            user and user.get('name') and user.get('password') and user.get("domain") and user.get("domain").get("id")
        ):
            raise IncompleteIdentity()

        identity = {"methods": ['password'], "password": {"user": user}}
        return identity