Example #1
0
def cmd_start(self, args, message):
    """/start"""
    msg = wrap("""
        Authenticate yourself via /auth and follow the instructions.
        Afterwards you can send me photos or images,
        which I will upload
        and link to in the IRC channel
        {conf.irc.channel} on {conf.irc.host}.

        Contact {conf.telegram.username_for_help}
        in case you are having problems.
    """).format(conf=self.conf)

    if message.sender.id in (self.conf.telegram.admin or []):
        msg = msg + "\n\n" + wrap("""
            More commands:

            /get_id - get your id

            More commands for admins:

            /blacklist [add | remove] <id> - modify the blacklist
        """)

    return msg
def fill(text, width, initindent = '', hangindent = ''):
    '''fill many paragraphs with optional indentation.'''
    global para_re, space_re
    if para_re is None:
        para_re = re.compile('(\n\n|\n\\s*[-*]\\s*)', re.M)
        space_re = re.compile(r'  +')

    def findparas():
        start = 0
        while True:
            m = para_re.search(text, start)
            if not m:
                uctext = unicode(text[start:], encoding.encoding)
                w = len(uctext)
                while 0 < w and uctext[w - 1].isspace():
                    w -= 1
                yield (uctext[:w].encode(encoding.encoding),
                       uctext[w:].encode(encoding.encoding))
                break
            yield text[start:m.start(0)], m.group(1)
            start = m.end(1)

    return "".join([util.wrap(space_re.sub(' ', util.wrap(para, width)),
                              width, initindent, hangindent) + rest
                    for para, rest in findparas()])
Example #3
0
def fill(text, width, initindent='', hangindent=''):
    '''fill many paragraphs with optional indentation.'''
    global para_re, space_re
    if para_re is None:
        para_re = re.compile('(\n\n|\n\\s*[-*]\\s*)', re.M)
        space_re = re.compile(r'  +')

    def findparas():
        start = 0
        while True:
            m = para_re.search(text, start)
            if not m:
                uctext = unicode(text[start:], encoding.encoding)
                w = len(uctext)
                while 0 < w and uctext[w - 1].isspace():
                    w -= 1
                yield (uctext[:w].encode(encoding.encoding),
                       uctext[w:].encode(encoding.encoding))
                break
            yield text[start:m.start(0)], m.group(1)
            start = m.end(1)

    return "".join([
        util.wrap(space_re.sub(' ', util.wrap(para, width)), width, initindent,
                  hangindent) + rest for para, rest in findparas()
    ])
def cmd_start(self, args, message):
    """/start"""
    msg = wrap("""
        Authenticate yourself via /auth and follow the instructions.
        Afterwards you can send me photos or images,
        which I will upload
        and link to in the IRC channel
        {conf.irc.channel} on {conf.irc.host}.

        Contact {conf.telegram.username_for_help}
        in case you are having problems.
    """).format(conf=self.conf)

    if message.sender.id in (self.conf.telegram.admin or []):
        msg = msg + "\n\n" + wrap("""
            More commands:

            /get_id - get your id

            More commands for admins:

            /blacklist [add | remove] <id> - modify the blacklist
        """)

    return msg
Example #5
0
 def set_mute(self, mute_state):
     if mute_state:
         self.connection.send(util.wrap(util.CMD_MUTEON))
         self.connection.recv(util.BUFFER_SIZE)
         self.volume = False
     else:
         self.connection.send(util.wrap(util.CMD_MUTEOFF))
         self.connection.recv(util.BUFFER_SIZE)
         self.volume = self.get_device_volume()
Example #6
0
 def pause(self):
     # Force this to toggle.
     if self.state == "pause":
         self.connection.send(util.wrap(util.CMD_PAUSE))
         self.connection.recv(util.BUFFER_SIZE)
         self.state = "play"
     elif self.state == "play":
         self.connection.send(util.wrap(util.CMD_PAUSE))
         self.connection.recv(util.BUFFER_SIZE)
         self.state = "pause"
Example #7
0
    def cbComputeActionGA3C(self, event):
        if self.operation_mode.mode!=self.operation_mode.NN:
            print 'Not in NN mode'
            print self.operation_mode.mode
            return


        # construct agent_state
        x = self.pose.pose.position.x; y = self.pose.pose.position.y
        v_x = self.vel.x; v_y = self.vel.y
        radius = self.veh_data['radius']; turning_dir = 0.0
        heading_angle = self.psi
        pref_speed = self.veh_data['pref_speed']
        goal_x = self.goal.pose.position.x; goal_y = self.goal.pose.position.y
        # in case current speed is larger than desired speed
        v = np.linalg.norm(np.array([v_x, v_y]))
        if v > pref_speed:
            v_x = v_x * pref_speed / v
            v_y = v_y * pref_speed / v

        host_agent = agent.Agent(x, y, goal_x, goal_y, radius, pref_speed, heading_angle, 0)
        host_agent.vel_global_frame = np.array([v_x, v_y])
        # host_agent.print_agent_info()

        other_agents_state = copy.deepcopy(self.other_agents_state)
        obs = host_agent.observe(other_agents_state)[1:]
        obs = np.expand_dims(obs, axis=0)
        # print "obs:", obs
        predictions = self.nn.predict_p(obs)[0]
        # print "predictions:", predictions
        # print "best action index:", np.argmax(predictions)
        raw_action = copy.deepcopy(self.actions[np.argmax(predictions)])
        action = np.array([pref_speed*raw_action[0], util.wrap(raw_action[1] + self.psi)])
        # print "raw_action:", raw_action
        # print "action:", action

        # if close to goal
        kp_v = 0.5
        kp_r = 1   

        if host_agent.dist_to_goal < 2.0: # and self.percentComplete>=0.9:
            # print "somewhat close to goal"
            pref_speed = max(min(kp_v * (host_agent.dist_to_goal-0.1), pref_speed), 0.0)
            action[0] = min(raw_action[0], pref_speed)
            turn_amount = max(min(kp_r * (host_agent.dist_to_goal-0.1), 1.0), 0.0) * raw_action[1]
            action[1] = util.wrap(turn_amount + self.psi)
        if host_agent.dist_to_goal < 0.3:
            self.stop_moving_flag = True
        else:
            self.stop_moving_flag = False

        # print 'chosen action (rel angle)', action[0], action[1]
        self.update_action(action)
Example #8
0
    def render(self):
        wrapped = []
        for line in self.buffer:
            wrapped.extend(util.wrap(line, self.w))


        self.clear()

        y = 0
        for line in wrapped:
            self.draw(line, y, 0)
            y += 1

        # TODO
        # have to have a more intelligent calculation (taking into
        # account line wrapping) of where the cursor is... that might
        # take some work, or really we'll just need to move the wrapping
        # into this class
        if self.focused:
            if self.editable and self.cx == self.w:
                self.showCursor(self.cy + 1, 0)
            elif self.editable:
                self.showCursor(self.cy, self.cx)
            else:
                self.hideCursor()
        else:
            self.hideCursor()
Example #9
0
    def cbComputeAction(self, event):

        tol = 1e-1
        x = self.pose.position.x
        y = self.pose.position.y

        goal_x = self.global_goal.pose.position.x
        goal_y = self.global_goal.pose.position.y

        self.goalReached(tol, x, y, goal_x, goal_y)
        if self.new_global_goal_received:
            #tb3 state

            v_x = self.vel.x
            v_y = self.vel.y

            heading_angle = self.psi

            host_agent = agent.Agent(x, y, goal_x, goal_y, self.radius,
                                     self.pref_speed, heading_angle, 0)
            host_agent.vel_global_frame = np.array([v_x, v_y])

            # Convert agent states into observation vector
            obs = host_agent.observe(self.other_agents_state)[1:]
            obs = np.expand_dims(obs, axis=0)

            predictions = self.nn.predict_p(obs)[0]
            raw_action = self.possible_actions.actions[np.argmax(predictions)]
            #action = np.array([host_agent.pref_speed*raw_action[0], util.wrap(raw_action[1] + host_agent.heading_global_frame)])
            action = np.array([
                self.pref_speed * raw_action[0],
                util.wrap(raw_action[1] + self.psi)
            ])
            self.tb3Move(action)
Example #10
0
def formatoption(block, width):
    desc = " ".join(map(str.strip, block["lines"]))
    colwidth = encoding.colwidth(block["optstr"])
    usablewidth = width - 1
    hanging = block["optstrwidth"]
    initindent = "%s%s  " % (block["optstr"], " " * ((hanging - colwidth)))
    hangindent = " " * (encoding.colwidth(initindent) + 1)
    return " %s\n" % (util.wrap(desc, usablewidth, initindent=initindent, hangindent=hangindent))
Example #11
0
 def next(self):
     # The Exstreamers have built-in rules as to what happens if you hit next and
     # there is no playlist running (inevitably something will start playing). We
     # are going to override that to stay more in control. It's not a terribly
     # common scenario, anyway.
     if self.state == "play":
         self.connection.send(util.wrap(util.CMD_NEXT))
         self.connection.recv(util.BUFFER_SIZE)
Example #12
0
def listexts(header, exts, maxlength):
    """return a text listing of the given extensions"""
    if not exts:
        return ""
    result = "\n%s\n\n" % header
    for name, desc in sorted(exts.iteritems()):
        desc = util.wrap(desc, maxlength + 4)
        result += " %s   %s\n" % (name.ljust(maxlength), desc)
    return result
Example #13
0
def add_changes_markup(dom, ins_nodes, del_nodes):
    """
    Add <ins> and <del> tags to the dom to show changes.
    """
    # add markup for inserted and deleted sections
    for node in reversed(del_nodes):
        # diff algorithm deletes nodes in reverse order, so un-reverse the
        # order for this iteration
        insert_or_append(node.orig_parent, node, node.orig_next_sibling)
        wrap(node, 'del')
    for node in ins_nodes:
        wrap(node, 'ins')
    # Perform post-processing and cleanup.
    remove_nesting(dom, 'del')
    remove_nesting(dom, 'ins')
    sort_del_before_ins(dom)
    merge_adjacent(dom, 'del')
    merge_adjacent(dom, 'ins')
Example #14
0
def add_changes_markup(dom, ins_nodes, del_nodes):
    """
    Add <ins> and <del> tags to the dom to show changes.
    """
    # add markup for inserted and deleted sections
    for node in reversed(del_nodes):
        # diff algorithm deletes nodes in reverse order, so un-reverse the
        # order for this iteration
        insert_or_append(node.orig_parent, node, node.orig_next_sibling)
        wrap(node, 'del')
    for node in ins_nodes:
        wrap(node, 'ins')
    # Perform post-processing and cleanup.
    remove_nesting(dom, 'del')
    remove_nesting(dom, 'ins')
    sort_del_before_ins(dom)
    merge_adjacent(dom, 'del')
    merge_adjacent(dom, 'ins')
Example #15
0
 def set_volume(self, vol):
     # Volume levels are defined 0 thru 20 (off thru max).
     # We will accept a volume percentage (0% thru 100%).
     if(vol > 100 or vol < 0):
         raise InvalidVolumeLevel('That volume is out of range.')
     converted_vol = util.round_to_base(vol, 5) / 5  # convert to base 0 thru 20
     self.connection.send(util.wrap(util.CMD_SETVOLUME, converted_vol))
     self.connection.recv(util.BUFFER_SIZE)
     self.volume = vol
Example #16
0
def listexts(header, exts, maxlength):
    '''return a text listing of the given extensions'''
    if not exts:
        return ''
    result = '\n%s\n\n' % header
    for name, desc in sorted(exts.iteritems()):
        desc = util.wrap(desc, maxlength + 4)
        result += ' %s   %s\n' % (name.ljust(maxlength), desc)
    return result
Example #17
0
def formatoption(block, width):
    desc = ' '.join(map(str.strip, block['lines']))
    colwidth = encoding.colwidth(block['optstr'])
    usablewidth = width - 1
    hanging = block['optstrwidth']
    initindent = '%s%s  ' % (block['optstr'], ' ' * ((hanging - colwidth)))
    hangindent = ' ' * (encoding.colwidth(initindent) + 1)
    return ' %s\n' % (util.wrap(
        desc, usablewidth, initindent=initindent, hangindent=hangindent))
def _dump_no_context_info(command, args):
    all_cls = {cls.name(): cls for cls in ZephyrBinaryRunner.get_runners() if
               command.name in cls.capabilities().commands}
    log.inf('All Zephyr runners which support {}:'.format(command.name),
            colorize=True)
    for line in util.wrap(', '.join(all_cls.keys()), INDENT):
        log.inf(line)
    if not args.runner:
        log.inf('Add -r RUNNER to print more information about any runner.',
                colorize=True)
Example #19
0
def formatoption(block, width):
    desc = ' '.join(map(str.strip, block['lines']))
    colwidth = encoding.colwidth(block['optstr'])
    usablewidth = width - 1
    hanging = block['optstrwidth']
    initindent = '%s%s  ' % (block['optstr'], ' ' * ((hanging - colwidth)))
    hangindent = ' ' * (encoding.colwidth(initindent) + 1)
    return ' %s\n' % (util.wrap(desc, usablewidth,
                                           initindent=initindent,
                                           hangindent=hangindent))
Example #20
0
 def predict_action(self, obs):
     #QUery the policy based on obs vector
     predictions = self.nn.predict_p(obs)[0]
     raw_action = self.possible_actions.actions[np.argmax(predictions)]
     action = np.array([
         host_agent.pref_speed * raw_action[0],
         util.wrap(raw_action[1] + host_agent.heading_global_frame)
     ])
     # print "action:", action
     # Action contains: [new forward speed, change in heading angle]
     return action
Example #21
0
File: Pager.py Project: dcrosta/dtk
    def render(self):
        """
        redraw what's in the visible range, based on our
        size and firstVisible
        """

        if self.lines is None:
            self.lines = util.wrap(self.text, self.w)

        self.clear()

        for i in range(self.firstVisible, min(len(self.lines), self.firstVisible + self.h)):
            self.draw(self.lines[i], i - self.firstVisible, 0);
    def control(self, event):
        possible_actions = network.Actions()
        num_actions = possible_actions.num_actions
        nn = network.NetworkVP_rnn(network.Config.DEVICE, 'network',
                                   num_actions)
        nn.simple_load(
            '/home/yeguo/turtlebot3_ws/src/cadrl_ros/checkpoints/network_01900000'
        )

        host_agent = agent.Agent(self.host_pos_x, self.host_pos_y,
                                 self.host_goal_x, self.host_goal_y,
                                 self.radius, self.pref_speed,
                                 self.host_heading_angle, 0)
        host_agent.vel_global_frame = np.array([self.host_vx, self.host_vy])
        other_agents = []
        #other_agents.append(agent.Agent(self.tb3_0_pos_x, self.tb3_0_pos_y, self.tb3_0_goal_x, self.tb3_0_goal_y, self.radius, self.pref_speed, self.other_agents_heading_angle, 1))
        other_agents.append(
            agent.Agent(self.tb3_1_pos_x, self.tb3_1_pos_y, self.tb3_1_goal_x,
                        self.tb3_1_goal_y, self.radius, self.pref_speed,
                        self.other_agents_heading_angle, 2))
        #other_agents.append(agent.Agent(self.tb3_2_pos_x, self.tb3_2_pos_y, self.tb3_2_goal_x, self.tb3_2_goal_y, self.radius, self.pref_speed, self.other_agents_heading_angle, 3))
        obs = host_agent.observe(other_agents)[1:]
        obs = np.expand_dims(obs, axis=0)

        predictions = nn.predict_p(obs, None)[0]
        raw_action = possible_actions.actions[np.argmax(predictions)]
        action = np.array([
            host_agent.pref_speed * raw_action[0],
            util.wrap(raw_action[1] + host_agent.heading_global_frame)
        ])
        print "action:", action
        command = Twist()
        command.linear.x = action[0]
        yaw_error = action[1] - self.psi
        if yaw_error > np.pi:
            yaw_error -= 2 * np.pi
        if yaw_error < -np.pi:
            yaw_error += 2 * np.pi
        command.angular.z = 2 * yaw_error
        print "host command:", command
        self.host_cmd_vel_pub.publish(command)
        #control agents
        tb3_0_command = Twist()
        tb3_0_command.linear.x = 0.05
        self.tb3_0_cmd_vel_pub.publish(tb3_0_command)
        tb3_1_command = Twist()
        tb3_1_command.linear.x = 0.05
        self.tb3_1_cmd_vel_pub.publish(tb3_1_command)
        tb3_2_command = Twist()
        tb3_2_command.linear.x = 0.05
        self.tb3_2_cmd_vel_pub.publish(tb3_2_command)
Example #23
0
def rotate_and_shift_mps(mps, start_pos, start_theta):
    # start_pos = [x, y] (2-element np.array)
    # start_theta = angle (float)
    rotation_matrix = np.array([[np.cos(start_theta),
                                 np.sin(start_theta)],
                                [-np.sin(start_theta),
                                 np.cos(start_theta)]])
    rotated_mps = np.empty_like(mps)
    rotated_mps[:, :, :2] = np.dot(mps[:, :, :2], rotation_matrix)
    rotated_mps[:, :, 2] = util.wrap(mps[:, :, 2] + start_theta)
    rotated_and_shifted_mps = np.empty_like(mps)
    rotated_and_shifted_mps[:, :, :2] = rotated_mps[:, :, :2] + start_pos
    rotated_and_shifted_mps[:, :, 2] = rotated_mps[:, :, 2]
    return rotated_and_shifted_mps
Example #24
0
    def run(self):
        # print 'Epoch:', self.index
        # print 'Start Pos:', start_x, start_y
        index = 0

        host_agent = agent.Agent(self.start_x, self.start_y, self.goal_x,
                                 self.goal_y, self.radius, self.pref_speed,
                                 self.heading_angle, index)
        host_agent.vel_global_frame = np.array(
            [self.velocity_x, self.velocity_y])
        # Sample observation data in a format easily generated from sensors
        other_agents_x = self.other_agents_x  #[  4,   7]
        other_agents_y = self.other_agents_y  #[  2,   2]
        other_agents_r = self.other_agents_r  #[  1,   2.5]
        other_agents_vx = self.other_agents_vx  #[  0,   0]
        other_agents_vy = self.other_agents_y  #[  0,   0]
        num_other_agents = len(other_agents_x)

        # Create Agent objects for each observed dynamic obstacle
        other_agents = []
        for i in range(num_other_agents):
            x = other_agents_x[i]
            y = other_agents_y[i]
            v_x = other_agents_vx[i]
            v_y = other_agents_vy[i]
            radius = other_agents_r[i]

            # dummy info - unobservable states not used by NN, just needed to create Agent object
            heading_angle = np.arctan2(v_y, v_x)
            pref_speed = np.linalg.norm(np.array([v_x, v_y]))
            goal_x = x + 5.0
            goal_y = y + 5.0

            other_agents.append(
                agent.Agent(x, y, goal_x, goal_y, radius, pref_speed,
                            heading_angle, i + 1))
        obs = host_agent.observe(other_agents)[1:]
        obs = np.expand_dims(obs, axis=0)
        predictions = self.nn.predict_p(obs, None)[0]
        raw_action = self.a.actions[np.argmax(predictions)]
        action = np.array([
            host_agent.pref_speed * raw_action[0],
            util.wrap(raw_action[1] + host_agent.heading_global_frame)
        ])
        return action
Example #25
0
    def get_agentCMD(self):
        host_agent, goal_x, goal_y = self.get_agentState()

        other_agents = self.observe_others(goal_x, goal_y)

        #convert agent state into obs vector
        obs = host_agent.observe(other_agents)[1:]
        obs = np.expand_dims(obs, axis=0)

        #QUery the policy based on obs vector
        predictions = self.nn.predict_p(obs)[0]
        raw_action = self.possible_actions.actions[np.argmax(predictions)]
        action = np.array([
            host_agent.pref_speed * raw_action[0],
            util.wrap(raw_action[1] + host_agent.heading_global_frame)
        ])
        print "action:", action
        # Action contains: [new forward speed, change in heading angle]
        self.control_vel(action)
    def husky_compute_actions(self, event):
        x = self.pose[0]
        y = self.pose[1]
        heading_angle = self.pose[2]
        goal_x = self.goal_x
        goal_y = self.goal_y
        radius = self.radius
        pref_speed = self.pref_speed
        distance = sqrt((self.pose[0] - self.goals[-1][0])**2 +
                        (self.pose[1] - self.goals[-1][1])**2)
        if distance < 2:
            pref_speed = 0.3
        index = self.index
        vx = self.vel * np.cos(heading_angle)
        vy = self.vel * np.sin(heading_angle)

        host_agent = agent.Agent(x, y, goal_x, goal_y, radius, pref_speed,
                                 heading_angle, index)
        host_agent.vel_global_frame = np.array([vx, vy])
        # host_agent.print_agent_info()

        other_agents_state = copy.deepcopy(self.other_agent)
        obs = host_agent.observe(other_agents_state)[1:]
        obs = np.expand_dims(obs, axis=0)
        # print "obs:", obs
        predictions = self.nn.predict_p(obs)[0]

        raw_action = copy.deepcopy(self.actions[np.argmax(predictions)])
        action = np.array([
            pref_speed * raw_action[0],
            util.wrap(raw_action[1] + self.pose[2])
        ])

        distance = sqrt((self.pose[0] - self.goals[-1][0])**2 +
                        (self.pose[1] - self.goals[-1][1])**2)
        if distance < 0.5:
            action = [0, 0]
            rospy.signal_shutdown('Done')
        self.desired_action = action

        return
Example #27
0
    def run_(self):
        # Create unused authcode and register callback
        authcode = self.irc_bot.new_auth_callback(self.do_authentication)

        msg = wrap("""
            Your Authcode is: {authcode}

            Within {conf.irc.auth_timeout}s,
            send "{nick} auth {authcode}" in
            {conf.irc.channel} on {conf.irc.host}
            with your usual nickname.
            If you want the bot to use a different name
            than your current IRC name,
            add an additional argument which will be stored instead
            (for the slack <-> IRC proxy).

            Example: "{nick} auth {authcode} my_actual_name"

            You can re-authenticate any time
            to overwrite the stored nick.
        """).format(conf=self.conf, authcode=authcode, nick=self.irc_bot.nick)
        self.tg_bot.send_message(self.message.chat.id, msg)

        # Register callback ...
        l.info("initiated authentication for {0.sender}, authcode: {1}",
               self.message, authcode)

        # ... and wait until do_authentication gets called, or timeout
        start_time = time.time()
        while time.time() < start_time + (self.conf.irc.auth_timeout or 300):
            if self.authenticated:
                break
            time.sleep(0.5)
        else:
            l.info("authentication timed out for {0.sender}", self.message)
            self.tg_bot.send_message(self.message.chat.id,
                                     "Authentication timed out")

        # Finish thread
        self.irc_bot.remove_auth_callback(authcode)
Example #28
0
    def run_(self):
        # Create unused authcode and register callback
        authcode = self.irc_bot.new_auth_callback(self.do_authentication)

        msg = wrap("""
            Your Authcode is: {authcode}

            Within {conf.irc.auth_timeout}s,
            send "{nick} auth {authcode}" in
            {conf.irc.channel} on {conf.irc.host}
            with your usual nickname.
            If you want the bot to use a different name
            than your current IRC name,
            add an additional argument which will be stored instead
            (for the slack <-> IRC proxy).

            Example: "{nick} auth {authcode} my_actual_name"

            You can re-authenticate any time
            to overwrite the stored nick.
        """).format(conf=self.conf, authcode=authcode, nick=self.irc_bot.nick)
        self.tg_bot.send_message(self.message.chat.id, msg)

        # Register callback ...
        l.info("initiated authentication for {0.sender}, authcode: {1}",
               self.message, authcode)

        # ... and wait until do_authentication gets called, or timeout
        start_time = time.time()
        while time.time() < start_time + (self.conf.irc.auth_timeout or 300):
            if self.authenticated:
                break
            time.sleep(0.5)
        else:
            l.info("authentication timed out for {0.sender}", self.message)
            self.tg_bot.send_message(self.message.chat.id, "Authentication timed out")

        # Finish thread
        self.irc_bot.remove_auth_callback(authcode)
Example #29
0
    def create_prompts(self) -> None:
        self.main_prompt = modify("""
                _  __              _
               | |/ /             | |
               | ' /_   _ _ __ ___| | __
               |  <| | | | '__/ __| |/ /
               | . \\ |_| | |  \\__ \\   <
               |_|\\_\\__,_|_|  |___/_|\\_\\
        _____ _                 _       _
       / ____(_)               | |     | |
      | (___  _ _ __ ___  _   _| | __ _| |_ ___  _ __
       \\___ \\| | '_ ` _ \\| | | | |/ _` | __/ _ \\| '__|
       ____) | | | | | | | |_| | | (_| | || (_) | |
      |_____/|_|_| |_| |_|\\__,_|_|\\__,_|\\__\\___/|_|
                               __  ___  _  _  ____
                              /_ |/ _ \\| || ||___ \\
                               | | (_) | || |_ __) |
                               | |\\__, |__   _|__ <
                               | |  / /   | | ___) |
                               |_| /_/    |_||____/

""", Color.YELLOW, Style.BOLD) + \
        "    " + color("1. ", Color.CYAN) + \
        modify("Start", Color.YELLOW, Style.UNDERLINE) + "        " + \
        color("2. ", Color.CYAN) + \
        modify("About Kursk Simulator", Color.YELLOW, Style.UNDERLINE) + "        " + \
        color("3. ", Color.CYAN) + modify("Quit", Color.YELLOW, Style.UNDERLINE) + "\n"

        about_message = wrap("""
Kursk Simulator: 1943 is a tank gunnery simulator built in Python. Tank armour
layouts and weapon penetration are modeled based on historical data collected
by the Allied governments after WWII. Kursk Simulator models the overmatch
mechanics (the interactions between weapons and armour that determine the
penetration, or non-penetration of a shell through armour) of tank gunnery,
with a simplified and stylized model based on elementary physics.
""")
        self.about_prompt = self.main_prompt + "\n" + about_message
Example #30
0
 def testWrap(self):
     self.assertEqual("This\nis", util.wrap("This\nis", 80))
     self.assertEqual("This is ", util.wrap("This is", 80))
     self.assertEqual("This\nis ", util.wrap("This is", 3))
     self.assertEqual("This\nis\n", util.wrap("This is\n", 3))
Example #31
0
 def previous(self):
     # See comment of next()
     if self.state == "play":
         self.connection.send(util.wrap(util.CMD_PREVIOUS))
         self.connection.recv(util.BUFFER_SIZE)
Example #32
0
    def cbComputeActionGA3C(self, event):
        if self.operation_mode.mode!=self.operation_mode.NN or self.stop_moving_flag:
            # print 'Not in NN mode'
            # print self.operation_mode.mode
            return
        


        # construct agent_state
        x = self.pose.pose.position.x; y = self.pose.pose.position.y
        v_x = self.vel.x; v_y = self.vel.y
        radius = self.veh_data['radius']; turning_dir = 0.0
        heading_angle = self.psi
        pref_speed = self.veh_data['pref_speed']
        goal_x = self.sub_goal.x
        goal_y = self.sub_goal.y
        marker_goal = [goal_x, goal_y]
        self.visualize_subgoal(marker_goal, None)
        
        # in case current speed is larger than desired speed
        # print goal_x+goal_y
        v = np.linalg.norm(np.array([v_x, v_y]))
        if v > pref_speed:
            v_x = v_x * pref_speed / v
            v_y = v_y * pref_speed / v

        host_agent = agent.Agent(x, y, goal_x, goal_y, radius, pref_speed, heading_angle, 0)
        host_agent.vel_global_frame = np.array([v_x, v_y])
        # host_agent.print_agent_info()

        other_agents_state = copy.deepcopy(self.other_agents_state)
        obs = host_agent.observe(other_agents_state)[1:]
        obs = np.expand_dims(obs, axis=0)

        #predictions = self.nn.predict_p(obs,None)[0]
        predictions = self.nn.predict_p(obs)[0]

        raw_action = copy.deepcopy(self.actions[np.argmax(predictions)])
        action = np.array([pref_speed*raw_action[0], util.wrap(raw_action[1] + self.psi)])


        # if close to goal
        kp_v = 0.5
        kp_r = 1   

        if host_agent.dist_to_goal < 2.0: # and self.percentComplete>=0.9:
            # print "somewhat close to goal"
            pref_speed = max(min(kp_v * (host_agent.dist_to_goal-0.1), pref_speed), 0.0)
            action[0] = min(raw_action[0], pref_speed)
            turn_amount = max(min(kp_r * (host_agent.dist_to_goal-0.1), 1.0), 0.0) * raw_action[1]
            action[1] = util.wrap(turn_amount + self.psi)
        if host_agent.dist_to_goal < 0.3:
            # current goal, reached, increment for next goal
            print("===============\ngoal reached: "+str([goal_x, goal_y]))
            self.stop_moving_flag = True
            self.new_global_goal_received = False
            self.stop_moving()
            # self.goal_idx += 1
        else:
            self.stop_moving_flag = False
            


        self.update_action(action)
Example #33
0
 def write(self, write_buf, encode_hdlc=False):
     if encode_hdlc:
         write_buf = util.wrap(write_buf)
     self.port.write(write_buf)
Example #34
0
def formatblock(block, width):
    """Format a block according to width."""
    if width <= 0:
        width = 78
    indent = ' ' * block['indent']
    if block['type'] == 'admonition':
        admonition = _admonitiontitles[block['admonitiontitle']]
        hang = len(block['lines'][-1]) - len(block['lines'][-1].lstrip())

        defindent = indent + hang * ' '
        text = ' '.join(map(str.strip, block['lines']))
        return '%s\n%s' % (
            indent + admonition,
            util.wrap(
                text, width=width, initindent=defindent, hangindent=defindent))
    if block['type'] == 'margin':
        return ''
    if block['type'] == 'literal':
        indent += '  '
        return indent + ('\n' + indent).join(block['lines'])
    if block['type'] == 'section':
        underline = encoding.colwidth(block['lines'][0]) * block['underline']
        return "%s%s\n%s%s" % (indent, block['lines'][0], indent, underline)
    if block['type'] == 'definition':
        term = indent + block['lines'][0]
        hang = len(block['lines'][-1]) - len(block['lines'][-1].lstrip())
        defindent = indent + hang * ' '
        text = ' '.join(map(str.strip, block['lines'][1:]))
        return '%s\n%s' % (
            term,
            util.wrap(
                text, width=width, initindent=defindent, hangindent=defindent))
    subindent = indent
    if block['type'] == 'bullet':
        if block['lines'][0].startswith('| '):
            # Remove bullet for line blocks and add no extra
            # indention.
            block['lines'][0] = block['lines'][0][2:]
        else:
            m = _bulletre.match(block['lines'][0])
            subindent = indent + m.end() * ' '
    elif block['type'] == 'field':
        keywidth = block['keywidth']
        key = block['key']

        subindent = indent + _fieldwidth * ' '
        if len(key) + 2 > _fieldwidth:
            # key too large, use full line width
            key = key.ljust(width)
        elif keywidth + 2 < _fieldwidth:
            # all keys are small, add only two spaces
            key = key.ljust(keywidth + 2)
            subindent = indent + (keywidth + 2) * ' '
        else:
            # mixed sizes, use fieldwidth for this one
            key = key.ljust(_fieldwidth)
        block['lines'][0] = key + block['lines'][0]
    elif block['type'] == 'option':
        m = _optionre.match(block['lines'][0])
        option, arg, rest = m.groups()
        subindent = indent + (len(option) + len(arg)) * ' '

    text = ' '.join(map(str.strip, block['lines']))
    return util.wrap(text,
                     width=width,
                     initindent=indent,
                     hangindent=subindent)
Example #35
0
def formatblock(block, width):
    """Format a block according to width."""
    if width <= 0:
        width = 78
    indent = ' ' * block['indent']
    if block['type'] == 'admonition':
        admonition = _admonitiontitles[block['admonitiontitle']]
        if not block['lines']:
            return indent + admonition + '\n'
        hang = len(block['lines'][-1]) - len(block['lines'][-1].lstrip())

        defindent = indent + hang * ' '
        text = ' '.join(map(str.strip, block['lines']))
        return '%s\n%s\n' % (
            indent + admonition,
            util.wrap(
                text, width=width, initindent=defindent, hangindent=defindent))
    if block['type'] == 'margin':
        return '\n'
    if block['type'] == 'literal':
        indent += '  '
        return indent + ('\n' + indent).join(block['lines']) + '\n'
    if block['type'] == 'section':
        underline = encoding.colwidth(block['lines'][0]) * block['underline']
        return "%s%s\n%s%s\n" % (indent, block['lines'][0], indent, underline)
    if block['type'] == 'table':
        table = block['table']
        # compute column widths
        widths = [max([encoding.colwidth(e) for e in c]) for c in zip(*table)]
        text = ''
        span = sum(widths) + len(widths) - 1
        indent = ' ' * block['indent']
        hang = ' ' * (len(indent) + span - widths[-1])

        for row in table:
            l = []
            for w, v in zip(widths, row):
                pad = ' ' * (w - encoding.colwidth(v))
                l.append(v + pad)
            l = ' '.join(l)
            l = util.wrap(l, width=width, initindent=indent, hangindent=hang)
            if not text and block['header']:
                text = l + '\n' + indent + '-' * (min(width, span)) + '\n'
            else:
                text += l + "\n"
        return text
    if block['type'] == 'definition':
        term = indent + block['lines'][0]
        hang = len(block['lines'][-1]) - len(block['lines'][-1].lstrip())
        defindent = indent + hang * ' '
        text = ' '.join(map(str.strip, block['lines'][1:]))
        return '%s\n%s\n' % (
            term,
            util.wrap(
                text, width=width, initindent=defindent, hangindent=defindent))
    subindent = indent
    if block['type'] == 'bullet':
        if block['lines'][0].startswith('| '):
            # Remove bullet for line blocks and add no extra
            # indention.
            block['lines'][0] = block['lines'][0][2:]
        else:
            m = _bulletre.match(block['lines'][0])
            subindent = indent + m.end() * ' '
    elif block['type'] == 'field':
        key = block['key']
        subindent = indent + _fieldwidth * ' '
        if len(key) + 2 > _fieldwidth:
            # key too large, use full line width
            key = key.ljust(width)
        else:
            # key fits within field width
            key = key.ljust(_fieldwidth)
        block['lines'][0] = key + block['lines'][0]
    elif block['type'] == 'option':
        return formatoption(block, width)

    text = ' '.join(map(str.strip, block['lines']))
    return util.wrap(
        text, width=width, initindent=indent, hangindent=subindent) + '\n'
Example #36
0
 def write(self, write_buf, encode_hdlc = False):
     if encode_hdlc:
         write_buf = util.wrap(write_buf)
     self.w_handle.write(write_buf)
Example #37
0
 def get_device_volume(self):
     self.connection.send(util.wrap(util.CMD_GETVOLUME))
     raw_vol = self.connection.recv(util.BUFFER_SIZE)
     vol_xml = etree.fromstring(raw_vol) # create xml representation
     return int(vol_xml.text) * 5  # convert to percentage
Example #38
0
def _wrap(s, width, indent, subindent=None):
    subindent = subindent or indent
    return util.wrap(s, width, indent=indent, subindent=subindent)
Example #39
0
    def cbComputeActionGA3C(self, event):
        feasible_actions = copy.deepcopy(self.feasible_actions)
        if self.operation_mode.mode != self.operation_mode.NN:
            print 'Not in NN mode'
            print self.operation_mode.mode
            return
        if len(feasible_actions.angles) == 0 \
            or len(feasible_actions.path_lengths)==0:
            print 'Invalid Feasible Actions'
            # print feasible_actions
            return

        # construct agent_state
        x = self.pose.pose.position.x
        y = self.pose.pose.position.y
        v_x = self.vel.x
        v_y = self.vel.y
        radius = self.veh_data['radius']
        turning_dir = 0.0
        heading_angle = self.psi
        pref_speed = self.veh_data['pref_speed']
        goal_x = self.goal.pose.position.x
        goal_y = self.goal.pose.position.y
        # in case current speed is larger than desired speed
        v = np.linalg.norm(np.array([v_x, v_y]))
        if v > pref_speed:
            v_x = v_x * pref_speed / v
            v_y = v_y * pref_speed / v

        host_agent = agent.Agent(x, y, goal_x, goal_y, radius, pref_speed,
                                 heading_angle, 0)
        host_agent.vel_global_frame = np.array([v_x, v_y])
        # host_agent.print_agent_info()

        other_agents_state = copy.deepcopy(self.other_agents_state)
        obs = host_agent.observe(other_agents_state)[1:]
        obs = np.expand_dims(obs, axis=0)
        # print "obs:", obs
        predictions = self.nn.predict_p(obs, None)[0]
        # print "predictions:", predictions
        # print "best action index:", np.argmax(predictions)
        raw_action = copy.deepcopy(self.actions[np.argmax(predictions)])
        action = np.array(
            [pref_speed * raw_action[0],
             util.wrap(raw_action[1] + self.psi)])
        # print "raw_action:", raw_action
        # print "action:", action

        # feasible_actions
        angles = (np.array(feasible_actions.angles) + np.pi) % (2 *
                                                                np.pi) - np.pi
        max_ranges = np.array(feasible_actions.max_speeds) - 0.3
        path_lengths = np.array(feasible_actions.path_lengths)
        # Sort the feasible actions by increasing angle
        order_inds = np.argsort(angles)
        max_ranges = max_ranges[order_inds]
        angles = angles[order_inds]
        path_lengths = path_lengths[order_inds]

        # Find which index corresponds to straight in front, and 90 deg each side
        zero_ind = np.digitize([self.psi + 0.01], angles) - 1
        self.d_min = max_ranges[zero_ind]
        # self.d_min = 100.0

        # if close to goal
        kp_v = 0.5
        kp_r = 1

        if host_agent.dist_to_goal < 2.0:  # and self.percentComplete>=0.9:
            # print "somewhat close to goal"
            pref_speed = max(
                min(kp_v * (host_agent.dist_to_goal - 0.1), pref_speed), 0.0)
            action[0] = min(raw_action[0], pref_speed)
            turn_amount = max(min(kp_r * (host_agent.dist_to_goal - 0.1), 1.0),
                              0.0) * raw_action[1]
            action[1] = util.wrap(turn_amount + self.psi)
        if host_agent.dist_to_goal < 0.3:
            self.stop_moving_flag = True
        else:
            self.stop_moving_flag = False

        # print 'chosen action (rel angle)', action[0], action[1]
        self.update_action(action)
Example #40
0
def _wrap(s, width, indent, subindent=None):
    subindent = subindent or indent
    return util.wrap(s, width, indent=indent, subindent=subindent)
Example #41
0
def formatblock(block, width):
    """Format a block according to width."""
    if width <= 0:
        width = 78
    indent = ' ' * block['indent']
    if block['type'] == 'admonition':
        admonition = _admonitiontitles[block['admonitiontitle']]
        hang = len(block['lines'][-1]) - len(block['lines'][-1].lstrip())

        defindent = indent + hang * ' '
        text = ' '.join(map(str.strip, block['lines']))
        return '%s\n%s\n' % (indent + admonition,
                             util.wrap(text, width=width,
                                       initindent=defindent,
                                       hangindent=defindent))
    if block['type'] == 'margin':
        return '\n'
    if block['type'] == 'literal':
        indent += '  '
        return indent + ('\n' + indent).join(block['lines']) + '\n'
    if block['type'] == 'section':
        underline = encoding.colwidth(block['lines'][0]) * block['underline']
        return "%s%s\n%s%s\n" % (indent, block['lines'][0],indent, underline)
    if block['type'] == 'table':
        table = block['table']
        # compute column widths
        widths = [max([encoding.colwidth(e) for e in c]) for c in zip(*table)]
        text = ''
        span = sum(widths) + len(widths) - 1
        indent = ' ' * block['indent']
        hang = ' ' * (len(indent) + span - widths[-1])

        for row in table:
            l = []
            for w, v in zip(widths, row):
                pad = ' ' * (w - encoding.colwidth(v))
                l.append(v + pad)
            l = ' '.join(l)
            l = util.wrap(l, width=width, initindent=indent, hangindent=hang)
            if not text and block['header']:
                text = l + '\n' + indent + '-' * (min(width, span)) + '\n'
            else:
                text += l + "\n"
        return text
    if block['type'] == 'definition':
        term = indent + block['lines'][0]
        hang = len(block['lines'][-1]) - len(block['lines'][-1].lstrip())
        defindent = indent + hang * ' '
        text = ' '.join(map(str.strip, block['lines'][1:]))
        return '%s\n%s\n' % (term, util.wrap(text, width=width,
                                             initindent=defindent,
                                             hangindent=defindent))
    subindent = indent
    if block['type'] == 'bullet':
        if block['lines'][0].startswith('| '):
            # Remove bullet for line blocks and add no extra
            # indention.
            block['lines'][0] = block['lines'][0][2:]
        else:
            m = _bulletre.match(block['lines'][0])
            subindent = indent + m.end() * ' '
    elif block['type'] == 'field':
        key = block['key']
        subindent = indent + _fieldwidth * ' '
        if len(key) + 2 > _fieldwidth:
            # key too large, use full line width
            key = key.ljust(width)
        else:
            # key fits within field width
            key = key.ljust(_fieldwidth)
        block['lines'][0] = key + block['lines'][0]
    elif block['type'] == 'option':
        return formatoption(block, width)

    text = ' '.join(map(str.strip, block['lines']))
    return util.wrap(text, width=width,
                     initindent=indent,
                     hangindent=subindent) + '\n'
def _dump_context(command, args, runner_args, cached_runner_var):
    build_dir = _build_dir(args, die_if_none=False)

    # Try to figure out the CMake cache file based on the build
    # directory or an explicit argument.
    if build_dir is not None:
        cache_file = path.abspath(
            path.join(build_dir, args.cmake_cache or cmake.DEFAULT_CACHE))
    elif args.cmake_cache:
        cache_file = path.abspath(args.cmake_cache)
    else:
        cache_file = None

    # Load the cache itself, if possible.
    if cache_file is None:
        log.wrn('No build directory (--build-dir) or CMake cache '
                '(--cache-file) given or found; output will be limited')
        cache = None
    else:
        try:
            cache = cmake.CMakeCache(cache_file)
        except Exception:
            log.die('Cannot load cache {}.'.format(cache_file))

    # If we have a build directory, try to ensure build artifacts are
    # up to date. If that doesn't work, still try to print information
    # on a best-effort basis.
    if build_dir and not args.skip_rebuild:
        try:
            cmake.run_build(build_dir)
        except CalledProcessError:
            msg = 'Failed re-building application; cannot load context. '
            if args.build_dir:
                msg += 'Is {} the right --build-dir?'.format(args.build_dir)
            else:
                msg += textwrap.dedent('''\
                Use --build-dir (-d) to specify a build directory; the one
                used was {}.'''.format(build_dir))
            log.die('\n'.join(textwrap.wrap(msg, initial_indent='',
                                            subsequent_indent=INDENT,
                                            break_on_hyphens=False)))

    if cache is None:
        _dump_no_context_info(command, args)
        if not args.runner:
            return

    if args.runner:
        # Just information on one runner was requested.
        _dump_one_runner_info(cache, args, build_dir, INDENT)
        return

    board = cache['CACHED_BOARD']

    all_cls = {cls.name(): cls for cls in ZephyrBinaryRunner.get_runners() if
               command.name in cls.capabilities().commands}
    available = [r for r in cache.get_list('ZEPHYR_RUNNERS') if r in all_cls]
    available_cls = {r: all_cls[r] for r in available if r in all_cls}

    default_runner = cache.get(cached_runner_var)
    cfg = cached_runner_config(build_dir, cache)

    log.inf('All Zephyr runners which support {}:'.format(command.name),
            colorize=True)
    for line in util.wrap(', '.join(all_cls.keys()), INDENT):
        log.inf(line)
    log.inf('(Not all may work with this build, see available runners below.)',
            colorize=True)

    if cache is None:
        log.warn('Missing or invalid CMake cache {}; there is no context.',
                 'Use --build-dir to specify the build directory.')
        return

    log.inf('Build directory:', colorize=True)
    log.inf(INDENT + build_dir)
    log.inf('Board:', colorize=True)
    log.inf(INDENT + board)
    log.inf('CMake cache:', colorize=True)
    log.inf(INDENT + cache_file)

    if not available:
        # Bail with a message if no runners are available.
        msg = ('No runners available for {}. '
               'Consult the documentation for instructions on how to run '
               'binaries on this target.').format(board)
        for line in util.wrap(msg, ''):
            log.inf(line, colorize=True)
        return

    log.inf('Available {} runners:'.format(command.name), colorize=True)
    log.inf(INDENT + ', '.join(available))
    log.inf('Additional options for available', command.name, 'runners:',
            colorize=True)
    for runner in available:
        _dump_runner_opt_help(runner, all_cls[runner])
    log.inf('Default {} runner:'.format(command.name), colorize=True)
    log.inf(INDENT + default_runner)
    _dump_runner_config(cfg, '', INDENT)
    log.inf('Runner-specific information:', colorize=True)
    for runner in available:
        log.inf('{}{}:'.format(INDENT, runner), colorize=True)
        _dump_runner_cached_opts(cache, runner, INDENT * 2, INDENT * 3)
        _dump_runner_caps(available_cls[runner], INDENT * 2)

    if len(available) > 1:
        log.inf('(Add -r RUNNER to just print information about one runner.)',
                colorize=True)
Example #43
0
########## 6 parent deck pulls new cards from all children instead of sequentially (ie. mostly first)
def my_fillNew( self, _old ):
    '''If 'new card merged fill' is enabled for the current deck, when we refill we
    pull from all child decks, sort combined pool of cards, then limit.
    If disabled, do the standard sequential fill method'''
    C = partial( cfg, None, self.col.decks.active()[0] )
    if not C('new card merged fill'): return _old( self )

    if self._newQueue:      return True
    if not self.newCount:   return False

    self._newQueue = self.col.db.all('''select id, due from cards where did in %s and queue = 0 and due >= ? order by due limit ?''' % self._deckLimit(), C('new card merged fill min due'), self.queueLimit )
    if self._newQueue:      return True

sched.Scheduler._fillNew = wrap( sched.Scheduler._fillNew, my_fillNew, 'around' )

########## handle skipping for 1-2
seenMorphs = set()

def markFocusSeen( self, n ):
    '''Mark a focusMorph as already seen so future new cards with the same focus
    will be skipped. Also prints number of cards to be skipped if enabled'''
    global seenMorphs
    try:
        if not focus( n ): return
        q = u'%s:%s' % ( focusName( n ), focus( n ) )
    except KeyError: return
    seenMorphs.add( focus(n) )
    numSkipped = len( self.mw.col.findNotes( q ) ) -1
    if numSkipped and cfg1('print number of alternatives skipped'):
Example #44
0
########## 6 parent deck pulls new cards from all children instead of sequentially (ie. mostly first)
def my_fillNew( self, _old ):
    '''If 'new card merged fill' is enabled for the current deck, when we refill we
    pull from all child decks, sort combined pool of cards, then limit.
    If disabled, do the standard sequential fill method'''
    C = partial( cfg, None, self.col.decks.active()[0] )
    if not C('new card merged fill'): return _old( self )

    if self._newQueue:      return True
    if not self.newCount:   return False

    self._newQueue = self.col.db.all('''select id, due from cards where did in %s and queue = 0 and due >= ? order by due limit ?''' % self._deckLimit(), C('new card merged fill min due'), self.queueLimit )
    if self._newQueue:      return True

sched.Scheduler._fillNew = wrap( sched.Scheduler._fillNew, my_fillNew, 'around' )

########## handle skipping for 1-2
seenMorphs = set()

def markFocusSeen( self, n ):
    '''Mark a focusMorph as already seen so future new cards with the same focus
    will be skipped. Also prints number of cards to be skipped if enabled'''
    global seenMorphs
    try:
        if not focus( n ): return
        q = u'%s:%s' % ( focusName( n ), focus( n ) )
    except KeyError: return
    seenMorphs.add( focus(n) )
    numSkipped = len( self.mw.col.findNotes( q ) ) -1
    if numSkipped and cfg1('print number of alternatives skipped'):
Example #45
0
    :param day_mae_mse:
    :return:
    '''
    maes = np.vstack((mae_mse[0] for mae_mse in mae_mse_by_hours)).T
    mses = np.vstack((mae_mse[1] for mae_mse in mae_mse_by_hours)).T
    level_datas = np.hstack((level_data for level_data in level_by_hours))
    day_maes = np.vstack((mae_mse[0] for mae_mse in day_mae_mse)).T
    day_mses = np.vstack((mae_mse[1] for mae_mse in day_mae_mse)).T
    results = np.hstack((maes, mses, level_datas, day_maes, day_mses))
    return results


if __name__ == '__main__':
    data = process_all()
    coll=Connect_DB()
    mongo_data= ReadOneStation(coll,start_time,end_time)
    wrap(data,mongo_data)
    # 使用偏函数 固定data,便于之后map操作
    #data = np.load('2015_12_30.npz')['arr_0']

    cal_mae_mse = partial(calculate_mae_mse, data)
    cal_level = partial(calculate_level, data)
    cal_day_mae_mse = partial(calculate_day_mae_mse, data)

    mae_mse_by_hours = map(cal_mae_mse, gaps)
    level_by_hours = map(cal_level, gaps)
    day_mae_mse = map(cal_day_mae_mse, day_gaps)

    results = h_stack_data(mae_mse_by_hours, level_by_hours, day_mae_mse)
    insert_to_mongo(db, results)
Example #46
0
def main():
    args = parser.parse_args()
    sequence = args.file.read()
    header, _, remain = sequence.partition("\n")
    if (header.startswith(">")):
        sequence = remain
    else:
        header = None

    sequence = sequence.replace("\n", "").upper()
    isDna = detectDNA(sequence)
    if (isDna is None):
        eprint("ERROR: Could not detect DNA/RNA")
        sys.exit(1)

    if (isDna):
        sequence = dnaToRna(sequence)


#print("IN SEQ         ",sequence)
#print("IN SEQ         ",complement(sequence));
    allTranslated = []
    for name, seq in permute(sequence, args.regenerateFromThreePrime):
        #print("translating",name.ljust(2),subdivide(seq));
        translated = translate(seq)
        unbrokenLength = countWithoutStop(translated)
        if args.readingframe:
            if int(name) == args.readingframe:
                allTranslated.append((unbrokenLength, name, translated))
        else:
            allTranslated.append((unbrokenLength, name, translated))

    def getKey(item):
        return item[0]

    if (not args.orderByFrame): allTranslated.sort(key=getKey, reverse=True)

    for trans in allTranslated[1:]:
        unbrokenLength, name, translated = trans
        longest = allTranslated[0][0]
        warnSize = args.warnLength.strip()
        if args.warnLength.endswith("%"):
            warnSize = longest * float(warnSize.strip("%")) / 100
        warnSize = int(warnSize)
        if (unbrokenLength >= warnSize):
            name, _, _ = header.partition(" ")
            name = name.strip(">")
            sys.stderr.write(
                "Translate: long frame detected in %s length:%d (longest: %d)\n"
                % (name, unbrokenLength, allTranslated[0][0]))

    if (args.readingFrameOnly):
        if (header): print(header, "[longest reading frame only]")
        print(
            util.wrap(extractLongestReadingFrame(allTranslated[0][2]),
                      args.wrap))
    elif (not args.showAll):
        if (header): print(header)
        print(util.wrap(allTranslated[0][2], args.wrap))
    else:
        #showall
        for trans in allTranslated:
            unbrokenLength, name, translated = trans
            print("Frame %s (max length %d)" % (name, unbrokenLength))
            if (header): print(header)
            print(translated)
            print()
Example #47
0
 def stop(self):
     # We can stop at any time; this command will always execute.
     self.connection.send(util.wrap(util.CMD_STOP))
     self.connection.recv(util.BUFFER_SIZE)
     self.state = "stop"
Example #48
0
        d['goals'][ name ] = { 'total':numUniqueReq, 'known':numUniqueKnown, 'freqTotal':numFreqReq, 'freqKnown':numFreqKnown }

    saveStats( d )
    mw.progress.finish()
    return d

def getStatsLink():
    d = loadStats()
    if not d: return ( 'K ???', '????' )

    name = 'K %d' % d['totalKnown']
    lines = []
    for goalName, g in sorted( d['goals'].items() ):
        #lines.append( '%s %d/%d %d%%' % ( goalName, g['known'], g['total'], 100.*g['known']/g['total'] ) )
        #lines.append( '%s %d%%' % ( goalName, 100.*g['known']/g['total'] ) )
        lines.append( '%s %d%% %d%%' % ( goalName, 100.*g['known']/g['total'], 100.*g['freqKnown']/g['freqTotal'] ) )
    details = '\n'.join( lines )
    return ( name, details )

def my_centerLinks( self, _old ):
    name, details = getStatsLink()
    links = [
        ["decks", _("Decks"), _("Shortcut key: %s") % "D"],
        ["add", _("Add"), _("Shortcut key: %s") % "A"],
        ["browse", _("Browse"), _("Shortcut key: %s") % "B"],
        ["morph", _(name), _(details)],
    ]
    return self._linkHTML( links )

toolbar.Toolbar._centerLinks = wrap( toolbar.Toolbar._centerLinks, my_centerLinks, 'around' )
Example #49
0
def formatblock(block, width):
    """Format a block according to width."""
    if width <= 0:
        width = 78
    indent = ' ' * block['indent']
    if block['type'] == 'admonition':
        admonition = _admonitiontitles[block['admonitiontitle']]
        hang = len(block['lines'][-1]) - len(block['lines'][-1].lstrip())

        defindent = indent + hang * ' '
        text = ' '.join(map(str.strip, block['lines']))
        return '%s\n%s' % (indent + admonition, util.wrap(text, width=width,
                                           initindent=defindent,
                                           hangindent=defindent))
    if block['type'] == 'margin':
        return ''
    if block['type'] == 'literal':
        indent += '  '
        return indent + ('\n' + indent).join(block['lines'])
    if block['type'] == 'section':
        underline = encoding.colwidth(block['lines'][0]) * block['underline']
        return "%s%s\n%s%s" % (indent, block['lines'][0],indent, underline)
    if block['type'] == 'definition':
        term = indent + block['lines'][0]
        hang = len(block['lines'][-1]) - len(block['lines'][-1].lstrip())
        defindent = indent + hang * ' '
        text = ' '.join(map(str.strip, block['lines'][1:]))
        return '%s\n%s' % (term, util.wrap(text, width=width,
                                           initindent=defindent,
                                           hangindent=defindent))
    subindent = indent
    if block['type'] == 'bullet':
        if block['lines'][0].startswith('| '):
            # Remove bullet for line blocks and add no extra
            # indention.
            block['lines'][0] = block['lines'][0][2:]
        else:
            m = _bulletre.match(block['lines'][0])
            subindent = indent + m.end() * ' '
    elif block['type'] == 'field':
        keywidth = block['keywidth']
        key = block['key']

        subindent = indent + _fieldwidth * ' '
        if len(key) + 2 > _fieldwidth:
            # key too large, use full line width
            key = key.ljust(width)
        elif keywidth + 2 < _fieldwidth:
            # all keys are small, add only two spaces
            key = key.ljust(keywidth + 2)
            subindent = indent + (keywidth + 2) * ' '
        else:
            # mixed sizes, use fieldwidth for this one
            key = key.ljust(_fieldwidth)
        block['lines'][0] = key + block['lines'][0]
    elif block['type'] == 'option':
        return formatoption(block, width)

    text = ' '.join(map(str.strip, block['lines']))
    return util.wrap(text, width=width,
                     initindent=indent,
                     hangindent=subindent)
Example #50
0
def getStatsLink():
    d = loadStats()
    if not d: return ('K ???', '????')

    name = 'K %d' % d['totalKnown']
    lines = []
    for goalName, g in sorted(d['goals'].items()):
        #lines.append( '%s %d/%d %d%%' % ( goalName, g['known'], g['total'], 100.*g['known']/g['total'] ) )
        #lines.append( '%s %d%%' % ( goalName, 100.*g['known']/g['total'] ) )
        lines.append('%s %d%% %d%%' %
                     (goalName, 100. * g['known'] / g['total'],
                      100. * g['freqKnown'] / g['freqTotal']))
    details = '\n'.join(lines)
    return (name, details)


def my_centerLinks(self, _old):
    name, details = getStatsLink()
    links = [
        ["decks", _("Decks"), _("Shortcut key: %s") % "D"],
        ["add", _("Add"), _("Shortcut key: %s") % "A"],
        ["browse", _("Browse"),
         _("Shortcut key: %s") % "B"],
        ["morph", _(name), _(details)],
    ]
    return self._linkHTML(links)


toolbar.Toolbar._centerLinks = wrap(toolbar.Toolbar._centerLinks,
                                    my_centerLinks, 'around')
Example #51
0
    def help(self):
        """
        Write option help out to the provide ui/shell.

        The help output consists of a usage string, a short command description,
        a detailed/long command description (formated from ReST - ReStructured
        Text), optional list of valid sub-commands, and a list of option groups
        (each option group represents the options of this or parent commands).

        Example::

            usage: app cmd [options]

            an example short description

                A longer description of the sub-command 'cmd' handled by the
                base application 'app'.

            commands:

                sub-cmd      a short description of the sub-cmd

            cmd options:

             -a --alpha      description of the 'alpha' option
             -b --bravo INT  description of the 'bravo' option

            app options:

             -c --charlie    description of the 'charlie' option

        The above example shows the help generated for a command 'cmd' handled
        by the base command (or application) 'app'. The command 'cmd' also has a
        sub-command named 'sub-cmd'.
        """
        self.ui.write('usage: %s %s\n\n' % (self._parent_usage(), self.usage))
        self.ui.write('%s\n\n' % self.short_desc())
        long_desc = self.long_desc()
        if long_desc:
            long_desc = self.ui.rst(long_desc, indent='    ')
            if long_desc:
                self.ui.write('%s\n\n' % long_desc)

        cmds = {}
        for name, cmd in self.cmdtable.iteritems():
            name = '    %s  ' % name.split('|')[0]
            cmds[name] = cmd.short_desc()

        cmds = [(key, cmds[key]) for key in sorted(cmds.iterkeys())]
        groups = []
        indent = 0

        if cmds:
            groups.append(('commands', cmds))
            indent = max(len(c[0]) for c in cmds)

        indent_, groups_ = self._option_help()

        groups.extend(groups_)
        indent = max(indent, indent_)
        hanging = indent * ' '
        for group in groups:
            self.ui.write('%s:\n\n' % group[0])
            for opt in group[1]:
                self.ui.write('%s\n' % util.wrap(
                    opt[1], self.ui.termwidth(), opt[0].ljust(indent), hanging))
            self.ui.write('\n')
Example #52
0
    def update_state(self, action, dt):
        if self.is_at_goal or self.ran_out_of_time or self.in_collision:
            if self.is_at_goal: self.was_at_goal_already = True
            if self.in_collision: self.was_in_collision_already = True
            self.vel_global_frame = np.array([0.0, 0.0])
            return

        # self.past_actions = np.roll(self.past_actions,1,axis=0)
        # self.past_actions[0,:] = action

        if self.action_time_lag > 0:
            # Store current action in dictionary, then look up the past action that should be executed this step
            self.chosen_action_dict[self.t] = action
            # print "-------------"
            # print "Agent id: %i" %self.id
            # print "Current t:", self.t
            # print "Current action:", action
            timestamp_of_action_to_execute = self.t - self.action_time_lag
            # print "timestamp_of_action_to_execute:", timestamp_of_action_to_execute
            if timestamp_of_action_to_execute < 0:
                # print "storing up actions...."
                action_to_execute = np.array([0.0, 0.0])
            else:
                nearest_timestamp, _ = util.find_nearest(
                    np.array(self.chosen_action_dict.keys()),
                    timestamp_of_action_to_execute)
                # print "nearest_timestamp:", nearest_timestamp
                action_to_execute = self.chosen_action_dict[
                    nearest_timestamp[0]]
            # print "action_to_execute:", action_to_execute
        else:
            action_to_execute = action

        selected_speed = action_to_execute[0] * self.pref_speed
        selected_heading = util.wrap(
            action_to_execute[1] +
            self.heading_global_frame)  # in global frame

        dx = selected_speed * np.cos(selected_heading) * dt
        dy = selected_speed * np.sin(selected_heading) * dt
        self.pos_global_frame += np.array([dx, dy])
        self.vel_global_frame[0] = selected_speed * np.cos(selected_heading)
        self.vel_global_frame[1] = selected_speed * np.sin(selected_heading)
        self.speed_global_frame = selected_speed
        self.heading_global_frame = selected_heading

        # Compute heading w.r.t. ref_prll, ref_orthog coordinate axes
        self.ref_prll, self.ref_orth = self.get_ref()
        ref_prll_angle_global_frame = np.arctan2(self.ref_prll[1],
                                                 self.ref_prll[0])
        self.heading_ego_frame = util.wrap(self.heading_global_frame -
                                           ref_prll_angle_global_frame)

        # Compute velocity w.r.t. ref_prll, ref_orthog coordinate axes
        cur_speed = np.linalg.norm(self.vel_global_frame)
        v_prll = cur_speed * np.cos(self.heading_ego_frame)
        v_orthog = cur_speed * np.sin(self.heading_ego_frame)
        self.vel_ego_frame = np.array([v_prll, v_orthog])

        # Update time left so agent does not run around forever
        self.time_remaining_to_reach_goal -= dt
        self.t += dt
        if self.time_remaining_to_reach_goal <= 0.0 and not Config.ROBOT_MODE:
            self.ran_out_of_time = True

        self._update_state_history()

        self._check_if_at_goal()

        return
Example #53
0
def formatblock(block, width):
    """Format a block according to width."""
    if width <= 0:
        width = 78
    indent = " " * block["indent"]
    if block["type"] == "admonition":
        admonition = _admonitiontitles[block["admonitiontitle"]]
        hang = len(block["lines"][-1]) - len(block["lines"][-1].lstrip())

        defindent = indent + hang * " "
        text = " ".join(map(str.strip, block["lines"]))
        return "%s\n%s\n" % (
            indent + admonition,
            util.wrap(text, width=width, initindent=defindent, hangindent=defindent),
        )
    if block["type"] == "margin":
        return "\n"
    if block["type"] == "literal":
        indent += "  "
        return indent + ("\n" + indent).join(block["lines"]) + "\n"
    if block["type"] == "section":
        underline = encoding.colwidth(block["lines"][0]) * block["underline"]
        return "%s%s\n%s%s\n" % (indent, block["lines"][0], indent, underline)
    if block["type"] == "table":
        table = block["table"]
        # compute column widths
        widths = [max([encoding.colwidth(e) for e in c]) for c in zip(*table)]
        text = ""
        span = sum(widths) + len(widths) - 1
        indent = " " * block["indent"]
        hang = " " * (len(indent) + span - widths[-1])

        for row in table:
            l = []
            for w, v in zip(widths, row):
                pad = " " * (w - encoding.colwidth(v))
                l.append(v + pad)
            l = " ".join(l)
            l = util.wrap(l, width=width, initindent=indent, hangindent=hang)
            if not text and block["header"]:
                text = l + "\n" + indent + "-" * (min(width, span)) + "\n"
            else:
                text += l + "\n"
        return text
    if block["type"] == "definition":
        term = indent + block["lines"][0]
        hang = len(block["lines"][-1]) - len(block["lines"][-1].lstrip())
        defindent = indent + hang * " "
        text = " ".join(map(str.strip, block["lines"][1:]))
        return "%s\n%s\n" % (term, util.wrap(text, width=width, initindent=defindent, hangindent=defindent))
    subindent = indent
    if block["type"] == "bullet":
        if block["lines"][0].startswith("| "):
            # Remove bullet for line blocks and add no extra
            # indention.
            block["lines"][0] = block["lines"][0][2:]
        else:
            m = _bulletre.match(block["lines"][0])
            subindent = indent + m.end() * " "
    elif block["type"] == "field":
        keywidth = block["keywidth"]
        key = block["key"]

        subindent = indent + _fieldwidth * " "
        if len(key) + 2 > _fieldwidth:
            # key too large, use full line width
            key = key.ljust(width)
        elif keywidth + 2 < _fieldwidth:
            # all keys are small, add only two spaces
            key = key.ljust(keywidth + 2)
            subindent = indent + (keywidth + 2) * " "
        else:
            # mixed sizes, use fieldwidth for this one
            key = key.ljust(_fieldwidth)
        block["lines"][0] = key + block["lines"][0]
    elif block["type"] == "option":
        return formatoption(block, width)

    text = " ".join(map(str.strip, block["lines"]))
    return util.wrap(text, width=width, initindent=indent, hangindent=subindent) + "\n"