signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def dist(self, other): | dx = self.x - other.x<EOL>dy = self.y - other.y<EOL>return math.sqrt(dx**<NUM_LIT:2> + dy**<NUM_LIT:2>)<EOL> | Distance to some other point. | f1598:c0:m3 |
def dist_sq(self, other): | dx = self.x - other.x<EOL>dy = self.y - other.y<EOL>return dx**<NUM_LIT:2> + dy**<NUM_LIT:2><EOL> | Distance squared to some other point. | f1598:c0:m4 |
def round(self): | return Point(int(round(self.x)), int(round(self.y)))<EOL> | Round `x` and `y` to integers. | f1598:c0:m5 |
def floor(self): | return Point(int(math.floor(self.x)), int(math.floor(self.y)))<EOL> | Round `x` and `y` down to integers. | f1598:c0:m6 |
def ceil(self): | return Point(int(math.ceil(self.x)), int(math.ceil(self.y)))<EOL> | Round `x` and `y` up to integers. | f1598:c0:m7 |
def abs(self): | return Point(abs(self.x), abs(self.y))<EOL> | Take the absolute value of `x` and `y`. | f1598:c0:m8 |
def len(self): | return math.sqrt(self.x**<NUM_LIT:2> + self.y**<NUM_LIT:2>)<EOL> | Length of the vector to this point. | f1598:c0:m9 |
def scale(self, target_len): | return self * (target_len / self.len())<EOL> | Scale the vector to have the target length. | f1598:c0:m10 |
def scale_max_size(self, max_size): | return self * (max_size / self).min_dim()<EOL> | Scale this value, keeping aspect ratio, but fitting inside `max_size`. | f1598:c0:m11 |
def scale_min_size(self, min_size): | return self * (min_size / self).max_dim()<EOL> | Scale this value, keeping aspect ratio, but fitting around `min_size`. | f1598:c0:m12 |
def transpose(self): | return Point(self.y, self.x)<EOL> | Flip x and y. | f1598:c0:m15 |
def contained_circle(self, pt, radius): | return self.dist(pt) < radius<EOL> | Is this point inside the circle defined by (`pt`, `radius`)? | f1598:c0:m19 |
def bound(self, p1, p2=None): | r = Rect(p1, p2)<EOL>return Point(min(max(self.x, r.l), r.r), min(max(self.y, r.t), r.b))<EOL> | Bound this point within the rect defined by (`p1`, `p2`). | f1598:c0:m20 |
def contains_point(self, pt): | return (self.l < pt.x and self.r > pt.x and<EOL>self.t < pt.y and self.b > pt.y)<EOL> | Is the point inside this rect? | f1598:c1:m15 |
def contains_circle(self, pt, radius): | return (self.l < pt.x - radius and self.r > pt.x + radius and<EOL>self.t < pt.y - radius and self.b > pt.y + radius)<EOL> | Is the circle completely inside this rect? | f1598:c1:m16 |
def intersects_circle(self, pt, radius): | <EOL>rect_corner = self.size / <NUM_LIT:2> <EOL>circle_center = (pt - self.center).abs() <EOL>if (circle_center.x > rect_corner.x + radius or<EOL>circle_center.y > rect_corner.y + radius):<EOL><INDENT>return False<EOL><DEDENT>if (circle_center.x <= rect_corner.x or<EOL>circle_center.y <= rect_corner.y):<EOL><INDENT>r... | Does the circle intersect with this rect? | f1598:c1:m17 |
def ham_dist(str1, str2): | assert len(str1) == len(str2)<EOL>return sum(c1 != c2 for c1, c2 in zip(str1, str2))<EOL> | Hamming distance. Count the number of differences between str1 and str2. | f1600:m0 |
def check_error(res, error_enum): | if res.HasField("<STR_LIT:error>"):<EOL><INDENT>enum_name = error_enum.DESCRIPTOR.full_name<EOL>error_name = error_enum.Name(res.error)<EOL>details = getattr(res, "<STR_LIT>", "<STR_LIT>")<EOL>raise RequestError("<STR_LIT>" % (enum_name, error_name, details), res)<EOL><DEDENT>return res<EOL> | Raise if the result has an error, otherwise return the result. | f1602:m0 |
def decorate_check_error(error_enum): | def decorator(func):<EOL><INDENT>@functools.wraps(func)<EOL>def _check_error(*args, **kwargs):<EOL><INDENT>return check_error(func(*args, **kwargs), error_enum)<EOL><DEDENT>return _check_error<EOL><DEDENT>return decorator<EOL> | Decorator to call `check_error` on the return value. | f1602:m1 |
def skip_status(*skipped): | def decorator(func):<EOL><INDENT>@functools.wraps(func)<EOL>def _skip_status(self, *args, **kwargs):<EOL><INDENT>if self.status not in skipped:<EOL><INDENT>return func(self, *args, **kwargs)<EOL><DEDENT><DEDENT>return _skip_status<EOL><DEDENT>return decorator<EOL> | Decorator to skip this call if we're in one of the skipped states. | f1602:m2 |
def valid_status(*valid): | def decorator(func):<EOL><INDENT>@functools.wraps(func)<EOL>def _valid_status(self, *args, **kwargs):<EOL><INDENT>if self.status not in valid:<EOL><INDENT>raise protocol.ProtocolError(<EOL>"<STR_LIT>" % (<EOL>func.__name__, self.status, "<STR_LIT:U+002C>".join(map(str, valid))))<EOL><DEDENT>return func(self, *args, **k... | Decorator to assert that we're in a valid state. | f1602:m3 |
def catch_game_end(func): | @functools.wraps(func)<EOL>def _catch_game_end(self, *args, **kwargs):<EOL><INDENT>"""<STR_LIT>"""<EOL>prev_status = self.status<EOL>try:<EOL><INDENT>return func(self, *args, **kwargs)<EOL><DEDENT>except protocol.ProtocolError as protocol_error:<EOL><INDENT>if prev_status == Status.in_game and (<EOL>"<STR_LIT>" in str(... | Decorator to handle 'Game has already ended' exceptions. | f1602:m4 |
@sw.decorate<EOL><INDENT>def _connect(self, host, port, proc, timeout_seconds):<DEDENT> | if "<STR_LIT::>" in host and not host.startswith("<STR_LIT:[>"): <EOL><INDENT>host = "<STR_LIT>" % host<EOL><DEDENT>url = "<STR_LIT>" % (host, port)<EOL>was_running = False<EOL>for i in range(timeout_seconds):<EOL><INDENT>is_running = proc and proc.running<EOL>was_running = was_running or is_running<EOL>if (i >= timeo... | Connect to the websocket, retrying as needed. Returns the socket. | f1602:c2:m1 |
@valid_status(Status.launched, Status.ended, Status.in_game, Status.in_replay)<EOL><INDENT>@decorate_check_error(sc_pb.ResponseCreateGame.Error)<EOL>@sw.decorate<EOL>def create_game(self, req_create_game):<DEDENT> | return self._client.send(create_game=req_create_game)<EOL> | Create a new game. This can only be done by the host. | f1602:c2:m3 |
@valid_status(Status.launched, Status.init_game)<EOL><INDENT>@decorate_check_error(sc_pb.ResponseSaveMap.Error)<EOL>@sw.decorate<EOL>def save_map(self, map_path, map_data):<DEDENT> | return self._client.send(save_map=sc_pb.RequestSaveMap(<EOL>map_path=map_path, map_data=map_data))<EOL> | Save a map into temp dir so create game can access it in multiplayer. | f1602:c2:m4 |
@valid_status(Status.launched, Status.init_game)<EOL><INDENT>@decorate_check_error(sc_pb.ResponseJoinGame.Error)<EOL>@sw.decorate<EOL>def join_game(self, req_join_game):<DEDENT> | return self._client.send(join_game=req_join_game)<EOL> | Join a game, done by all connected clients. | f1602:c2:m5 |
@valid_status(Status.ended, Status.in_game)<EOL><INDENT>@decorate_check_error(sc_pb.ResponseRestartGame.Error)<EOL>@sw.decorate<EOL>def restart(self):<DEDENT> | return self._client.send(restart_game=sc_pb.RequestRestartGame())<EOL> | Restart the game. Only done by the host. | f1602:c2:m6 |
@valid_status(Status.launched, Status.ended, Status.in_game, Status.in_replay)<EOL><INDENT>@decorate_check_error(sc_pb.ResponseStartReplay.Error)<EOL>@sw.decorate<EOL>def start_replay(self, req_start_replay):<DEDENT> | return self._client.send(start_replay=req_start_replay)<EOL> | Start a replay. | f1602:c2:m7 |
@valid_status(Status.in_game, Status.in_replay)<EOL><INDENT>@sw.decorate<EOL>def game_info(self):<DEDENT> | return self._client.send(game_info=sc_pb.RequestGameInfo())<EOL> | Get the basic information about the game. | f1602:c2:m8 |
@valid_status(Status.in_game, Status.in_replay)<EOL><INDENT>@sw.decorate<EOL>def data_raw(self):<DEDENT> | return self._client.send(data=sc_pb.RequestData(<EOL>ability_id=True, unit_type_id=True))<EOL> | Get the raw static data for the current game. Prefer `data` instead. | f1602:c2:m9 |
def data(self): | return static_data.StaticData(self.data_raw())<EOL> | Get the static data for the current game. | f1602:c2:m10 |
@valid_status(Status.in_game, Status.in_replay, Status.ended)<EOL><INDENT>@sw.decorate<EOL>def observe(self):<DEDENT> | return self._client.send(observation=sc_pb.RequestObservation())<EOL> | Get a current observation. | f1602:c2:m11 |
@valid_status(Status.in_game, Status.in_replay)<EOL><INDENT>@sw.decorate<EOL>def step(self, count=<NUM_LIT:1>):<DEDENT> | return self._client.send(step=sc_pb.RequestStep(count=count))<EOL> | Step the engine forward by one (or more) step. | f1602:c2:m12 |
@skip_status(Status.in_replay)<EOL><INDENT>@valid_status(Status.in_game)<EOL>@catch_game_end<EOL>@sw.decorate<EOL>def actions(self, req_action):<DEDENT> | if FLAGS.sc2_log_actions:<EOL><INDENT>for action in req_action.actions:<EOL><INDENT>sys.stderr.write(str(action))<EOL>sys.stderr.flush()<EOL><DEDENT><DEDENT>return self._client.send(action=req_action)<EOL> | Send a `sc_pb.RequestAction`, which may include multiple actions. | f1602:c2:m13 |
def act(self, action): | if action and action.ListFields(): <EOL><INDENT>return self.actions(sc_pb.RequestAction(actions=[action]))<EOL><DEDENT> | Send a single action. This is a shortcut for `actions`. | f1602:c2:m14 |
def chat(self, message): | if message:<EOL><INDENT>action_chat = sc_pb.ActionChat(<EOL>channel=sc_pb.ActionChat.Broadcast, message=message)<EOL>action = sc_pb.Action(action_chat=action_chat)<EOL>return self.act(action)<EOL><DEDENT> | Send chat message as a broadcast. | f1602:c2:m15 |
@valid_status(Status.in_game, Status.ended)<EOL><INDENT>@sw.decorate<EOL>def leave(self):<DEDENT> | return self._client.send(leave_game=sc_pb.RequestLeaveGame())<EOL> | Disconnect from a multiplayer game. | f1602:c2:m16 |
@valid_status(Status.in_game, Status.ended)<EOL><INDENT>@sw.decorate<EOL>def save_replay(self):<DEDENT> | res = self._client.send(save_replay=sc_pb.RequestSaveReplay())<EOL>return res.data<EOL> | Save a replay, returning the data. | f1602:c2:m17 |
@valid_status(Status.in_game)<EOL><INDENT>@sw.decorate<EOL>def debug(self, debug_commands):<DEDENT> | if isinstance(debug_commands, sc_debug.DebugCommand):<EOL><INDENT>debug_commands = [debug_commands]<EOL><DEDENT>return self._client.send(debug=sc_pb.RequestDebug(debug=debug_commands))<EOL> | Run a debug command. | f1602:c2:m18 |
@skip_status(Status.quit)<EOL><INDENT>@sw.decorate<EOL>def quit(self):<DEDENT> | try:<EOL><INDENT>self._client.write(sc_pb.Request(quit=sc_pb.RequestQuit()))<EOL><DEDENT>except protocol.ConnectionError:<EOL><INDENT>pass <EOL><DEDENT>finally:<EOL><INDENT>self.close()<EOL><DEDENT> | Shut down the SC2 process. | f1602:c2:m19 |
def _shutdown_proc(p, timeout): | freq = <NUM_LIT:10> <EOL>for _ in range(<NUM_LIT:1> + timeout * freq):<EOL><INDENT>ret = p.poll()<EOL>if ret is not None:<EOL><INDENT>logging.info("<STR_LIT>")<EOL>return ret<EOL><DEDENT>time.sleep(<NUM_LIT:1> / freq)<EOL><DEDENT>logging.warning("<STR_LIT>")<EOL>p.kill()<EOL>return p.wait()<EOL> | Wait for a proc to shut down, then terminate or kill it after `timeout`. | f1605:m0 |
def __init__(self, run_config, exec_path, version, full_screen=False,<EOL>extra_args=None, verbose=False, host=None, port=None,<EOL>connect=True, timeout_seconds=None, window_size=(<NUM_LIT>, <NUM_LIT>),<EOL>window_loc=(<NUM_LIT:50>, <NUM_LIT:50>), **kwargs): | self._proc = None<EOL>self._controller = None<EOL>self._check_exists(exec_path)<EOL>self._tmp_dir = tempfile.mkdtemp(prefix="<STR_LIT>", dir=run_config.tmp_dir)<EOL>self._host = host or "<STR_LIT:127.0.0.1>"<EOL>self._port = port or portpicker.pick_unused_port()<EOL>self._version = version<EOL>args = [<EOL>exec_path,<E... | Launch the SC2 process.
Args:
run_config: `run_configs.lib.RunConfig` object.
exec_path: Path to the binary to run.
version: `run_configs.lib.Version` object.
full_screen: Whether to launch the game window full_screen on win/mac.
extra_args: List of additional ... | f1605:c1:m0 |
@sw.decorate<EOL><INDENT>def close(self):<DEDENT> | if hasattr(self, "<STR_LIT>") and self._controller:<EOL><INDENT>self._controller.quit()<EOL>self._controller.close()<EOL>self._controller = None<EOL><DEDENT>self._shutdown()<EOL>if hasattr(self, "<STR_LIT>") and self._port:<EOL><INDENT>portpicker.return_port(self._port)<EOL>self._port = None<EOL><DEDENT>if hasattr(self... | Shut down the game and clean up. | f1605:c1:m1 |
def _launch(self, run_config, args, **kwargs): | del kwargs<EOL>try:<EOL><INDENT>with sw("<STR_LIT>"):<EOL><INDENT>return subprocess.Popen(args, cwd=run_config.cwd, env=run_config.env)<EOL><DEDENT><DEDENT>except OSError:<EOL><INDENT>logging.exception("<STR_LIT>")<EOL>raise SC2LaunchError("<STR_LIT>" % args)<EOL><DEDENT> | Launch the process and return the process object. | f1605:c1:m10 |
def _shutdown(self): | if self._proc:<EOL><INDENT>ret = _shutdown_proc(self._proc, <NUM_LIT:3>)<EOL>logging.info("<STR_LIT>", ret)<EOL>self._proc = None<EOL><DEDENT> | Terminate the sub-process. | f1605:c1:m11 |
def __getitem__(self, indices): | indices = self._indices(indices)<EOL>obj = super(NamedNumpyArray, self).__getitem__(indices)<EOL>if isinstance(obj, np.ndarray): <EOL><INDENT>if not isinstance(indices, tuple):<EOL><INDENT>indices = (indices,)<EOL><DEDENT>new_names = []<EOL>dim = <NUM_LIT:0><EOL>for i, index in enumerate(indices):<EOL><INDENT>if isins... | Get by indexing lookup. | f1606:c1:m4 |
def __repr__(self): | names = []<EOL>for dim_names in self._index_names:<EOL><INDENT>if dim_names:<EOL><INDENT>dim_names = [n for n, _ in sorted(dim_names.items(),<EOL>key=lambda item: item[<NUM_LIT:1>])]<EOL>if len(dim_names) > <NUM_LIT:11>:<EOL><INDENT>dim_names = dim_names[:<NUM_LIT:5>] + ["<STR_LIT>"] + dim_names[-<NUM_LIT:5>:]<EOL><DED... | A repr, parsing the original and adding the names param. | f1606:c1:m8 |
def _indices(self, indices): | if isinstance(indices, tuple):<EOL><INDENT>out = []<EOL>dim = <NUM_LIT:0><EOL>for i, index in enumerate(indices):<EOL><INDENT>if index is Ellipsis:<EOL><INDENT>out.append(index)<EOL>dim = len(self.shape) - len(indices) + i<EOL><DEDENT>else:<EOL><INDENT>out.append(self._get_index(dim, index))<EOL><DEDENT>dim += <NUM_LIT... | Turn all string indices into int indices, preserving ellipsis. | f1606:c1:m11 |
def _get_index(self, dim, index): | if isinstance(index, six.string_types):<EOL><INDENT>try:<EOL><INDENT>return self._index_names[dim][index]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise KeyError("<STR_LIT>" % (index, dim))<EOL><DEDENT>except TypeError:<EOL><INDENT>raise TypeError(<EOL>"<STR_LIT>" % (dim, index))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>r... | Turn a string into a real index, otherwise return the index. | f1606:c1:m12 |
def spatial(action, action_space): | if action_space == ActionSpace.FEATURES:<EOL><INDENT>return action.action_feature_layer<EOL><DEDENT>elif action_space == ActionSpace.RGB:<EOL><INDENT>return action.action_render<EOL><DEDENT>else:<EOL><INDENT>raise ValueError("<STR_LIT>" % action_space)<EOL><DEDENT> | Choose the action space for the action proto. | f1609:m0 |
def move_camera(action, action_space, minimap): | minimap.assign_to(spatial(action, action_space).camera_move.center_minimap)<EOL> | Move the camera. | f1609:m2 |
def select_point(action, action_space, select_point_act, screen): | select = spatial(action, action_space).unit_selection_point<EOL>screen.assign_to(select.selection_screen_coord)<EOL>select.type = select_point_act<EOL> | Select a unit at a point. | f1609:m3 |
def select_rect(action, action_space, select_add, screen, screen2): | select = spatial(action, action_space).unit_selection_rect<EOL>out_rect = select.selection_screen_coord.add()<EOL>screen_rect = point.Rect(screen, screen2)<EOL>screen_rect.tl.assign_to(out_rect.p0)<EOL>screen_rect.br.assign_to(out_rect.p1)<EOL>select.selection_add = bool(select_add)<EOL> | Select units within a rectangle. | f1609:m4 |
def select_idle_worker(action, action_space, select_worker): | del action_space<EOL>action.action_ui.select_idle_worker.type = select_worker<EOL> | Select an idle worker. | f1609:m5 |
def select_army(action, action_space, select_add): | del action_space<EOL>action.action_ui.select_army.selection_add = select_add<EOL> | Select the entire army. | f1609:m6 |
def select_warp_gates(action, action_space, select_add): | del action_space<EOL>action.action_ui.select_warp_gates.selection_add = select_add<EOL> | Select all warp gates. | f1609:m7 |
def select_larva(action, action_space): | del action_space<EOL>action.action_ui.select_larva.SetInParent()<EOL> | Select all larva. | f1609:m8 |
def select_unit(action, action_space, select_unit_act, select_unit_id): | del action_space<EOL>select = action.action_ui.multi_panel<EOL>select.type = select_unit_act<EOL>select.unit_index = select_unit_id<EOL> | Select a specific unit from the multi-unit selection. | f1609:m9 |
def control_group(action, action_space, control_group_act, control_group_id): | del action_space<EOL>select = action.action_ui.control_group<EOL>select.action = control_group_act<EOL>select.control_group_index = control_group_id<EOL> | Act on a control group, selecting, setting, etc. | f1609:m10 |
def unload(action, action_space, unload_id): | del action_space<EOL>action.action_ui.cargo_panel.unit_index = unload_id<EOL> | Unload a unit from a transport/bunker/nydus/etc. | f1609:m11 |
def build_queue(action, action_space, build_queue_id): | del action_space<EOL>action.action_ui.production_panel.unit_index = build_queue_id<EOL> | Cancel a unit in the build queue. | f1609:m12 |
def cmd_quick(action, action_space, ability_id, queued): | action_cmd = spatial(action, action_space).unit_command<EOL>action_cmd.ability_id = ability_id<EOL>action_cmd.queue_command = queued<EOL> | Do a quick command like 'Stop' or 'Stim'. | f1609:m13 |
def cmd_screen(action, action_space, ability_id, queued, screen): | action_cmd = spatial(action, action_space).unit_command<EOL>action_cmd.ability_id = ability_id<EOL>action_cmd.queue_command = queued<EOL>screen.assign_to(action_cmd.target_screen_coord)<EOL> | Do a command that needs a point on the screen. | f1609:m14 |
def cmd_minimap(action, action_space, ability_id, queued, minimap): | action_cmd = spatial(action, action_space).unit_command<EOL>action_cmd.ability_id = ability_id<EOL>action_cmd.queue_command = queued<EOL>minimap.assign_to(action_cmd.target_minimap_coord)<EOL> | Do a command that needs a point on the minimap. | f1609:m15 |
def autocast(action, action_space, ability_id): | del action_space<EOL>action.action_ui.toggle_autocast.ability_id = ability_id<EOL> | Toggle autocast. | f1609:m16 |
@classmethod<EOL><INDENT>def enum(cls, options, values):<DEDENT> | names, real = zip(*options)<EOL>del names <EOL>def factory(i, name):<EOL><INDENT>return cls(i, name, (len(real),), lambda a: real[a[<NUM_LIT:0>]], values)<EOL><DEDENT>return factory<EOL> | Create an ArgumentType where you choose one of a set of known values. | f1609:c1:m2 |
@classmethod<EOL><INDENT>def scalar(cls, value):<DEDENT> | return lambda i, name: cls(i, name, (value,), lambda a: a[<NUM_LIT:0>], None)<EOL> | Create an ArgumentType with a single scalar in range(value). | f1609:c1:m3 |
@classmethod<EOL><INDENT>def point(cls): <DEDENT> | def factory(i, name):<EOL><INDENT>return cls(i, name, (<NUM_LIT:0>, <NUM_LIT:0>), lambda a: point.Point(*a).floor(), None)<EOL><DEDENT>return factory<EOL> | Create an ArgumentType that is represented by a point.Point. | f1609:c1:m4 |
@classmethod<EOL><INDENT>def spec(cls, id_, name, sizes):<DEDENT> | return cls(id_, name, sizes, None, None)<EOL> | Create an ArgumentType to be used in ValidActions. | f1609:c1:m5 |
@classmethod<EOL><INDENT>def types(cls, **kwargs):<DEDENT> | named = {name: factory(Arguments._fields.index(name), name)<EOL>for name, factory in six.iteritems(kwargs)}<EOL>return cls(**named)<EOL> | Create an Arguments of the possible Types. | f1609:c2:m0 |
@classmethod<EOL><INDENT>def ui_func(cls, id_, name, function_type, avail_fn=always):<DEDENT> | return cls(id_, name, <NUM_LIT:0>, <NUM_LIT:0>, function_type, FUNCTION_TYPES[function_type],<EOL>avail_fn)<EOL> | Define a function representing a ui action. | f1609:c3:m0 |
@classmethod<EOL><INDENT>def ability(cls, id_, name, function_type, ability_id, general_id=<NUM_LIT:0>):<DEDENT> | assert function_type in ABILITY_FUNCTIONS<EOL>return cls(id_, name, ability_id, general_id, function_type,<EOL>FUNCTION_TYPES[function_type], None)<EOL> | Define a function represented as a game ability. | f1609:c3:m1 |
@classmethod<EOL><INDENT>def spec(cls, id_, name, args):<DEDENT> | return cls(id_, name, None, None, None, args, None)<EOL> | Create a Function to be used in ValidActions. | f1609:c3:m2 |
def __call__(self, *args): | return FunctionCall.init_with_validation(self.id, args)<EOL> | A convenient way to create a FunctionCall from this Function. | f1609:c3:m5 |
def str(self, space=False): | return "<STR_LIT>" % (str(int(self.id)).rjust(space and <NUM_LIT:4>),<EOL>self.name.ljust(space and <NUM_LIT:50>),<EOL>"<STR_LIT>".join(str(a) for a in self.args))<EOL> | String version. Set space=True to line them all up nicely. | f1609:c3:m7 |
@classmethod<EOL><INDENT>def init_with_validation(cls, function, arguments):<DEDENT> | func = FUNCTIONS[function]<EOL>args = []<EOL>for arg, arg_type in zip(arguments, func.args):<EOL><INDENT>if arg_type.values: <EOL><INDENT>if isinstance(arg, six.string_types):<EOL><INDENT>try:<EOL><INDENT>args.append([arg_type.values[arg]])<EOL><DEDENT>except KeyError:<EOL><INDENT>raise KeyError("<STR_LIT>" % (<EOL>ar... | Return a `FunctionCall` given some validation for the function and args.
Args:
function: A function name or id, to be converted into a function id enum.
arguments: An iterable of function arguments. Arguments that are enum
types can be passed by name. Arguments that only take ... | f1609:c5:m0 |
@classmethod<EOL><INDENT>def all_arguments(cls, function, arguments):<DEDENT> | if isinstance(arguments, dict):<EOL><INDENT>arguments = Arguments(**arguments)<EOL><DEDENT>elif not isinstance(arguments, Arguments):<EOL><INDENT>arguments = Arguments(*arguments)<EOL><DEDENT>return cls(function, arguments)<EOL> | Helper function for creating `FunctionCall`s with `Arguments`.
Args:
function: The value to store for the action function.
arguments: The values to store for the arguments of the action. Can either
be an `Arguments` object, a `dict`, or an iterable. If a `dict` or an
... | f1609:c5:m1 |
def pick_unused_ports(num_ports, retry_interval_secs=<NUM_LIT:3>, retry_attempts=<NUM_LIT:5>): | ports = set()<EOL>for _ in range(retry_attempts):<EOL><INDENT>ports.update(<EOL>portpicker.pick_unused_port() for _ in range(num_ports - len(ports)))<EOL>ports.discard(None) <EOL>if len(ports) == num_ports:<EOL><INDENT>return list(ports)<EOL><DEDENT>time.sleep(retry_interval_secs)<EOL><DEDENT>return_ports(ports)<EOL>r... | Reserves and returns a list of `num_ports` unused ports. | f1610:m0 |
def pick_contiguous_unused_ports(<EOL>num_ports,<EOL>retry_interval_secs=<NUM_LIT:3>,<EOL>retry_attempts=<NUM_LIT:5>): | for _ in range(retry_attempts):<EOL><INDENT>start_port = portpicker.pick_unused_port()<EOL>if start_port is not None:<EOL><INDENT>ports = [start_port + p for p in range(num_ports)]<EOL>if all(portpicker.is_port_free(p) for p in ports):<EOL><INDENT>return ports<EOL><DEDENT>else:<EOL><INDENT>return_ports(ports)<EOL><DEDE... | Reserves and returns a list of `num_ports` contiguous unused ports. | f1610:m1 |
def return_ports(ports): | for port in ports:<EOL><INDENT>portpicker.return_port(port)<EOL><DEDENT> | Returns previously reserved ports so that may be reused. | f1610:m2 |
def smooth_hue_palette(scale): | <EOL>array = numpy.arange(scale)<EOL>h = array * (<NUM_LIT:6> / scale) <EOL>x = <NUM_LIT:255> * (<NUM_LIT:1> - numpy.absolute(numpy.mod(h, <NUM_LIT:2>) - <NUM_LIT:1>))<EOL>c = <NUM_LIT:255><EOL>out = numpy.zeros(h.shape + (<NUM_LIT:3>,), float)<EOL>r = out[..., <NUM_LIT:0>]<EOL>g = out[..., <NUM_LIT:1>]<EOL>b = out[..... | Takes an array of ints and returns a corresponding colored rgb array. | f1611:m0 |
def piece_wise_linear(scale, points): | assert len(points) >= <NUM_LIT:2><EOL>assert points[<NUM_LIT:0>][<NUM_LIT:0>] == <NUM_LIT:0><EOL>assert points[-<NUM_LIT:1>][<NUM_LIT:0>] == <NUM_LIT:1><EOL>assert all(i < j for i, j in zip(points[:-<NUM_LIT:1>], points[<NUM_LIT:1>:]))<EOL>out = numpy.zeros((scale, <NUM_LIT:3>))<EOL>p1, c1 = points[<NUM_LIT:0>]<EOL>p2,... | Create a palette that is piece-wise linear given some colors at points. | f1611:m2 |
def unit_type(scale=None): | <EOL>palette_size = scale or max(static_data.UNIT_TYPES) + <NUM_LIT:1><EOL>palette = shuffled_hue(palette_size)<EOL>assert len(static_data.UNIT_TYPES) <= len(distinct_colors)<EOL>for i, v in enumerate(static_data.UNIT_TYPES):<EOL><INDENT>palette[v] = distinct_colors[i]<EOL><DEDENT>return palette<EOL> | Returns a palette that maps unit types to rgb colors. | f1611:m5 |
def __init__(self, data): | self._units = {u.unit_id: u.name for u in data.units}<EOL>self._unit_stats = {u.unit_id: u for u in data.units}<EOL>self._abilities = {a.ability_id: a for a in data.abilities}<EOL>self._general_abilities = {a.remaps_to_ability_id<EOL>for a in data.abilities<EOL>if a.remaps_to_ability_id}<EOL>for a in six.itervalues(sel... | Takes data from RequestData. | f1612:c0:m0 |
@contextlib.contextmanager<EOL>def catch_websocket_connection_errors(): | try:<EOL><INDENT>yield<EOL><DEDENT>except websocket.WebSocketConnectionClosedException:<EOL><INDENT>raise ConnectionError("<STR_LIT>"<EOL>"<STR_LIT>")<EOL><DEDENT>except websocket.WebSocketTimeoutException:<EOL><INDENT>raise ConnectionError("<STR_LIT>")<EOL><DEDENT>except socket.error as e:<EOL><INDENT>raise Connection... | A context manager that translates websocket errors into ConnectionError. | f1613:m0 |
@sw.decorate<EOL><INDENT>def read(self):<DEDENT> | if FLAGS.sc2_verbose_protocol:<EOL><INDENT>self._log("<STR_LIT>".center(<NUM_LIT>, "<STR_LIT:->"))<EOL>start = time.time()<EOL><DEDENT>response = self._read()<EOL>if FLAGS.sc2_verbose_protocol:<EOL><INDENT>self._log("<STR_LIT>" % (<NUM_LIT:1000> * (time.time() - start)))<EOL>self._log_packet(response)<EOL><DEDENT>if no... | Read a Response, do some validation, and return it. | f1613:c2:m3 |
@sw.decorate<EOL><INDENT>def write(self, request):<DEDENT> | if FLAGS.sc2_verbose_protocol:<EOL><INDENT>self._log("<STR_LIT>".center(<NUM_LIT>, "<STR_LIT:->") + "<STR_LIT:\n>")<EOL>self._log_packet(request)<EOL><DEDENT>self._write(request)<EOL> | Write a Request. | f1613:c2:m4 |
def send_req(self, request): | self.write(request)<EOL>return self.read()<EOL> | Write a pre-filled Request and return the Response. | f1613:c2:m5 |
def send(self, **kwargs): | assert len(kwargs) == <NUM_LIT:1>, "<STR_LIT>"<EOL>res = self.send_req(sc_pb.Request(**kwargs))<EOL>return getattr(res, list(kwargs.keys())[<NUM_LIT:0>])<EOL> | Create and send a specific request, and return the response.
For example: send(ping=sc_pb.RequestPing()) => sc_pb.ResponsePing
Args:
**kwargs: A single kwarg with the name and value to fill in to Request.
Returns:
The Response corresponding to your request. | f1613:c2:m6 |
def _log(self, s): | <EOL>sys.stderr.write(s)<EOL>sys.stderr.flush()<EOL> | r"""Log a string. It flushes but doesn't append \n, so do that yourself. | f1613:c2:m8 |
def _read(self): | with sw("<STR_LIT>"):<EOL><INDENT>with catch_websocket_connection_errors():<EOL><INDENT>response_str = self._sock.recv()<EOL><DEDENT><DEDENT>if not response_str:<EOL><INDENT>raise ProtocolError("<STR_LIT>")<EOL><DEDENT>response = sc_pb.Response()<EOL>with sw("<STR_LIT>"):<EOL><INDENT>response.ParseFromString(response_s... | Actually read the response and parse it, returning a Response. | f1613:c2:m9 |
def _write(self, request): | with sw("<STR_LIT>"):<EOL><INDENT>request_str = request.SerializeToString()<EOL><DEDENT>with sw("<STR_LIT>"):<EOL><INDENT>with catch_websocket_connection_errors():<EOL><INDENT>self._sock.send(request_str)<EOL><DEDENT><DEDENT> | Actually serialize and write the request. | f1613:c2:m10 |
def _to_point(dims): | assert dims<EOL>if isinstance(dims, (tuple, list)):<EOL><INDENT>if len(dims) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(<EOL>"<STR_LIT>".format(dims))<EOL><DEDENT>else:<EOL><INDENT>width = int(dims[<NUM_LIT:0>])<EOL>height = int(dims[<NUM_LIT:1>])<EOL>if width <= <NUM_LIT:0> or height <= <NUM_LIT:0>:<EOL><INDENT>rais... | Convert (width, height) or size -> point.Point. | f1614:m0 |
def parse_agent_interface_format(<EOL>feature_screen=None,<EOL>feature_minimap=None,<EOL>rgb_screen=None,<EOL>rgb_minimap=None,<EOL>action_space=None,<EOL>camera_width_world_units=None,<EOL>use_feature_units=False,<EOL>use_raw_units=False,<EOL>use_unit_counts=False,<EOL>use_camera_position=False): | if feature_screen or feature_minimap:<EOL><INDENT>feature_dimensions = Dimensions(<EOL>screen=feature_screen,<EOL>minimap=feature_minimap)<EOL><DEDENT>else:<EOL><INDENT>feature_dimensions = None<EOL><DEDENT>if rgb_screen or rgb_minimap:<EOL><INDENT>rgb_dimensions = Dimensions(<EOL>screen=rgb_screen,<EOL>minimap=rgb_min... | Creates an AgentInterfaceFormat object from keyword args.
Convenient when using dictionaries or command-line arguments for config.
Note that the feature_* and rgb_* properties define the respective spatial
observation dimensions and accept:
* None or 0 to disable that spatial observation.
... | f1614:m1 |
def features_from_game_info(<EOL>game_info,<EOL>use_feature_units=False,<EOL>use_raw_units=False,<EOL>action_space=None,<EOL>hide_specific_actions=True,<EOL>use_unit_counts=False,<EOL>use_camera_position=False): | if game_info.options.HasField("<STR_LIT>"):<EOL><INDENT>fl_opts = game_info.options.feature_layer<EOL>feature_dimensions = Dimensions(<EOL>screen=(fl_opts.resolution.x, fl_opts.resolution.y),<EOL>minimap=(fl_opts.minimap_resolution.x, fl_opts.minimap_resolution.y))<EOL><DEDENT>else:<EOL><INDENT>feature_dimensions = Non... | Construct a Features object using data extracted from game info.
Args:
game_info: A `sc_pb.ResponseGameInfo` from the game.
use_feature_units: Whether to include the feature unit observation.
use_raw_units: Whether to include raw unit data in observations. This
differs from feature_unit... | f1614:m2 |
def _init_valid_functions(action_dimensions): | sizes = {<EOL>"<STR_LIT>": tuple(int(i) for i in action_dimensions.screen),<EOL>"<STR_LIT>": tuple(int(i) for i in action_dimensions.screen),<EOL>"<STR_LIT>": tuple(int(i) for i in action_dimensions.minimap),<EOL>}<EOL>types = actions.Arguments(*[<EOL>actions.ArgumentType.spec(t.id, t.name, sizes.get(t.name, t.sizes))<... | Initialize ValidFunctions and set up the callbacks. | f1614:m3 |
def unpack(self, obs): | planes = getattr(obs.feature_layer_data, self.layer_set)<EOL>plane = getattr(planes, self.name)<EOL>return self.unpack_layer(plane)<EOL> | Return a correctly shaped numpy array for this feature. | f1614:c13:m0 |
@staticmethod<EOL><INDENT>@sw.decorate<EOL>def unpack_layer(plane):<DEDENT> | size = point.Point.build(plane.size)<EOL>if size == (<NUM_LIT:0>, <NUM_LIT:0>):<EOL><INDENT>return None<EOL><DEDENT>data = np.frombuffer(plane.data, dtype=Feature.dtypes[plane.bits_per_pixel])<EOL>if plane.bits_per_pixel == <NUM_LIT:1>:<EOL><INDENT>data = np.unpackbits(data)<EOL>if data.shape[<NUM_LIT:0>] != size.x * s... | Return a correctly shaped numpy array given the feature layer bytes. | f1614:c13:m1 |
@staticmethod<EOL><INDENT>@sw.decorate<EOL>def unpack_rgb_image(plane):<DEDENT> | assert plane.bits_per_pixel == <NUM_LIT>, "<STR_LIT>".format(plane.bits_per_pixel)<EOL>size = point.Point.build(plane.size)<EOL>data = np.frombuffer(plane.data, dtype=np.uint8)<EOL>return data.reshape(size.y, size.x, <NUM_LIT:3>)<EOL> | Return a correctly shaped numpy array given the image bytes. | f1614:c13:m2 |
def __init__(<EOL>self,<EOL>feature_dimensions=None,<EOL>rgb_dimensions=None,<EOL>action_space=None,<EOL>camera_width_world_units=None,<EOL>use_feature_units=False,<EOL>use_raw_units=False,<EOL>use_unit_counts=False,<EOL>use_camera_position=False,<EOL>hide_specific_actions=True): | if not feature_dimensions and not rgb_dimensions:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>if action_space:<EOL><INDENT>if not isinstance(action_space, actions.ActionSpace):<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>if ((action_space == actions.ActionSpace.FEATURES and<EOL>not feature_dimension... | Initializer.
Args:
feature_dimensions: Feature layer `Dimension`s. Either this or
rgb_dimensions (or both) must be set.
rgb_dimensions: RGB `Dimension`. Either this or feature_dimensions
(or both) must be set.
action_space: If you pass both feature and ... | f1614:c17:m0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.