Skip to content

The roadmap

Jump to bottom
o355 edited this page Jul 7, 2017 · 15 revisions

Instead of keeping this ancient to-do list, originally made around 0.2 beta (as a way to keep track of what's to come and what was finished), I thought I'd make a nice roadmap laying out the future of PyWeather.

The initial implementation - Should be completed in September 2017

The initial implementation is the stage in which the features I originally associated with PyWeather come to fruition. Right now, the features that are completed in the initial implementation are as follows:

  • Current information
  • 1.5 day/10 day hourly information
  • 10-day forecast information
  • Alerts information
  • Almanac
  • Historical weather
  • Setup script (and as an extension, PyWeather being configurable by the end user)
  • Radar viewer

However, I'd like to implement these remaining features before I move on to the "Extra stuff" stage:

  • PWS mode
  • Hurricane/tide data

The extra stuff - Should be completed in January 2018

Once all the initial features are coded in, I'll begin to code in extra stuff that I wanted to code into PyWeather. At this point, the list looks like such:

  • Favorite locations (and as an extension, current location through geo IP)
  • Yesterday's weather
  • Webcam images
  • Some form of a historical planner

I estimate for these features to be completed in January 2018, but this estimate is not set in stone.

The cleanup phase - Should be completed in February/March 2018

Following the extra stuff phase, I'll be using probably PyCharm to clean up code, and to conform to PEP 8 standards, as best as I can. Doing this basically includes:

  • Not going over 79 lines (I may bump this up to 89 or 90 lines for the sake of my own sanity), all that fun stuff

I still won't care horribly about efficiency, but if I see some glaring code-hogging, and stupid code, I'll probably fix it.

After this, PyWeather 1.0 is released. I'll keep updating PyWeather, maybe with new API features when Wunderground releases new API features, and likely to get Python 4 compatibility whenever it decides to drop. (if somehow Python 4 drops before March 2018, Python 4 compatibility will be added after I'm done with code cleanup.)

Exploring object oriented programming through arguments - Could be completed in early 2019

Past the cleanup phase, I'd like to explore object-oriented programming, by using Python libraries, modules, whatever you call them.

My first shot at doing this would be command line arguments. I could just as well easily use existing code to help me here. Examples include:

$ pyweather setup - Sets up PyWeather $ pyweather - Gives the summary screen we all know and love (would include alerts, currently, hourly, forecast, and sunset/sunrise $ pyweather -c - Gives current weather (in detailed form) $ pyweather -c -l "New York City" - Gives current weather for New York City

More challenging concepts include: $ pyweather -ahc - Gives alerts, hourly, and current weather in non-detailed form $ pyweather -ahc -d -l "New York City" - Gives alerts, hourly, and current weather in detailed form for New York City

Data types that would be included would go as follows:

  • Current information
  • 1.5 day (and as an extension, 10 day with -H instead of -h) hourly - This would be displayed in table format
  • Forecast data
  • Alerts
  • Almanac (and potentially "detailed" including hourly, in table format)
  • Sunrise/sunset

I'd like to go this route before I go towards working on modules.

Exploring object oriented programming through modules - Could be completed in early 2020

Following doing command-line PyWeather, I'd like to see about coding PyWeather as a library. A few examples I'd like to do are as follows:

Print the current temperature for NYC, in this example, it's 50 degrees:

currentforecast = pyweather_oop.currentforecast(1234abcd, "New York City")
print(currentforecast.tempf)```

`>>> 50`

And even more challenging. Do this (where high temp is 70, low temp is 30, conditions are sunny):
```import pyweather_oop
dailyforecast = pyweather_oop.currentforecast(1234abcd, "New York City", day=2)
print(dailyforecast.hightempf)
print(dailyforecast.lowtempf)
print(dailyforecast.conditions)```

```>>> 70
>>> 30
>>> "Sunny"```

Another challenging example, city is NYC, there are 3 alerts.

```import pyweather_oop
alerts = pyweather_oop.alerts(1234abcd, "New York City")
alertcount = alerts.alertcounter(int) <-- Potentially user-specifiable var type
for x in range(0, alertcount):
print(alerts.title(x)) <-- Where x is alert counter```

```>>> "Example Alert 1"
>>> "Example Alert 2"
>>> "Example Alert 3"```
Clone this wiki locally