🏗 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/deep_sleep/deep_sleep_component.h

@@ -0,0 +1,111 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/automation.h"
+
+namespace esphome {
+namespace deep_sleep {
+
+#ifdef ARDUINO_ARCH_ESP32
+
+/** The values of this enum define what should be done if deep sleep is set up with a wakeup pin on the ESP32
+ * and the scenario occurs that the wakeup pin is already in the wakeup state.
+ */
+enum WakeupPinMode {
+  WAKEUP_PIN_MODE_IGNORE = 0,  ///< Ignore the fact that we will wake up when going into deep sleep.
+  WAKEUP_PIN_MODE_KEEP_AWAKE,  ///< As long as the wakeup pin is still in the wakeup state, keep awake.
+
+  /** Automatically invert the wakeup level. For example if we were set up to wake up on HIGH, but the pin
+   * is already high when attempting to enter deep sleep, re-configure deep sleep to wake up on LOW level.
+   */
+  WAKEUP_PIN_MODE_INVERT_WAKEUP,
+};
+
+struct Ext1Wakeup {
+  uint64_t mask;
+  esp_sleep_ext1_wakeup_mode_t wakeup_mode;
+};
+
+#endif
+
+template<typename... Ts> class EnterDeepSleepAction;
+
+template<typename... Ts> class PreventDeepSleepAction;
+
+/** This component allows setting up the node to go into deep sleep mode to conserve battery.
+ *
+ * To set this component up, first set *when* the deep sleep should trigger using set_run_cycles
+ * and set_run_duration, then set how long the deep sleep should last using set_sleep_duration and optionally
+ * on the ESP32 set_wakeup_pin.
+ */
+class DeepSleepComponent : public Component {
+ public:
+  /// Set the duration in ms the component should sleep once it's in deep sleep mode.
+  void set_sleep_duration(uint32_t time_ms);
+#ifdef ARDUINO_ARCH_ESP32
+  /** Set the pin to wake up to on the ESP32 once it's in deep sleep mode.
+   * Use the inverted property to set the wakeup level.
+   */
+  void set_wakeup_pin(GPIOPin *pin) { this->wakeup_pin_ = pin; }
+
+  void set_wakeup_pin_mode(WakeupPinMode wakeup_pin_mode);
+
+  void set_ext1_wakeup(Ext1Wakeup ext1_wakeup);
+#endif
+  /// Set a duration in ms for how long the code should run before entering deep sleep mode.
+  void set_run_duration(uint32_t time_ms);
+
+  void setup() override;
+  void dump_config() override;
+  void loop() override;
+  float get_loop_priority() const override;
+  float get_setup_priority() const override;
+
+  /// Helper to enter deep sleep mode
+  void begin_sleep(bool manual = false);
+
+  void prevent_deep_sleep();
+
+ protected:
+  optional<uint64_t> sleep_duration_;
+#ifdef ARDUINO_ARCH_ESP32
+  optional<GPIOPin *> wakeup_pin_;
+  WakeupPinMode wakeup_pin_mode_{WAKEUP_PIN_MODE_IGNORE};
+  optional<Ext1Wakeup> ext1_wakeup_;
+#endif
+  optional<uint32_t> run_duration_;
+  bool next_enter_deep_sleep_{false};
+  bool prevent_{false};
+};
+
+extern bool global_has_deep_sleep;
+
+template<typename... Ts> class EnterDeepSleepAction : public Action<Ts...> {
+ public:
+  EnterDeepSleepAction(DeepSleepComponent *deep_sleep) : deep_sleep_(deep_sleep) {}
+
+  void play(Ts... x) override {
+    this->deep_sleep_->begin_sleep(true);
+    this->play_next(x...);
+  }
+
+ protected:
+  DeepSleepComponent *deep_sleep_;
+};
+
+template<typename... Ts> class PreventDeepSleepAction : public Action<Ts...> {
+ public:
+  PreventDeepSleepAction(DeepSleepComponent *deep_sleep) : deep_sleep_(deep_sleep) {}
+
+  void play(Ts... x) override {
+    this->deep_sleep_->prevent_deep_sleep();
+    this->play_next(x...);
+  }
+
+ protected:
+  DeepSleepComponent *deep_sleep_;
+};
+
+}  // namespace deep_sleep
+}  // namespace esphome