SYMBOL INDEX (209 symbols across 15 files)

FILE: asm2vec/asm.py
  class Instruction (line 4) | class Instruction:
    method __init__ (line 5) | def __init__(self, op: str, *args: str):
    method op (line 9) | def op(self) -> str:
    method number_of_args (line 12) | def number_of_args(self) -> int:
    method args (line 15) | def args(self) -> List[str]:
  function parse_instruction (line 19) | def parse_instruction(code: str) -> Instruction:
  class BasicBlock (line 29) | class BasicBlock:
    method __init__ (line 32) | def __init__(self):
    method __iter__ (line 41) | def __iter__(self):
    method __len__ (line 44) | def __len__(self):
    method __hash__ (line 47) | def __hash__(self):
    method __eq__ (line 50) | def __eq__(self, other):
    method __ne__ (line 55) | def __ne__(self, other):
    method id (line 58) | def id(self) -> int:
    method add_instruction (line 61) | def add_instruction(self, instr: Instruction) -> None:
    method body_instructions (line 64) | def body_instructions(self) -> List[Instruction]:
    method instructions (line 67) | def instructions(self) -> List[Instruction]:
    method add_predecessor (line 70) | def add_predecessor(self, predecessor: 'BasicBlock') -> None:
    method add_successor (line 74) | def add_successor(self, successor: 'BasicBlock') -> None:
    method first_instruction (line 78) | def first_instruction(self) -> Instruction:
    method last_instruction (line 81) | def last_instruction(self) -> Instruction:
    method predecessors (line 84) | def predecessors(self) -> List['BasicBlock']:
    method in_degree (line 87) | def in_degree(self) -> int:
    method successors (line 90) | def successors(self) -> List['BasicBlock']:
    method out_degree (line 93) | def out_degree(self) -> int:
  class CFGWalkerCallback (line 97) | class CFGWalkerCallback:
    method __call__ (line 98) | def __call__(self, *args, **kwargs):
    method on_enter (line 101) | def on_enter(self, block: BasicBlock) -> None:
    method on_exit (line 104) | def on_exit(self, block: BasicBlock) -> None:
  function _walk_cfg (line 111) | def _walk_cfg(entry: BasicBlock, action: CFGWalkerCallbackType, visited:...
  function walk_cfg (line 125) | def walk_cfg(entry: BasicBlock, action: CFGWalkerCallbackType) -> None:
  class Function (line 129) | class Function:
    method __init__ (line 132) | def __init__(self, entry: BasicBlock, name: str = None):
    method __len__ (line 142) | def __len__(self) -> int:
    method __hash__ (line 152) | def __hash__(self):
    method __eq__ (line 155) | def __eq__(self, other):
    method __ne__ (line 160) | def __ne__(self, other):
    method id (line 163) | def id(self) -> int:
    method entry (line 166) | def entry(self) -> BasicBlock:
    method name (line 169) | def name(self) -> str:
    method add_callee (line 172) | def add_callee(self, f: 'Function') -> None:
    method callees (line 176) | def callees(self) -> List['Function']:
    method out_degree (line 179) | def out_degree(self) -> int:
    method add_caller (line 182) | def add_caller(self, f: 'Function') -> None:
    method callers (line 186) | def callers(self) -> List['Function']:
    method in_degree (line 189) | def in_degree(self) -> int:

FILE: asm2vec/internal/atomic.py
  class LockContextManager (line 5) | class LockContextManager:
    method __init__ (line 6) | def __init__(self, lock: threading.Lock):
    method __enter__ (line 10) | def __enter__(self):
    method __exit__ (line 13) | def __exit__(self, exc_type, exc_val, exc_tb):
    method exited (line 17) | def exited(self) -> bool:
  class Atomic (line 21) | class Atomic:
    class AtomicContextManager (line 22) | class AtomicContextManager(LockContextManager):
      method __init__ (line 23) | def __init__(self, atomic: 'Atomic'):
      method __enter__ (line 28) | def __enter__(self):
      method __exit__ (line 32) | def __exit__(self, exc_type, exc_val, exc_tb):
      method value (line 35) | def value(self) -> Any:
      method set (line 40) | def set(self, value: Any) -> None:
    method __init__ (line 45) | def __init__(self, value: Any):
    method lock (line 49) | def lock(self) -> AtomicContextManager:
    method value (line 52) | def value(self) -> Any:

FILE: asm2vec/internal/parse.py
  class AssemblySyntaxError (line 7) | class AssemblySyntaxError(Exception):
    method __init__ (line 8) | def __init__(self, message: str = None):
    method message (line 11) | def message(self) -> str:
  function raise_asm_syntax_error (line 15) | def raise_asm_syntax_error(expect: str, found: str) -> None:
  function is_jmp (line 48) | def is_jmp(op: str) -> bool:
  function is_conditional_jmp (line 52) | def is_conditional_jmp(op: str) -> bool:
  function is_call (line 56) | def is_call(op: str) -> bool:
  function is_ret (line 60) | def is_ret(op: str) -> bool:
  function is_reg (line 64) | def is_reg(arg: str) -> bool:
  class CFGBuilder (line 68) | class CFGBuilder:
    method __init__ (line 69) | def __init__(self, context: 'ParseContext'):
    method _logger (line 75) | def _logger(self) -> logging.Logger:
    method _allocate_block (line 78) | def _allocate_block(self) -> int:
    method _allocate_named_block (line 82) | def _allocate_named_block(self, name: str) -> int:
    method _get_active_block (line 90) | def _get_active_block(self) -> asm2vec.asm.BasicBlock:
    method _set_active_block (line 93) | def _set_active_block(self, block_id: int) -> None:
    method _has_active_block (line 96) | def _has_active_block(self) -> bool:
    method _close_active_block (line 99) | def _close_active_block(self) -> None:
    method _add_jmp (line 102) | def _add_jmp(self, op: str, args: List[str]) -> None:
    method add_instr (line 113) | def add_instr(self, op: str, args: List[str]) -> None:
    method set_label (line 125) | def set_label(self, label: str) -> None:
    method build (line 142) | def build(self) -> List[asm2vec.asm.Function]:
  class ParseOptions (line 183) | class ParseOptions:
    method __init__ (line 184) | def __init__(self, **kwargs):
    method func_names (line 187) | def func_names(self) -> List[str]:
  class ParseContext (line 191) | class ParseContext:
    method __init__ (line 192) | def __init__(self, **kwargs):
    method logger (line 197) | def logger(self) -> logging.Logger:
    method options (line 200) | def options(self) -> ParseOptions:
    method builder (line 203) | def builder(self) -> CFGBuilder:
  function is_fullmatch (line 238) | def is_fullmatch(pattern, s: str) -> bool:
  function parse_asm_label (line 242) | def parse_asm_label(ln: str, context: ParseContext) -> None:
  function parse_asm_instr (line 250) | def parse_asm_instr(ln: str, context: ParseContext) -> None:
  function parse_asm_line (line 262) | def parse_asm_line(ln: str, context: ParseContext) -> None:
  function parse_asm_lines (line 274) | def parse_asm_lines(lines: Iterable[str], **kwargs) -> List[asm2vec.asm....

FILE: asm2vec/internal/repr.py
  function _random_walk (line 19) | def _random_walk(f: Function) -> List[Instruction]:
  function _edge_sampling (line 36) | def _edge_sampling(f: Function) -> List[List[Instruction]]:
  function make_sequential_function (line 56) | def make_sequential_function(f: Function, num_of_random_walks: int = 10)...
  function _get_function_tokens (line 67) | def _get_function_tokens(f: Function, dim: int = 200) -> List[Vectorized...
  function _make_function_repo_helper (line 81) | def _make_function_repo_helper(vocab: Dict[str, Token], funcs: List[Func...
  function make_function_repo (line 124) | def make_function_repo(funcs: List[Function], dim: int, num_of_rnd_walks...
  function make_estimate_repo (line 128) | def make_estimate_repo(vocabulary: Dict[str, Token], f: Function,

FILE: asm2vec/internal/sampling.py
  class NegativeSampler (line 7) | class NegativeSampler:
    method __init__ (line 8) | def __init__(self, distribution: List[Tuple[T, float]], alpha: float =...
    method sample (line 12) | def sample(self, k: int) -> List[T]:

FILE: asm2vec/internal/training.py
  class Asm2VecParams (line 19) | class Asm2VecParams:
    method __init__ (line 20) | def __init__(self, **kwargs):
    method to_dict (line 29) | def to_dict(self) -> Dict[str, Any]:
    method populate (line 40) | def populate(self, rep: Dict[bytes, Any]) -> None:
  class SequenceWindow (line 50) | class SequenceWindow:
    method __init__ (line 51) | def __init__(self, sequence: List[Instruction], vocabulary: Dict[str, ...
    method move_next (line 67) | def move_next(self) -> bool:
    method prev_ins (line 89) | def prev_ins(self) -> Instruction:
    method prev_ins_op (line 92) | def prev_ins_op(self) -> VectorizedToken:
    method prev_ins_args (line 95) | def prev_ins_args(self) -> List[VectorizedToken]:
    method curr_ins (line 98) | def curr_ins(self) -> Instruction:
    method curr_ins_op (line 101) | def curr_ins_op(self) -> VectorizedToken:
    method curr_ins_args (line 104) | def curr_ins_args(self) -> List[VectorizedToken]:
    method next_ins (line 107) | def next_ins(self) -> Instruction:
    method next_ins_op (line 110) | def next_ins_op(self) -> VectorizedToken:
    method next_ins_args (line 113) | def next_ins_args(self) -> List[VectorizedToken]:
  class TrainingContext (line 117) | class TrainingContext:
    class Counter (line 118) | class Counter:
      method __init__ (line 119) | def __init__(self, context: 'TrainingContext', name: str, initial: i...
      method val (line 124) | def val(self) -> int:
      method inc (line 128) | def inc(self) -> int:
      method reset (line 133) | def reset(self) -> int:
    method __init__ (line 141) | def __init__(self, repo: FunctionRepository, params: Asm2VecParams, is...
    method repo (line 150) | def repo(self) -> FunctionRepository:
    method params (line 153) | def params(self) -> Asm2VecParams:
    method lock (line 156) | def lock(self) -> LockContextManager:
    method alpha (line 159) | def alpha(self) -> float:
    method set_alpha (line 163) | def set_alpha(self, alpha: float) -> None:
    method sampler (line 167) | def sampler(self) -> NegativeSampler:
    method is_estimating (line 170) | def is_estimating(self) -> bool:
    method create_sequence_window (line 173) | def create_sequence_window(self, seq: List[Instruction]) -> SequenceWi...
    method get_counter (line 176) | def get_counter(self, name: str) -> Counter:
    method add_counter (line 180) | def add_counter(self, name: str, initial: int = 0) -> Counter:
  function _sigmoid (line 187) | def _sigmoid(x: float) -> float:
  function _identity (line 191) | def _identity(cond: bool) -> int:
  function _dot_sigmoid (line 195) | def _dot_sigmoid(lhs: np.ndarray, rhs: np.ndarray) -> float:
  function _get_inst_repr (line 200) | def _get_inst_repr(op: VectorizedToken, args: List[VectorizedToken]) -> ...
  function _train_vectorized (line 208) | def _train_vectorized(wnd: SequenceWindow, f: VectorizedFunction, contex...
  function _train_sequence (line 264) | def _train_sequence(f: VectorizedFunction, seq: List[Instruction], conte...
  function train (line 270) | def train(repository: FunctionRepository, params: Asm2VecParams) -> None:
  function estimate (line 296) | def estimate(f: VectorizedFunction, estimate_repo: FunctionRepository, p...

FILE: asm2vec/internal/util.py
  function make_small_ndarray (line 4) | def make_small_ndarray(dim: int) -> np.ndarray:

FILE: asm2vec/logging.py
  function asm2vec_logger (line 4) | def asm2vec_logger() -> logging.Logger:
  function config_asm2vec_logging (line 8) | def config_asm2vec_logging(**kwargs):

FILE: asm2vec/model.py
  class Asm2VecMemento (line 13) | class Asm2VecMemento:
    method __init__ (line 14) | def __init__(self):
    method serialize (line 18) | def serialize(self) -> Dict[str, Any]:
    method populate (line 24) | def populate(self, rep: Dict[bytes, Any]) -> None:
  class Asm2Vec (line 30) | class Asm2Vec:
    method __init__ (line 31) | def __init__(self, **kwargs):
    method memento (line 35) | def memento(self) -> Asm2VecMemento:
    method set_memento (line 41) | def set_memento(self, memento: Asm2VecMemento) -> None:
    method make_function_repo (line 45) | def make_function_repo(self, funcs: List[asm2vec.asm.Function]) -> asm...
    method train (line 49) | def train(self, repo: asm2vec.repo.FunctionRepository) -> None:
    method to_vec (line 53) | def to_vec(self, f: asm2vec.asm.Function) -> np.ndarray:

FILE: asm2vec/parse.py
  function parse_text (line 9) | def parse_text(asm: str, **kwargs) -> List[asm2vec.asm.Function]:
  function parse_fp (line 13) | def parse_fp(fp, **kwargs) -> List[asm2vec.asm.Function]:
  function parse (line 17) | def parse(asm_file_name: str, **kwargs) -> List[asm2vec.asm.Function]:

FILE: asm2vec/repo.py
  class SequentialFunction (line 9) | class SequentialFunction:
    method __init__ (line 10) | def __init__(self, fid: int, name: str, sequences: List[List[asm2vec.a...
    method id (line 15) | def id(self) -> int:
    method name (line 18) | def name(self) -> str:
    method sequences (line 21) | def sequences(self) -> List[List[asm2vec.asm.Instruction]]:
  class VectorizedFunction (line 25) | class VectorizedFunction:
    method __init__ (line 26) | def __init__(self, f: SequentialFunction, v: np.ndarray = None, dim: i...
    method sequential (line 30) | def sequential(self) -> SequentialFunction:
  class VectorizedToken (line 34) | class VectorizedToken:
    method __init__ (line 35) | def __init__(self, name: str, v: np.ndarray = None, v_pred: np.ndarray...
    method __eq__ (line 40) | def __eq__(self, other):
    method __ne__ (line 46) | def __ne__(self, other):
    method name (line 49) | def name(self) -> str:
  class Token (line 53) | class Token:
    method __init__ (line 54) | def __init__(self, vt: VectorizedToken, count: int = 1):
    method vectorized (line 59) | def vectorized(self) -> VectorizedToken:
    method name (line 62) | def name(self) -> str:
  class FunctionRepository (line 66) | class FunctionRepository:
    method __init__ (line 67) | def __init__(self, funcs: List[VectorizedFunction], vocab: Dict[str, T...
    method funcs (line 72) | def funcs(self) -> List[VectorizedFunction]:
    method vocab (line 75) | def vocab(self) -> Dict[str, Token]:
    method num_of_tokens (line 78) | def num_of_tokens(self) -> int:
  function _serialize_token (line 82) | def _serialize_token(token: Token) -> Dict[str, Any]:
  function _deserialize_token (line 92) | def _deserialize_token(rep: Dict[bytes, Any]) -> Token:
  function serialize_vocabulary (line 105) | def serialize_vocabulary(vocab: Dict[str, Token]) -> Dict[str, Any]:
  function deserialize_vocabulary (line 109) | def deserialize_vocabulary(rep: Dict[bytes, Any]) -> Dict[str, Token]:
  function _serialize_sequence (line 113) | def _serialize_sequence(seq: List[asm2vec.asm.Instruction]) -> List[Any]:
  function _deserialize_sequence (line 117) | def _deserialize_sequence(rep: List[Any]) -> List[asm2vec.asm.Instruction]:
  function _serialize_vectorized_function (line 122) | def _serialize_vectorized_function(func: VectorizedFunction, include_seq...
  function _deserialize_vectorized_function (line 135) | def _deserialize_vectorized_function(rep: Dict[bytes, Any]) -> Vectorize...
  function serialize_function_repo (line 149) | def serialize_function_repo(repo: FunctionRepository, flags: int) -> Dic...
  function deserialize_function_repo (line 162) | def deserialize_function_repo(rep: Dict[bytes, Any]) -> FunctionRepository:

FILE: examples/training-estimating.py
  function cosine_similarity (line 8) | def cosine_similarity(v1, v2):
  function main (line 12) | def main():

FILE: tests/asm_test.py
  class InstructionTest (line 6) | class InstructionTest(ut.TestCase):
    method test_parse_instruction (line 7) | def test_parse_instruction(self):
    method test_parse_instruction_one_operand (line 12) | def test_parse_instruction_one_operand(self):
    method test_parse_instruction_no_operands (line 17) | def test_parse_instruction_no_operands(self):
  class BasicBlockTest (line 23) | class BasicBlockTest(ut.TestCase):
  class FunctionTest (line 27) | class FunctionTest(ut.TestCase):

FILE: tests/parse_test.py
  class ParseTest (line 51) | class ParseTest(ut.TestCase):
    method test_parse_text (line 52) | def test_parse_text(self):

FILE: tests/utilities_test.py
  class PermutationTest (line 6) | class PermutationTest(ut.TestCase):
    method test_permute (line 7) | def test_permute(self):
    method test_inv_permute (line 13) | def test_inv_permute(self):