def run(self):
while True:
try:
print("Enter the name of a city.")
location = input(">>> ")
weather = Weather(self.api.get_current_weather(location=location))
weather.display_weather()
except ValueError as e:
print("Error getting the weather: {}".format(e))
except KeyError as e:
print("There was an error reading the weather data at the location you entered.")
class WeatherTestCase(unittest.TestCase):
def setUp(self):
self.weather = Weather()
def test_1a_is_stormy(self):
"""weather is stormy"""
random.seed(2)
self.assertTrue(self.weather.is_stormy())
def test_1b_is_stormy(self):
"""weather is not stormy"""
random.seed(9)
self.assertFalse(self.weather.is_stormy())
class WeatherTestCase(unittest.TestCase):
def setUp(self):
self.weather = Weather()
def test_1a_is_stormy(self):
"""weather is stormy"""
random.seed( 2 )
self.assertTrue(self.weather.is_stormy())
def test_1b_is_stormy(self):
"""weather is not stormy"""
random.seed( 9 )
self.assertFalse(self.weather.is_stormy())
def collect_data(self, status, last_watered_time):
weather_dict = Weather().current()
current_time = time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime())
sensor_dict = dict()
val1 = sensor_dict["moisture_sensor_1"] = ADC.sensor_val(
"capacitive", 0)
val2 = sensor_dict["moisture_sensor_2"] = ADC.sensor_val(
"capacitive", 1)
val3 = sensor_dict["moisture_sensor_3"] = ADC.sensor_val(
"capacitive", 2)
val4 = sensor_dict["moisture_sensor_4"] = ADC.sensor_val(
"capacitive", 3)
sensor_dict["resistive_moisture"] = ADC.sensor_val("resistive", 4)
sensor_dict["average_moisture"] = ADC.average_moisture(
[val1, val2, val3, val4])
sensor_dict.update(weather_dict)
sensor_dict["watered"] = status
sensor_dict["last_watering_time"] = last_watered_time
sensor_dict["time"] = current_time
sensor_dict["hour"] = time.strptime(current_time,
"%Y-%m-%dT%H:%M:%S")[3]
for field in File.FIELD_NAMES:
print(field, " : ", sensor_dict[field], end=", ")
print("\n\n")
return sensor_dict
def test_get_ridability_score(self):
dry, light_rain, storm, fog, humid = self.get_weather_types()
weather = Weather()
light_rain_score = weather.get_ridability_score(light_rain)
storm_score = weather.get_ridability_score(storm)
humid_score = weather.get_ridability_score(humid)
fog_score = weather.get_ridability_score(fog)
dry_score = weather.get_ridability_score(dry)
self.assertGreater(dry_score, light_rain_score)
self.assertGreater(light_rain_score, storm_score)
self.assertGreater(dry_score, fog_score)
self.assertGreater(dry_score, humid_score)
self.assertGreater(humid_score, storm_score)
self.assertGreater(fog_score, storm_score)
async def test_weather_no_forecast():
db_wrapper = MockDatabaseWrapper()
weather = Weather(db_wrapper)
message = await weather.process_message("завтра")
assert message == {
"desc": None,
"text": "К сожалению, у меня нет данных о погоде на 2020-05-06",
"author": None,
"picture": None
}
async def test_weather_date_is_none():
db_wrapper = MockDatabaseWrapper()
weather = Weather(db_wrapper)
message = await weather.process_message("Погода")
assert message == {
"desc": None,
"text":
"Не смог распознать сообщение! Погоду можно узнать только на ближайшую неделю.",
"author": None,
"picture": None
}
def test_weather_parse_forecast_to_weather_type():
forecast = get_base_forecast()
forecast.condition = Condition.CLOUDY_AND_RAIN
assert WeatherType.RAINY == Weather._parse_forecast_to_weather_type(
forecast)
forecast.condition = Condition.CLOUDY_AND_LIGHT_SNOW
assert WeatherType.SNOWY == Weather._parse_forecast_to_weather_type(
forecast)
forecast.condition = Condition.CLEAR
forecast.season = Season.SPRING
assert WeatherType.SPRING == Weather._parse_forecast_to_weather_type(
forecast)
forecast.season = Season.AUTUMN
assert WeatherType.AUTUMN == Weather._parse_forecast_to_weather_type(
forecast)
forecast.season = Season.WINTER
assert WeatherType.WARM == Weather._parse_forecast_to_weather_type(
forecast)
forecast.hours['10'] = {'temp': 5, 'feels_like': 3}
assert WeatherType.COLD == Weather._parse_forecast_to_weather_type(
forecast)
def reply(bot, update):
chat_id = update.message.chat_id
user_id = update.message.from_user.id
text = update.message.text
chat_state = state.get(chat_id, START)
user = users.get(user_id)
if user is None:
users[user_id] = user = User()
if chat_state == AWAIT_PLACE:
state[chat_id] = AWAIT_TIME_OF_DAY
user.place = geocoder.get_place(text)
bot.sendMessage(
chat_id=chat_id,
text="Cool! I've recorded your location as {0}.".format(user.place))
# ask time
reply_markup = ReplyKeyboardMarkup(
[map(KeyboardButton, TIME_OF_DAY_OPTIONS)],
one_time_keyboard=True)
bot.sendMessage(chat_id=chat_id, text="When do you go for rides?", reply_markup=reply_markup)
elif chat_state == AWAIT_TIME_OF_DAY:
state[chat_id] = AWAIT_FREQUENCY
user.can_ride_morning = text in (MORNINGS, NO_PREFERENCE)
user.can_ride_evening = text in (EVENINGS, NO_PREFERENCE)
# ask frequency
reply_markup = ReplyKeyboardMarkup(
[map(KeyboardButton, map(str, range(1, 8)))],
one_time_keyboard=True)
bot.sendMessage(chat_id=chat_id, text="How many rides do you do per week?", reply_markup=reply_markup)
elif chat_state == AWAIT_TIME_OF_DAY:
state[chat_id] = SLEEPING
user.frequency = float(text)
weather = Weather()
day, score, weather_score = weather.suggest_time(user)
bot.sendMessage(chat_id=chat_id, text="I'd suggest a ride on {0}".format(day.strftime('%A %x')))
async def process_weather(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['city'] = message.text
weather = Weather.get_weather_by_city(message.text)
text = _('Nothing found(')
if weather:
temp = weather.get('temp')
temp_min = weather.get('temp_min', '-')
temp_max = str(weather.get('temp_max', '-'))
pressure = str(weather.get('pressure', '-')) + 'hPa'
humidity = str(weather.get('humidity', '-')) + '%'
feels_like = str(weather.get('feels_like', '-'))
text = [
_("Temperature: {}").format(temp),
_("Minimum temp: {}").format(temp_min),
_("Maximum temp: {}").format(temp_max),
_("Feels like: {}").format(feels_like),
_("Pressure: {}").format(pressure),
_("Humidity: {}").format(humidity)
]
await message.answer("\n".join(text))
await state.finish()
if __name__ == '__main__':
logging.basicConfig(format='%(asctime)s %(message)s', level=LOG_LEVEL)
logging.info('Starting...')
cam = Camera()
prop = Property()
relays = Relays()
triac_hat = TriacHat()
sensors = Sensors()
growing = Growing()
metrics = Metrics()
fan = Fan()
light = Light()
humidify = Humidify()
weather = Weather()
# Init start settings
fan.init(triac_hat)
start_prometheus_exporter(EXPORTER_SERVER_PORT)
logging.debug('Prometheus exporter listen on 0.0.0.0:{port}'.format(port=EXPORTER_SERVER_PORT))
update_metrics()
light_control()
fan_control()
humidify_control()
update_weather_info()
make_photo_timelapse()
def test_airport_does_not_let_plane_land_when_stormy(self):
airport = Airport(Weather(99))
with self.assertRaises(RuntimeError):
airport.landPlane("Plane")
def test_airport_does_not_let_plane_take_off_when_stormy(self):
airport = Airport(Weather(1))
airport.landPlane("Plane")
airport.updateWeather(Weather(99))
with self.assertRaises(RuntimeError):
airport.takeOffPlane("Plane")
def test_suggest_time(self):
place = DummyPlace(37.4418834, -122.1430195)
weather = Weather()
user = User(place=place, can_ride_morning=True, frequency=2)
day, score, weather_score = weather.suggest_time(user)
def setUp(self):
self.weather = Weather()
self.airport = Airport(self.weather)
self.plane = Plane()
self.weather.is_stormy = MagicMock(return_value=False)
def test_gets_forecast_when_given_location():
weather = Weather()
assert weather.get_forecast("London") == "Cloudy"
def view_weather():
weather = Weather()
weather.get_weather()
def setUp(self):
self.weather = Weather()
def test_parse_date_from_text(messages, result):
for message in messages:
assert result == Weather._parse_date_from_text(text=message)
YANDEX_API_KEY = os.environ.get("YANDEX_WEATHER_API_KEY")
if not YANDEX_API_KEY:
sys.exit("Set environment variable YANDEX_WEATHER_API_KEY")
parser = ArgumentParser()
parser.add_argument("--config",
required=True,
help="path to service config file")
args = parser.parse_args()
# Define and parse all options as tornado options
define_options.init(args.config)
# Set logging
with open(options.log_config_path) as f:
log_config_path = json.load(f)
logging.config.dictConfig(log_config_path)
event_loop = asyncio.get_event_loop()
# Init db
db_wrapper = DatabaseWrapper(options.db_uri)
event_loop.run_until_complete(db_wrapper.init())
event_loop.create_task(update_weather(
db_wrapper, YANDEX_API_KEY)) # Start updating forecasts
weather = Weather(db_wrapper)
api_app = api.create_app(weather)
web.run_app(api_app, host=options.host, port=options.port)
def __init__(self, weather=Weather(), capacity=20):
self.planes = []
self.weather = weather
self.capacity = capacity
def setUp(self):
self.weather = Weather()
def test_sunny1(self):
weather = Weather(1)
self.assertEqual(weather.storm, False)
def test_stormy(self):
weather = Weather(99)
self.assertEqual(weather.storm, True)
