def main():
parser = argparse.ArgumentParser()
parser.add_argument("-o", "--oauth", type=str, default=None,
help=("Use Oauth Token instead of username and "
"password credentials"))
parser.add_argument("-s", "--save", action="store_true",
help=("Save the Oauth Token provided by using the o "
"flag"))
parser.add_argument("-c", "--config", action="store_true",
help="Alter configs only")
parser.add_argument("-n", "--name", type=str, default=None,
help="Give repository Name")
parser.add_argument("-p", "--private", type=bool, default=None,
help="Sets repository to be Private")
parser.add_argument("-l", "--local", action="store_true", default=False,
help=("Clone the Created Repository to the Local \"Directory\"))
args = parser.parse_args()
# Don't Read the Config File in Config Mode
# (ONLY WRITE IN THIS MODE)
if args.config is True:
# Don't allow repository creation data
# to be passed into th program in
# Config mode
if (not args.name and args.private is not None) or \
(args.oauth and not args.save):
cprint("\tError: Cannot Create Repositories in Config Mode",
color="Red")
cprint("\t Run program without the c flag!", color="Red")
exit()
elif args.oauth is None:
# Read the config file for token
# if user hasn't provided token
# as a command line argument
with open(CONFIG_PATH, "r") as c:
config = load(c)
args.oauth = config["token"]
if args.oauth:
# Make sure the token provided actually works
response = get('https://api.github.com/user',
headers={'Authorization': f'token {args.oauth}'})
response_handler("OAUTH Authorization", response, (200,))
if args.save:
# Write token to save file if s flag is included
config = {"token": args.oauth}
with open(CONFIG_PATH, "w") as c:
dump(config, c)
args.name = create_rep(args.name, args.private, args.oauth)
if args.local:
# Clone repo if the local flag is included
username = response.json()["login"]
system(f"git clone https://github.com/{username}/{args.name}.git")
def sendEventToPlayer(self, player, eventName, data=None):
# logging
if data:
helpers.cprint("<== sending event '%s' to player%d with data:" % (eventName, player.id), helpers.lcolors.OUTGOING)
print helpers.treeDict(data)
else:
helpers.cprint("<== sending event '%s' to player%d" % (eventName, player.id), helpers.lcolors.OUTGOING)
self.sendMessageToPlayer(player, json.dumps({'eventName':eventName, 'data':data}))
def response_handler(action, response, accepted):
status = response.status_code
if status not in accepted:
msg = response.json()["message"]
cprint(f"\tError: {action} failed with code {status} ({msg})",
color="Red")
exit()
else:
cprint(f"\t{action} Status: {status} (Successful)", color="Green")
def compare(dim, member):
jet_func = jet.__dict__[member]
numpy_func = np.__dict__[member]
args = getargspec(jet.intake.__dict__[member]).args
if dim == 0:
shape = ()
elif dim == 1:
shape = (3, )
elif dim == 2:
shape = (4, 4)
mat_1 = rand_mat(shape)
mat_2 = rand_mat(shape)
try:
if args in [['array'], ['x']]:
equal(numpy_func(mat_1), jit(jet_func)(mat_1), member)
elif args == ['x', 'y']:
equal(numpy_func(mat_1, mat_2),
jit(jet_func)(mat_1, mat_2), member)
elif 'input_tuple' in args:
equal(numpy_func((mat_1, mat_2)),
jit(lambda x, y: jet_func((x, y)))(mat_1, mat_2), member)
elif 'size' in args:
equal(numpy_func(shape), jit(lambda: jet_func(shape))(), member)
elif member == 'eye':
equal(numpy_func(shape[0]),
jit(lambda: jet_func(shape[0]))(), member)
elif member == 'where':
equal(numpy_func(False, mat_1, mat_2),
jit(lambda x, y: jet_func(False, x, y))(mat_1, mat_2),
member + ', False')
equal(numpy_func(True, mat_1, mat_2),
jit(lambda x, y: jet_func(True, x, y))(mat_1, mat_2),
member + ', True')
elif member == 'clip':
equal(numpy_func(mat_1, -0.5, 0.5),
jit(lambda x: jet_func(x, -0.5, 0.5))(mat_1), member)
elif member == 'reshape':
equal(
numpy_func(mat_1, (shape[0] / 2, shape[1] * 2)),
jit(lambda x: jet_func(x, (shape[0] / 2, shape[1] * 2)))(
mat_1), member + ', 2D')
equal(numpy_func(mat_1, (shape[0]**2, )),
jit(lambda x: jet_func(x, (shape[0]**2, )))(mat_1),
member + ', 1D')
else:
assert (False)
except KeyboardInterrupt:
sys.exit(0)
except:
e = sys.exc_info()[0]
if mode:
raise (e)
else:
cprint(member, False, e)
def equal(x, y, member, tol=ERROR_MAX):
if np.any(np.isnan(x)):
x = np.nan_to_num(x)
y = np.nan_to_num(y)
if mode:
assert (np.all(abs(x - y) < tol))
else:
try:
cprint(member, np.all(abs(x - y) < tol), (x, y))
except:
cprint(member, False, (x, y))
def test_mix():
for dim, members in enumerate(mix):
print("-------")
print("2D x {dim}D".format(dim=dim))
print("-------")
mat = rand_mat((4, 4))
vec = rand_mat((4, ))
scalar = rand_mat(())
for member in members:
jet_func = jet.__dict__[member]
numpy_func = np.__dict__[member]
try:
if dim == 0:
equal(numpy_func(mat, scalar),
jit(jet_func)(mat, scalar), member)
else:
equal(numpy_func(mat, vec),
jit(jet_func)(mat, vec), member)
except SystemExit:
cprint(member, False)
import helpers
import contextio as c
CONSUMER_KEY = "YOUR_CONTEXTIO_CONSUMER_KEY"
CONSUMER_SECRET = "YOUR_CONTEXTIO_CONSUMER_KEY"
EXISTING_USER_ID = "AN_EXISTING_LITE_API_USER_ID" # see the ContextIO dev console
api = c.ContextIO(consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
api_version="lite",
debug=True)
user = c.User(api, {"id": EXISTING_USER_ID})
helpers.headerprint("FETCHING USER INFO (Lite API)")
user.get()
helpers.cprint("id", user.id)
helpers.cprint("email_accounts", user.email_accounts)
helpers.cprint("email_addresses", user.email_addresses)
helpers.cprint("created", user.created)
helpers.cprint("first_name", user.first_name)
helpers.cprint("last_name", user.last_name)
helpers.cprint("resource_url", user.resource_url)
print "\n"
import helpers
import contextio as c
CONSUMER_KEY = "YOUR_CONTEXTIO_CONSUMER_KEY"
CONSUMER_SECRET = "YOUR_CONTEXTIO_CONSUMER_KEY"
EXISTING_USER_ID = "AN_EXISTING_LITE_API_USER_ID" # see the ContextIO dev console
api = c.ContextIO(
consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
api_version="lite",
debug=True
)
user = c.User(api, {"id": EXISTING_USER_ID})
helpers.headerprint("FETCHING USER INFO (Lite API)")
user.get()
helpers.cprint("id", user.id)
helpers.cprint("email_accounts", user.email_accounts)
helpers.cprint("email_addresses", user.email_addresses)
helpers.cprint("created", user.created)
helpers.cprint("first_name", user.first_name)
helpers.cprint("last_name", user.last_name)
helpers.cprint("resource_url", user.resource_url)
print "\n"
import helpers
import contextio as c
CONSUMER_KEY = "YOUR_CONTEXTIO_CONSUMER_KEY"
CONSUMER_SECRET = "YOUR_CONTEXTIO_CONSUMER_KEY"
EXISTING_ACCOUNT_ID = "AN_EXISTING_2.0_API_ACCOUNT_ID" # see the ContextIO dev console
api = c.ContextIO(consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET, debug=True)
account = c.Account(api, {"id": EXISTING_ACCOUNT_ID})
helpers.headerprint("FETCHING ACCOUNT INFO (Lite API)")
account.get()
helpers.cprint("id", account.id)
helpers.cprint("username", account.username)
helpers.cprint("created", account.created)
helpers.cprint("suspended", account.suspended)
helpers.cprint("email_addresses", account.email_addresses)
helpers.cprint("first_name", account.first_name)
helpers.cprint("last_name", account.last_name)
helpers.cprint("password_expired", account.password_expired)
helpers.cprint("sources", account.sources)
helpers.cprint("resource_url", account.resource_url)
print "\n"
response = get('https://api.github.com/user',
headers={'Authorization': f'token {args.oauth}'})
response_handler("OAUTH Authorization", response, (200,))
if args.save:
# Write token to save file if s flag is included
config = {"token": args.oauth}
with open(CONFIG_PATH, "w") as c:
dump(config, c)
args.name = create_rep(args.name, args.private, args.oauth)
if args.local:
# Clone repo if the local flag is included
username = response.json()["login"]
system(f"git clone https://github.com/{username}/{args.name}.git")
if __name__ == "__main__":
try:
cprint("Ctrl-Z to Exit Program", color="Cyan")
main()
except EOFError as e:
# Don't do anything for EOFError
# that is passed in when Ctrl-Z
# is passed in as input
pass
finally:
cprint("Encountered End of Program", color="Magenta")
exit()
