def test01_initial_sql(self):
"Testing geographic initial SQL."
if DISABLE: return
if SpatialBackend.oracle:
# Oracle doesn't allow strings longer than 4000 characters
# in SQL files, and I'm stumped on how to use Oracle BFILE's
# in PLSQL, so we set up the larger geometries manually, rather
# than relying on the initial SQL.
# Routine for returning the path to the data files.
data_dir = os.path.join(os.path.dirname(__file__), 'sql')
def get_file(wkt_file):
return os.path.join(data_dir, wkt_file)
State(name='Colorado', poly=fromfile(get_file('co.wkt'))).save()
State(name='Kansas', poly=fromfile(get_file('ks.wkt'))).save()
Country(name='Texas', mpoly=fromfile(get_file('tx.wkt'))).save()
Country(name='New Zealand', mpoly=fromfile(get_file('nz.wkt'))).save()
# Ensuring that data was loaded from initial SQL.
self.assertEqual(2, Country.objects.count())
self.assertEqual(8, City.objects.count())
# Oracle cannot handle NULL geometry values w/certain queries.
if SpatialBackend.oracle: n_state = 2
else: n_state = 3
self.assertEqual(n_state, State.objects.count())
def test_if_returns_all_state_cases_from_database(self):
State().save(self.db.session, abbreviation='SP', name='São Paulo',
lat= 12.0001, lng= 25.0001)
State().save(self.db.session, abbreviation='SP', name='São Paulo',
lat= 12.0001, lng= 25.0001)
StateCases().save(self.db.session, state_id=1, totalcases=1,
totalcasesms=1, notconfirmedbyms=0,
deaths=0, url='https://some_url.com.br')
StateCases().save(self.db.session, state_id=2, totalcases=1,
totalcasesms=1, notconfirmedbyms=0,
deaths=0, url='https://some_url.com.br')
self.db.session.commit()
result = state_services.get_state_cases()
self.assertEqual(len(result), 2)
self.assertEqual(result, [{
"stateCode": "SP",
"stateName": "São Paulo",
"lat": 12.0001,
"lng": 25.0001,
"cases": {
"totalCases": 1,
"deaths": 0
}
}, {
"stateCode": "SP",
"stateName": "São Paulo",
"lat": 12.0001,
"lng": 25.0001,
"cases": {
"totalCases": 1,
"deaths": 0
}
}])
def setUp(self):
"""Create test client, add sample data."""
db.drop_all()
db.create_all()
# add states
s1 = State(name="oh")
s2 = State(name="ca")
s3 = State(name="ny")
s4 = State(name="nc")
db.session.add_all([s1, s2, s3, s4])
db.session.commit()
self.testuser = User.signUp(username="******",
password="******",
email="*****@*****.**",
address_line1="123 Line One",
address_line2="456 Line Two",
state_name="oh",
zip_code="43212")
self.testuser_id = 111
self.testuser.id = self.testuser_id
db.session.commit()
self.client = app.test_client()
def test_if_fetches_all_state_cases_from_database(self):
State().save(self.db.session,
abbreviation='SP',
name='São Paulo',
lat=12.0001,
lng=25.0001)
State().save(self.db.session,
abbreviation='SP',
name='São Paulo',
lat=12.0001,
lng=25.0001)
StateCases().save(self.db.session,
state_id=1,
totalcases=1,
totalcasesms=1,
notconfirmedbyms=0,
deaths=0,
url='https://some_url.com.br')
StateCases().save(self.db.session,
state_id=2,
totalcases=1,
totalcasesms=1,
notconfirmedbyms=0,
deaths=0,
url='https://some_url.com.br')
self.db.session.commit()
result = StateCases().fetch_all(self.db.session)
self.assertEqual(len(result), 2)
def setUp(self):
"""Create test client, add sample data."""
db.drop_all()
db.create_all()
self.client = app.test_client()
# add states
s1 = State(name="oh")
s2 = State(name="ca")
s3 = State(name="ny")
s4 = State(name="nc")
db.session.add_all([s1, s2, s3, s4])
db.session.commit()
# add test users
self.testuser = User.signUp(username="******",
password="******",
email="*****@*****.**",
address_line1="123 Sunset Ave",
address_line2="Apt B",
state_name="ca",
zip_code="99999")
db.session.commit()
self.testuser = User.query.get(self.testuser.id)
self.testuser_id = 111
self.testuser.id = self.testuser_id
db.session.commit()
a1 = Address(user_id=self.testuser_id,
address_line1="123 Street",
state_name="ri",
zip_code="43015",
favorite=True,
nickname="Brutus's House")
a3 = Address(user_id=self.testuser_id,
address_line1="789 Street",
state_name="ny",
zip_code="88888",
favorite=False,
nickname="Sister's House")
a4 = Address(user_id=self.testuser_id,
address_line1="112 Street",
state_name="nc",
zip_code="88888",
favorite=True,
nickname="Vacation Home")
db.session.add_all([a1, a3, a4])
db.session.commit()
ua1 = User_Addresses(user_id=self.testuser_id, address_id=4)
ua2 = User_Addresses(user_id=self.testuser_id, address_id=5)
ua3 = User_Addresses(user_id=self.testuser_id, address_id=6)
db.session.add_all([ua1, ua2, ua3])
db.session.commit()
def test_return_all_cases_per_state(self):
State().save(self.db.session,
abbreviation='SP',
name='São Paulo',
lat=12.0001,
lng=25.0001)
State().save(self.db.session,
abbreviation='MG',
name='Minas Gerais',
lat=13.0001,
lng=26.0001)
StateCases().save(self.db.session,
state_id=1,
totalcases=1,
totalcasesms=1,
notconfirmedbyms=0,
deaths=0,
url='https://some_url.com.br')
StateCases().save(self.db.session,
state_id=2,
totalcases=5,
totalcasesms=3,
notconfirmedbyms=2,
deaths=8,
url='https://some_url.com.br')
self.db.session.commit()
resp = self.client.get(
'/data_api/v1/cases/state',
headers={
'Authorization':
f"Bearer {self.authentication['access_token']}"
})
response = json.loads(resp.get_data(as_text=True))
self.assertEqual(len(response), 2)
self.assertEqual(resp.status_code, 200)
self.assertEqual(response, [{
"stateCode": "SP",
"stateName": "São Paulo",
"lat": "12.0001",
"lng": "25.0001",
"cases": {
"totalCases": 1,
"deaths": 0
}
}, {
"stateCode": "MG",
"stateName": "Minas Gerais",
"lat": "13.0001",
"lng": "26.0001",
"cases": {
"totalCases": 5,
"deaths": 8
}
}])
def setUp(self):
"""Create test client, add sample data."""
db.drop_all()
db.create_all()
self.client = app.test_client()
# add states
s1 = State(name="oh")
s2 = State(name="ca")
s3 = State(name="ny")
s4 = State(name="nc")
db.session.add_all([s1, s2, s3, s4])
db.session.commit()
# add test users
self.testuser = User.signUp(username="******",
password="******",
email="*****@*****.**",
address_line1="123 Line One",
address_line2="456 Line Two",
state_name="oh",
zip_code="43212")
self.testuser_id = 111
self.testuser.id = self.testuser_id
self.testuser = User.signUp(username="******",
password="******",
email="*****@*****.**",
address_line1="123 Line One",
address_line2="456 Line Two",
state_name="ny",
zip_code="43212")
self.testuser_two_id = 222
self.testuser_two.id = self.testuser_two_id
db.session.commit()
testuser = User.query.get(self.testuser_id)
testuser_two = User.query.get(self.testuser_two_id)
self.testuser = testuser
self.testuser_id = self.testuser_id
self.testuser_two = testuser_two
self.testuser_two_id = self.testuser_two_id
self.u3 = User.signUp("three_user", "*****@*****.**", "password", "ca")
self.u4 = User.signUp("four_user", "*****@*****.**", "password", "ca")
db.session.commit()
def test_child_State(self):
""" Tests if the class State is a child class """
state = State()
self.assertIsInstance(state, BaseModel)
self.assertTrue(hasattr(state, "id")
self.assertTrue(hasattr(state, "created_at"))
self.assertTrue(hasattr(state, "updated_at"))
def test_name(self):
""" Tests for the attr name"""
state = State()
self.assertTrue(hasattr(state, "name"))
self.assertEqual(state.name, ""))
async def get_service_state(self, path: str) -> Optional[ServiceState]:
"""Returns service states by its url"""
query = """
SELECT path, status_code, state, create_time, update_time FROM path_state WHERE path = %(path)s;
"""
try:
with (await self._connection.cursor(cursor_factory=psycopg2.extras.DictCursor)) \
as cur: # type: cursor.Cursor
query = cur.mogrify(query, {'path': path})
await cur.execute(query)
result = await cur.fetchone()
if not result:
return
return ServiceState(path=result['path'],
state=State(result['state']),
status_code=result['status_code'],
create_time=result['create_time'],
update_time=result['update_time'])
except Exception as err:
logger.exception(err)
raise err
def test_return_404_when_city_report_by_term_not_exists(self):
State().save(self.db.session,
id=1,
name="state1",
abbreviation="s1",
lat=0,
lng=0)
City().save(self.db.session,
id=1,
city='c1',
ibge_id=1,
country='Country1',
state_id=1,
totalcases=10)
City().save(self.db.session,
id=2,
city='c2',
ibge_id=2,
country='Country1',
state_id=1,
totalcases=20)
self.db.session.commit()
resp = self.client.get(
'/data_api/v1/cases/city/c3/report',
headers={
'Authorization':
f"Bearer {self.authentication['access_token']}"
})
self.assertEqual(resp.status_code, 404)
def start_game(offer):
error = False
try:
if 'userId' in session:
player_id = session['userId']
else:
player = Player()
Player.insert(player)
player_id = player.id
session['userId'] = player.id
offer = Offer.query.filter_by(id=offer).first()
new_game = Game(player_one=offer.player_one, player_two = player_id)
Game.insert(new_game)
game = new_game.id
offer.delete()
current_state = State(game_id=new_game.id, move_number=1,move='white',position=start_position)
State.insert(current_state)
data = current_state.position
except:
error = True
db.session.rollback()
print(sys.exc_info())
finally:
db.session.close()
if error:
return 'error'
else:
return redirect(url_for('black', game = game))
def test_search_on_location_by_term_returns_Null_when_not_exists(self):
State().save(self.db.session,
id=1,
name="state1",
abbreviation="s1",
lat=0,
lng=0)
City().save(self.db.session,
id=1,
city='c1',
ibge_id=1,
country='Country1',
state_id=1,
totalcases=10)
City().save(self.db.session,
id=2,
city='c2',
ibge_id=2,
country='Country1',
state_id=1,
totalcases=20)
self.db.session.commit()
response = city_services.search_on_location_by_term('c3')
self.assertEqual(len(response), 0)
self.assertEqual(response, [])
def test_create_state_failure(self):
from models import State
try:
State()
self.assert_(False, "Abstract class couldn't have instance")
except:
pass
def create_state_nodes(df):
n_nodes = 0
for _, row in df.drop_duplicates(subset=["state"]).iterrows():
state = State(name=row["state"])
state.save()
n_nodes += 1
print("created {} nodes".format(n_nodes))
def prob_data_assoc(self, state, Z):
N = len(Z)
P_D = self.sensor_model.P_D
int_c = self.sensor_model.intensity_c
estimates = []
for i in range(N):
z_ingate = self.density.ellips_gating(state, Z[i])
preds = self.density.pred_likelihood(
state, z_ingate) if z_ingate.size else np.array([])
m = preds.size
w = np.zeros(m + 1)
hyp = np.array([None] * (m + 1), dtype=np.object)
hyp[m] = State(x=state.x, P=state.P)
w[:m] = preds + np.log(P_D / int_c)
w[m] = np.log(1 - P_D)
w, W = norm_log_weights(w)
for j in range(m):
hyp[j] = self.density.update(state, z_ingate[:, j])
w, hyp = prune_hyp(w, hyp, self.w_min)
w, W = norm_log_weights(w)
state = self.density.moment_matching(w, hyp)
estimates.append(state.x)
state = self.density.predict(state)
return estimates
def test_create_action(self):
state = State(
planets={
0: Planet(x=-10, y=1),
1: Planet(x=10, y=2),
2: Planet(x=0, y=10),
},
hyperlanes={
(0, 1): Hyperlane(origin=0, target=1),
(1, 0): Hyperlane(origin=1, target=0),
},
)
valid_actions = {
(-10, 1, 10, 2),
(10, 2, -10, 1),
}
invalid_actions = {
(-10, 1, 0, 10),
(0, 10, -10, 1),
(0, 10, 10, 2),
(10, 2, 0, 10),
}
self.assertFalse(valid_actions.intersection(invalid_actions))
for _ in range(100):
action = create_action(state, correct=True)
self.assertIn(action, valid_actions)
for _ in range(100):
action = create_action(state, correct=False)
self.assertIn(action, invalid_actions)
def get_state():
try:
state = State.objects.get()
except State.DoesNotExist:
state = State()
state.save()
return state
def DO_NOT_RUN():
state_result = json.loads(
requests.get(
'https://corona.lmao.ninja/v2/historical/usacounties').text)
excluded_states = [
'diamond princess', 'grand princess', 'american samoa',
'northern mariana islands'
]
state_result = [
elem for elem in state_result if elem not in excluded_states
]
# delete existing entries
print('Deleted ' + str(County.query.delete()) + ' counties')
print('Deleted ' + str(State.query.delete()) + ' states')
#repopulate database
for state_name in state_result:
result = json.loads(
requests.get(
'https://corona.lmao.ninja/v2/historical/usacounties/' +
state_name + '?lastdays=14').text)
state = State(name=state_name.title())
print('State: ' + state.name)
sum_2_week_cases = 0
sum_current_cases = 0
try:
for county in result:
name = county['county']
if name is not None and 'out of' not in name and name != 'unassigned':
case_list = list(county['timeline']['cases'].values())
cases_2_weeks_ago = case_list[0]
current_cases = case_list[-1]
new_cases = current_cases - cases_2_weeks_ago
sum_2_week_cases += cases_2_weeks_ago
sum_current_cases += current_cases
print(name)
county = County(name=name.title(),
state=state,
cases_2_weeks_ago=cases_2_weeks_ago,
total_cases=current_cases,
new_cases=new_cases)
db.session.add(county)
except Exception as e:
print('ERROR: Unable to add counties for the state ' + state_name +
' ' + str(e))
state.cases_2_weeks_ago = sum_2_week_cases
state.total_cases = sum_current_cases
state.new_cases = sum_current_cases - sum_2_week_cases
db.session.commit()
def move():
error = False
if request.method == 'POST':
content = json.loads(request.data)
figure = content.get('figure', None)
promote = content.get('promote', None)
move_number = content.get('moveNumber', None)
gameId = content.get('gameId', None)
app.logger.info('gameId: %s' % gameId)
if figure:
if session['userId']:
state = State.query.filter_by(game_id=gameId).order_by(
State.move_number.desc()).first()
app.logger.info('state: %s' % state)
check = legal(state, figure, content['move'])
if check == 1:
try:
legal_move = reffery(state, figure, content['move'],
promote)
next_state = State(
game_id=state.game_id,
move_number=state.move_number + 1,
move=legal_move['next_move'],
position=legal_move['new_position'],
white_timer=legal_move['time']['white'],
black_timer=legal_move['time']['black'])
State.insert(next_state)
data = next_state.format()
cash_put(state.game_id, state.move_number + 1)
except:
error = True
db.session.rollback()
app.logger.info(sys.exc_info())
app.logger.info(sys.argv[1])
finally:
db.session.close()
if error:
return json.dumps({'error': True})
return json.dumps(data)
#return json.dumps({'promotion': data})
else:
return json.dumps({'error': check})
if move_number:
if session['userId']:
cashed = cash_get(gameId, move_number)
if cashed:
return json.dumps(None)
state = State.query.join(Game).filter(
or_(Game.player_one == session['userId'],
Game.player_two == session['userId'])).order_by(
State.move_number.desc()).first()
new_state = state.format()
db.session.close()
if move_number < new_state['move_number']:
return json.dumps(new_state)
else:
return json.dumps(None)
else:
return json.dumps({'kas': 'per huiniene'})
def setUpClass(cls):
# Create a city/state to use later
state1 = State(id=1, name='PA')
city1 = City(id=1, name='Philadelphia', state_id=1)
o1 = Official(id=1, name='Official', office='Mayor')
db.session.add_all([state1, city1, o1])
db.session.commit()
def test_to_dict_result(self):
""" Tests the result of the dict """
state = State()
new_dict = state.to_dict()
self.assertEqual(new_dict["__class__"], "State")
self.assertEqual(type(new_dict["created_at"]), str)
self.assertEqual(type(new_dict["updated_at"]), str)
self.assertEqual(type(new_dict["id"]), str)
def state_add():
data = request.get_json()
if data is None:
return 'Not a JSON', 400
if 'name' not in data.keys():
return 'Missing name', 400
state = State(**data)
state.save()
return jsonify(state.to_json()), 201
def create_state(name, capital, date_est, abbr, motto):
new_state = State(name=name,
capital=capital or None,
date_est=date_est or None,
abbr=abbr or None,
motto=motto or None)
db.session.add(new_state)
db.session.commit()
return jsonify(new_state.as_dict())
def populate_states(ses):
with open('data/states.json', 'r') as f:
data = load(f)
db_states = []
for s in data['mx_states']:
db_states.append(State(state_name=s[0], abbreviation=s[1],
latitude=s[2], longitude=s[3]))
ses.add_all(db_states)
def testState_1(self):
texas = State("Texas", "TX", "Best State Ever", "CST", "Rick Perry",
"Austin", "San Antonio", 1000, 1300, 1200, "Big Bend",
"Campground 1", "https://www.google.com", "imageUrl")
database.session.add(texas)
state = State.query.first()
self.assertTrue(state.name == "Texas")
self.assertTrue(state.abbreviations == "TX")
def gaussian_sum(self, state, Z):
N = len(Z)
P_D = self.sensor_model.P_D
int_c = self.sensor_model.intensity_c
estimates = []
w, W = norm_log_weights(np.array([np.log(1)]))
hyp = np.array([State(state.x, state.P)], dtype=np.object)
for k in range(N):
H = w.size
w_h = []
hyp_h = []
for i in range(H):
z_ingate = self.density.ellips_gating(hyp[i], Z[k])
preds = self.density.pred_likelihood(
hyp[i], z_ingate) if z_ingate.size else np.array([])
m = preds.size
w_h.append(w[i] + np.log(1 - P_D))
hyp_h.append(State(hyp[i].x, hyp[i].P))
for j in range(m):
state_upd = self.density.update(hyp[i], z_ingate[:, j])
w_h.append(w[i] + preds[j] + np.log(P_D / int_c))
hyp_h.append(state_upd)
w = np.array(w_h)
hyp = np.array(hyp_h, dtype=np.object)
w, W = norm_log_weights(w)
w, hyp = prune_hyp(w, hyp, self.w_min)
w, W = norm_log_weights(w)
w, hyp = self.density.mixture_reduction(w, hyp)
w, hyp = cap_hyp(w, hyp, self.M)
w, W = norm_log_weights(w)
idx = np.argmax(w)
estimates.append(hyp[idx].x)
for i in range(w.size):
hyp[i] = self.density.predict(hyp[i])
return estimates
def test_non_auto_increment_pk(self):
with self.assertNumQueries(1):
State.objects.bulk_create(
[State(two_letter_code=s) for s in ["IL", "NY", "CA", "ME"]])
self.assertQuerysetEqual(State.objects.order_by("two_letter_code"), [
"CA",
"IL",
"ME",
"NY",
], attrgetter("two_letter_code"))
def test_if_save_method_saves_state_on_database(self):
State().save(self.db.session,
abbreviation='SP',
name='São Paulo',
lat=12.0001,
lng=25.0001)
self.db.session.commit()
_model = self.db.session.query(State).filter_by(
abbreviation='SP').first()
self.assertIsNotNone(_model)
def validate_city(city_name, state_name):
city = City.query.filter_by(name=city_name).first()
if not city:
state = State.query.filter_by(name=state_name).first()
if not state:
state = State(name=state_name)
city = City(name=city_name, state=state)
db.session.add(city)
db.session.commit()
return city
def update(self, state, z):
H = self.meas_model.H(state.x)
S = np.dot(np.dot(H, state.P), H.T) + self.meas_model.R
S = (S + S.T) / 2.
S_inv = np.linalg.inv(S)
K = np.dot(np.dot(state.P, H.T), S_inv)
I = np.eye(self.motion_model.dim) - np.dot(K, H)
x = state.x + np.dot(K, z - self.meas_model.h(state.x))
P = np.dot(I, state.P)
return State(x, P)
