def test_drive_distance_at_lower_bound(self):
img_src = self._pictures_dir + "straight_no_turn_3in.jpg"
follower = Follower(test_img_src=img_src)
follower.follow()
self.assertEqual(follower._speed, 0)
def test_drive_distance_below_lower_bound(self):
img_src = self._pictures_dir + "straight_no_turn_third_car_length.jpg"
follower = Follower(test_img_src=img_src)
follower.follow()
self.assertAlmostEqual(follower._speed, 0)
def test_detect_tag_not_found(self):
img_src = self._pictures_dir + "no_tag.jpg"
follower = Follower(test_img_src=img_src)
follower.follow()
self.assertEqual(follower._tag_data, self._default_tag_data)
def save(self):
is_new = self.CommentID is None
super(Comment, self).save()
from follower import Follower
if self.Type == 'Comments':
already_follows = Follower.query.filter(
and_(Follower.Type == 'Comments',
Follower.ParentID == self.ParentID,
Follower.UserID == self.UserID)).first()
if not already_follows:
follower = Follower(Type='Comments',
ParentID=self.ParentID,
UserID=self.UserID)
follower.save()
if is_new and self.Type == 'Forums':
from forum import Forum
forum = Forum.query.filter(
and_(Forum.ForumID == self.ParentID, Forum.SFDC_ID
is not None)).first()
if forum:
self.create_case_comment(forum.SFDC_ID)
if is_new:
self.notify_followers()
def test_detect_tag_found(self):
img_src = self._pictures_dir + "straight_no_turn_5in.jpg"
follower = Follower(test_img_src=img_src)
follower.follow()
self.assertNotEqual(follower._tag_data, self._default_tag_data)
def test_drive_distance_valid(self):
img_src = self._pictures_dir + "straight_no_turn_5in.jpg"
follower = Follower(test_img_src=img_src)
follower.follow()
self.assertEqual(follower._speed, LEADER_MAX_SPEED)
def save(self):
is_new = self.SequenceID is None
super(Sequence, self).save()
if is_new:
follower = Follower(ParentID=self.SequenceID,
Type='Sequences',
UserID=self.UserID)
follower.save()
def main():
tag = TagRecognition()
bt = Bluetoothctl()
BT_ADDR = "5C:BA:37:26:6D:9A"
# If an ARTag is detected, the vehicle will become a follower.
# If an ARTag is not detected, the vehicle will become a leader.
if tag.detect():
vehicle = Follower()
else:
if not is_controller_connected():
# If a controller is not connected, remove it to avoid problems
# connecting with it again.
disconnect_and_remove_device(bt, BT_ADDR)
bt.start_scan()
while not is_controller_connected():
bt.connect(BT_ADDR)
sleep(Follower.CYCLE_TIME)
vehicle = Leader()
# This loop makes the vehicle move. If the vehicle sees an ARTag then
# it is a follower vehicle, otherwise it is a leader vehicle.
timer_set = False
start_time = time.time()
while True:
tag_visible = tag.detect()
if isinstance(vehicle, Leader):
vehicle.lead()
if tag_visible:
while is_controller_connected():
bt.disconnect('5C:BA:37:26:6D:9A')
sleep(Follower.CYCLE_TIME)
vehicle = Follower()
else:
vehicle.follow()
if tag_visible:
timer_set = False
elif not timer_set:
start_time = time.time()
timer_set = True
if (time.time() - start_time) > 5 and timer_set:
timer_set = False
disconnect_and_remove_device(bt,BT_ADDR)
bt.start_scan()
bt.connect('5C:BA:37:26:6D:9A')
sleep(Follower.CYCLE_TIME)
if is_controller_connected():
vehicle = Leader()
else:
start_time = time.time()
timer_set = True
def set_and_send_follower(conn, cursor, person, authorization):
f = Follower()
if f.set_follower(person["url_token"], authorization):
send_to_db.send_f(cursor, f)
conn.commit()
cursor.close()
conn.close()
else:
person_fail_info = "person=" + person["url_token"]
write_log("person_failure_log", person_fail_info)
def row_to_SAR(row):
nonlocal follow
features = row['features']
state = Follower.get_state(features, follow.last_action)
action = [row['throttle'], row['direction']]
reward = Follower.get_reward(features, state, action)
follow.last_action = action
follow.last_state = state
return state, action_from_throttle_direction(*action), reward
def run(args):
rospy.init_node('formation')
# Update control every 100 ms.
rate_limiter = rospy.Rate(100)
leader = Leader("tb3_0", rate_limiter)
follower_1 = Follower("tb3_1",
desired_rel_pos=np.array([-0.5, 0.35, 0.0]),
rate_limiter=rate_limiter,
des_d=0.4,
des_psi=2 * np.pi / 3,
leader=leader,
laser_range=[np.pi, np.pi])
follower_2 = Follower("tb3_2",
desired_rel_pos=np.array([-0.5, -0.35, 0.0]),
rate_limiter=rate_limiter,
des_d=0.4,
des_psi=4 * np.pi / 3,
leader=leader,
laser_range=[np.pi, np.pi])
while not rospy.is_shutdown():
if follower_1.ready and follower_2.ready:
leader.update_velocities()
leader.publish_leg()
leader.slam.update()
follower_1.formation_velocity()
follower_2.formation_velocity()
rate_limiter.sleep()
def row_to_features(row):
image_path = os.path.join(DATA_DIR, *row['image_file'].split('/'))
# print(image_path)
if not os.path.isfile(image_path):
print(f"Image file '{image_path}' is missing!")
return None
return Follower.get_features(cv2.imread(image_path))
def test_should_navigate_along_list_of_waypoints_with_logging(self):
waypoint1 = Waypoint(Position(11, 11), 10)
waypoint2 = Waypoint(Position(13, 13), 10)
follower = Follower(self.exchange, [waypoint1, waypoint2],
self.mock_logger)
self.event_source.start()
self.mock_logger.info.assert_has_calls([
call('Follower, next waypoint +11.000000,+11.000000'),
call(
'Navigator, steering to +11.000000,+11.000000, bearing 44.4, distance 155941.2m, review after 20s'
),
call('Navigator, arrived at +11.000000,+11.000000'),
call('Follower, next waypoint +13.000000,+13.000000'),
call(
'Navigator, steering to +13.000000,+13.000000, bearing 44.2, distance 155399.6m, review after 20s'
),
call('Navigator, arrived at +13.000000,+13.000000'),
call(
'**************************************************************'
),
call('Follower, all waypoints reached, navigation complete'),
call(
'**************************************************************'
)
])
def test_should_signal_a_navigate_event_using_the_first_waypoint(self):
self.listen(EventName.navigate)
firstwaypoint = Waypoint(Position(1, 1), 5)
follower = Follower(self.exchange, [firstwaypoint], self.mock_logger)
self.exchange.publish(Event(EventName.start))
self.assertEqual(self.last_event.name, EventName.navigate)
self.assertEqual(self.last_event.waypoint, firstwaypoint)
class World:
def __init__(self,screen_width,screen_height):
self.screen_width = screen_width
self.screen_height = screen_height
self.background_color = (0,0,0)
self.mouse = Mouse()
self.follower = Follower()
def update(self,time_passed):
mouse_position = self.mouse.get_position()
self.mouse.update(time_passed)
self.follower.update(time_passed,mouse_position)
def render(self,screen):
screen.fill(self.background_color)
self.mouse.render(screen)
self.follower.render(screen)
def setUp(self):
dict = Dictionary()
state = Follower()
self.node = Node(0, state, [], dict, [])
dict2 = Dictionary()
state2 = Candidate()
self.node2 = Node(1, state2, [], dict2, [self.node])
self.node2.neighbors.append(self.node2)
def serverFunction(name):
server = config[name]["object"]
if server._serverState == followerState:
print "Started server with name ", name
elif server._serverState == resumeState:
print "Resumed server with name ", name
print server._commitIndex
print server._log
server._state = Follower()
server._state.set_server(server)
server._state.on_resume()
server._serverState = followerState
while (True):
if type(server._state) == Leader:
if time.time() >= server._state._timeoutTime:
server._state._send_heart_beat()
if type(server._state
) == Candidate and time.time() >= server._state._timeoutTime:
server._state = Follower()
server._state.set_server(server)
if type(server._state) == Follower and term >= 1:
if time.time() >= server._state._timeoutTime:
print server._name, "finds that the leader is dead"
server._serverState = candidateState
time.sleep(0.0001)
if server._serverState == deadState:
print "Killed server with name", name
server._state = Follower()
server._state.set_server(server)
print server._commitIndex
return
if server._serverState == candidateState and type(
server._state) != Candidate:
timeout = randint(0.1e5, 5e5)
timeout = 1.0 * timeout / 1e6
time.sleep(timeout)
if server._serverState == candidateState:
server._state = Candidate()
server._state.set_server(server)
def sushi_is_following(al):
if get_event_status("sushi_is_following") == 1:
al.learner.followers.append(
Follower(
al,
direction=Direction.DOWN,
sprite='dog',
name='ซูชิ',
x=-1,
y=-1,
))
def setFollowers(self):
num = self.followerParams.num - len(self.followers)
if num > 0:
for i in range(0, num):
self.followers.append(Follower(self.leader, self.followerParams,\
self.globalParams, self.grid))
elif num < 0:
num *= -1
for i in range(0, num):
popd = self.followers.pop()
self.grid.remove(popd, popd.loc.x, popd.loc.y)
def classify_episode(episode_name):
start_time = time.time()
# Read csv
csv_path = os.path.join(DATA_DIR, episode_name + '.csv')
if not os.path.isfile(csv_path):
print(f"No csv for episode '{episode_name}'")
return None
episode_df = pd.read_csv(csv_path)
# Features
def row_to_features(row):
image_path = os.path.join(DATA_DIR, *row['image_file'].split('/'))
# print(image_path)
if not os.path.isfile(image_path):
print(f"Image file '{image_path}' is missing!")
return None
return Follower.get_features(cv2.imread(image_path))
episode_df['features'] = episode_df.apply(row_to_features, axis=1)
# State
follow = Follower()
def row_to_SAR(row):
nonlocal follow
features = row['features']
state = Follower.get_state(features, follow.last_action)
action = [row['throttle'], row['direction']]
reward = Follower.get_reward(features, state, action)
follow.last_action = action
follow.last_state = state
return state, action_from_throttle_direction(*action), reward
episode_df['state'], episode_df['action'], episode_df['reward'] = zip(*episode_df.apply(row_to_SAR, axis=1))
# Save only some columns
csv_df = episode_df[['image_file', 'state', 'action', 'reward']]
# Change State object into tuple so it gets saved in csv properly
csv_df['state'] = csv_df.apply(lambda x: x['state'].as_tuple(), axis=1)
csv_df.to_csv(os.path.join(CLASSIFIED_CSV_DIR, episode_name + '.csv'), index=False)
duration = time.time() - start_time
print(f"Classification took {duration}s\t for '{episode_name}'")
print("State counts:", episode_df['state'].value_counts(), sep='\n')
return episode_df
def test_should_navigate_to_the_next_waypoint_when_a_waypoint_is_reached(
self):
self.listen(EventName.navigate)
waypoint1 = Waypoint(Position(1, 1), 5)
waypoint2 = Waypoint(Position(2, 2), 5)
follower = Follower(self.exchange, [waypoint1, waypoint2],
self.mock_logger)
self.exchange.publish(Event(EventName.start))
self.exchange.publish(Event(EventName.arrived, waypoint1))
self.assertEqual(self.last_event.waypoint, waypoint2)
def get_followers(session, conn, cursor, user_token_id, page_start, page_end):
count = 0
count_should_be = 0
authorization = get_authorization("cookies")
query_headers["authorization"] = authorization
for i in range(page_start, page_end):
this_page_url = 'https://www.zhihu.com/people/' + user_token_id + '/followers?page=' + str(
i)
query_url = 'https://www.zhihu.com/api/v4/members/' + user_token_id + '/followers'
payload["offset"] = i * 20
query_headers["Referer"] = this_page_url
try:
# get followers list
json_meta_data = session.get(query_url,
headers=query_headers,
params=payload)
json_data = json.loads(json_meta_data.text, encoding="utf8")
for person in json_data["data"]:
count_should_be += 1
f = Follower()
if f.set_follower(person["url_token"], authorization):
if send_to_db.send_f(cursor, f):
count += 1
if count % 100 == 0:
print("person count: " + str(count) + ". ")
conn.commit()
else:
person_fail_info = "person=" + person[
"url_token"] + ". Should: " + str(
count_should_be) + ", Real: " + str(count) + "."
write_log("person_failure_log", person_fail_info)
except KeyError as ke:
print(repr(ke))
page_fail_info = "page=" + str(i) + ". Failure code: " + KeyError
with open("page_failure_log", "a") as f:
f.write(page_fail_info + "\n")
f.close()
except requests.exceptions.RequestException as rerr:
print(repr(rerr))
page_fail_info = "page=" + str(i) + ". Failure code: " + str(
json_meta_data.status_code)
write_log("page_failure_log", page_fail_info)
time.sleep(600)
if is_login(session):
print("继续运行")
else:
login(session, phone_data['phone_num'], phone_data['password'],
phone_login_url)
return count, count_should_be
def save(self):
is_new = self.ID is None
super(Molecule, self).save()
if not self.Approved and TO_APPROVE_ID:
from comment import Comment
from forum import Forum
forum = Forum.query.filter_by(
Subject='To Approve Molecules').first()
msg = "Please review <a href='%s'>%s</a>" % (self.details_url,
self.Name)
comm = Comment(Message=msg,
UserID=self.UserID,
ParentID=forum.ForumID,
Type="Forums",
RenderType="html")
comm.save()
if is_new:
follower = Follower(ParentID=self.ID,
Type='Molecules',
UserID=self.UserID)
follower.save()
def follow(self, waypoints):
self.application_logger.info(
'**************************************************************')
self.application_logger.info(
'*** Pi-Nav starting navigation: ' +
datetime.datetime.now().strftime("%Y-%m-%d"))
self.application_logger.info(
'**************************************************************')
self.self_test.run()
self.rudder_servo.set_position(0)
self.follower = Follower(self.exchange, waypoints,
self.application_logger)
self.event_source.start()
def _talked_to_nim_in_plane_4(al: "All"):
al.mas.current_map.npcs = [
npc for npc in al.mas.current_map.npcs if npc.name != "Nim"
]
al.learner.followers.append(
Follower(
al,
direction=Direction.DOWN,
sprite='nim',
name='Nim',
x=57,
y=54,
))
set_event('nim_is_following', 1)
def on_vote_received(self, message):
self._votes[message.sender] = message
if len(self._votes.keys()) >= (self._server._total_nodes - 1) / 2:
leader = Leader()
leader.set_server(self._server)
print "Server", self._server._name, "has been elected leader"
self._server._serverState = leaderState
for n in self._server._neighbors:
if n._serverState != deadState:
n._serverState = followerState
n._state = Follower()
n._state.set_server(n)
return leader, None
return self, None
def _talk_to_sushi_0(al: "All"):
al.learner.followers.append(
Follower(
al,
direction=Direction.DOWN,
sprite='dog',
name='ซูชิ',
x=51,
y=10,
))
# set_event('talk_to_sushi', 0)
set_event('sushi_is_following', 1)
# Remove sushi
al.mas.current_map.npcs = [
npc for npc in al.mas.current_map.npcs if npc.name != "sushi"
]
def follow_forums(self):
from forum import Forum
from follower import Follower
exclude_following_list = ['To Approve Molecules']
forums = Forum.query.filter(
or_(
and_(Forum.Subject.notin_(exclude_following_list),
Forum.AccountID == SOFIEBIO_ACCOUNTID),
and_(Forum.Type == 'Issue',
Forum.AccountID == self.AccountID))).all()
for forum in forums:
follower = Follower(UserID=self.UserID,
Type=forum.Type,
ParentID=forum.ForumID)
db.session.add(follower)
db.session.commit()
def decide_role(tag_data):
"""
Creates a Leader or Follower object.
:param tag_data: Return value of TagRecognition.detect().
:return: If tag_data is None, the vehicle will become a Leader. Otherwise,
it will become a Follower.
:rtype: Leader or Follower
"""
if tag_data:
vehicle = Follower()
else:
vehicle = Leader()
return vehicle
def test_should_navigate_along_list_of_waypoints_with_logging(self):
waypoint1 = Waypoint(Position(1, 1), 5)
waypoint2 = Waypoint(Position(2, 2), 5)
follower = Follower(self.exchange, [waypoint1, waypoint2],
self.mock_logger)
self.exchange.publish(Event(EventName.start))
self.exchange.publish(Event(EventName.arrived, waypoint1))
self.exchange.publish(Event(EventName.arrived, waypoint2))
self.mock_logger.info.assert_has_calls([
call('Follower, next waypoint +1.000000,+1.000000'),
call('Follower, next waypoint +2.000000,+2.000000'),
call(
'**************************************************************'
),
call('Follower, all waypoints reached, navigation complete'),
call(
'**************************************************************'
)
])
return
def get_followers_info(user_id):
workers_pool = mps.Pool()
for follower_info in workers_pool.imap_unordered(parse_follower, followers_iter(user_id)):
yield follower_info
workers_pool.close()
return
if __name__ == "__main__":
if len(sys.argv) >= 1:
# for info in get_followers_info(user_id=1921850126):
for info in get_followers_info(user_id=sys.argv[-1]):
if info is not False:
# do something with data which parsed by parse_follower
flw = Follower(user_id=info.id, owner=sys.argv[-1])
flw.latitude = info.latitude
flw.longitude = info.longitude
# flw.country = info.country
# session.add(Follower(user_id=info.id,country=info.country))
# session.commit()
session.add(flw)
session.commit()
execfile("lcountry.py")
print info
def __init__(self,screen_width,screen_height):
self.screen_width = screen_width
self.screen_height = screen_height
self.background_color = (0,0,0)
self.mouse = Mouse()
self.follower = Follower()
def __init__(self, des_dist=1): Follower.__init__(self) self.des_dist = des_dist
