def get_date_intervals(start_date, end_date, terms):
start_day = start_date.day
start_month = start_date.month
start_year = start_date.year
end_day = end_date.day
end_month = end_date.month
end_year = end_date.year
start = pendulum.Pendulum(start_year, start_month, start_day)
end = pendulum.Pendulum(end_year, end_month, end_day)
period = pendulum.period(start, end)
if terms == 'Monthly':
return [dt.format('%B %d, %Y') for dt in period.range('months')][1:]
elif terms == 'Quarterly':
return [dt.format('%B %d, %Y') for dt in period.range('months', 3)][1:]
elif terms == 'Semi-Annually':
return [dt.format('%B %d, %Y') for dt in period.range('months', 6)][1:]
elif terms == 'Annually':
return [dt.format('%B %d, %Y')
for dt in period.range('months', 12)][1:]
async def test_user_create_not_matching_certified_on(alice_backend_sock, alice,
mallory):
date1 = pendulum.Pendulum(2000, 1, 1)
date2 = date1.add(seconds=1)
cu = UserCertificateContent(
author=alice.device_id,
timestamp=date1,
user_id=mallory.user_id,
public_key=mallory.public_key,
is_admin=False,
).dump_and_sign(alice.signing_key)
cd = DeviceCertificateContent(
author=alice.device_id,
timestamp=date2,
device_id=mallory.device_id,
verify_key=mallory.verify_key,
).dump_and_sign(alice.signing_key)
with freeze_time(date1):
rep = await user_create(alice_backend_sock,
user_certificate=cu,
device_certificate=cd)
assert rep == {
"status":
"invalid_data",
"reason":
"Device and User certifications must have the same timestamp.",
}
async def test_user_create_certify_too_old(alice_backend_sock, alice, mallory):
too_old = pendulum.Pendulum(2000, 1, 1)
now = too_old.add(seconds=INVITATION_VALIDITY + 1)
cu = UserCertificateContent(
author=alice.device_id,
timestamp=too_old,
user_id=mallory.user_id,
public_key=mallory.public_key,
is_admin=False,
).dump_and_sign(alice.signing_key)
cd = DeviceCertificateContent(
author=alice.device_id,
timestamp=too_old,
device_id=mallory.device_id,
verify_key=mallory.verify_key,
).dump_and_sign(alice.signing_key)
with freeze_time(now):
rep = await user_create(alice_backend_sock,
user_certificate=cu,
device_certificate=cd)
assert rep == {
"status": "invalid_certification",
"reason": "Invalid timestamp in certification.",
}
async def test_user_create_certificate_too_old(alice_backend_sock, alice,
mallory):
too_old = pendulum.Pendulum(2000, 1, 1)
now = too_old.add(seconds=INVITATION_VALIDITY + 1)
user_certificate = UserCertificateContent(
author=alice.device_id,
timestamp=too_old,
user_id=mallory.user_id,
public_key=mallory.public_key,
profile=UserProfile.STANDARD,
).dump_and_sign(alice.signing_key)
device_certificate = DeviceCertificateContent(
author=alice.device_id,
timestamp=too_old,
device_id=mallory.device_id,
verify_key=mallory.verify_key,
).dump_and_sign(alice.signing_key)
with freeze_time(now):
rep = await user_create(
alice_backend_sock,
user_certificate=user_certificate,
device_certificate=device_certificate,
redacted_user_certificate=user_certificate,
redacted_device_certificate=device_certificate,
)
assert rep == {
"status": "invalid_certification",
"reason": "Invalid timestamp in certificate.",
}
def main01_constant_input_simulation():
""" Simple simulation of a pendulum system. Choose a constant
control input Tss, and simulate system's output behavior. """
m, g, l, k = 1, 10, 1, 2
pend = pendulum.Pendulum(m, g, l, k)
theta0, theta_dot0 = 1, 0
x0 = np.array([theta0, theta_dot0])
t_start, t_end = 0, 10
sample_count = 1000
t = np.linspace(t_start, t_end, sample_count)
tspan = [t_start, t_end]
# Constant control input
Tss = 0
T = lambda t, x: Tss
f = lambda t, x: pend.state_space_static_controller(t, x, T)
sol = scipy.integrate.solve_ivp(f, tspan, x0, t_eval=t)
fig, ax = fc.new_figure()
ax.plot(sol.t, sol.y[0], label='$\\theta$')
ax.plot(sol.t, sol.y[1], label='$\\dot{\\theta}$')
ax.set_xlabel('$t$')
ax.grid()
ax.legend()
Path('./figures').mkdir(parents=True, exist_ok=True)
plt.savefig('figures/unforced_response.pdf', pad_inches=0.0)
def get_datetime(date, tz_name=None, *args):
tz = pytz.timezone(tz_name or DEFAULT_TZ_NAME)
if isinstance(date, int):
return pendulum.Pendulum(date, *args, tzinfo=tz)
if isinstance(date, datetime.datetime):
return pendulum.Pendulum.instance(date, tz).astimezone(tz)
if isinstance(date, str):
return parse_date(date)
return pendulum.Pendulum.instance(
datetime.datetime.combine(date, datetime.time.min), tz).astimezone(tz)
def setUp(self):
self.test_series = [
{
'parameters': [
{
'start_date': pendulum.Pendulum(1889, 2, 28),
'end_date': pendulum.Pendulum(2017, 5, 27),
'data_types': ['Data Types'],
'parameter_code': '00060',
'parameter_name': 'Discharge, dm3/s'
},
{
'start_date': pendulum.Pendulum(1890, 12, 1),
'end_date': pendulum.Pendulum(2018, 3, 25),
'data_types': ['Data Types'],
'parameter_code': '00010',
'parameter_name': 'Temperature, K'
}
]
}
]
def main():
#initialize environment
env = pendulum.Pendulum()
ppo = PPO(args, env)
for epoch in range(args.epochs):
print('Training Epoch ' + str(epoch + 1) + '/' + str(args.epochs))
ppo.train()
ppo.save_model()
ppo.generate_results()
async def test_user_revoke_certify_too_old(backend, alice_backend_sock, alice,
bob):
now = pendulum.Pendulum(2000, 1, 1)
revoked_user_certificate = RevokedUserCertificateContent(
author=alice.device_id, timestamp=now,
user_id=bob.user_id).dump_and_sign(alice.signing_key)
with freeze_time(now.add(seconds=INVITATION_VALIDITY + 1)):
rep = await user_revoke(
alice_backend_sock,
revoked_user_certificate=revoked_user_certificate)
assert rep == {
"status": "invalid_certification",
"reason": "Invalid timestamp in certification.",
}
async def test_device_create_certify_too_old(alice_backend_sock, alice,
alice_nd):
now = pendulum.Pendulum(2000, 1, 1)
device_certificate = DeviceCertificateContent(
author=alice.device_id,
timestamp=now,
device_id=alice_nd.device_id,
verify_key=alice_nd.verify_key,
).dump_and_sign(alice.signing_key)
with freeze_time(now.add(seconds=INVITATION_VALIDITY + 1)):
rep = await device_create(alice_backend_sock,
device_certificate=device_certificate,
encrypted_answer=b"<good>")
assert rep == {
"status": "invalid_certification",
"reason": "Invalid timestamp in certification.",
}
def main03_feedback_state_stabilization():
""" Simulation of a pendulum system. The system is controlled by
a stabilizing state-feedback controller around desired angle
delta. """
m, g, l, k = 1, 10, 1, 2
a, b, c = g / l, k / m, 1 / m / l / l
delta = pi / 4 # Desired value of angle theta at equilibrium point
pend = pendulum.Pendulum(m, g, l, k)
theta0, theta_dot0 = 0, 0
x0 = np.array([theta0, theta_dot0])
# State feedback control
k1, k2 = 1, 1
T = lambda t, x: -k1 * (x[0] - delta) - k2 * x[1] + a * sin(delta) / c
f = lambda t, x: pend.state_space_static_controller(t, x, T)
t_start, t_end = 0, 10
N = 1000
t = np.linspace(t_start, t_end, N)
tspan = [t_start, t_end]
sol = scipy.integrate.solve_ivp(f, tspan, x0, t_eval=t)
control = T(sol.t, sol.y)
fig, axs = fc.new_figure(subplot_count=2, height=2 * fc.DEFAULT_HEIGHT)
axs[0].plot([t_start, t_end], [pi / 4, pi / 4],
'r--',
label='Reference $\\delta$')
axs[0].plot(sol.t, sol.y[0], label='$\\theta$')
axs[0].plot(sol.t, sol.y[1], label='$\\dot{\\theta}$')
axs[1].plot(sol.t, control, 'g', label='$T$')
axs[0].set_xlabel('$t$')
axs[0].grid()
axs[0].legend()
axs[1].set_xlabel('$t$')
axs[1].grid()
axs[1].legend()
Path('./figures').mkdir(parents=True, exist_ok=True)
plt.savefig('figures/state_feedback.pdf', pad_inches=0.0)
async def test_user_revoke_ok(backend, backend_sock_factory, adam_backend_sock,
alice, adam):
now = pendulum.Pendulum(2000, 10, 11)
alice_revocation = RevokedUserCertificateContent(
author=adam.device_id, timestamp=now,
user_id=alice.user_id).dump_and_sign(adam.signing_key)
with backend.event_bus.listen() as spy:
with freeze_time(now):
rep = await user_revoke(adam_backend_sock,
revoked_user_certificate=alice_revocation)
assert rep == {"status": "ok"}
await spy.wait_with_timeout("user.revoked", {
"organization_id": alice.organization_id,
"user_id": alice.user_id
})
# Alice cannot connect from now on...
with pytest.raises(HandshakeRevokedDevice):
async with backend_sock_factory(backend, alice):
pass
def main05_integral_control():
""" Simulation of a pendulum system. The system is controlled by
an integral controller, which is stabilized by linearization
around desired angle delta and state-feedback. """
# Good values for m to test are: 0.1, 1, 2 (1 is nominal)
m, g, l, k = 0.1, 10, 1, 2
pend = pendulum.Pendulum(m, g, l, k)
delta = pi / 4
k1, k2, k3 = 8, 2, 10
K = np.array([k1, k2, k3])
test_integral_controller_constraints(K, m, g, l, k, delta)
theta0, theta_dot0, sigma0 = 0, 0, 0
x0 = np.array([theta0, theta_dot0, sigma0])
t_start, t_end = 0, 10
N = 1000
t = np.linspace(t_start, t_end, N)
tspan = [t_start, t_end]
f_original = pend.state_space_integral_controller
f = lambda t, x: f_original(t, x, K, delta)
sol = scipy.integrate.solve_ivp(f, tspan, x0, t_eval=t)
fig, ax = fc.new_figure()
ax.plot([t_start, t_end], [delta, delta],
'r--',
label='Reference $\\delta$')
ax.plot(sol.t, sol.y[0], label='$\\theta$')
ax.plot(sol.t, sol.y[1], label='$\\dot{\\theta}$')
ax.plot(sol.t, sol.y[2], label='$\\sigma$')
ax.set_xlabel('$t$')
ax.grid()
ax.legend()
Path('./figures').mkdir(parents=True, exist_ok=True)
plt.savefig('figures/integral_control_small_mass.pdf', pad_inches=0.0)
def main04_output_feedback_stabilization():
""" Simulation of a pendulum system. The system is controlled by
a stabilizing output-feedback controller around desired angle
delta. States are estimated by an observer. """
m, g, l, k = 1, 10, 1, 2
delta = pi / 4
pend = pendulum.Pendulum(m, g, l, k)
x0 = np.array([0, 0, 0, 0])
t_start, t_end = 0, 10
N = 1000
t = np.linspace(t_start, t_end, N)
tspan = [t_start, t_end]
k1, k2, h1, h2 = 1, 1, 1, 1
K = np.array([k1, k2])
H = np.array([h1, h2])
f_original = pend.state_space_observer_controller
f = lambda t, x: f_original(t, x, K, H, delta)
sol = scipy.integrate.solve_ivp(f, tspan, x0, t_eval=t)
fig, ax = fc.new_figure()
ax.plot([t_start, t_end], [delta, delta],
'r--',
label='Reference $\\delta$')
ax.plot(sol.t, sol.y[0], label='$\\theta$')
ax.plot(sol.t, sol.y[1], label='$\\dot{\\theta}$')
ax.plot(sol.t, sol.y[2], label='$\\hat{\\theta}$')
ax.plot(sol.t, sol.y[3], label='$\\hat{\\dot{\\theta}}$')
ax.set_xlabel('$t$')
ax.grid()
ax.legend()
Path('./figures').mkdir(parents=True, exist_ok=True)
plt.savefig('figures/output_feedback.pdf', pad_inches=0.0)
def main02_constant_input_simulation_fixed_delta():
""" Simple simulation of a pendulum system. Choose a constant
desired output angle delta; a constant control input Tss
will be calculated to obtain a stable equilibrium at the
desired output angle delta. """
m, g, l, k = 1, 10, 1, 2
a, b, c = g / l, k / m, 1 / m / l / l
pend = pendulum.Pendulum(m, g, l, k)
theta0, theta_dot0 = 0, 0
x0 = np.array([theta0, theta_dot0])
t_start, t_end = 0, 10
sample_count = 1000
t = np.linspace(t_start, t_end, sample_count)
tspan = [t_start, t_end]
# Constant control input derived from desired constant angle
delta = pi / 4
Tss = a / c * sin(delta)
T = lambda t, x: Tss
f = lambda t, x: pend.state_space_static_controller(t, x, T)
sol = scipy.integrate.solve_ivp(f, tspan, x0, t_eval=t)
fig, ax = fc.new_figure()
ax.plot([t_start, t_end], [delta, delta],
'r--',
label='Reference $\\delta$')
ax.plot(sol.t, sol.y[0], label='$\\theta$')
ax.plot(sol.t, sol.y[1], label='$\\dot{\\theta}$')
ax.set_xlabel('$t$')
ax.grid()
ax.legend()
Path('./figures').mkdir(parents=True, exist_ok=True)
plt.savefig('figures/constant_control.pdf', pad_inches=0.0)
async def test_organization_with_expiration_date_create_and_bootstrap(
backend,
organization_factory,
local_device_factory,
alice,
administration_backend_sock,
apiv1_backend_sock_factory,
):
neworg = organization_factory("NewOrg")
# 1) Create organization, note this means `neworg.bootstrap_token`
# will contain an invalid token
with freeze_time("2000-01-01"):
expiration_date = pendulum.Pendulum(2000, 1, 2)
rep = await organization_create(administration_backend_sock,
neworg.organization_id,
expiration_date=expiration_date)
assert rep == {
"status": "ok",
"bootstrap_token": ANY,
"expiration_date": expiration_date
}
bootstrap_token = rep["bootstrap_token"]
# 2) Bootstrap organization
# Use an existing user name to make sure they didn't mix together
newalice = local_device_factory("alice@dev1",
neworg,
profile=UserProfile.ADMIN)
backend_newalice, backend_newalice_first_device = local_device_to_backend_user(
newalice, neworg)
async with apiv1_backend_sock_factory(backend,
neworg.organization_id) as sock:
rep = await organization_bootstrap(
sock,
bootstrap_token,
backend_newalice.user_certificate,
backend_newalice_first_device.device_certificate,
neworg.root_verify_key,
)
assert rep == {"status": "ok"}
# 3) Now our new device can connect the backend
async with apiv1_backend_sock_factory(backend, newalice) as sock:
await ping(sock)
# 4) Make sure alice from the other organization is still working
async with apiv1_backend_sock_factory(backend, alice) as sock:
await ping(sock)
# 5) Now advance after the expiration
with freeze_time("2000-01-02"):
# Both anonymous and authenticated connections are refused
with pytest.raises(HandshakeOrganizationExpired):
async with apiv1_backend_sock_factory(backend, newalice):
pass
with pytest.raises(HandshakeOrganizationExpired):
async with apiv1_backend_sock_factory(backend,
neworg.organization_id):
pass
UTC = pendulum.timezone('UTC')
datetime_now = datetime.datetime.now(pytz.timezone('MST'))
# Mongo drops portion of microsecond, field truncates automatically for consistency
datetime_now = datetime_now.replace(microsecond=int(math.floor(datetime_now.microsecond / 1000) * 1000))
pendulum_now = pendulum.instance(datetime_now)
pendulum_interval = pendulum.interval(minutes=5)
@pytest.mark.parametrize('field_name,dt,expected_raw', [
('Incident Closed', pendulum_now, DatetimeField.format_datetime(pendulum_now)),
(
'Date Field',
pendulum_now,
DatetimeField.format_datetime(pendulum.Pendulum(pendulum_now.year, pendulum_now.month, pendulum_now.day))
),
('Time Field', pendulum_now, DatetimeField.format_datetime(pendulum_now)),
('Incident Duration', pendulum_interval, pendulum_interval.in_seconds() * 1000)
])
def test_raw_serialization(mock_record, field_name, dt, expected_raw):
"""Test that datetime field values are appropriately serialized to raw"""
mock_record[field_name] = dt
field_id = mock_record.app.get_field_definition_by_name(field_name)['id']
assert mock_record._raw['values'][field_id] == expected_raw
@pytest.mark.parametrize('valid_date_obj', [
datetime_now,
datetime_now.date(),
pendulum_now,
'g': g
}
# compute the dynamic trajectories for all grid points (
trajectories = np.zeros((grids.shape[1], int(T / dt) * 2))
steps = int(T / dt)
# for ind, point in enumerate(grids.T):
# print(f'ind = {ind}')
# print(f'ind = {ind}')
# print(f'point = {point}')
# if ind >= 2:
# break
ind = 0
point = grids.T[0]
wave = {'phi': point[0], 'dphi': point[1]}
vary_length_pendulum = pendulum.Pendulum(wave, attributes)
vary_length_pendulum.main()
states = np.hstack((vary_length_pendulum.asym_control_phi,
vary_length_pendulum.asym_control_dphi))
trajectories[ind, :] = np.copy(states)
t = np.arange(0, T, dt)
x0 = grids.T[0]
beta = np.linalg.norm(x0) * np.exp(-.05 * t)
states = np.vstack((trajectories[0, :steps], trajectories[1, :steps]))
phi = np.linalg.norm(states, axis=0)
fig = plt.figure(figsize=[16, 9])
plt.plot(t, beta, 'r--')
plt.plot(t, phi, 'k')
plt.show()
# we can create a robot
import numpy as np
import tqdm
import pendulum
robot = pendulum.Pendulum()
# assume we set theta and dtheta = 0 and u = -5, we can get the next state using
x = np.array([0, 0])
u = -5
x_next = robot.next_state(x, u)
# we don't want 2pi to be in the set because it's the same as 0
discretized_theta = np.linspace(0, 2 * np.pi, 50, endpoint=False)
discretized_thetadot = np.linspace(-6, 6, 50)
# now given an arbitrary continuous state theta
theta_arbitrary = 0.23471
# we can find the index of the closest element in the set of discretized states
index_in_discretized_theta = np.argmin(np.abs(discretized_theta - theta_arbitrary))
# and find the closed discretized state
closest_state = discretized_theta[index_in_discretized_theta]
print(f'the discretized theta closest to {theta_arbitrary} is {closest_state} with index {index_in_discretized_theta}')
def cost(x, u):
theta = x[0]
def test_derivative():
ta = pendulum.Pendulum(L=2.7)
theta, v = ta(0, [math.pi / 6, 0.15])
assert math.isclose(theta, 0.15)
assert math.isclose(v, -1.81666666667)
def test_motionless():
ta = pendulum.Pendulum()
theta, v = ta(0, [0, 0])
assert math.isclose(theta, 0)
assert math.isclose(v, 0)
def main():
# Create environment
env = pendulum.Pendulum()
######################################
#
# EXAMPLE OF CREATING A VIDEO
#
# Define a policy that maps every state to the "zero torque" action
policy = lambda s: np.array([0])
# Simulate an episode and save the result as an animated gif
env.video(policy, filename='results_pendulum.gif')
#
######################################
######################################
#
# EXAMPLE OF CREATING A PLOT
#
# Initialize simulation
s = env.reset()
# Create dict to store data from simulation
data = {
't': [0],
's': [s],
'a': [],
'r': [],
}
# Simulate until episode is done
done = False
while not done:
a = np.array([random.gauss(0, 1)])
(s, r, done) = env.step(a)
data['t'].append(data['t'][-1] + 1)
data['s'].append(s)
data['a'].append(a)
data['r'].append(r)
# Parse data from simulation
data['s'] = np.array(data['s'])
data['a'] = np.array(data['a'])
theta = data['s'][:, 0]
thetadot = data['s'][:, 1]
tau = data['a'][:, 0]
# Plot data and save to png file
fig, ax = plt.subplots(3, 1, figsize=(10, 10))
ax[0].plot(data['t'], theta, label='theta')
ax[0].plot(data['t'], thetadot, label='thetadot')
ax[0].legend()
ax[1].plot(data['t'][:-1], tau, label='tau')
ax[1].legend()
ax[2].plot(data['t'][:-1], data['r'], label='r')
ax[2].legend()
ax[2].set_xlabel('time step')
plt.tight_layout()
plt.savefig('results_pendulum.png')
def test_exceptions():
ta = pendulum.Pendulum(L=2.7)
with pytest.raises(AttributeError):
ta.t
ta.theta
ta.omega
def test_atrest():
ta = pendulum.Pendulum(L=2.7)
ta.solve((0, 0), [0, 30], 0.2)
assert all(np.isclose(0, ta.theta))
assert all(np.isclose(0, ta.omega))
assert all(np.isclose(ta.t, np.arange(0, 30 + 0.2, 0.2)))
def get_feed_prices(node):
active_providers = defaultdict(set)
for chain in ['bts', 'steem']:
provider_names = {p.lower() for p in cfg[chain]['feed_providers']}
for name, provider in ALL_FEED_PROVIDERS.items():
if name in provider_names:
active_providers[chain].add(provider())
# get currency rates from yahoo
# do not include:
# - BTC as we don't get it from yahoo
# - USD as it is our base currency
yahoo_prices = []
# try:
# yahoo = YahooFeedProvider()
# yahoo_prices = yahoo.get(YAHOO_ASSETS | {'CNY'}, 'USD') # still get CNY, we might need it later
#
# except Exception as e:
# log.warning(e)
currency_layer_prices = []
try:
currency_layer = CurrencyLayerFeedProvider()
currency_layer_prices = currency_layer.get(
tuple(YAHOO_ASSETS | {'CNY'}), 'USD')
except Exception as e:
log.debug('Could not get feeds from CurrencyLayer: {}'.format(e))
fixer_prices = []
try:
fixer_prices = FixerFeedProvider().get_all(base='USD')
except Exception as e:
log.warning('Could not get feeds from fixer.io: {}'.format(e))
# get gold and silver
gold_silver_prices = []
quandl = QuandlFeedProvider()
try:
gold_silver_prices += [
quandl.get('GOLD', 'USD'),
quandl.get('SILVER', 'USD')
]
except Exception as e:
log.debug('Could not get gold/silver feeds from Quandl')
# uphold = UpholdFeedProvider()
# try:
# gold_silver_prices += [uphold.get('GOLD', 'USD'),
# uphold.get('SILVER', 'USD')]
# except Exception as e:
# log.debug('Could not get gold/silver feeds from Uphold')
base_usd_price = FeedSet(yahoo_prices + currency_layer_prices +
fixer_prices + gold_silver_prices)
# 1- get the BitShares price in major markets: BTC, USD and CNY
btcavg = core.config['credentials']['bitcoinaverage']
bitcoinavg = BitcoinAverageFeedProvider(btcavg['secret_key'],
btcavg['public_key'])
bitfinex = BitfinexFeedProvider()
bitstamp = BitstampFeedProvider()
bittrex = BittrexFeedProvider()
btc38 = Btc38FeedProvider()
bter = BterFeedProvider()
cmc = CoinMarketCapFeedProvider()
coincap = CoinCapFeedProvider()
poloniex = PoloniexFeedProvider()
yunbi = YunbiFeedProvider()
livecoin = LivecoinFeedProvider()
aex = AEXFeedProvider()
zb = ZBFeedProvider()
# 1.1- first get the bts/btc valuation
providers_bts_btc = {poloniex, bittrex, livecoin, aex, zb
} & active_providers['bts']
if not providers_bts_btc:
log.warning('No feed providers for BTS/BTC feed price')
all_feeds = get_multi_feeds('get', [('BTS', 'BTC')], providers_bts_btc)
feeds_bts_btc = all_feeds.filter('BTS', 'BTC')
if not feeds_bts_btc:
# in last resort, just get our data from coinmarketcap and coincap
log.info(
'getting bts/btc directly from coinmarketcap, no other sources available'
)
feeds_bts_btc = FeedSet(
[cmc.get('BTS', 'BTC'),
coincap.get('BTS', 'BTC')])
if not feeds_bts_btc:
raise core.NoFeedData('Could not get any BTS/BTC feeds')
btc_price = feeds_bts_btc.price()
# 1.2- get the btc/usd (bitcoin avg)
feeds_btc_usd = get_multi_feeds(
'get', [('BTC', 'USD')],
{bitcoinavg, cmc, bitfinex, bitstamp} & active_providers['bts']
) # coincap seems to be off sometimes, do not use it
if not feeds_btc_usd:
raise core.NoFeedData('Could not get any BTC/USD feeds')
btc_usd = feeds_btc_usd.price()
usd_price = btc_price * btc_usd
# 1.3- get the bts/cny valuation directly from cny markets. Going from bts/btc and
# btc/cny to bts/cny introduces a slight difference (2-3%) that doesn't exist on
# the actual chinese markets
providers_bts_cny = {bter, btc38, yunbi} & active_providers['bts']
# TODO: should go at the beginning: submit all fetching tasks to an event loop / threaded executor,
# compute valuations once we have everything
#all_feeds.append(get_multi_feeds('get', [('BTS', 'CNY')], providers_bts_cny))
feeds_bts_cny = get_multi_feeds('get', [('BTS', 'CNY')], providers_bts_cny)
if not feeds_bts_cny:
# if we couldn't get the feeds for cny, go BTS->BTC, BTC->CNY
log.debug('Could not get any BTS/CNY feeds, going BTS->BTC, BTC->CNY')
bts_cny = btc_price * btc_usd / base_usd_price.price('CNY')
# # if we couldn't get the feeds for cny, try picking up our last value
# if price_history.get('cny'):
# log.warning('Could not get any BTS/CNY feeds, using last feed price')
# bts_cny = price_history['cny'][-1]
# else:
# raise core.NoFeedData('Could not get any BTS/CNY feeds')
else:
bts_cny = feeds_bts_cny.price()
cny_price = bts_cny
feeds = {
} # TODO: do we really want to reset the global var 'feeds' everytime we come here?
feeds['BTC'] = btc_price
feeds['USD'] = usd_price
feeds['CNY'] = cny_price
feeds['HERO'] = usd_price / (1.05**(
(pendulum.today() - pendulum.Pendulum(1913, 12, 23)).in_days() /
365.2425))
log.debug('Got btc/usd price: {}'.format(btc_usd))
log.debug('Got usd price: {}'.format(usd_price))
log.debug('Got cny price: {}'.format(cny_price))
# 2- now get the BitShares price in all other required currencies
for asset in YAHOO_ASSETS:
try:
feeds[asset] = usd_price / base_usd_price.price(asset)
except Exception:
log.warning('no feed price for asset {}'.format(asset))
# 2.1- RUBLE is used temporarily by RUDEX instead of bitRUB (black swan)
# see https://bitsharestalk.org/index.php/topic,24004.0/all.html
feeds['RUBLE'] = feeds['RUB']
# 3- get the feeds for major composite indices # REMOVED, was using yahoo, GoogleFeedProvider, BloombergFeedProvider
# 4- get other assets
altcap = get_multi_feeds('get', [('ALTCAP', 'BTC')], {coincap, cmc})
altcap = altcap.price(stddev_tolerance=0.08)
feeds['ALTCAP'] = altcap
gridcoin = get_multi_feeds('get', [('GRIDCOIN', 'BTC')],
{poloniex, bittrex})
feeds['GRIDCOIN'] = btc_price / gridcoin.price(stddev_tolerance=0.1)
steem_btc = get_multi_feeds('get', [('STEEM', 'BTC')], {poloniex, bittrex}
& active_providers['steem'])
steem_usd = steem_btc.price() * btc_usd
feeds['STEEM'] = steem_usd
# 5- Bit20 asset
if 'BTWTY' not in get_disabled_assets():
bit20 = get_bit20_feed(node, usd_price)
if bit20 is not None:
feeds['BTWTY'] = bit20
# 6- HERTZ asset
if 'HERTZ' not in get_disabled_assets():
hertz_reference_timestamp = "2015-10-13T14:12:24+00:00" # Bitshares 2.0 genesis block timestamp
hertz_current_timestamp = pendulum.now().timestamp(
) # Current timestamp for reference within the hertz script
hertz_amplitude = 1 / 3 # 33.33..% fluctuation
hertz_period_days = 28 # 30.43 days converted to an UNIX timestamp // TODO: Potentially change this value to 28
hertz_phase_days = 0.908056 # Time offset from genesis till the first wednesday, to set wednesday as the primary Hz day.
hertz_reference_asset_price = usd_price
hertz = get_hertz_feed(hertz_reference_timestamp,
hertz_current_timestamp, hertz_period_days,
hertz_phase_days, hertz_reference_asset_price,
hertz_amplitude)
if hertz is not None:
feeds['HERTZ'] = hertz
# 7- update price history for all feeds
for cur, price in feeds.items():
price_history[cur].append(price)
return feeds
def test_radius():
ta = pendulum.Pendulum(L=2.7)
ta.solve((math.pi / 6, 0.15), [0, 30], 0.2)
assert all(np.isclose(ta.x**2 + ta.y**2, 2.7**2))
def get(asset, base):
log.debug('checking feeds for %s/%s at %s' % (asset, base, NAME))
price_usd = 1.05 ** ((pendulum.today() - pendulum.Pendulum(1913, 12, 23)).in_days() / 365.2425)
return FeedPrice(price_usd, asset, base)
def mod_15_mins(t):
if not isinstance(t, pendulum.Pendulum):
raise TypeError('function mod_15_mins expects a pendulum.Pendulum object')
quarter_in_hour = t.minute / 15
return pendulum.Pendulum()
def get_feed_prices(node):
def active_providers_bts(providers):
feed_providers = {p.lower() for p in cfg['bts']['feed_providers']}
return {p for p in providers if p.NAME.lower() in feed_providers}
def active_providers_steem(providers):
feed_providers = {p.lower() for p in cfg['steem']['feed_providers']}
return {p for p in providers if p.NAME.lower() in feed_providers}
providers = core.get_plugin_dict('bts_tools.feed_providers')
# 0- get forex data + gold/silved in USD
currency_layer_prices = []
try:
currency_layer_prices = providers.CurrencyLayer.get(
BASE_ASSETS - {'BTC', 'USD'}, 'USD')
except Exception as e:
log.debug('Could not get feeds from CurrencyLayer: {}'.format(e))
fixer_prices = []
try:
fixer_prices = providers.Fixer.get_all(base='USD')
except Exception as e:
log.debug('Could not get feeds from fixer.io: {}'.format(e))
gold_silver_prices = []
try:
gold_silver_prices += [
providers.Quandl.get('GOLD', 'USD'),
providers.Quandl.get('SILVER', 'USD')
]
except Exception as e:
log.debug('Could not get gold/silver feeds from Quandl: {}'.format(e))
base_usd_price = FeedSet(currency_layer_prices + fixer_prices +
gold_silver_prices + providers.Uphold.get_all())
base_usd_price = base_usd_price.filter(base='USD')
# 1- get the BitShares price in major markets: BTC, USD and CNY
# 1.1- first get the bts/btc valuation
providers_bts_btc = active_providers_bts({
providers.Poloniex, providers.Bittrex, providers.Livecoin,
providers.aex, providers.zb, providers.Binance
})
if not providers_bts_btc:
log.warning('No feed providers for BTS/BTC feed price')
all_feeds = get_multi_feeds('get', [('BTS', 'BTC')], providers_bts_btc)
feeds_bts_btc = all_feeds.filter('BTS', 'BTC')
if not feeds_bts_btc:
# in last resort, just get our data from coinmarketcap and coincap
log.info(
'getting bts/btc directly from coinmarketcap, no other sources available'
)
feeds_bts_btc = FeedSet([
providers.CoinMarketCap.get('BTS', 'BTC'),
providers.CoinCap.get('BTS', 'BTC')
])
if not feeds_bts_btc:
raise core.NoFeedData('Could not get any BTS/BTC feeds')
btc_price = feeds_bts_btc.price()
# 1.2- get the btc/usd (bitcoin avg)
feeds_btc_usd = get_multi_feeds(
'get', [('BTC', 'USD')],
active_providers_bts({
providers.BitcoinAverage, providers.CoinMarketCap,
providers.Bitfinex, providers.Bitstamp
})) # coincap seems to be off sometimes, do not use it
if not feeds_btc_usd:
raise core.NoFeedData('Could not get any BTC/USD feeds')
btc_usd = feeds_btc_usd.price()
usd_price = btc_price * btc_usd
# 1.3- get the bts/cny valuation directly from cny markets. Going from bts/btc and
# btc/cny to bts/cny introduces a slight difference (2-3%) that doesn't exist on
# the actual chinese markets
# TODO: should go at the beginning: submit all fetching tasks to an event loop / threaded executor,
# compute valuations once we have everything
feeds_bts_cny = get_multi_feeds(
'get', [('BTS', 'CNY')],
active_providers_bts(
{providers.Bter, providers.BTC38, providers.Yunbi}))
if not feeds_bts_cny:
# if we couldn't get the feeds for cny, go BTS->BTC, BTC->CNY
log.debug('Could not get any BTS/CNY feeds, going BTS->BTC, BTC->CNY')
bts_cny = btc_price * btc_usd / base_usd_price.price('CNY')
# # if we couldn't get the feeds for cny, try picking up our last value
# if price_history.get('cny'):
# log.warning('Could not get any BTS/CNY feeds, using last feed price')
# bts_cny = price_history['cny'][-1]
# else:
# raise core.NoFeedData('Could not get any BTS/CNY feeds')
else:
bts_cny = feeds_bts_cny.price()
cny_price = bts_cny
feeds = {
} # TODO: do we really want to reset the global var 'feeds' everytime we come here?
feeds['BTC'] = btc_price
feeds['USD'] = usd_price
feeds['CNY'] = cny_price
feeds['HERO'] = usd_price / (1.05**(
(pendulum.today() - pendulum.Pendulum(1913, 12, 23)).in_days() /
365.2425))
log.debug('Got btc/usd price: {}'.format(btc_usd))
log.debug('Got usd price: {}'.format(usd_price))
log.debug('Got cny price: {}'.format(cny_price))
# 2- now get the BitShares price in all other required currencies
for asset in BASE_ASSETS - {'BTC', 'USD', 'CNY'}:
try:
feeds[asset] = usd_price / base_usd_price.price(asset, 'USD')
except Exception:
log.warning('no feed price for asset {}'.format(asset))
# 2.1- RUBLE is used temporarily by RUDEX instead of bitRUB (black swan)
# see https://bitsharestalk.org/index.php/topic,24004.0/all.html
feeds['RUBLE'] = feeds['RUB']
# 3- get the feeds for major composite indices # REMOVED, was using yahoo, GoogleFeedProvider, BloombergFeedProvider
# 4- get other assets
altcap = get_multi_feeds('get', [('ALTCAP', 'BTC')],
{providers.CoinCap, providers.CoinMarketCap})
altcap = altcap.price(stddev_tolerance=0.08)
feeds['ALTCAP'] = altcap
gridcoin = get_multi_feeds('get', [('GRIDCOIN', 'BTC')],
{providers.Poloniex, providers.Bittrex})
feeds['GRIDCOIN'] = btc_price / gridcoin.price(stddev_tolerance=0.1)
steem_btc = get_multi_feeds(
'get', [('STEEM', 'BTC')],
active_providers_steem({providers.Poloniex, providers.Bittrex}))
steem_usd = steem_btc.price() * btc_usd
feeds['STEEM'] = steem_usd
golos_btc = get_multi_feeds(
'get', [('GOLOS', 'BTC')],
active_providers_steem({providers.Bittrex, providers.Livecoin}))
golos_bts = btc_price / golos_btc.price()
feeds['GOLOS'] = golos_bts
# 5- Bit20 asset
if 'BTWTY' not in get_disabled_assets():
try:
bit20 = get_bit20_feed(node, usd_price)
if bit20 is not None:
feeds['BTWTY'] = bit20
except core.NoFeedData as e:
log.warning(e)
# 6- HERTZ asset
if 'HERTZ' not in get_disabled_assets():
hertz_reference_timestamp = "2015-10-13T14:12:24+00:00" # Bitshares 2.0 genesis block timestamp
hertz_current_timestamp = pendulum.now().timestamp(
) # Current timestamp for reference within the hertz script
hertz_amplitude = 0.14 # 14% fluctuation (1% per day)
hertz_period_days = 28 # 28 days
hertz_phase_days = 0.908056 # Time offset from genesis till the first wednesday, to set wednesday as the primary Hz day.
hertz_reference_asset_price = usd_price
hertz = get_hertz_feed(hertz_reference_timestamp,
hertz_current_timestamp, hertz_period_days,
hertz_phase_days, hertz_reference_asset_price,
hertz_amplitude)
if hertz is not None:
feeds['HERTZ'] = hertz
# 7- update price history for all feeds
for cur, price in feeds.items():
price_history[cur].append(price)
return feeds
import os
from math import sin, cos, pi
import matplotlib.pyplot as plt
import pendulum
pendulum = pendulum.Pendulum(
.001,
[0, 0., pi, 0.],
10,
)
data = pendulum.integrate()
fig = plt.figure(0)
fig.suptitle("Pendulum on Cart")
cart_time_line = plt.subplot2grid((12, 12), (9, 0), colspan=12, rowspan=3)
cart_time_line.axis([
0,
10,
min(data[:, 1]) * 1.1,
max(data[:, 1]) * 1.1 + .1,
])
cart_time_line.set_xlabel('time (s)')
cart_time_line.set_ylabel('x (m)')
cart_time_line.plot(data[:, 0], data[:, 1], 'r-')
pendulum_time_line = cart_time_line.twinx()
pendulum_time_line.axis(
[0, 10, min(data[:, 3]) * 1.1 - .1,
