\

        `origin`
            Topic identity (commonly a subject identifier) of the originator of the cable
        `cable`
            Topic identity (commonly a subject identifier) of the cable.
175842
def _sent_by(self, origin, cable):
        
        self._assoc(psis.SENT_BY_TYPE,
                    psis.SENDER_TYPE, origin,
                    psis.CABLE_TYPE, cable)
1138758
function Topic(name, account, region) {
            this._region = new AliMNS.Region(AliMNS.City.Hangzhou);
            this._pattern = "%s://%s.mns.%s.aliyuncs.com/topics/%s";
            this._name = name;
            this._account = account;
            // region
            if (region) {
                if (typeof region === "string")
                    this._region = new AliMNS.Region(region, AliMNS.NetworkType.Public, AliMNS.Zone.China);
                else
                    this._region = region;
            }
            // make url
            this._urlAttr = this.makeAttrURL();
            this._urlSubscription = this.makeSubscriptionURL();
            this._urlPublish = this.makePublishURL();
            // create the OpenStack object
            this._openStack = new AliMNS.OpenStack(account);
        }
18449
def subject_public_key(self, value):
        

        is_oscrypto = isinstance(value, asymmetric.PublicKey)
        if not isinstance(value, keys.PublicKeyInfo) and not is_oscrypto:
            raise TypeError(_pretty_message(
                '''
                subject_public_key must be an instance of
                asn1crypto.keys.PublicKeyInfo or oscrypto.asymmetric.PublicKey,
                not %s
                ''',
                _type_name(value)
            ))

        if is_oscrypto:
            value = value.asn1

        self._subject_public_key = value

        self._key_identifier = self._subject_public_key.sha1
        self._authority_key_identifier = None
134394
def _russianreporter_cable_ids():
    
    s = urllib2.urlopen(_RR_IRI).read()
    return set(_WL_CABLE_ID_PATTERN.findall(s))
1290677
def create_identity(user_id, curve_name):
    """"""
    result = interface.Identity(identity_str='gpg://', curve_name=curve_name)
    result.identity_dict['host'] = user_id
    return result
1021873
def with_subject(self, subject):
        
        return self.__class__(
            self._signer,
            service_account_email=self._service_account_email,
            scopes=self._scopes,
            token_uri=self._token_uri,
            subject=subject,
            project_id=self._project_id,
            additional_claims=self._additional_claims.copy())
968662
private String rdIdentifier()
	{
		StringBuilder id = new StringBuilder();
		id.append(ch);

		while (restOfName(rdCh()))
		{
			id.append(ch);
		}

		return id.toString();
	}
603325
def build_header
      header = Header.new
      header["callerid"] = @caller_id
      header["topic"] = @topic_name
      header["md5sum"] = @topic_type.md5sum
      header["type"] = @topic_type.type
      if latching?
        header["latching"]  = '1'
      end
      header
    end
1300216
def origin=(new_origin)
      if new_origin
        if !new_origin.respond_to?(:to_str)
          raise TypeError, "Can't convert #{new_origin.class} into String."
        end
        new_origin = new_origin.to_str
        new_scheme = new_origin[/^([^:\/?#]+):\/\//, 1]
        unless new_scheme
          raise InvalidURIError, 'An origin cannot omit the scheme.'
        end
        new_host = new_origin[/:\/\/([^\/?#:]+)/, 1]
        unless new_host
          raise InvalidURIError, 'An origin cannot omit the host.'
        end
        new_port = new_origin[/:([^:@\[\]\/]*?)$/, 1]
      end

      self.scheme = defined?(new_scheme) ? new_scheme : nil
      self.host = defined?(new_host) ? new_host : nil
      self.port = defined?(new_port) ? new_port : nil
      self.userinfo = nil

      # Reset dependent values
      remove_instance_variable(:@userinfo) if defined?(@userinfo)
      remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
      remove_instance_variable(:@authority) if defined?(@authority)
      remove_instance_variable(:@normalized_authority) if defined?(@normalized_authority)
      remove_composite_values

      # Ensure we haven't created an invalid URI
      validate()
    end
1073374
def unique_identifier(self):
        
        for t in IDENTIFIER_PRIORITY:
            found = self._tree.getroot().find('.//mods:identifier[@type="%s"]' % t, NS)
            if found is not None:
                return found.text
496052
def p_identifier(self, tree):
        '''  '''
        tree.value = tree.attr
        tree.svalue = tree.attr
178393
def get_authority_key_identifier(self):
        """"""

        try:
            ski = self.x509.extensions.get_extension_for_class(x509.SubjectKeyIdentifier)
        except x509.ExtensionNotFound:
            return x509.AuthorityKeyIdentifier.from_issuer_public_key(self.x509.public_key())
        else:
            return x509.AuthorityKeyIdentifier.from_issuer_subject_key_identifier(ski)
113097
def lookup(self, topic):
        """"""
        nsq.assert_valid_topic_name(topic)
        return self._request('GET', '/lookup', fields={'topic': topic})
982900
def t_identifier(self, s):
        '
        self.rv.append(Token(type='IDENTIFIER', attr=s))
1233605
def push_identity(self, identifiers):
        
        if (not identifiers):
            msg = ("Specified Subject identifiers cannot be None or empty "
                   "for 'run as' functionality.")
            raise ValueError(msg)

        stack = self.get_run_as_identifiers_stack()

        if (not stack):
            stack = []

        stack.append(identifiers)
        session = self.get_session()
        session.set_internal_attribute(self.run_as_identifiers_session_key, stack)
1089811
def subject_key_identifier(self):
        """"""
        try:
            ext = self.x509.extensions.get_extension_for_oid(ExtensionOID.SUBJECT_KEY_IDENTIFIER)
        except x509.ExtensionNotFound:
            return None
        return SubjectKeyIdentifier(ext)
720863
def update_subject_identifier_on_save(self):
        
        if not self.subject_identifier:
            self.subject_identifier = self.subject_identifier_as_pk.hex
        elif re.match(UUID_PATTERN, self.subject_identifier):
            pass
        return self.subject_identifier