🏗 Merge C++ into python codebase (#504)

## Description:

Move esphome-core codebase into esphome (and a bunch of other refactors). See https://github.com/esphome/feature-requests/issues/97

Yes this is a shit ton of work and no there's no way to automate it :( But it will be worth it 👍

Progress:
- Core support (file copy etc): 80%
- Base Abstractions (light, switch): ~50%
- Integrations: ~10%
- Working? Yes, (but only with ported components).

Other refactors:
- Moves all codegen related stuff into a single class: `esphome.codegen` (imported as `cg`)
- Rework coroutine syntax
- Move from `component/platform.py` to `domain/component.py` structure as with HA
- Move all defaults out of C++ and into config validation.
- Remove `make_...` helpers from Application class. Reason: Merge conflicts with every single new integration.
- Pointer Variables are stored globally instead of locally in setup(). Reason: stack size limit.

Future work:
- Rework const.py - Move all `CONF_...` into a conf class (usage `conf.UPDATE_INTERVAL` vs `CONF_UPDATE_INTERVAL`). Reason: Less convoluted import block
- Enable loading from `custom_components` folder.

**Related issue (if applicable):** https://github.com/esphome/feature-requests/issues/97

**Pull request in [esphome-docs](https://github.com/esphome/esphome-docs) with documentation (if applicable):** esphome/esphome-docs#<esphome-docs PR number goes here>

## Checklist:
  - [ ] The code change is tested and works locally.
  - [ ] Tests have been added to verify that the new code works (under `tests/` folder).

If user exposed functionality or configuration variables are added/changed:
  - [ ] Documentation added/updated in [esphomedocs](https://github.com/OttoWinter/esphomedocs).

esphome/components/power_supply/__init__.py

@@ -0,0 +1,24 @@
+from esphome import pins
+import esphome.config_validation as cv
+import esphome.codegen as cg
+from esphome.const import CONF_ENABLE_TIME, CONF_ID, CONF_KEEP_ON_TIME, CONF_PIN
+
+power_supply_ns = cg.esphome_ns.namespace('power_supply')
+PowerSupply = power_supply_ns.class_('PowerSupply', cg.Component)
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.Required(CONF_ID): cv.declare_variable_id(PowerSupply),
+    cv.Required(CONF_PIN): pins.gpio_output_pin_schema,
+    cv.Optional(CONF_ENABLE_TIME, default='20ms'): cv.positive_time_period_milliseconds,
+    cv.Optional(CONF_KEEP_ON_TIME, default='10s'): cv.positive_time_period_milliseconds,
+}).extend(cv.COMPONENT_SCHEMA)
+
+
+def to_code(config):
+    pin = yield cg.gpio_pin_expression(config[CONF_PIN])
+
+    var = cg.new_Pvariable(config[CONF_ID], pin, config[CONF_ENABLE_TIME],
+                           config[CONF_KEEP_ON_TIME])
+    yield cg.register_component(var, config)
+    cg.add_define('USE_POWER_SUPPLY')

esphome/components/power_supply/power_supply.cpp

@@ -0,0 +1,67 @@
+#include "power_supply.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace power_supply {
+
+static const char *TAG = "power_supply";
+
+void PowerSupply::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up Power Supply...");
+
+  this->pin_->setup();
+  this->pin_->digital_write(false);
+  this->enabled_ = false;
+}
+void PowerSupply::dump_config() {
+  ESP_LOGCONFIG(TAG, "Power Supply:");
+  LOG_PIN("  Pin: ", this->pin_);
+  ESP_LOGCONFIG(TAG, "  Time to enable: %u ms", this->enable_time_);
+  ESP_LOGCONFIG(TAG, "  Keep on time: %.1f s", this->keep_on_time_ / 1000.0f);
+}
+
+float PowerSupply::get_setup_priority() const { return setup_priority::IO; }
+
+PowerSupply::PowerSupply(GPIOPin *pin, uint32_t enable_time, uint32_t keep_on_time)
+    : pin_(pin), enable_time_(enable_time), keep_on_time_(keep_on_time) {}
+
+bool PowerSupply::is_enabled() const { return this->enabled_; }
+
+void PowerSupply::request_high_power() {
+  this->cancel_timeout("power-supply-off");
+  this->pin_->digital_write(true);
+
+  if (this->active_requests_ == 0) {
+    // we need to enable the power supply.
+    // cancel old timeout if it exists because we now definitely have a high power mode.
+    ESP_LOGD(TAG, "Enabling power supply.");
+    delay(this->enable_time_);
+  }
+  this->enabled_ = true;
+  // increase active requests
+  this->active_requests_++;
+}
+
+void PowerSupply::unrequest_high_power() {
+  this->active_requests_--;
+  if (this->active_requests_ < 0) {
+    // if asserts are disabled we're just going to use 0 as our now counter.
+    this->active_requests_ = 0;
+  }
+
+  if (this->active_requests_ == 0) {
+    // set timeout for power supply off
+    this->set_timeout("power-supply-off", this->keep_on_time_, [this]() {
+      ESP_LOGD(TAG, "Disabling power supply.");
+      this->pin_->digital_write(false);
+      this->enabled_ = false;
+    });
+  }
+}
+void PowerSupply::on_shutdown() {
+  this->active_requests_ = 0;
+  this->pin_->digital_write(false);
+}
+
+}  // namespace power_supply
+}  // namespace esphome

esphome/components/power_supply/power_supply.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/esphal.h"
+
+namespace esphome {
+namespace power_supply {
+
+class PowerSupply : public Component {
+ public:
+  explicit PowerSupply(GPIOPin *pin, uint32_t enable_time, uint32_t keep_on_time);
+
+  /// Is this power supply currently on?
+  bool is_enabled() const;
+
+  /// Request high power mode. Use unrequest_high_power() to remove this request.
+  void request_high_power();
+
+  /// Un-request high power mode.
+  void unrequest_high_power();
+
+  // ========== INTERNAL METHODS ==========
+  // (In most use cases you won't need these)
+  /// Register callbacks.
+  void setup() override;
+  void dump_config() override;
+  /// Hardware setup priority (+1).
+  float get_setup_priority() const override;
+
+  void on_shutdown() override;
+
+ protected:
+  GPIOPin *pin_;
+  bool enabled_{false};
+  uint32_t enable_time_;
+  uint32_t keep_on_time_;
+  int16_t active_requests_{0};  // use signed integer to make catching negative requests easier.
+};
+
+}  // namespace power_supply
+}  // namespace esphome