Set all the Evidence stmt_tag to my deep matches-key hash.
329214
def _tag_evidence(self):
        """"""
        h = self.get_hash(shallow=False)
        for ev in self.evidence:
            ev.stmt_tag = h
        return
268619
def _add_hash(cls, attrs):
    
    cls.__hash__ = _make_hash(attrs, frozen=False, cache_hash=False)
    return cls
294255
def set_tag(self, tag):
        """"""
        return Eq(
            self._lhs, self._rhs, tag=tag,
            _prev_lhs=self._prev_lhs, _prev_rhs=self._prev_rhs,
            _prev_tags=self._prev_tags)
1288800
def to_payload
      version.htb << [depth].pack('C') << parent_fingerprint.htb <<
          [number].pack('N') << chain_code << [0x00].pack('C') << key.priv_key.htb
    end
1020080
def _load_codes(self, tag, ssh=False):
        """"""
        codes = []
        for code in tag:
            if code.tag == "trunk":
                codes.append(code.attrib["value"])
        
        if ssh == False:
            self._vardict["codes"] = codes
        else:
            self._vardict["ssh.codes"] = codes
1215042
def fixup_simple_stmt(parent, i, stmt_node):
    
    for semi_ind, node in enumerate(stmt_node.children):
        if node.type == token.SEMI: # *sigh*
            break
    else:
        return

    node.remove() # kill the semicolon
    new_expr = Node(syms.expr_stmt, [])
    new_stmt = Node(syms.simple_stmt, [new_expr])
    while stmt_node.children[semi_ind:]:
        move_node = stmt_node.children[semi_ind]
        new_expr.append_child(move_node.clone())
        move_node.remove()
    parent.insert_child(i, new_stmt)
    new_leaf1 = new_stmt.children[0].children[0]
    old_leaf1 = stmt_node.children[0].children[0]
    new_leaf1.prefix = old_leaf1.prefix
716412
def tag(self, *tag, **kwtags):
        """"""
        if not tag:
            pass
        elif len(tag) == 1 and isinstance(tag[0], dict):
            self._meta.update(tag[0])
        else:
            raise TypeError('Tags must be provided as key-word arguments or '
                            'a dictionary')
        self._meta.update(kwtags)
        return self
47552
def _get_filtered_stmts(self, _, node, _stmts, mystmt):
        """"""
        if self.statement() is mystmt:
            # original node's statement is the assignment, only keep
            # current node (gen exp, list comp)
            return [node], True
        return _stmts, False
795907
def _set_transmaps(self):
        """"""
        if self._std == 'ascii':
            self._lower_chars = string.ascii_lowercase
            self._upper_chars = string.ascii_uppercase

        elif self._std == 'rfc1459':
            self._lower_chars = (string.ascii_lowercase +
                                 ''.join(chr(i) for i in range(123, 127)))
            self._upper_chars = (string.ascii_uppercase +
                                 ''.join(chr(i) for i in range(91, 95)))

        elif self._std == 'rfc1459-strict':
            self._lower_chars = (string.ascii_lowercase +
                                 ''.join(chr(i) for i in range(123, 126)))
            self._upper_chars = (string.ascii_uppercase +
                                 ''.join(chr(i) for i in range(91, 94)))
470129
def set_memory_cache(self, results, key=None):
        """"""
        key = self.model.hash if key is None else key
        self.memory_cache[key] = results
286499
def update(self):
        """"""
        if "tag_groups" not in self._device_dict:
            return
        for group in self.tag_groups:
            group.update()
        for i in range(len(self._device_dict["tag_groups"])):
            tag_group_dict = self._device_dict["tag_groups"][i]
            for group in self.tag_groups:
                if group.name == tag_group_dict["common.ALLTYPES_NAME"]:
                    self._device_dict["tag_groups"][i] = group.as_dict()
446267
def set_tag(self, key, value):
        
        with self.update_lock:
            if key == ext_tags.SAMPLING_PRIORITY and not self._set_sampling_priority(value):
                return self
            if self.is_sampled():
                tag = thrift.make_tag(
                    key=key,
                    value=value,
                    max_length=self.tracer.max_tag_value_length, )
                self.tags.append(tag)
        return self
511022
def _init_prtfmt(self, key="fmta"):
        """"""
        prtfmt = self.gosubdag.prt_attr[key]
        return prtfmt.replace("{NS}", "{NS} {hdr1usr01:2} {num_usrgos:>4} uGOs")
348799
def set(self, tclass, tnum, tlvt=0, tdata=b''):
        """"""
        if isinstance(tdata, bytearray):
            tdata = bytes(tdata)
        elif not isinstance(tdata, bytes):
            raise TypeError("tag data must be bytes or bytearray")

        self.tagClass = tclass
        self.tagNumber = tnum
        self.tagLVT = tlvt
        self.tagData = tdata
480907
def add_stmt(stmt, arg_rules):
    """"""
    (arg, rules) = arg_rules
    stmt_map[stmt] = (arg, rules)
1187748
def _set_cache_(self, attr):
        """"""
        if attr in TagObject.__slots__:
            ostream = self.repo.odb.stream(self.binsha)
            lines = ostream.read().decode(defenc).splitlines()

            obj, hexsha = lines[0].split(" ")       # object <hexsha> @UnusedVariable
            type_token, type_name = lines[1].split(" ")  # type <type_name> @UnusedVariable
            self.object = \
                get_object_type_by_name(type_name.encode('ascii'))(self.repo, hex_to_bin(hexsha))

            self.tag = lines[2][4:]  # tag <tag name>

            tagger_info = lines[3]  # tagger <actor> <date>
            self.tagger, self.tagged_date, self.tagger_tz_offset = parse_actor_and_date(tagger_info)

            # line 4 empty - it could mark the beginning of the next header
            # in case there really is no message, it would not exist. Otherwise
            # a newline separates header from message
            if len(lines) > 5:
                self.message = "\n".join(lines[5:])
            else:
                self.message = ''
        # END check our attributes
        else:
            super(TagObject, self)._set_cache_(attr)
746562
def _get_stmt_matching_groups(stmts):
        """"""
        def match_func(x): return x.matches_key()

        # Remove exact duplicates using a set() call, then make copies:
        logger.debug('%d statements before removing object duplicates.' %
                     len(stmts))
        st = list(set(stmts))
        logger.debug('%d statements after removing object duplicates.' %
                     len(stmts))
        # Group statements according to whether they are matches (differing
        # only in their evidence).
        # Sort the statements in place by matches_key()
        st.sort(key=match_func)

        return itertools.groupby(st, key=match_func)