SYMBOL INDEX (443 symbols across 31 files)

FILE: docs/source/conf.py
  function skip (line 55) | def skip(app, what, name, obj, would_skip, options):
  function setup (line 61) | def setup(app):

FILE: nasim/__init__.py
  function make_benchmark (line 13) | def make_benchmark(scenario_name,
  function load (line 57) | def load(path,
  function generate (line 97) | def generate(num_hosts,
  function _register (line 139) | def _register(id, entry_point, kwargs, nondeterministic, force=True):

FILE: nasim/agents/bruteforce_agent.py
  function run_bruteforce_agent (line 23) | def run_bruteforce_agent(env, step_limit=1e6, verbose=True):

FILE: nasim/agents/dqn_agent.py
  class ReplayMemory (line 47) | class ReplayMemory:
    method __init__ (line 49) | def __init__(self, capacity, s_dims, device="cpu"):
    method store (line 59) | def store(self, s, a, next_s, r, done):
    method sample_batch (line 68) | def sample_batch(self, batch_size):
  class DQN (line 78) | class DQN(nn.Module):
    method __init__ (line 81) | def __init__(self, input_dim, layers, num_actions):
    method forward (line 88) | def forward(self, x):
    method save_DQN (line 94) | def save_DQN(self, file_path):
    method load_DQN (line 97) | def load_DQN(self, file_path):
    method get_action (line 100) | def get_action(self, x):
  class DQNAgent (line 107) | class DQNAgent:
    method __init__ (line 110) | def __init__(self,
    method save (line 182) | def save(self, save_path):
    method load (line 185) | def load(self, load_path):
    method get_epsilon (line 188) | def get_epsilon(self):
    method get_egreedy_action (line 193) | def get_egreedy_action(self, o, epsilon):
    method optimize (line 199) | def optimize(self):
    method train (line 228) | def train(self):
    method run_train_episode (line 270) | def run_train_episode(self, step_limit):
    method run_eval_episode (line 294) | def run_eval_episode(self,

FILE: nasim/agents/keyboard_agent.py
  function print_actions (line 22) | def print_actions(action_space):
  function choose_flat_action (line 28) | def choose_flat_action(env):
  function display_actions (line 40) | def display_actions(actions):
  function choose_item (line 49) | def choose_item(items):
  function choose_param_action (line 58) | def choose_param_action(env):
  function choose_action (line 131) | def choose_action(env):
  function run_keyboard_agent (line 141) | def run_keyboard_agent(env):
  function run_generative_keyboard_agent (line 185) | def run_generative_keyboard_agent(env, render_mode="human"):

FILE: nasim/agents/ql_agent.py
  class TabularQFunction (line 44) | class TabularQFunction:
    method __init__ (line 47) | def __init__(self, num_actions):
    method __call__ (line 51) | def __call__(self, x):
    method forward (line 54) | def forward(self, x):
    method forward_batch (line 61) | def forward_batch(self, x_batch):
    method update_batch (line 64) | def update_batch(self, s_batch, a_batch, delta_batch):
    method update (line 69) | def update(self, s, a, delta):
    method get_action (line 73) | def get_action(self, x):
    method display (line 76) | def display(self):
  class TabularQLearningAgent (line 80) | class TabularQLearningAgent:
    method __init__ (line 83) | def __init__(self,
    method get_epsilon (line 129) | def get_epsilon(self):
    method get_egreedy_action (line 134) | def get_egreedy_action(self, o, epsilon):
    method optimize (line 139) | def optimize(self, s, a, next_s, r, done):
    method train (line 158) | def train(self):
    method run_train_episode (line 200) | def run_train_episode(self, step_limit):
    method run_eval_episode (line 223) | def run_eval_episode(self,

FILE: nasim/agents/ql_replay_agent.py
  class ReplayMemory (line 46) | class ReplayMemory:
    method __init__ (line 49) | def __init__(self, capacity, s_dims):
    method store (line 58) | def store(self, s, a, next_s, r, done):
    method sample_batch (line 67) | def sample_batch(self, batch_size):
  class TabularQFunction (line 77) | class TabularQFunction:
    method __init__ (line 80) | def __init__(self, num_actions):
    method __call__ (line 84) | def __call__(self, x):
    method forward (line 87) | def forward(self, x):
    method forward_batch (line 94) | def forward_batch(self, x_batch):
    method update (line 97) | def update(self, s_batch, a_batch, delta_batch):
    method get_action (line 102) | def get_action(self, x):
    method display (line 105) | def display(self):
  class TabularQLearningAgent (line 109) | class TabularQLearningAgent:
    method __init__ (line 112) | def __init__(self,
    method get_epsilon (line 164) | def get_epsilon(self):
    method get_egreedy_action (line 169) | def get_egreedy_action(self, o, epsilon):
    method optimize (line 174) | def optimize(self):
    method train (line 199) | def train(self):
    method run_train_episode (line 241) | def run_train_episode(self, step_limit):
    method run_eval_episode (line 267) | def run_eval_episode(self,

FILE: nasim/agents/random_agent.py
  function run_random_agent (line 22) | def run_random_agent(env, step_limit=1e6, verbose=True):

FILE: nasim/envs/action.py
  function load_action_list (line 43) | def load_action_list(scenario):
  class Action (line 79) | class Action:
    method __init__ (line 111) | def __init__(self,
    method is_exploit (line 140) | def is_exploit(self):
    method is_privilege_escalation (line 150) | def is_privilege_escalation(self):
    method is_scan (line 160) | def is_scan(self):
    method is_remote (line 170) | def is_remote(self):
    method is_service_scan (line 183) | def is_service_scan(self):
    method is_os_scan (line 193) | def is_os_scan(self):
    method is_subnet_scan (line 203) | def is_subnet_scan(self):
    method is_process_scan (line 213) | def is_process_scan(self):
    method is_noop (line 223) | def is_noop(self):
    method __str__ (line 233) | def __str__(self):
    method __hash__ (line 240) | def __hash__(self):
    method __eq__ (line 243) | def __eq__(self, other):
  class Exploit (line 256) | class Exploit(Action):
    method __init__ (line 273) | def __init__(self,
    method __str__ (line 312) | def __str__(self):
    method __eq__ (line 316) | def __eq__(self, other):
  class PrivilegeEscalation (line 324) | class PrivilegeEscalation(Action):
    method __init__ (line 343) | def __init__(self,
    method __str__ (line 383) | def __str__(self):
    method __eq__ (line 387) | def __eq__(self, other):
  class ServiceScan (line 395) | class ServiceScan(Action):
    method __init__ (line 401) | def __init__(self,
  class OSScan (line 428) | class OSScan(Action):
    method __init__ (line 434) | def __init__(self,
  class SubnetScan (line 461) | class SubnetScan(Action):
    method __init__ (line 467) | def __init__(self,
  class ProcessScan (line 494) | class ProcessScan(Action):
    method __init__ (line 500) | def __init__(self,
  class NoOp (line 527) | class NoOp(Action):
    method __init__ (line 533) | def __init__(self, *args, **kwargs):
  class ActionResult (line 541) | class ActionResult:
    method __init__ (line 578) | def __init__(self,
    method info (line 631) | def info(self):
    method __str__ (line 653) | def __str__(self):
  class FlatActionSpace (line 660) | class FlatActionSpace(spaces.Discrete):
    method __init__ (line 675) | def __init__(self, scenario):
    method get_action (line 685) | def get_action(self, action_idx):
  class ParameterisedActionSpace (line 704) | class ParameterisedActionSpace(spaces.MultiDiscrete):
    method __init__ (line 764) | def __init__(self, scenario):
    method get_action (line 785) | def get_action(self, action_vec):
    method _get_scan_action_def (line 840) | def _get_scan_action_def(self, a_class):
    method _get_exploit_def (line 854) | def _get_exploit_def(self, service, os):
    method _get_privesc_def (line 863) | def _get_privesc_def(self, proc, os):

FILE: nasim/envs/environment.py
  class NASimEnv (line 16) | class NASimEnv(gym.Env):
    method __init__ (line 59) | def __init__(self,
    method reset (line 110) | def reset(self, *, seed=None, options=None):
    method step (line 143) | def step(self, action):
    method generative_step (line 191) | def generative_step(self, state, action):
    method generate_random_initial_state (line 230) | def generate_random_initial_state(self):
    method generate_initial_state (line 244) | def generate_initial_state(self):
    method render (line 259) | def render(self):
    method render_obs (line 271) | def render_obs(self, mode="human", obs=None):
    method render_state (line 305) | def render_state(self, mode="human", state=None):
    method render_action (line 345) | def render_action(self, action):
    method render_episode (line 362) | def render_episode(self, episode, width=7, height=7):
    method render_network_graph (line 380) | def render_network_graph(self, ax=None, show=False):
    method get_minimum_hops (line 398) | def get_minimum_hops(self):
    method get_action_mask (line 412) | def get_action_mask(self):
    method get_score_upper_bound (line 431) | def get_score_upper_bound(self):
    method goal_reached (line 451) | def goal_reached(self, state=None):
    method __str__ (line 471) | def __str__(self):
    method close (line 481) | def close(self):

FILE: nasim/envs/gym_env.py
  class NASimGymEnv (line 5) | class NASimGymEnv(NASimEnv):
    method __init__ (line 11) | def __init__(self,

FILE: nasim/envs/host_vector.py
  class HostVector (line 13) | class HostVector:
    method __init__ (line 82) | def __init__(self, vector):
    method vectorize (line 86) | def vectorize(cls, host, address_space_bounds, vector=None):
    method vectorize_random (line 115) | def vectorize_random(cls, host, address_space_bounds, vector=None):
    method compromised (line 132) | def compromised(self):
    method compromised (line 136) | def compromised(self, val):
    method discovered (line 140) | def discovered(self):
    method discovered (line 144) | def discovered(self, val):
    method reachable (line 148) | def reachable(self):
    method reachable (line 152) | def reachable(self, val):
    method address (line 156) | def address(self):
    method value (line 163) | def value(self):
    method discovery_value (line 167) | def discovery_value(self):
    method access (line 171) | def access(self):
    method access (line 175) | def access(self, val):
    method services (line 179) | def services(self):
    method os (line 186) | def os(self):
    method processes (line 193) | def processes(self):
    method is_running_service (line 199) | def is_running_service(self, srv):
    method is_running_os (line 203) | def is_running_os(self, os):
    method is_running_process (line 207) | def is_running_process(self, proc):
    method perform_action (line 211) | def perform_action(self, action):
    method observe (line 297) | def observe(self,
    method readable (line 338) | def readable(self):
    method copy (line 341) | def copy(self):
    method numpy (line 345) | def numpy(self):
    method _initialize (line 349) | def _initialize(cls, address_space_bounds, services, os_info, processes):
    method _update_vector_idxs (line 366) | def _update_vector_idxs(cls):
    method _subnet_address_idx_slice (line 383) | def _subnet_address_idx_slice(cls):
    method _host_address_idx_slice (line 387) | def _host_address_idx_slice(cls):
    method _get_service_idx (line 391) | def _get_service_idx(cls, srv_num):
    method _service_idx_slice (line 395) | def _service_idx_slice(cls):
    method _get_os_idx (line 399) | def _get_os_idx(cls, os_num):
    method _os_idx_slice (line 403) | def _os_idx_slice(cls):
    method _get_process_idx (line 407) | def _get_process_idx(cls, proc_num):
    method _process_idx_slice (line 411) | def _process_idx_slice(cls):
    method get_readable (line 415) | def get_readable(cls, vector):
    method reset (line 435) | def reset(cls):
    method __repr__ (line 443) | def __repr__(self):
    method __hash__ (line 446) | def __hash__(self):
    method __eq__ (line 449) | def __eq__(self, other):

FILE: nasim/envs/network.py
  class Network (line 11) | class Network:
    method __init__ (line 14) | def __init__(self, scenario):
    method reset (line 25) | def reset(self, state):
    method perform_action (line 36) | def perform_action(self, state, action):
    method _perform_subnet_scan (line 99) | def _perform_subnet_scan(self, next_state, action):
    method _update (line 131) | def _update(self, state, action, action_obs):
    method _update_reachable (line 135) | def _update_reachable(self, state, compromised_addr):
    method get_sensitive_hosts (line 146) | def get_sensitive_hosts(self):
    method is_sensitive_host (line 149) | def is_sensitive_host(self, host_address):
    method subnets_connected (line 152) | def subnets_connected(self, subnet_1, subnet_2):
    method subnet_traffic_permitted (line 155) | def subnet_traffic_permitted(self, src_subnet, dest_subnet, service):
    method host_traffic_permitted (line 163) | def host_traffic_permitted(self, src_addr, dest_addr, service):
    method has_required_remote_permission (line 167) | def has_required_remote_permission(self, state, action):
    method traffic_permitted (line 187) | def traffic_permitted(self, state, host_addr, service):
    method subnet_public (line 204) | def subnet_public(self, subnet):
    method get_number_of_subnets (line 207) | def get_number_of_subnets(self):
    method all_sensitive_hosts_compromised (line 210) | def all_sensitive_hosts_compromised(self, state):
    method get_total_sensitive_host_value (line 216) | def get_total_sensitive_host_value(self):
    method get_total_discovery_value (line 222) | def get_total_discovery_value(self):
    method get_minimal_hops (line 228) | def get_minimal_hops(self):
    method get_subnet_depths (line 233) | def get_subnet_depths(self):
    method __str__ (line 236) | def __str__(self):

FILE: nasim/envs/observation.py
  class Observation (line 7) | class Observation:
    method __init__ (line 51) | def __init__(self, state_shape):
    method get_space_bounds (line 63) | def get_space_bounds(scenario):
    method from_numpy (line 82) | def from_numpy(cls, o_array, state_shape):
    method from_state (line 89) | def from_state(self, state):
    method from_action_result (line 92) | def from_action_result(self, action_result):
    method from_state_and_action (line 102) | def from_state_and_action(self, state, action_result):
    method update_from_host (line 106) | def update_from_host(self, host_idx, host_obs_vector):
    method success (line 110) | def success(self):
    method connection_error (line 121) | def connection_error(self):
    method permission_error (line 132) | def permission_error(self):
    method undefined_error (line 143) | def undefined_error(self):
    method shape_flat (line 153) | def shape_flat(self):
    method shape (line 163) | def shape(self):
    method numpy_flat (line 173) | def numpy_flat(self):
    method numpy (line 183) | def numpy(self):
    method get_readable (line 193) | def get_readable(self):
    method __str__ (line 217) | def __str__(self):
    method __eq__ (line 220) | def __eq__(self, other):
    method __hash__ (line 223) | def __hash__(self):

FILE: nasim/envs/render.py
  class Viewer (line 31) | class Viewer:
    method __init__ (line 34) | def __init__(self, network):
    method render_graph (line 45) | def render_graph(self, state, ax=None, show=False, width=5, height=6):
    method render_episode (line 98) | def render_episode(self, episode, width=7, height=5):
    method render_readable (line 116) | def render_readable(self, obs):
    method render_readable_state (line 131) | def render_readable_state(self, state):
    method close (line 144) | def close(self):
    method _construct_table_from_dict (line 148) | def _construct_table_from_dict(self, d):
    method _construct_table_from_list_of_dicts (line 155) | def _construct_table_from_list_of_dicts(self, l):
    method _construct_graph (line 163) | def _construct_graph(self, state):
    method _get_host_positions (line 209) | def _get_host_positions(self, network):
    method _get_host_position (line 269) | def _get_host_position(self, m, positions, address_space, row_min, row...
    method _get_subnets (line 307) | def _get_subnets(self, network):
  class EpisodeViewer (line 328) | class EpisodeViewer:
    method __init__ (line 331) | def __init__(self, episode, G, sensitive_hosts, width=7, height=7):
    method _setup_GUI (line 343) | def _setup_GUI(self, width, height):
    method _close (line 371) | def _close(self):
    method _next_graph (line 375) | def _next_graph(self):
    method _previous_graph (line 382) | def _previous_graph(self):
    method _update_graph (line 387) | def _update_graph(self, G, state):
    method _draw_graph (line 398) | def _draw_graph(self, G):
    method legend (line 446) | def legend(compromised=True):
  function get_host_representation (line 463) | def get_host_representation(state, sensitive_hosts, m, representation):

FILE: nasim/envs/state.py
  class State (line 7) | class State:
    method __init__ (line 25) | def __init__(self, network_tensor, host_num_map):
    method tensorize (line 39) | def tensorize(cls, network):
    method generate_initial_state (line 54) | def generate_initial_state(cls, network):
    method generate_random_initial_state (line 60) | def generate_random_initial_state(cls, network):
    method from_numpy (line 79) | def from_numpy(cls, s_array, state_shape, host_num_map):
    method reset (line 85) | def reset(cls):
    method hosts (line 90) | def hosts(self):
    method copy (line 96) | def copy(self):
    method get_initial_observation (line 100) | def get_initial_observation(self, fully_obs):
    method get_observation (line 123) | def get_observation(self, action, action_result, fully_obs):
    method shape_flat (line 202) | def shape_flat(self):
    method shape (line 205) | def shape(self):
    method numpy_flat (line 208) | def numpy_flat(self):
    method numpy (line 211) | def numpy(self):
    method update_host (line 214) | def update_host(self, host_addr, host_vector):
    method get_host (line 218) | def get_host(self, host_addr):
    method get_host_idx (line 222) | def get_host_idx(self, host_addr):
    method get_host_and_idx (line 225) | def get_host_and_idx(self, host_addr):
    method host_reachable (line 229) | def host_reachable(self, host_addr):
    method host_compromised (line 232) | def host_compromised(self, host_addr):
    method host_discovered (line 235) | def host_discovered(self, host_addr):
    method host_has_access (line 238) | def host_has_access(self, host_addr, access_level):
    method set_host_compromised (line 241) | def set_host_compromised(self, host_addr):
    method set_host_reachable (line 244) | def set_host_reachable(self, host_addr):
    method set_host_discovered (line 247) | def set_host_discovered(self, host_addr):
    method get_host_value (line 250) | def get_host_value(self, host_address):
    method host_is_running_service (line 253) | def host_is_running_service(self, host_addr, service):
    method host_is_running_os (line 256) | def host_is_running_os(self, host_addr, os):
    method get_total_host_value (line 259) | def get_total_host_value(self):
    method state_size (line 266) | def state_size(self):
    method get_readable (line 269) | def get_readable(self):
    method __str__ (line 277) | def __str__(self):
    method __hash__ (line 284) | def __hash__(self):
    method __eq__ (line 287) | def __eq__(self, other):

FILE: nasim/envs/utils.py
  class OneHotBool (line 9) | class OneHotBool(enum.IntEnum):
    method from_bool (line 15) | def from_bool(b):
    method __str__ (line 20) | def __str__(self):
    method __repr__ (line 23) | def __repr__(self):
  class ServiceState (line 27) | class ServiceState(enum.IntEnum):
    method __str__ (line 33) | def __str__(self):
    method __repr__ (line 36) | def __repr__(self):
  class AccessLevel (line 40) | class AccessLevel(enum.IntEnum):
    method __str__ (line 45) | def __str__(self):
    method __repr__ (line 48) | def __repr__(self):
  function get_minimal_hops_to_goal (line 52) | def get_minimal_hops_to_goal(topology, sensitive_addresses):
  function min_subnet_depth (line 105) | def min_subnet_depth(topology):

FILE: nasim/scenarios/__init__.py
  function make_benchmark_scenario (line 8) | def make_benchmark_scenario(scenario_name, seed=None):
  function generate_scenario (line 42) | def generate_scenario(num_hosts, num_services, **params):
  function load_scenario (line 63) | def load_scenario(path, name=None):
  function get_scenario_max (line 83) | def get_scenario_max(scenario_name):

FILE: nasim/scenarios/generator.py
  class ScenarioGenerator (line 25) | class ScenarioGenerator:
    method generate (line 66) | def generate(self,
    method _construct_scenario (line 226) | def _construct_scenario(self):
    method _generate_subnets (line 249) | def _generate_subnets(self, num_hosts):
    method _generate_topology (line 269) | def _generate_topology(self):
    method _generate_address_space_bounds (line 302) | def _generate_address_space_bounds(self, address_space_bounds):
    method _generate_os (line 325) | def _generate_os(self, num_os):
    method _generate_services (line 328) | def _generate_services(self, num_services):
    method _generate_processes (line 331) | def _generate_processes(self, num_processes):
    method _generate_exploits (line 334) | def _generate_exploits(self, num_exploits, exploit_cost, exploit_probs):
    method _generate_privescs (line 359) | def _generate_privescs(self, num_privesc, privesc_cost, privesc_probs):
    method _get_action_probs (line 402) | def _get_action_probs(self, num_actions, action_probs):
    method _generate_sensitive_hosts (line 433) | def _generate_sensitive_hosts(self, r_sensitive, r_user, random_goal):
    method _generate_uniform_hosts (line 449) | def _generate_uniform_hosts(self):
    method _possible_host_configs (line 482) | def _possible_host_configs(self):
    method _permutations (line 505) | def _permutations(self, n):
    method _generate_correlated_hosts (line 536) | def _generate_correlated_hosts(self, alpha_H, alpha_V, lambda_V):
    method _get_host_config (line 575) | def _get_host_config(self,
    method _sample_config (line 600) | def _sample_config(self,
    method _dirichlet_process (line 623) | def _dirichlet_process(self,
    method _dirichlet_sample (line 649) | def _dirichlet_sample(self, alpha_V, choices, prev_vals):
    method _is_sensitive_host (line 662) | def _is_sensitive_host(self, addr):
    method _convert_to_service_map (line 665) | def _convert_to_service_map(self, config):
    method _convert_to_process_map (line 672) | def _convert_to_process_map(self, config):
    method _convert_to_os_map (line 679) | def _convert_to_os_map(self, os):
    method _ensure_host_vulnerability (line 691) | def _ensure_host_vulnerability(self):
    method _host_is_vulnerable (line 716) | def _host_is_vulnerable(self, host, access_level=u.USER_ACCESS):
    method _host_is_vulnerable_to_exploit (line 726) | def _host_is_vulnerable_to_exploit(self, host, exploit_def):
    method _host_is_vulnerable_to_privesc (line 733) | def _host_is_vulnerable_to_privesc(self, host, privesc_def):
    method _update_host_to_vulnerable (line 740) | def _update_host_to_vulnerable(self, host, access_level=u.USER_ACCESS):
    method _update_host_exploit_vulnerability (line 767) | def _update_host_exploit_vulnerability(self, host, os_constraint):
    method _update_host_privesc_vulnerability (line 791) | def _update_host_privesc_vulnerability(self, host, os_constraint):
    method _update_host_os (line 813) | def _update_host_os(self, host, os):
    method _get_host_value (line 819) | def _get_host_value(self, address):
    method _generate_firewall (line 822) | def _generate_firewall(self, restrictiveness):

FILE: nasim/scenarios/host.py
  class Host (line 2) | class Host:
    method __init__ (line 10) | def __init__(self,
    method is_running_service (line 65) | def is_running_service(self, service):
    method is_running_os (line 68) | def is_running_os(self, os):
    method is_running_process (line 71) | def is_running_process(self, process):
    method traffic_permitted (line 74) | def traffic_permitted(self, addr, service):
    method __str__ (line 77) | def __str__(self):
    method __repr__ (line 106) | def __repr__(self):

FILE: nasim/scenarios/loader.py
  class ScenarioLoader (line 64) | class ScenarioLoader:
    method load (line 66) | def load(self, file_path, name=None):
    method _construct_scenario (line 108) | def _construct_scenario(self):
    method _check_scenario_sections_valid (line 129) | def _check_scenario_sections_valid(self):
    method _parse_subnets (line 152) | def _parse_subnets(self):
    method _validate_subnets (line 160) | def _validate_subnets(self, subnets):
    method _parse_topology (line 167) | def _parse_topology(self):
    method _validate_topology (line 172) | def _validate_topology(self, topology):
    method _parse_os (line 189) | def _parse_os(self):
    method _validate_os (line 194) | def _validate_os(self, os):
    method _parse_services (line 200) | def _parse_services(self):
    method _validate_services (line 205) | def _validate_services(self, services):
    method _parse_processes (line 211) | def _parse_processes(self):
    method _validate_processes (line 216) | def _validate_processes(self, processes):
    method _parse_sensitive_hosts (line 222) | def _parse_sensitive_hosts(self):
    method _validate_sensitive_hosts (line 230) | def _validate_sensitive_hosts(self, sensitive_hosts):
    method _is_valid_subnet_ID (line 268) | def _is_valid_subnet_ID(self, subnet_ID):
    method _is_valid_host_address (line 275) | def _is_valid_host_address(self, subnet_ID, host_ID):
    method _parse_exploits (line 284) | def _parse_exploits(self):
    method _validate_exploits (line 289) | def _validate_exploits(self, exploits):
    method _validate_single_exploit (line 293) | def _validate_single_exploit(self, e_name, e):
    method _parse_privescs (line 326) | def _parse_privescs(self):
    method _validate_privescs (line 330) | def _validate_privescs(self, privescs):
    method _validate_single_privesc (line 334) | def _validate_single_privesc(self, pe_name, pe):
    method _parse_scan_costs (line 369) | def _parse_scan_costs(self):
    method _validate_scan_cost (line 382) | def _validate_scan_cost(self, scan_name, scan_cost):
    method _parse_host_configs (line 385) | def _parse_host_configs(self):
    method _validate_host_configs (line 389) | def _validate_host_configs(self, host_configs):
    method _has_all_host_addresses (line 401) | def _has_all_host_addresses(self, addresses):
    method _validate_host_config (line 412) | def _validate_host_config(self, addr, cfg):
    method _validate_host_address (line 479) | def _validate_host_address(self, addr, err_prefix=""):
    method _parse_firewall (line 500) | def _parse_firewall(self):
    method _validate_firewall (line 508) | def _validate_firewall(self, firewall):
    method _contains_all_required_firewalls (line 519) | def _contains_all_required_firewalls(self, firewall):
    method _is_valid_firewall_setting (line 529) | def _is_valid_firewall_setting(self, f):
    method _parse_hosts (line 541) | def _parse_hosts(self):
    method _construct_host_config (line 560) | def _construct_host_config(self, host_cfg):
    method _get_host_value (line 572) | def _get_host_value(self, address, host_cfg):
    method _parse_step_limit (line 577) | def _parse_step_limit(self):

FILE: nasim/scenarios/scenario.py
  class Scenario (line 7) | class Scenario:
    method __init__ (line 9) | def __init__(self, scenario_dict, name=None, generated=False):
    method step_limit (line 23) | def step_limit(self):
    method services (line 27) | def services(self):
    method num_services (line 31) | def num_services(self):
    method os (line 35) | def os(self):
    method num_os (line 39) | def num_os(self):
    method processes (line 43) | def processes(self):
    method num_processes (line 47) | def num_processes(self):
    method access_levels (line 51) | def access_levels(self):
    method exploits (line 55) | def exploits(self):
    method privescs (line 59) | def privescs(self):
    method exploit_map (line 63) | def exploit_map(self):
    method privesc_map (line 97) | def privesc_map(self):
    method subnets (line 131) | def subnets(self):
    method topology (line 135) | def topology(self):
    method sensitive_hosts (line 139) | def sensitive_hosts(self):
    method sensitive_addresses (line 143) | def sensitive_addresses(self):
    method firewall (line 147) | def firewall(self):
    method hosts (line 151) | def hosts(self):
    method address_space (line 155) | def address_space(self):
    method service_scan_cost (line 159) | def service_scan_cost(self):
    method os_scan_cost (line 163) | def os_scan_cost(self):
    method subnet_scan_cost (line 167) | def subnet_scan_cost(self):
    method process_scan_cost (line 171) | def process_scan_cost(self):
    method address_space_bounds (line 175) | def address_space_bounds(self):
    method host_value_bounds (line 181) | def host_value_bounds(self):
    method host_discovery_value_bounds (line 197) | def host_discovery_value_bounds(self):
    method display (line 212) | def display(self):
    method get_action_space_size (line 215) | def get_action_space_size(self):
    method get_state_space_size (line 223) | def get_state_space_size(self):
    method get_state_dims (line 237) | def get_state_dims(self):
    method get_observation_dims (line 250) | def get_observation_dims(self):
    method get_description (line 254) | def get_description(self):

FILE: nasim/scenarios/utils.py
  function load_yaml (line 60) | def load_yaml(file_path):
  function get_file_name (line 82) | def get_file_name(file_path):

FILE: nasim/scripts/describe_scenarios.py
  function describe_scenarios (line 32) | def describe_scenarios(output=None):

FILE: nasim/scripts/run_random_benchmarks.py
  function print_msg (line 22) | def print_msg(msg):
  class Result (line 26) | class Result:
    method __init__ (line 28) | def __init__(self, name):
    method add (line 33) | def add(self, steps, reward):
    method summarize (line 37) | def summarize(self):
    method get_formatted_summary (line 44) | def get_formatted_summary(self):
  function run_scenario (line 52) | def run_scenario(args):
  function collate_results (line 65) | def collate_results(results):
  function output_results (line 75) | def output_results(results, output=None):
  function run_random_benchmark (line 94) | def run_random_benchmark(num_cpus=1, num_seeds=10, output=None):

FILE: nasim/scripts/train_dqn.py
  class BestDQN (line 7) | class BestDQN(DQNAgent):
    method __init__ (line 10) | def __init__(self,
    method run_train_episode (line 20) | def run_train_episode(self, step_limit):

FILE: setup.py
  function get_version (line 22) | def get_version():

FILE: test/test_bruteforce.py
  function test_bruteforce_static (line 18) | def test_bruteforce_static(scenario, seed, fully_obs, flat_actions, flat...
  function test_bruteforce_gen (line 36) | def test_bruteforce_gen(scenario, seed, fully_obs, flat_actions, flat_obs):

FILE: test/test_env.py
  function test_render_error (line 10) | def test_render_error():
  function test_render_readable (line 17) | def test_render_readable():
  function test_render_state_error (line 23) | def test_render_state_error():
  function test_render_state_readable (line 30) | def test_render_state_readable():
  function test_render_action (line 37) | def test_render_action(flat_actions):
  function test_get_total_discovery_value (line 47) | def test_get_total_discovery_value(scenario, expected_value):
  function test_get_total_sensitive_host_value (line 58) | def test_get_total_sensitive_host_value(scenario, expected_value):
  function test_get_minumum_hops (line 69) | def test_get_minumum_hops(scenario, expected_value):

FILE: test/test_generator.py
  function test_generator (line 14) | def test_generator(scenario, seed):

FILE: test/test_gym_bruteforce.py
  function test_gym_reload (line 16) | def test_gym_reload():
  function test_bruteforce (line 26) | def test_bruteforce(scenario, po, obs, actions,v):