Performs revocation of a Claim.

        :param schemaId: The schema ID (reference to claim
        definition schema)
        :param i: claim's sequence number within accumulator
185148
async def revoke(self, schemaId: ID, i):
        
        acc, ts = await self._nonRevocationIssuer.revoke(schemaId, i)
        await self.wallet.submitAccumUpdate(schemaId=schemaId, accum=acc,
                                            timestampMs=ts)
1288861
def unregister(self, uuid):
        
        schema = self._schbyuuid.pop(uuid)

        # clean schemas by name
        self._schbyname[schema.name].remove(schema)
        if not self._schbyname[schema.name]:
            del self._schbyname[schema.name]
334266
def get_revocation_reason(self):
        """"""
        if self.revoked is False:
            return

        if self.revoked_reason == '' or self.revoked_reason is None:
            return x509.ReasonFlags.unspecified
        else:
            return getattr(x509.ReasonFlags, self.revoked_reason)
1143706
public void setClaimedVictim() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) 
            Tr.debug(this, tc, "marking this mc as _claimedVictim");
        _claimedVictim = true;

    }
406073
public <O extends Schema> O setId(String schemaId) {
        getJson().put("id", schemaId);
        return (O)this;
    }
888237
def schema_key(s_id: str) -> SchemaKey:
    

    s_key = s_id.split(':')
    s_key.pop(1)  # take out indy-sdk schema marker: 2 marks indy-sdk schema id

    return SchemaKey(*s_key)
1336803
def _reset_id_table(self, mapping):
        """"""
        if not hasattr(self, "_initialized_id_tables"):
            self._initialized_id_tables = set()
        id_table_name = "{}_sf_ids".format(mapping["table"])
        if id_table_name not in self._initialized_id_tables:
            if id_table_name in self.metadata.tables:
                self.metadata.remove(self.metadata.tables[id_table_name])
            id_table = Table(
                id_table_name,
                self.metadata,
                Column("id", Unicode(255), primary_key=True),
                Column("sf_id", Unicode(18)),
            )
            if id_table.exists():
                id_table.drop()
            id_table.create()
            self._initialized_id_tables.add(id_table_name)
        return id_table_name
441459
def revoke_leadership(self, broker_ids):
        
        for b_id in broker_ids:
            try:
                broker = self.cluster_topology.brokers[b_id]
            except KeyError:
                self.log.error("Invalid broker id %s.", b_id)
                raise InvalidBrokerIdError(
                    "Broker id {} does not exist in cluster".format(b_id),
                )
            broker.mark_revoked_leadership()

        assert(len(self.cluster_topology.brokers) - len(broker_ids) > 0), "Not " \
            "all brokers can be revoked for leadership"
        opt_leader_cnt = len(self.cluster_topology.partitions) // (
            len(self.cluster_topology.brokers) - len(broker_ids)
        )
        # Balanced brokers transfer leadership to their under-balanced followers
        self.rebalancing_non_followers(opt_leader_cnt)

        # If the broker-ids to be revoked from leadership are still leaders for any
        # partitions, try to forcefully move their leadership to followers if possible
        pending_brokers = [
            b for b in six.itervalues(self.cluster_topology.brokers)
            if b.revoked_leadership and b.count_preferred_replica() > 0
        ]
        for b in pending_brokers:
            self._force_revoke_leadership(b)
107174
def cred_def_id(issuer_did: str, schema_seq_no: int) -> str:
    

    return '{}:3:CL:{}:{}'.format(issuer_did, schema_seq_no, CD_ID_TAG)
643395
def delete(self, force_drop=False, *args, **kwargs):
        
        if connection.schema_name not in (self.schema_name, get_public_schema_name()):
            raise Exception("Can't delete tenant outside it's own schema or "
                            "the public schema. Current schema is %s."
                            % connection.schema_name)

        if schema_exists(self.schema_name) and (self.auto_drop_schema or force_drop):
            cursor = connection.cursor()
            cursor.execute('DROP SCHEMA IF EXISTS %s CASCADE' % self.schema_name)

        return super(TenantMixin, self).delete(*args, **kwargs)
1133229
def renew(id, increment = 0)
      json = client.put("/v1/sys/renew/#{id}", JSON.fast_generate(
        increment: increment,
      ))
      return Secret.decode(json)
    end
703849
public void revoke(OrderedHashSet granteeList, SchemaObject dbObject,
                       Right rights, Grantee grantor, boolean grantOption,
                       boolean cascade) {

        if (!grantor.isFullyAccessibleByRole(dbObject)) {
            throw Error.error(ErrorCode.X_42501, dbObject.getName().name);
        }

        if (grantor.isAdmin()) {
            grantor = dbObject.getOwner();
        }

        for (int i = 0; i < granteeList.size(); i++) {
            String  name = (String) granteeList.get(i);
            Grantee g    = get(name);

            if (g == null) {
                throw Error.error(ErrorCode.X_28501, name);
            }

            if (isImmutable(name)) {
                throw Error.error(ErrorCode.X_28502, name);
            }
        }

        for (int i = 0; i < granteeList.size(); i++) {
            String  name = (String) granteeList.get(i);
            Grantee g    = get(name);

            g.revoke(dbObject, rights, grantor, grantOption);
            g.updateAllRights();

            if (g.isRole) {
                updateAllRights(g);
            }
        }
    }
3790
def get_schema(self, schema_id):
        
        res = requests.get(self._url('/schemas/ids/{}', schema_id))
        raise_if_failed(res)
        return json.loads(res.json()['schema'])
331205
def userinfo_in_id_token_claims(endpoint_context, session, def_itc=None):
    
    if def_itc:
        itc = def_itc
    else:
        itc = {}

    itc.update(id_token_claims(session))

    if not itc:
        return None

    _claims = by_schema(endpoint_context.id_token_schema, **itc)

    if _claims:
        return collect_user_info(endpoint_context, session, _claims)
    else:
        return None
1192005
def revoke(self, cert_id, reason=''):
        
        result = self.client.service.revoke(authData=self.auth, id=cert_id, reason=reason)

        if result == 0:
            return jsend.success()
        else:
            return self._create_error(result)
697250
def userinfo_claims(self, access_token, scope_request, claims_request):
        
        id_token = oidc.userinfo(access_token, scope_request, claims_request)
        return id_token.claims
1079220
void revoke(SchemaObject object, Right right, Grantee grantor,
                boolean grantOption) {

        final HsqlName name     = object.getName();
        Iterator       it       = directRightsMap.get(name);
        Right          existing = null;

        while (it.hasNext()) {
            existing = (Right) it.next();

            if (existing.grantor == grantor) {
                break;
            }
        }

        if (existing == null) {
            return;
        }

        if (existing.grantableRights != null) {
            existing.grantableRights.remove(object, right);
        }

        if (grantOption) {
            return;
        }

        if (right.isFull) {
            directRightsMap.remove(name, existing);
            grantor.grantedRightsMap.remove(name, existing);
            updateAllRights();

            return;
        }

        existing.remove(object, right);

        if (existing.isEmpty()) {
            directRightsMap.remove(name, existing);
            grantor.grantedRightsMap.remove(object, existing);
        }

        updateAllRights();

        return;
    }