Return the signature contents of this callable action.
507271
def get_presig(self, target, source, env):
        """"""
        try:
            return self.gc(target, source, env)
        except AttributeError:
            return self.funccontents
222490
def _build_signature(self):
        """"""
        sig_contents = \
            self.payload + "." + \
            b64encode(b"application/xml").decode("ascii") + "." + \
            b64encode(b"base64url").decode("ascii") + "." + \
            b64encode(b"RSA-SHA256").decode("ascii")
        sig_hash = SHA256.new(sig_contents.encode("ascii"))
        cipher = PKCS1_v1_5.new(self.private_key)
        sig = urlsafe_b64encode(cipher.sign(sig_hash))
        key_id = urlsafe_b64encode(bytes(self.author_handle, encoding="utf-8"))
        return sig, key_id
524744
def repr_part(self):
        """"""
        optargs = [('weighting', array_str(self.array, nprint=10), ''),
                   ('exponent', self.exponent, 2.0)]
        return signature_string([], optargs, sep=',\n',
                                mod=[[], ['!s', ':.4']])
838357
def params(self):
        
        return [{"name": p_name, "type": p_type.__name__}
                for (p_name, p_type) in self.signature.parameter_types]
1256735
def signature(name: str) -> Optional[Tuple]:
    
    return url_signature(name) if is_url(name) else file_signature(name) if is_file(name) else None
681772
def method_signature
      @parameters.map { |info| info.name == 'body' ? "body = {}" : Heroics.ruby_name(info.name) }.join(', ')
    end
381941
def signature(self):
        ''' 
        '''
        return self.name, [str(x.type) for x in self.elems]
283866
public String signature() {
        if (typeParameters.isEmpty()) {
            return name;
        } else {
            return name + '<' + Joiner.on(", ").join(typeParameters) + '>';
        }
    }
1370228
private function signature()
    {
        if (isset($this->apiKey)) {
            $apiKey = $this->apiKey;
        } else {
            $apiKey = \RpayLite\RpayLite::$apiKey;
        }
        $array_payload = array();
        array_push($array_payload, $this['key']);
        foreach ($this['items'] as $item) {
            array_push($array_payload, $item['id']);
            array_push($array_payload, $item['name']);
            array_push($array_payload, $item['unit_price']);
            array_push($array_payload, $item['quantity']);
        }
        if (isset($this['cart_id'])) {
            array_push($array_payload, $this['cart_id']);
        } else {
            array_push($array_payload, "");
        }
        $payload = join(";", $array_payload) . ";";
        return hash_hmac("SHA1", $payload, $apiKey);
    }
287138
def _get_signature(self):
        

        keys = list(self.params.keys())

        keys.sort()

        string = ""

        for name in keys:
            string += name
            string += self.params[name]

        string += self.api_secret

        return md5(string)
1189021
def extract_full_summary_from_signature(operation):
    
    lines = inspect.getdoc(operation)
    regex = r'\s*(:param)\s+(.+?)\s*:(.*)'
    summary = ''
    if lines:
        match = re.search(regex, lines)
        summary = lines[:match.regs[0][0]] if match else lines

    summary = summary.replace('\n', ' ').replace('\r', '')
    return summary
1048314
static String getMethodSignature(Method m) {
      StringBuilder result = new StringBuilder();
      result.append('(');
      for (Class<?> parameterType : m.getParameterTypes()) {
        result.append(getSignature(parameterType));
      }
      result.append(")");
      result.append(getSignature(m.getReturnType()));
      return result.toString();
    }
1075765
def getsignaturefromtext(text, objname):
    """"""
    if isinstance(text, dict):
        text = text.get('docstring', '')
    # Regexps
    oneline_re = objname + r'\([^\)].+?(?<=[\w\]\}\'"])\)(?!,)'
    multiline_re = objname + r'\([^\)]+(?<=[\w\]\}\'"])\)(?!,)'
    multiline_end_parenleft_re = r'(%s\([^\)]+(\),\n.+)+(?<=[\w\]\}\'"])\))'
    # Grabbing signatures
    if not text:
        text = ''
    sigs_1 = re.findall(oneline_re + '|' + multiline_re, text)
    sigs_2 = [g[0] for g in re.findall(multiline_end_parenleft_re % objname, text)]
    all_sigs = sigs_1 + sigs_2
    # The most relevant signature is usually the first one. There could be
    # others in doctests but those are not so important
    if all_sigs:
        return all_sigs[0]
    else:
        return ''
173804
public String getSignature() {
        final StringBuilder builder = new StringBuilder("(");
        parameters.forEach(builder::append);
        return builder.append(')').append(returnType).toString();
    }
587974
def signature_base
      parts = [normalized_request_method, base_string_uri, normalized_request_params_string]
      parts.map { |v| OAuthenticator.escape(v) }.join('&')
    end
1126505
def getPoseActionData(self, action, eOrigin, fPredictedSecondsFromNow, unActionDataSize, ulRestrictToDevice):
        """"""

        fn = self.function_table.getPoseActionData
        pActionData = InputPoseActionData_t()
        result = fn(action, eOrigin, fPredictedSecondsFromNow, byref(pActionData), unActionDataSize, ulRestrictToDevice)
        return result, pActionData
1208647
public synchronized String getSignature() {
        if (signature == null) {
            CachedClass [] parameters = getParameterTypes();
            final String name = getName();
            StringBuilder buf = new StringBuilder(name.length()+parameters.length*10);
            buf.append(getReturnType().getName());
            
            buf.append(' ');
            buf.append(name);
            buf.append('(');
            for (int i = 0; i < parameters.length; i++) {
                if (i > 0) {
                    buf.append(", ");
                }
                buf.append(parameters[i].getName());
            }
            buf.append(')');
            signature = buf.toString();
        }
        return signature;
    }