mirror of
https://github.com/Threnklyn/esphome-dev.git
synced 2026-06-05 20:38:27 +02:00
[Huge] Util Refactor, Dashboard Improvements, Hass.io Auth API, Better Validation Errors, Conditions, Custom Platforms, Substitutions (#234)
* Implement custom sensor platform * Update * Ethernet * Lint * Fix * Login page * Rename cookie secret * Update manifest * Update cookie check logic * Favicon * Fix * Favicon manifest * Fix * Fix * Fix * Use hostname * Message * Temporary commit for screenshot * Automatic board selection * Undo temporary commit * Update esphomeyaml-edge * In-dashboard editing and hosting files locally * Update esphomeyaml-edge * Better ANSI color escaping * Message * Lint * Download Efficiency * Fix gitlab * Fix * Rename extra_libraries to libraries * Add example * Update README.md * Update README.md * Update README.md * HassIO -> Hass.io * Updates * Add update available notice * Update * Fix substitutions * Better error message * Re-do dashboard ANSI colors * Only include FastLED if user says so * Autoscroll logs * Remove old checks * Use safer RedirectText * Improvements * Fix * Use enviornment variable * Use http://hassio/host/info * Fix conditions * Update platformio versions * Revert "Use enviornment variable" This reverts commit 7f038eb5d26df72f76ea9ae76774e2cec1fd7f59. * Fix * README update * Temp * Better invalid config messages * Platformio debug * Improve error messages * Debug * Remove debug * Multi Conf * Update * Better paths * Remove unused * Fixes * Lint * lib_ignore * Try fix platformio colors * Fix dashboard scrolling * Revert * Lint * Revert
This commit is contained in:
Otto Winter
+24
-680
@@ -1,17 +1,9 @@
|
||||
from __future__ import print_function
|
||||
|
||||
from collections import OrderedDict, deque
|
||||
import inspect
|
||||
import errno
|
||||
import logging
|
||||
import os
|
||||
|
||||
from esphomeyaml import core
|
||||
from esphomeyaml.const import CONF_AVAILABILITY, CONF_COMMAND_TOPIC, CONF_DISCOVERY, \
|
||||
CONF_INVERTED, \
|
||||
CONF_MODE, CONF_NUMBER, CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_PCF8574, \
|
||||
CONF_RETAIN, CONF_STATE_TOPIC, CONF_TOPIC, CONF_SETUP_PRIORITY
|
||||
from esphomeyaml.core import ESPHomeYAMLError, HexInt, Lambda, TimePeriodMicroseconds, \
|
||||
TimePeriodMilliseconds, TimePeriodSeconds
|
||||
import subprocess
|
||||
|
||||
_LOGGER = logging.getLogger(__name__)
|
||||
|
||||
@@ -44,206 +36,6 @@ def indent(text, padding=u' '):
|
||||
return u'\n'.join(indent_list(text, padding))
|
||||
|
||||
|
||||
class Expression(object):
|
||||
def __init__(self):
|
||||
self.requires = []
|
||||
self.required = False
|
||||
|
||||
def __str__(self):
|
||||
raise NotImplementedError
|
||||
|
||||
def require(self):
|
||||
self.required = True
|
||||
for require in self.requires:
|
||||
if require.required:
|
||||
continue
|
||||
require.require()
|
||||
|
||||
def has_side_effects(self):
|
||||
return self.required
|
||||
|
||||
|
||||
class RawExpression(Expression):
|
||||
def __init__(self, text):
|
||||
super(RawExpression, self).__init__()
|
||||
self.text = text
|
||||
|
||||
def __str__(self):
|
||||
return str(self.text)
|
||||
|
||||
|
||||
# pylint: disable=redefined-builtin
|
||||
class AssignmentExpression(Expression):
|
||||
def __init__(self, type, modifier, name, rhs, obj):
|
||||
super(AssignmentExpression, self).__init__()
|
||||
self.type = type
|
||||
self.modifier = modifier
|
||||
self.name = name
|
||||
self.rhs = safe_exp(rhs)
|
||||
self.requires.append(self.rhs)
|
||||
self.obj = obj
|
||||
|
||||
def __str__(self):
|
||||
type_ = self.type
|
||||
return u"{} {}{} = {}".format(type_, self.modifier, self.name, self.rhs)
|
||||
|
||||
def has_side_effects(self):
|
||||
return self.rhs.has_side_effects()
|
||||
|
||||
|
||||
class ExpressionList(Expression):
|
||||
def __init__(self, *args):
|
||||
super(ExpressionList, self).__init__()
|
||||
# Remove every None on end
|
||||
args = list(args)
|
||||
while args and args[-1] is None:
|
||||
args.pop()
|
||||
self.args = []
|
||||
for arg in args:
|
||||
exp = safe_exp(arg)
|
||||
self.requires.append(exp)
|
||||
self.args.append(exp)
|
||||
|
||||
def __str__(self):
|
||||
text = u", ".join(unicode(x) for x in self.args)
|
||||
return indent_all_but_first_and_last(text)
|
||||
|
||||
|
||||
class TemplateArguments(Expression):
|
||||
def __init__(self, *args):
|
||||
super(TemplateArguments, self).__init__()
|
||||
self.args = ExpressionList(*args)
|
||||
self.requires.append(self.args)
|
||||
|
||||
def __str__(self):
|
||||
return u'<{}>'.format(self.args)
|
||||
|
||||
|
||||
class CallExpression(Expression):
|
||||
def __init__(self, base, *args):
|
||||
super(CallExpression, self).__init__()
|
||||
self.base = base
|
||||
if args and isinstance(args[0], TemplateArguments):
|
||||
self.template_args = args[0]
|
||||
self.requires.append(self.template_args)
|
||||
args = args[1:]
|
||||
else:
|
||||
self.template_args = None
|
||||
self.args = ExpressionList(*args)
|
||||
self.requires.append(self.args)
|
||||
|
||||
def __str__(self):
|
||||
if self.template_args is not None:
|
||||
return u'{}{}({})'.format(self.base, self.template_args, self.args)
|
||||
return u'{}({})'.format(self.base, self.args)
|
||||
|
||||
|
||||
class StructInitializer(Expression):
|
||||
def __init__(self, base, *args):
|
||||
super(StructInitializer, self).__init__()
|
||||
self.base = base
|
||||
if isinstance(base, Expression):
|
||||
self.requires.append(base)
|
||||
if not isinstance(args, OrderedDict):
|
||||
args = OrderedDict(args)
|
||||
self.args = OrderedDict()
|
||||
for key, value in args.iteritems():
|
||||
if value is None:
|
||||
continue
|
||||
exp = safe_exp(value)
|
||||
self.args[key] = exp
|
||||
self.requires.append(exp)
|
||||
|
||||
def __str__(self):
|
||||
cpp = u'{}{{\n'.format(self.base)
|
||||
for key, value in self.args.iteritems():
|
||||
cpp += u' .{} = {},\n'.format(key, value)
|
||||
cpp += u'}'
|
||||
return cpp
|
||||
|
||||
|
||||
class ArrayInitializer(Expression):
|
||||
def __init__(self, *args, **kwargs):
|
||||
super(ArrayInitializer, self).__init__()
|
||||
self.multiline = kwargs.get('multiline', True)
|
||||
self.args = []
|
||||
for arg in args:
|
||||
if arg is None:
|
||||
continue
|
||||
exp = safe_exp(arg)
|
||||
self.args.append(exp)
|
||||
self.requires.append(exp)
|
||||
|
||||
def __str__(self):
|
||||
if not self.args:
|
||||
return u'{}'
|
||||
if self.multiline:
|
||||
cpp = u'{\n'
|
||||
for arg in self.args:
|
||||
cpp += u' {},\n'.format(arg)
|
||||
cpp += u'}'
|
||||
else:
|
||||
cpp = u'{' + u', '.join(str(arg) for arg in self.args) + u'}'
|
||||
return cpp
|
||||
|
||||
|
||||
# pylint: disable=invalid-name
|
||||
class ParameterExpression(Expression):
|
||||
def __init__(self, type, id):
|
||||
super(ParameterExpression, self).__init__()
|
||||
self.type = type
|
||||
self.id = id
|
||||
|
||||
def __str__(self):
|
||||
return u"{} {}".format(self.type, self.id)
|
||||
|
||||
|
||||
class ParameterListExpression(Expression):
|
||||
def __init__(self, *parameters):
|
||||
super(ParameterListExpression, self).__init__()
|
||||
self.parameters = []
|
||||
for parameter in parameters:
|
||||
if not isinstance(parameter, ParameterExpression):
|
||||
parameter = ParameterExpression(*parameter)
|
||||
self.parameters.append(parameter)
|
||||
self.requires.append(parameter)
|
||||
|
||||
def __str__(self):
|
||||
return u", ".join(unicode(x) for x in self.parameters)
|
||||
|
||||
|
||||
class LambdaExpression(Expression):
|
||||
def __init__(self, parts, parameters, capture='=', return_type=None):
|
||||
super(LambdaExpression, self).__init__()
|
||||
self.parts = parts
|
||||
if not isinstance(parameters, ParameterListExpression):
|
||||
parameters = ParameterListExpression(*parameters)
|
||||
self.parameters = parameters
|
||||
self.requires.append(self.parameters)
|
||||
self.capture = capture
|
||||
self.return_type = return_type
|
||||
if return_type is not None:
|
||||
self.requires.append(return_type)
|
||||
for i in range(1, len(parts), 3):
|
||||
self.requires.append(parts[i])
|
||||
|
||||
def __str__(self):
|
||||
cpp = u'[{}]({})'.format(self.capture, self.parameters)
|
||||
if self.return_type is not None:
|
||||
cpp += u' -> {}'.format(self.return_type)
|
||||
cpp += u' {{\n{}\n}}'.format(self.content)
|
||||
return indent_all_but_first_and_last(cpp)
|
||||
|
||||
@property
|
||||
def content(self):
|
||||
return u''.join(unicode(part) for part in self.parts)
|
||||
|
||||
|
||||
class Literal(Expression):
|
||||
def __str__(self):
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
# From https://stackoverflow.com/a/14945195/8924614
|
||||
def cpp_string_escape(string, encoding='utf-8'):
|
||||
if isinstance(string, unicode):
|
||||
@@ -257,477 +49,29 @@ def cpp_string_escape(string, encoding='utf-8'):
|
||||
return '"' + result + '"'
|
||||
|
||||
|
||||
class StringLiteral(Literal):
|
||||
def __init__(self, string):
|
||||
super(StringLiteral, self).__init__()
|
||||
self.string = string
|
||||
|
||||
def __str__(self):
|
||||
return u'{}'.format(cpp_string_escape(self.string))
|
||||
|
||||
|
||||
class IntLiteral(Literal):
|
||||
def __init__(self, i):
|
||||
super(IntLiteral, self).__init__()
|
||||
self.i = i
|
||||
|
||||
def __str__(self):
|
||||
if self.i > 4294967295:
|
||||
return u'{}ULL'.format(self.i)
|
||||
if self.i > 2147483647:
|
||||
return u'{}UL'.format(self.i)
|
||||
if self.i < -2147483648:
|
||||
return u'{}LL'.format(self.i)
|
||||
return unicode(self.i)
|
||||
|
||||
|
||||
class BoolLiteral(Literal):
|
||||
def __init__(self, binary):
|
||||
super(BoolLiteral, self).__init__()
|
||||
self.binary = binary
|
||||
|
||||
def __str__(self):
|
||||
return u"true" if self.binary else u"false"
|
||||
|
||||
|
||||
class HexIntLiteral(Literal):
|
||||
def __init__(self, i):
|
||||
super(HexIntLiteral, self).__init__()
|
||||
self.i = HexInt(i)
|
||||
|
||||
def __str__(self):
|
||||
return str(self.i)
|
||||
|
||||
|
||||
class FloatLiteral(Literal):
|
||||
def __init__(self, value):
|
||||
super(FloatLiteral, self).__init__()
|
||||
self.float_ = value
|
||||
|
||||
def __str__(self):
|
||||
return u"{:f}f".format(self.float_)
|
||||
|
||||
|
||||
def safe_exp(obj):
|
||||
if isinstance(obj, Expression):
|
||||
return obj
|
||||
elif isinstance(obj, bool):
|
||||
return BoolLiteral(obj)
|
||||
elif isinstance(obj, (str, unicode)):
|
||||
return StringLiteral(obj)
|
||||
elif isinstance(obj, HexInt):
|
||||
return HexIntLiteral(obj)
|
||||
elif isinstance(obj, (int, long)):
|
||||
return IntLiteral(obj)
|
||||
elif isinstance(obj, float):
|
||||
return FloatLiteral(obj)
|
||||
elif isinstance(obj, TimePeriodMicroseconds):
|
||||
return IntLiteral(int(obj.total_microseconds))
|
||||
elif isinstance(obj, TimePeriodMilliseconds):
|
||||
return IntLiteral(int(obj.total_milliseconds))
|
||||
elif isinstance(obj, TimePeriodSeconds):
|
||||
return IntLiteral(int(obj.total_seconds))
|
||||
raise ValueError(u"Object is not an expression", obj)
|
||||
|
||||
|
||||
class Statement(object):
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def __str__(self):
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
class RawStatement(Statement):
|
||||
def __init__(self, text):
|
||||
super(RawStatement, self).__init__()
|
||||
self.text = text
|
||||
|
||||
def __str__(self):
|
||||
return self.text
|
||||
|
||||
|
||||
class ExpressionStatement(Statement):
|
||||
def __init__(self, expression):
|
||||
super(ExpressionStatement, self).__init__()
|
||||
self.expression = safe_exp(expression)
|
||||
|
||||
def __str__(self):
|
||||
return u"{};".format(self.expression)
|
||||
|
||||
|
||||
def statement(expression):
|
||||
if isinstance(expression, Statement):
|
||||
return expression
|
||||
return ExpressionStatement(expression)
|
||||
|
||||
|
||||
def register_variable(id, obj):
|
||||
_LOGGER.debug("Registered variable %s of type %s", id.id, id.type)
|
||||
_VARIABLES[id] = obj
|
||||
|
||||
|
||||
# pylint: disable=redefined-builtin, invalid-name
|
||||
def variable(id, rhs, type=None):
|
||||
rhs = safe_exp(rhs)
|
||||
obj = MockObj(id, u'.')
|
||||
id.type = type or id.type
|
||||
assignment = AssignmentExpression(id.type, '', id, rhs, obj)
|
||||
add(assignment)
|
||||
register_variable(id, obj)
|
||||
obj.requires.append(assignment)
|
||||
return obj
|
||||
|
||||
|
||||
def Pvariable(id, rhs, has_side_effects=True, type=None):
|
||||
rhs = safe_exp(rhs)
|
||||
if not has_side_effects and hasattr(rhs, '_has_side_effects'):
|
||||
# pylint: disable=attribute-defined-outside-init, protected-access
|
||||
rhs._has_side_effects = False
|
||||
obj = MockObj(id, u'->', has_side_effects=has_side_effects)
|
||||
id.type = type or id.type
|
||||
assignment = AssignmentExpression(id.type, '*', id, rhs, obj)
|
||||
add(assignment)
|
||||
register_variable(id, obj)
|
||||
obj.requires.append(assignment)
|
||||
return obj
|
||||
|
||||
|
||||
_TASKS = deque()
|
||||
_VARIABLES = {}
|
||||
_EXPRESSIONS = []
|
||||
|
||||
|
||||
def get_variable(id):
|
||||
while True:
|
||||
if id in _VARIABLES:
|
||||
yield _VARIABLES[id]
|
||||
return
|
||||
_LOGGER.debug("Waiting for variable %s", id)
|
||||
yield None
|
||||
|
||||
|
||||
def get_variable_with_full_id(id):
|
||||
while True:
|
||||
for k, v in _VARIABLES.iteritems():
|
||||
if k == id:
|
||||
yield (k, v)
|
||||
return
|
||||
_LOGGER.debug("Waiting for variable %s", id)
|
||||
yield None, None
|
||||
|
||||
|
||||
def process_lambda(value, parameters, capture='=', return_type=None):
|
||||
from esphomeyaml.components.globals import GlobalVariableComponent
|
||||
|
||||
if value is None:
|
||||
yield
|
||||
return
|
||||
parts = value.parts[:]
|
||||
for i, id in enumerate(value.requires_ids):
|
||||
for full_id, var in get_variable_with_full_id(id):
|
||||
yield
|
||||
if full_id is not None and isinstance(full_id.type, MockObjClass) and \
|
||||
full_id.type.inherits_from(GlobalVariableComponent):
|
||||
parts[i * 3 + 1] = var.value()
|
||||
continue
|
||||
|
||||
if parts[i * 3 + 2] == '.':
|
||||
parts[i * 3 + 1] = var._
|
||||
else:
|
||||
parts[i * 3 + 1] = var
|
||||
parts[i * 3 + 2] = ''
|
||||
yield LambdaExpression(parts, parameters, capture, return_type)
|
||||
|
||||
|
||||
def templatable(value, input_type, output_type):
|
||||
if isinstance(value, Lambda):
|
||||
lambda_ = None
|
||||
for lambda_ in process_lambda(value, [(input_type, 'x')], return_type=output_type):
|
||||
yield None
|
||||
yield lambda_
|
||||
else:
|
||||
yield value
|
||||
|
||||
|
||||
def add_job(func, *args, **kwargs):
|
||||
domain = kwargs.get('domain')
|
||||
if inspect.isgeneratorfunction(func):
|
||||
def func_():
|
||||
yield
|
||||
for _ in func(*args):
|
||||
yield
|
||||
else:
|
||||
def func_():
|
||||
yield
|
||||
func(*args)
|
||||
gen = func_()
|
||||
_TASKS.append((gen, domain))
|
||||
return gen
|
||||
|
||||
|
||||
def flush_tasks():
|
||||
i = 0
|
||||
while _TASKS:
|
||||
i += 1
|
||||
if i > 1000000:
|
||||
raise ESPHomeYAMLError("Circular dependency detected!")
|
||||
|
||||
task, domain = _TASKS.popleft()
|
||||
_LOGGER.debug("Executing task for domain=%s", domain)
|
||||
try:
|
||||
task.next()
|
||||
_TASKS.append((task, domain))
|
||||
except StopIteration:
|
||||
_LOGGER.debug(" -> %s finished", domain)
|
||||
|
||||
|
||||
def add(expression, require=True):
|
||||
if require and isinstance(expression, Expression):
|
||||
expression.require()
|
||||
_EXPRESSIONS.append(expression)
|
||||
_LOGGER.debug("Adding: %s", statement(expression))
|
||||
return expression
|
||||
|
||||
|
||||
class MockObj(Expression):
|
||||
def __init__(self, base, op=u'.', has_side_effects=True):
|
||||
self.base = base
|
||||
self.op = op
|
||||
self._has_side_effects = has_side_effects
|
||||
super(MockObj, self).__init__()
|
||||
|
||||
def __getattr__(self, attr):
|
||||
if attr == u'_':
|
||||
obj = MockObj(u'{}{}'.format(self.base, self.op))
|
||||
obj.requires.append(self)
|
||||
return obj
|
||||
if attr == u'new':
|
||||
obj = MockObj(u'new {}'.format(self.base), u'->')
|
||||
obj.requires.append(self)
|
||||
return obj
|
||||
next_op = u'.'
|
||||
if attr.startswith(u'P') and self.op not in ['::', '']:
|
||||
attr = attr[1:]
|
||||
next_op = u'->'
|
||||
if attr.startswith(u'_'):
|
||||
attr = attr[1:]
|
||||
obj = MockObj(u'{}{}{}'.format(self.base, self.op, attr), next_op)
|
||||
obj.requires.append(self)
|
||||
return obj
|
||||
|
||||
def __call__(self, *args, **kwargs):
|
||||
call = CallExpression(self.base, *args)
|
||||
obj = MockObj(call, self.op)
|
||||
obj.requires.append(self)
|
||||
obj.requires.append(call)
|
||||
return obj
|
||||
|
||||
def __str__(self):
|
||||
return unicode(self.base)
|
||||
|
||||
def require(self):
|
||||
self.required = True
|
||||
for require in self.requires:
|
||||
if require.required:
|
||||
continue
|
||||
require.require()
|
||||
|
||||
def template(self, args):
|
||||
if not isinstance(args, TemplateArguments):
|
||||
args = TemplateArguments(args)
|
||||
obj = MockObj(u'{}{}'.format(self.base, args))
|
||||
obj.requires.append(self)
|
||||
obj.requires.append(args)
|
||||
return obj
|
||||
|
||||
def namespace(self, name):
|
||||
obj = MockObj(u'{}{}{}'.format(self.base, self.op, name), u'::')
|
||||
obj.requires.append(self)
|
||||
return obj
|
||||
|
||||
def class_(self, name, *parents):
|
||||
obj = MockObjClass(u'{}::{}'.format(self.base, name), u'.', parents=parents)
|
||||
obj.requires.append(self)
|
||||
return obj
|
||||
|
||||
def struct(self, name):
|
||||
return self.class_(name)
|
||||
|
||||
def enum(self, name, is_class=False):
|
||||
if is_class:
|
||||
return self.namespace(name)
|
||||
|
||||
return self
|
||||
|
||||
def operator(self, name):
|
||||
if name == 'ref':
|
||||
obj = MockObj(u'{} &'.format(self.base), u'')
|
||||
obj.requires.append(self)
|
||||
return obj
|
||||
if name == "const":
|
||||
obj = MockObj(u'const {}'.format(self.base), u'')
|
||||
obj.requires.append(self)
|
||||
return obj
|
||||
raise NotImplementedError()
|
||||
|
||||
def has_side_effects(self):
|
||||
return self._has_side_effects
|
||||
|
||||
def __getitem__(self, item):
|
||||
next_op = u'.'
|
||||
if isinstance(item, str) and item.startswith(u'P'):
|
||||
item = item[1:]
|
||||
next_op = u'->'
|
||||
obj = MockObj(u'{}[{}]'.format(self.base, item), next_op)
|
||||
obj.requires.append(self)
|
||||
if isinstance(item, Expression):
|
||||
obj.requires.append(item)
|
||||
return obj
|
||||
|
||||
|
||||
class MockObjClass(MockObj):
|
||||
def __init__(self, *args, **kwargs):
|
||||
parens = kwargs.pop('parents')
|
||||
MockObj.__init__(self, *args, **kwargs)
|
||||
self._parents = []
|
||||
for paren in parens:
|
||||
if not isinstance(paren, MockObjClass):
|
||||
raise ValueError
|
||||
self._parents.append(paren)
|
||||
# pylint: disable=protected-access
|
||||
self._parents += paren._parents
|
||||
|
||||
def inherits_from(self, other):
|
||||
if self == other:
|
||||
return True
|
||||
for parent in self._parents:
|
||||
if parent == other:
|
||||
return True
|
||||
return False
|
||||
|
||||
def template(self, args):
|
||||
if not isinstance(args, TemplateArguments):
|
||||
args = TemplateArguments(args)
|
||||
new_parents = self._parents[:]
|
||||
new_parents.append(self)
|
||||
obj = MockObjClass(u'{}{}'.format(self.base, args), parents=new_parents)
|
||||
obj.requires.append(self)
|
||||
obj.requires.append(args)
|
||||
return obj
|
||||
|
||||
|
||||
global_ns = MockObj('', '')
|
||||
float_ = global_ns.namespace('float')
|
||||
bool_ = global_ns.namespace('bool')
|
||||
std_ns = global_ns.namespace('std')
|
||||
std_string = std_ns.string
|
||||
uint8 = global_ns.namespace('uint8_t')
|
||||
uint16 = global_ns.namespace('uint16_t')
|
||||
uint32 = global_ns.namespace('uint32_t')
|
||||
int32 = global_ns.namespace('int32_t')
|
||||
const_char_p = global_ns.namespace('const char *')
|
||||
NAN = global_ns.namespace('NAN')
|
||||
esphomelib_ns = global_ns # using namespace esphomelib;
|
||||
NoArg = esphomelib_ns.NoArg
|
||||
App = esphomelib_ns.App
|
||||
io_ns = esphomelib_ns.namespace('io')
|
||||
Nameable = esphomelib_ns.class_('Nameable')
|
||||
Trigger = esphomelib_ns.class_('Trigger')
|
||||
Action = esphomelib_ns.class_('Action')
|
||||
Component = esphomelib_ns.class_('Component')
|
||||
PollingComponent = esphomelib_ns.class_('PollingComponent', Component)
|
||||
Application = esphomelib_ns.class_('Application')
|
||||
optional = esphomelib_ns.class_('optional')
|
||||
arduino_json_ns = global_ns.namespace('ArduinoJson')
|
||||
JsonObject = arduino_json_ns.class_('JsonObject')
|
||||
JsonObjectRef = JsonObject.operator('ref')
|
||||
JsonObjectConstRef = JsonObjectRef.operator('const')
|
||||
Controller = esphomelib_ns.class_('Controller')
|
||||
StoringController = esphomelib_ns.class_('StoringController', Controller)
|
||||
|
||||
GPIOPin = esphomelib_ns.class_('GPIOPin')
|
||||
GPIOOutputPin = esphomelib_ns.class_('GPIOOutputPin', GPIOPin)
|
||||
GPIOInputPin = esphomelib_ns.class_('GPIOInputPin', GPIOPin)
|
||||
|
||||
|
||||
def get_gpio_pin_number(conf):
|
||||
if isinstance(conf, int):
|
||||
return conf
|
||||
return conf[CONF_NUMBER]
|
||||
|
||||
|
||||
def generic_gpio_pin_expression_(conf, mock_obj, default_mode):
|
||||
if conf is None:
|
||||
return
|
||||
number = conf[CONF_NUMBER]
|
||||
inverted = conf.get(CONF_INVERTED)
|
||||
if CONF_PCF8574 in conf:
|
||||
hub = None
|
||||
for hub in get_variable(conf[CONF_PCF8574]):
|
||||
yield None
|
||||
if default_mode == u'INPUT':
|
||||
mode = conf.get(CONF_MODE, u'INPUT')
|
||||
yield hub.make_input_pin(number,
|
||||
RawExpression('PCF8574_' + mode),
|
||||
inverted)
|
||||
return
|
||||
elif default_mode == u'OUTPUT':
|
||||
yield hub.make_output_pin(number, inverted)
|
||||
return
|
||||
else:
|
||||
raise ESPHomeYAMLError(u"Unknown default mode {}".format(default_mode))
|
||||
if len(conf) == 1:
|
||||
yield IntLiteral(number)
|
||||
return
|
||||
mode = RawExpression(conf.get(CONF_MODE, default_mode))
|
||||
yield mock_obj(number, mode, inverted)
|
||||
|
||||
|
||||
def gpio_output_pin_expression(conf):
|
||||
exp = None
|
||||
for exp in generic_gpio_pin_expression_(conf, GPIOOutputPin, 'OUTPUT'):
|
||||
yield None
|
||||
yield exp
|
||||
|
||||
|
||||
def gpio_input_pin_expression(conf):
|
||||
exp = None
|
||||
for exp in generic_gpio_pin_expression_(conf, GPIOInputPin, 'INPUT'):
|
||||
yield None
|
||||
yield exp
|
||||
|
||||
|
||||
def setup_mqtt_component(obj, config):
|
||||
if CONF_RETAIN in config:
|
||||
add(obj.set_retain(config[CONF_RETAIN]))
|
||||
if not config.get(CONF_DISCOVERY, True):
|
||||
add(obj.disable_discovery())
|
||||
if CONF_STATE_TOPIC in config:
|
||||
add(obj.set_custom_state_topic(config[CONF_STATE_TOPIC]))
|
||||
if CONF_COMMAND_TOPIC in config:
|
||||
add(obj.set_custom_command_topic(config[CONF_COMMAND_TOPIC]))
|
||||
if CONF_AVAILABILITY in config:
|
||||
availability = config[CONF_AVAILABILITY]
|
||||
if not availability:
|
||||
add(obj.disable_availability())
|
||||
else:
|
||||
add(obj.set_availability(availability[CONF_TOPIC], availability[CONF_PAYLOAD_AVAILABLE],
|
||||
availability[CONF_PAYLOAD_NOT_AVAILABLE]))
|
||||
|
||||
|
||||
def setup_component(obj, config):
|
||||
if CONF_SETUP_PRIORITY in config:
|
||||
add(obj.set_setup_priority(config[CONF_SETUP_PRIORITY]))
|
||||
|
||||
|
||||
def color(the_color, message='', reset=None):
|
||||
"""Color helper."""
|
||||
def color(the_color, message=''):
|
||||
from colorlog.escape_codes import escape_codes, parse_colors
|
||||
|
||||
if not message:
|
||||
return parse_colors(the_color)
|
||||
return parse_colors(the_color) + message + escape_codes[reset or 'reset']
|
||||
res = parse_colors(the_color)
|
||||
else:
|
||||
res = parse_colors(the_color) + message + escape_codes['reset']
|
||||
|
||||
return res
|
||||
|
||||
|
||||
def relative_path(path):
|
||||
return os.path.join(os.path.dirname(core.CONFIG_PATH), os.path.expanduser(path))
|
||||
def run_system_command(*args):
|
||||
p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||||
stdout, stderr = p.communicate()
|
||||
rc = p.returncode
|
||||
return rc, stdout, stderr
|
||||
|
||||
|
||||
def mkdir_p(path):
|
||||
try:
|
||||
os.makedirs(path)
|
||||
except OSError as exc:
|
||||
if exc.errno == errno.EEXIST and os.path.isdir(path):
|
||||
pass
|
||||
else:
|
||||
raise
|
||||
|
||||
Reference in New Issue
Block a user