def entry_point():
"""
External entry point which calls main() and
if Stop is raised, calls sys.exit()
"""
try:
main(items=[
(AlreadyMerged.NAME, AlreadyMerged),
(CheckMilestone.NAME, CheckMilestone),
(CheckStatus.NAME, CheckStatus),
(Deploy.NAME, Deploy),
(Label.NAME, Label),
(Merge.NAME, Merge),
(Rebase.NAME, Rebase),
(Token.NAME, Token),
(SetCommitStatus.NAME, SetCommitStatus),
(TagRelease.NAME, TagRelease),
(TravisMerge.NAME, TravisMerge),
(Version.NAME, Version),
(UnrebasedPRs.NAME, UnrebasedPRs),
(UpdateSubmodules.NAME, UpdateSubmodules),
])
except Stop, stop:
print stop,
sys.exit(stop.rc)
def eval_defend_submissions():
parameters_filepath = "./helper_files/parameters_holdout.ini"
evasion_methods = ['natural', 'rfgsm_k', 'topk', 'bca_k', 'grosse']
for model_filepath in glob.glob(os.path.join(DEFEND_DIR, '*.pt')):
submission_name = re.search(
"\[training:.*\|", model_filepath).group(0)[:-1].split(':')[-1]
print("Evaluating {}'s submission".format(submission_name))
set_parameter(parameters_filepath, "general", "experiment_suffix",
submission_name)
set_parameter(parameters_filepath, "general", "training_method",
submission_name)
set_parameter(parameters_filepath, "general", "load_model_weights",
"True")
set_parameter(parameters_filepath, "general", "model_weights_path",
model_filepath)
set_parameter(parameters_filepath, "challenge", "eval", "True")
set_parameter(parameters_filepath, "challenge", "defend", "True")
set_parameter(parameters_filepath, "challenge", "attack", "False")
for evasion_method in evasion_methods:
set_parameter(parameters_filepath, "general", "evasion_method",
evasion_method)
main(config_file=parameters_filepath)
create_tex_tables(filespath="./result_files")
def eval_attack_submssions():
parameters_filepath = "./helper_files/parameters_attack.ini"
model_filepath = "./helper_files/[training:natural|evasion:dfgsm_k]_demo-model.pt"
for attack_filepath in glob.glob(os.path.join(ATTACK_DIR, '*.npy')):
if attack_filepath.split('/')[-1] == "aes.npy": continue
submission_name = attack_filepath.split('/')[-1].split('_')[-1][:-4]
print("Evaluating {}'s submission".format(submission_name))
copyfile(attack_filepath, os.path.join(ATTACK_DIR, 'aes.npy'))
set_parameter(parameters_filepath, "general", "experiment_suffix",
submission_name)
set_parameter(parameters_filepath, "general", "training_method",
"secret_model")
set_parameter(parameters_filepath, "general", "load_model_weights",
"True")
set_parameter(parameters_filepath, "general", "model_weights_path",
model_filepath)
set_parameter(parameters_filepath, "challenge", "eval", "True")
set_parameter(parameters_filepath, "challenge", "defend", "False")
set_parameter(parameters_filepath, "challenge", "attack", "True")
set_parameter(parameters_filepath, "general", "evasion_method",
submission_name)
set_parameter(parameters_filepath, "challenge", "adv_examples_path",
ATTACK_DIR)
main(config_file=parameters_filepath)
create_tex_tables(filespath="./result_files")
print("Check evasion latex table file in results_files")
def _frameworkstart(strqueue, keyqueue):
try:
global _running
while _running:
framework.main(strqueue, keyqueue)
time.sleep(.01)
except SystemExit:
_running = False
def _frameworkstart(strqueue, keyqueue):
try:
global _running
while _running:
framework.main(strqueue, keyqueue)
time.sleep(.01)
except SystemExit:
_running = False
def entry_point():
"""
External entry point which calls main() and
if Stop is raised, calls sys.exit()
"""
try:
main(items=[
(UpgradeCommand.NAME, UpgradeCommand),
(DownloadCommand.NAME, DownloadCommand),
(Version.NAME, Version)])
except Stop, stop:
print stop,
sys.exit(stop.rc)
def entry_point(items=tuple()):
"""
External entry point which calls main() and
if Stop is raised, calls sys.exit()
"""
try:
if not items:
from example import ExampleCommand
from version import Version
items = [(ExampleCommand.NAME, ExampleCommand),
(Version.NAME, Version)]
main("yaclifw", items=items)
except Stop, stop:
print stop,
sys.exit(stop.rc)
config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
neat.DefaultSpeciesSet, neat.DefaultStagnation,
config_path)
with open(net_name, 'rb') as f:
c = pickle.load(f)
net = neat.nn.FeedForwardNetwork.create(c, config)
from evolve_feedforward_box2d import NeuralNetworkController
return NeuralNetworkController(net)
if __name__ == "__main__":
initial_position = 2.3
initial_rotation = 0.0
run_off_winner_neat = True
if run_off_winner_neat:
controller = load_winner_net_controller()
# print(c)
# node_names = {-1: 'x', -2: 'dx', -3: 'theta', -4: 'dtheta', 0: 'control'}
#visualize.draw_net(config, c, view=True, node_names=node_names,
# filename="winner-feedforward-enabled-pruned.gv", show_disabled=False, prune_unused=True)
else:
controller = TrivialProportionalController()
main(CartPendulumDemo, controller, initial_position, initial_rotation)
@route("/josh/")
class josh(bo.baseObject):
def GET(self):
self.data = ''
for bit in self.env:
self.data += ("%s : %s<br>" % (str(bit), str(self.env[bit])))
yield self.data
yield self.endPolling()
@route("/josh/(.*)/")
class joshMember(bo.baseObject):
def GET(self):
self.data = ''
for member in self.members:
self.data += ("<h1>%s</h1>" % str(member))
for bit in self.env:
self.data += ("%s : %s" % (str(bit), str(self.env[bit])))
yield self.data
yield self.endPolling()
if __name__ == '__main__':
fw.main()
stat, ret = self.client_v1.review.get(self.review_id)
ret = json.loads(ret)
self.assertEqual(stat, status_code['OK'])
self.assertTrue(isinstance(ret, dict))
self.assertTrue(self.review_id in ret['id']['$t'])
# 针对 review_id 的获取特定评论异常测试函数
def test_get_reviews_exception_review_id_v1(self):
invalid_review_id = 'BadUserId' # bad review id
stat, ret = self.client_v1.review.get(invalid_review_id)
self.assertEqual(stat, status_code['NOT_FOUND'])
self.assertTrue(isinstance(ret, str))
self.assertEqual('wrong subject id:\'' + invalid_review_id + '\'', ret)
invalid_review_id = '0000001' # wrong review id
stat, ret = self.client_v1.review.get(invalid_review_id)
self.assertEqual(stat, status_code['NOT_FOUND'])
self.assertTrue(isinstance(ret, str))
self.assertEqual('wrong subject id:\'' + invalid_review_id + '\'', ret)
invalid_review_id = '' # empty review id
stat, ret = self.client_v1.review.get(invalid_review_id)
self.assertEqual(stat, status_code['NOT_FOUND'])
self.assertTrue(isinstance(ret, str))
self.assertEqual('wrong subject id:\'' + invalid_review_id + '\'', ret)
if __name__ == '__main__':
main(testRunner=test_runner())
from simulator import Simulator
import framework
import physicsSettings
from learningSettings import learningSettings
import cProfile
def test():
simulator = Simulator(False)
while (True):
simulator.Step(physicsSettings.fwSettings)
if (learningSettings.useGraphics):
framework.main(Simulator)
else:
cProfile.runctx('test()', globals(), locals(), 'profileResults1.pstats')
plank = fixtureDef(
shape=polygonShape(box=(0.6, 0.125)),
density=20,
friction=0.2,
)
# Create one Chain (Only the left end is fixed)
prevBody = ground
y = 25
numPlanks = 30
for i in range(numPlanks):
body = self.world.CreateDynamicBody(
position=(0.5 + i, y),
fixtures=plank,
)
#You can try a WeldJoint for a slightly different effect.
#self.world.CreateWeldJoint(
self.world.CreateRevoluteJoint(
bodyA=prevBody,
bodyB=body,
anchor=(i, y),
)
prevBody = body
if __name__ == "__main__":
main(Chain)
# The ground
ground = create_fixed_box(self.world,
p_ll=b2Vec2(xlow, ylow),
p_hr=b2Vec2(xhi, yhi))
# The bodies
radius = 1
columnCount = 5
rowCount = 5
for j in range(columnCount):
for i in range(rowCount):
create_circle(self.world,
(-10 + (2.1 * j + 1 + 0.01 * i) * radius,
(2 * i + 1) * radius), radius)
self.world.gravity = (0, -9.81)
b_ix = -1
for b in self.world.bodies:
b_ix += 1
b.userData.id = b_ix
def Step(self, settings):
super(Confined, self).Step(settings)
if __name__ == "__main__":
main(Confined)
self.assertEqual(None, ret)
def test_read_doumail(self):
ret = self.client.doumail.read(self.doumail_id)
self.assertEqual('R', ret['status'])
def test_reads_doumail(self):
ret = self.client.doumail.reads(self.doumail_ids)
self.assertTrue(isinstance(ret, dict))
self.assertTrue(isinstance(ret['mails'], list))
def test_delete_doumail(self):
doumail = self.client.doumail.inbox()
doumail_id = doumail['mails'][0]['id']
ret = self.client.doumail.delete(doumail_id)
self.assertEqual({}, ret)
def test_deletes_doumail(self):
doumail = self.client.doumail.inbox()
doumail_ids = [m['id'] for m in doumail['mails']][:2]
ret = self.client.doumail.deletes(ids=doumail_ids)
self.assertEqual({}, ret)
if __name__ == '__main__':
main()
from __future__ import print_function
import os
import sys
sys.path.append(os.path.abspath("framework"))
from benchmarks import CPUConvnets
from benchmarks import CPULSTMBench
from benchmarks import CPUNNBench
from benchmarks import CUDALSTMBench
from benchmarks import NumpyUnaryComparison
from benchmarks import CPUUnaryBench
from benchmarks import NumpyReduceComparison
import framework
if __name__ == "__main__":
framework.main(
sys.argv,
[
CPUNNBench,
CPUConvnets,
# CPULSTMBench,
CPUUnaryBench,
CUDALSTMBench,
# NumpyReduceComparison,
# NumpyUnaryComparison,
],
)
position=(-10.0, 0),
fixtures=b2.Fixture(shape=b2.Circle(radius=1.0),
density=1.0)
)
controller.add_body(body)
# And finally, some triangles
for i in range(5):
body = self.world.create_dynamic_body(
position=(-10+3.0*i, 20),
fixtures=b2.Fixture(
shape=b2.Polygon(
vertices=[(-0.5,0),(0,-0.5),(0.5, 0.0)]),
density=1.0)
)
controller.add_body(body)
# And (really) finally this time, just something so we can be sure
# edges work, too.
edge = world.create_dynamic_body(
fixtures=b2.Fixture(shape=b2.Edge((5, 0),(5, 3)),
density=1.0)
)
controller.add_body(edge)
if __name__=="__main__":
main(Buoyancy)
def main():
framework.main(Game)
ground.create_edge_fixture(vertices=[(50, 0), (50, 10)], friction=0.2)
for i in range(2, 18, 2):
body = self.world.create_dynamic_body(position=(-10.1, i))
body.create_polygon_fixture(box=(3.0, 1.0), density=3.0)
self.blob_radius = 2
self.bodies, self.joints = create_blob(
self.world, (-10, 50), self.blob_radius, circle_radius=0.5)
def Keyboard(self, key):
if key == Keys.K_w:
self.jump = 10000
elif key == Keys.K_a:
self.move = -500
elif key == Keys.K_d:
self.move = 500
elif key == Keys.K_s:
self.move = 0
self.jump = 100
def Step(self, settings):
Framework.Step(self, settings)
blob_step(self.world, self.bodies,
self.blob_radius, self.jump, self.move)
self.jump = 100
if __name__ == "__main__":
main(GishTribute)
learningSettings.foodUses,
learningSettings.foodEnergy)
self.generationsElapsed += 1
self.groupsElapsed = 0
#What to do at the end of the experiment
def afterExperiment(self, settings):
Simulator.experimentCount += 1
self.population.saveToFile(self.fileHandler.popSaveName)
if (Simulator.experimentCount >= learningSettings.numberOfExperiments):
exit()
else:
self.__init__(False)
#Find the agent currently driving this walker for this group
def findAgentForWalker(self, walkerIndex, groupSize):
agentIndex = self.groupsElapsed * groupSize + walkerIndex
#If the walker wasn't actually being driven by anything, return None
if (agentIndex >= self.population.size()):
return None
return self.population.agentList[agentIndex]
def resetWalkers(self):
#Reset all walkers
for walker in self.walkerList:
walker.resetPosition()
if __name__ == "__main__":
main(Simulator)
plank=fixtureDef(
shape=polygonShape(box=(0.6,0.125)),
density=20,
friction=0.2,
)
# Create one Chain (Only the left end is fixed)
prevBody = ground
y = 25
numPlanks = 30
for i in range(numPlanks):
body = self.world.CreateDynamicBody(
position=(0.5+i, y),
fixtures=plank,
)
#You can try a WeldJoint for a slightly different effect.
#self.world.CreateWeldJoint(
self.world.CreateRevoluteJoint(
bodyA=prevBody,
bodyB=body,
anchor=(i, y),
)
prevBody = body
if __name__=="__main__":
main(Chain)
# if self.cnt % 10 == 0:
# self.cnt += 1
# #print ctrls
for idx, joint in enumerate(self.joints):
joint.motorEnabled = True
joint.motorSpeed = ctrls[idx] * 10
joint.maxMotorTorque = 1000
com_pos = reduce(add, [x.mass * x.worldCenter for x in self.bodies])
com_vel = reduce(add, [x.mass * x.linearVelocity for x in self.bodies])
pos = [x.worldCenter for x in self.bodies]
rot = [x.angle for x in self.bodies]
linvel = [x.linearVelocity for x in self.bodies]
angvel = [x.angularVelocity for x in self.bodies]
# xpos = [x.position for x in self.bodies]
# qpos = [
print com_pos, com_vel
# for body in self.bodies:
# print body.userData["name"], body.linearVelocity
super(Hopper, self).Step(settings)
if __name__ == "__main__":
main(Hopper)
"graph":"STG", "content":"CIU", "time":"LDF", "trust":"IT",
"delta":540, "beta":0.1, "t0":365, "k":10, "gamma":0.7, "alpha":0.9
}
rs_list = [rs1_param, rs2_param] # list of configurated recsys
# ----> Read data
import csv
linkstream = []
with open(input_dataset_file,'rb') as input_file:
input_file = csv.reader(input_file, delimiter=separator_df)
for line in input_file:
if len(line) >= 5:
t,u,i,c,r = int(line[pos_t]), line[pos_u], line[pos_i], line[pos_c], float(line[pos_r])
linkstream.append( (t, u, i, c, r) )
linkstream = sorted(linkstream, key=lambda tup: tup[0])
trust_network = []
if input_trust_network!=None or input_trust_network!="":
with open(input_trust_network,'rb') as input_file:
input_file = csv.reader(input_file, delimiter=separator_tn)
for line in input_file:
if len(line) >= 2:
u,trusted = line[pos_user], line[pos_trusted]
trust_network.append( (u, trusted) )
fw.main(rs_list, linkstream, trust_network, eval_metric, number_of_time_slices)
# delete
review_id = ret['id']
stat, ret = self.client_v2.movie.review.delete(review_id)
# 针对 review_id 的删除电影评论异常测试函数
def test_delete_review_exception_review_id_v2(self):
invalid_review_id = "BadReviewId" # bad review id
stat, ret = self.client_v2.movie.review.delete(invalid_review_id)
self.assertEqual(stat, status_code['BAD_REQUEST'])
self.assertTrue(isinstance(ret, dict))
self.assertEqual('invalid_request_uri', ret['msg'])
self.assertEqual(107, ret['code'])
invalid_review_id = '1000000000' # wrong review id
stat, ret = self.client_v2.movie.review.delete(invalid_review_id)
self.assertEqual(stat, status_code['NOT_FOUND'])
self.assertTrue(isinstance(ret, dict))
self.assertEqual('review_not_found', ret['msg'])
self.assertEqual(5006, ret['code'])
invalid_review_id = '' # empty review id
stat, ret = self.client_v2.movie.review.delete(invalid_review_id)
self.assertEqual(stat, status_code['BAD_REQUEST'])
self.assertTrue(isinstance(ret, dict))
self.assertEqual('invalid_request_uri', ret['msg'])
self.assertEqual(107, ret['code'])
if __name__ == '__main__':
main(testRunner=test_runner())
# Reusing the fixture we previously defined above
fixture.shape.box = (0.75, 0.75)
self.payload = self.world.CreateDynamicBody(
position=(0, 8),
fixtures=fixture,
)
def Keyboard(self, key):
if key == Keys.K_d:
self.platform.type = b2_dynamicBody
elif key == Keys.K_s:
self.platform.type = b2_staticBody
elif key == Keys.K_k:
self.platform.type = b2_kinematicBody
self.platform.linearVelocity = (-self.speed, 0)
self.platform.angularVelocity = 0
def Step(self, settings):
super(BodyTypes, self).Step(settings)
if self.platform.type == b2_kinematicBody:
p = self.platform.transform.position
v = self.platform.linearVelocity
if ((p.x < -10 and v.x < 0) or (p.x > 10 and v.x > 0)):
v.x = -v.x
self.platform.linearVelocity = v
if __name__ == "__main__":
main(BodyTypes)
controller.add_body(body)
# Create a bridge, and add it to the controller
num_planks = 30
plank_bodies = create_bridge(self.world, ground, (1.0, 0.25), (-14.5, 5), num_planks, 0.2, 10)
for body in plank_bodies:
controller.add_body(body)
# Create a circle underneath the bridge
body = self.world.create_dynamic_body(
position=(-10.0, 0),
fixtures=b2.Fixture(shape=b2.Circle(radius=1.0),
density=10.0)
)
controller.add_body(body)
# And finally, some triangles
for i in range(5):
body = self.world.create_dynamic_body(
position=(-10+3.0*i, 20),
fixtures=b2.Fixture(shape=b2.Polygon(vertices=[(-0.5,0),(0,-0.5),(0.5, 0.0)]),
density=1.0)
)
controller.add_body(body)
if __name__=="__main__":
main(Gravity)
self.laser_body = self.world.CreateDynamicBody(
userData='laser',
position=(0, 2),
fixtures=b2FixtureDef(density=4.0,
shape=b2PolygonShape(box=(LASER_HALF_WIDTH,
1))))
for i in range(2):
self.world.CreateDynamicBody(userData=LASER_SPLIT_TAG,
position=(3.0 + i * 6, 8),
fixtures=b2FixtureDef(
density=5.0,
shape=b2PolygonShape(box=(3, 3))))
def Keyboard(self, key):
if key == Keys.K_c:
laser_cut(self.world,
self.laser_body,
laser_half_width=LASER_HALF_WIDTH)
def Step(self, settings):
Framework.Step(self, settings)
laser_display(self.renderer,
self.laser_body,
laser_half_width=LASER_HALF_WIDTH)
if __name__ == "__main__":
main(BoxCutter)
for ind in pop:
for i in range(len(ind)):
if ind[i] > ubounds[i]:
ind[i] = ubounds[i]
elif ind[i] < lbounds[i]:
ind[i] = lbounds[i]
return pop
return wrappper
return decorator
def init(benchmark):
lbounds = tuple(benchmark.get_lbounds())
ubounds = tuple(benchmark.get_ubounds())
min_ = min(lbounds)
max_ = max(ubounds)
centroid = uniform(lbounds, ubounds)
sigma = 0.3 * (max_ - min_)
lambda_ = int(4 + 3 * log(benchmark.ndim))
strategy = cma.Strategy(centroid=centroid, sigma=sigma, lambda_=lambda_)
toolbox = base.Toolbox()
toolbox.register("generate", strategy.generate, creator.Individual)
toolbox.register("update", strategy.update)
toolbox.register("bounds", checkBounds(lbounds, ubounds))
toolbox.decorate("generate", toolbox.bounds)
return toolbox
if __name__ == "__main__":
main(init)
# b.expects(:binary?).never
# assert !b.indexable?
def test_language(self):
def _check_lang(sample):
blob = self.blob(sample['path'])
assert blob.language, 'No language for %s' % sample['path']
assert sample['language'] == blob.language.name, blob.name
Samples.each(_check_lang)
def test_lexer(self):
assert find_lexer_class('Ruby') == self.blob("Ruby/foo.rb").lexer
def test_colorize(self):
assert colorize == self.blob("Ruby/foo.rb").colorize()
def test_colorize_without_wrapper(self):
assert colorize_without_wrapper == self.blob("Ruby/foo.rb").colorize_without_wrapper()
def test_colorize_does_skip_minified_files(self):
assert None == self.blob("JavaScript/jquery-1.6.1.min.js").colorize()
# Pygments.rb was taking exceeding long on this particular file
def test_colorize_doesnt_blow_up_with_files_with_high_ratio_of_long_lines(self):
assert None == self.blob("JavaScript/steelseries-min.js").colorize()
if __name__ == '__main__':
main()
@route("/josh/")
class josh(bo.baseObject):
def GET(self):
self.data = ''
for bit in self.env:
self.data += ("%s : %s<br>" % (str(bit), str(self.env[bit])))
yield self.data
yield self.endPolling()
@route("/josh/(.*)/")
class joshMember(bo.baseObject):
def GET(self):
self.data = ''
for member in self.members:
self.data += ("<h1>%s</h1>" % str(member))
for bit in self.env:
self.data += ("%s : %s" % (str(bit), str(self.env[bit])))
yield self.data
yield self.endPolling()
if __name__ == '__main__':
fw.main()
