def handle_new_task(call):
"""Called when a user creates a new Todoist Task from HASS."""
project_name = call.data[PROJECT_NAME]
project_id = project_id_lookup[project_name]
# Create the task
item = api.items.add(call.data[CONTENT], project_id)
if LABELS in call.data:
task_labels = call.data[LABELS]
label_ids = [
label_id_lookup[label.lower()] for label in task_labels
]
item.update(labels=label_ids)
if PRIORITY in call.data:
item.update(priority=call.data[PRIORITY])
if DUE_DATE in call.data:
due_date = dt.parse_datetime(call.data[DUE_DATE])
if due_date is None:
due = dt.parse_date(call.data[DUE_DATE])
due_date = datetime(due.year, due.month, due.day)
# Format it in the manner Todoist expects
due_date = dt.as_utc(due_date)
date_format = '%Y-%m-%dT%H:%M'
due_date = datetime.strftime(due_date, date_format)
item.update(due_date_utc=due_date)
# Commit changes
api.commit()
_LOGGER.debug("Created Todoist task: %s", call.data[CONTENT])
async def async_added_to_hass(self):
"""Run when entity about to be added."""
await super().async_added_to_hass()
# Priority 1: Initial value
if self.state is not None:
return
# Priority 2: Old state
old_state = await self.async_get_last_state()
if old_state is None:
self._current_datetime = dt_util.parse_datetime(DEFAULT_VALUE)
return
if self.has_date and self.has_time:
date_time = dt_util.parse_datetime(old_state.state)
if date_time is None:
self._current_datetime = dt_util.parse_datetime(DEFAULT_VALUE)
return
self._current_datetime = date_time
elif self.has_date:
date = dt_util.parse_date(old_state.state)
if date is None:
self._current_datetime = dt_util.parse_datetime(DEFAULT_VALUE)
return
self._current_datetime = datetime.datetime.combine(
date, DEFAULT_TIME)
else:
time = dt_util.parse_time(old_state.state)
if time is None:
self._current_datetime = dt_util.parse_datetime(DEFAULT_VALUE)
return
self._current_datetime = datetime.datetime.combine(
DEFAULT_DATE, time)
def __init__(self, config: dict) -> None:
"""Initialize a select input."""
self._config = config
self.editable = True
self._current_datetime = None
initial = config.get(CONF_INITIAL)
if not initial:
return
if self.has_date and self.has_time:
current_datetime = dt_util.parse_datetime(initial)
elif self.has_date:
date = dt_util.parse_date(initial)
current_datetime = py_datetime.datetime.combine(date, DEFAULT_TIME)
else:
time = dt_util.parse_time(initial)
current_datetime = py_datetime.datetime.combine(
py_datetime.date.today(), time
)
# If the user passed in an initial value with a timezone, convert it to right tz
if current_datetime.tzinfo is not None:
self._current_datetime = current_datetime.astimezone(
dt_util.DEFAULT_TIME_ZONE
)
else:
self._current_datetime = current_datetime.replace(
tzinfo=dt_util.DEFAULT_TIME_ZONE
)
def handle_new_task(call):
"""Call when a user creates a new Todoist Task from HASS."""
project_name = call.data[PROJECT_NAME]
project_id = project_id_lookup[project_name]
# Create the task
item = api.items.add(call.data[CONTENT], project_id)
if LABELS in call.data:
task_labels = call.data[LABELS]
label_ids = [
label_id_lookup[label.lower()]
for label in task_labels]
item.update(labels=label_ids)
if PRIORITY in call.data:
item.update(priority=call.data[PRIORITY])
if DUE_DATE in call.data:
due_date = dt.parse_datetime(call.data[DUE_DATE])
if due_date is None:
due = dt.parse_date(call.data[DUE_DATE])
due_date = datetime(due.year, due.month, due.day)
# Format it in the manner Todoist expects
due_date = dt.as_utc(due_date)
date_format = '%Y-%m-%dT%H:%M'
due_date = datetime.strftime(due_date, date_format)
item.update(due_date_utc=due_date)
# Commit changes
api.commit()
_LOGGER.debug("Created Todoist task: %s", call.data[CONTENT])
def _get_date(date):
"""Get the dateTime from date or dateTime as a local."""
if 'date' in date:
return dt.as_utc(dt.dt.datetime.combine(
dt.parse_date(date['date']), dt.dt.time()))
else:
return dt.parse_datetime(date['dateTime'])
def _get_date(date):
"""Get the dateTime from date or dateTime as a local."""
if 'date' in date:
return dt.start_of_local_day(dt.dt.datetime.combine(
dt.parse_date(date['date']), dt.dt.time.min))
else:
return dt.as_local(dt.parse_datetime(date['dateTime']))
def get_date(date):
"""Get the dateTime from date or dateTime as a local."""
if "date" in date:
return dt.start_of_local_day(
dt.dt.datetime.combine(dt.parse_date(date["date"]),
dt.dt.time.min))
return dt.as_local(dt.parse_datetime(date["dateTime"]))
async def async_added_to_hass(self):
"""Run when entity about to be added."""
await super().async_added_to_hass()
restore_val = None
# Priority 1: Initial State
if self._initial is not None:
restore_val = self._initial
# Priority 2: Old state
if restore_val is None:
old_state = await self.async_get_last_state()
if old_state is not None:
restore_val = old_state.state
if not self.has_date:
if not restore_val:
restore_val = DEFAULT_VALUE.split()[1]
self._current_datetime = dt_util.parse_time(restore_val)
elif not self.has_time:
if not restore_val:
restore_val = DEFAULT_VALUE.split()[0]
self._current_datetime = dt_util.parse_date(restore_val)
else:
if not restore_val:
restore_val = DEFAULT_VALUE
self._current_datetime = dt_util.parse_datetime(restore_val)
async def async_setup_platform(hass,
config,
async_add_entities,
discovery_info=None):
"""Set up the Anniversary sensor."""
if hass.config.time_zone is None:
_LOGGER.error("Timezone is not set in Home Assistant configuration")
return False
sensors = []
for device, device_config in config[CONF_SENSORS].items():
date_str = device_config.get(ATTR_DATE)
is_lunar = device_config.get(CONF_IS_LUNAR_DATE)
is_intercalation = device_config.get(CONF_INTERCALATION)
anniv_type = device_config.get(CONF_TYPE)
name = device_config.get(CONF_NAME)
if name == '':
name = device
is_mmdd = False
if dt_util.parse_date(date_str) is None:
year_added_date_str = str(
dt_util.as_local(
dt_util.utcnow()).date().year) + "-" + date_str
if dt_util.parse_date(year_added_date_str) is not None:
date_str = year_added_date_str
is_mmdd = True
else:
continue
sensor = AnniversarySensor(hass, device, name, date_str, is_lunar,
is_intercalation, anniv_type, is_mmdd)
async_track_point_in_utc_time(hass, sensor.point_in_time_listener,
sensor.get_next_interval())
sensors.append(sensor)
sensor = AnniversaryTTSSensor(hass, "anniversary_tts",
config.get(CONF_TTS_DAYS),
config.get(CONF_TTS_SCAN_INTERVAL))
async_track_point_in_utc_time(hass, sensor.point_in_time_listener,
sensor.get_next_interval())
sensors.append(sensor)
async_add_entities(sensors, True)
def _get_date(date):
"""Get the dateTime from date or dateTime as a local."""
if 'date' in date:
return dt.start_of_local_day(
dt.dt.datetime.combine(dt.parse_date(date['date']),
dt.dt.time.min))
else:
return dt.as_local(dt.parse_datetime(date['dateTime']))
def to_python(self, value):
"""Validate and convert date."""
parsed = dt_util.parse_date(value)
if parsed is None:
raise ValidationError()
return parsed
def to_python(self, value):
"""Validate and convert date."""
parsed = dt_util.parse_date(value)
if parsed is None:
raise ValidationError()
return parsed
def _get_date(date):
"""Get the dateTime from date or dateTime as a local."""
if 'date' in date:
return dt.as_utc(
dt.dt.datetime.combine(dt.parse_date(date['date']),
dt.dt.time()))
else:
return dt.parse_datetime(date['dateTime'])
def validate_date(value: str) -> str:
"""Input must be either none or a valid date."""
if value is None:
return None
date = dt_util.parse_date(value)
if date is None:
raise vol.Invalid("Invalid date entered: {}".format(value))
else:
return date.strftime("%Y-%m-%d")
def get_date(date: dict[str, Any]) -> datetime.datetime:
"""Get the dateTime from date or dateTime as a local."""
if "date" in date:
parsed_date = dt.parse_date(date["date"])
assert parsed_date
return dt.start_of_local_day(
datetime.datetime.combine(parsed_date, datetime.time.min))
parsed_datetime = dt.parse_datetime(date["dateTime"])
assert parsed_datetime
return dt.as_local(parsed_datetime)
def lunar_gapja(self, lunarDate):
intercalation = False
if '윤달' in lunarDate:
intercalation = True
lunarDate = lunarDate.replace(INTERCALATION, '')
lunar = dt_util.parse_date(lunarDate)
calendar = KoreanLunarCalendar()
calendar.setLunarDate(lunar.year, lunar.month, lunar.day,
intercalation)
return calendar.getGapJaString()
def update(self):
"""Update the data for the pickup."""
from pyden.exceptions import HTTPError
try:
next_date = parse_date(self._client.next_pickup(self._pickup_type))
self.humanized_pickup = self._humanize_pickup(next_date)
self.raw_date = next_date.strftime('%B %e, %Y')
except HTTPError as exc:
_LOGGER.error('Unable to get next %s pickup date: %s',
self._pickup_type, exc)
def _update(self):
"""Update device state."""
import fedexdeliverymanager
status_counts = defaultdict(int)
for package in fedexdeliverymanager.get_packages(self._session):
status = slugify(package['primary_status'])
skip = status == STATUS_DELIVERED and \
parse_date(package['delivery_date']) < now().date()
if skip:
continue
status_counts[status] += 1
self._attributes = {ATTR_ATTRIBUTION: fedexdeliverymanager.ATTRIBUTION}
self._attributes.update(status_counts)
self._state = sum(status_counts.values())
def date(value) -> date_sys:
"""Validate and transform a date."""
if isinstance(value, date_sys):
return value
try:
date_val = dt_util.parse_date(value)
except TypeError:
raise vol.Invalid('Not a parseable type')
if date_val is None:
raise vol.Invalid("Could not parse date")
return date_val
def date(value: Any) -> date_sys:
"""Validate and transform a date."""
if isinstance(value, date_sys):
return value
try:
date_val = dt_util.parse_date(value)
except TypeError as err:
raise vol.Invalid("Not a parseable type") from err
if date_val is None:
raise vol.Invalid("Could not parse date")
return date_val
def to_datetime(obj):
"""To datetime."""
if isinstance(obj, datetime):
date_obj = (obj.replace(
tzinfo=dt.DEFAULT_TIME_ZONE) if obj.tzinfo is None else obj)
elif isinstance(obj, date):
date_obj = dt.start_of_local_day(
dt.dt.datetime.combine(obj, dt.dt.time.min))
elif "date" in obj:
date_obj = dt.start_of_local_day(
dt.dt.datetime.combine(dt.parse_date(obj["date"]),
dt.dt.time.min))
else:
date_obj = dt.as_local(dt.parse_datetime(obj["dateTime"]))
return dt.as_utc(date_obj)
def __init__(self, hass, deviceId, name, dateStr, lunar, intercalation,
aType, mmdd):
"""Initialize the sensor."""
self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT,
deviceId,
hass=hass)
self._name = name
self._date = dt_util.parse_date(dateStr)
self._lunar = lunar
self._intercalation = intercalation
self._type = aType
self._mmdd = mmdd
self._state = None
self.hass = hass
self._update_internal_state(dt_util.utcnow())
def lunar_to_solar(self, today, thisYear):
lunarDate = self._date
calendar = KoreanLunarCalendar()
if thisYear or self._mmdd:
calendar.setLunarDate(today.year, lunarDate.month, lunarDate.day,
self._intercalation)
if calendar.SolarIsoFormat() == '0000-00-00':
lunarDate2 = lunarDate - timedelta(1)
calendar.setLunarDate(today.year, lunarDate2.month,
lunarDate2.day, self._intercalation)
_LOGGER.warn("Non-existent date correction : %s -> %s",
lunarDate, calendar.SolarIsoFormat())
else:
calendar.setLunarDate(lunarDate.year, lunarDate.month,
lunarDate.day, self._intercalation)
return dt_util.parse_date(calendar.SolarIsoFormat())
def _update(self):
"""Update device state."""
import fedexdeliverymanager
status_counts = defaultdict(int)
for package in fedexdeliverymanager.get_packages(self._session):
status = slugify(package['primary_status'])
skip = status == STATUS_DELIVERED and \
parse_date(package['delivery_date']) < now().date()
if skip:
continue
status_counts[status] += 1
self._attributes = {
ATTR_ATTRIBUTION: fedexdeliverymanager.ATTRIBUTION
}
self._attributes.update(status_counts)
self._state = sum(status_counts.values())
def __init__(self, config: typing.Dict) -> None:
"""Initialize a select input."""
self._config = config
self.editable = True
self._current_datetime = None
initial = config.get(CONF_INITIAL)
if initial:
if self.has_date and self.has_time:
self._current_datetime = dt_util.parse_datetime(initial)
elif self.has_date:
date = dt_util.parse_date(initial)
self._current_datetime = datetime.datetime.combine(
date, DEFAULT_TIME)
else:
time = dt_util.parse_time(initial)
self._current_datetime = datetime.datetime.combine(
DEFAULT_DATE, time)
def lunar_gapja(self, lunarDate):
intercalation = False
if '윤달' in lunarDate:
intercalation = True
lunarDate = lunarDate.replace(INTERCALATION, '')
calendar = KoreanLunarCalendar()
try:
lunar = dt_util.parse_date(lunarDate)
calendar.setLunarDate(lunar.year, lunar.month, lunar.day,
intercalation)
except AttributeError:
try:
calendar.setLunarDate(lunarDate[:4], lunarDate[5:7],
lunarDate[8:], intercalation)
except:
return "-"
return calendar.getGapJaString()
def _update(self):
"""Update device state."""
import upsmychoice
status_counts = defaultdict(int)
try:
for package in upsmychoice.get_packages(self._session):
status = slugify(package['status'])
skip = status == STATUS_DELIVERED and \
parse_date(package['delivery_date']) < now().date()
if skip:
continue
status_counts[status] += 1
except upsmychoice.UPSError:
_LOGGER.error('Could not connect to UPS My Choice account')
self._attributes = {ATTR_ATTRIBUTION: upsmychoice.ATTRIBUTION}
self._attributes.update(status_counts)
self._state = sum(status_counts.values())
async def async_added_to_hass(self):
"""Run when entity about to be added."""
await super().async_added_to_hass()
# Priority 1: Initial value
if self.state is not None:
return
default_value = py_datetime.datetime.today().strftime(
"%Y-%m-%d 00:00:00")
# Priority 2: Old state
old_state = await self.async_get_last_state()
if old_state is None:
self._current_datetime = dt_util.parse_datetime(default_value)
return
if self.has_date and self.has_time:
date_time = dt_util.parse_datetime(old_state.state)
if date_time is None:
current_datetime = dt_util.parse_datetime(default_value)
else:
current_datetime = date_time
elif self.has_date:
date = dt_util.parse_date(old_state.state)
if date is None:
current_datetime = dt_util.parse_datetime(default_value)
else:
current_datetime = py_datetime.datetime.combine(
date, DEFAULT_TIME)
else:
time = dt_util.parse_time(old_state.state)
if time is None:
current_datetime = dt_util.parse_datetime(default_value)
else:
current_datetime = py_datetime.datetime.combine(
py_datetime.date.today(), time)
self._current_datetime = current_datetime.replace(
tzinfo=dt_util.DEFAULT_TIME_ZONE)
def _update(self):
"""Update device state."""
import upsmychoice
status_counts = defaultdict(int)
try:
for package in upsmychoice.get_packages(self._session):
status = slugify(package['status'])
skip = status == STATUS_DELIVERED and \
parse_date(package['delivery_date']) < now().date()
if skip:
continue
status_counts[status] += 1
except upsmychoice.UPSError:
_LOGGER.error('Could not connect to UPS My Choice account')
self._attributes = {
ATTR_ATTRIBUTION: upsmychoice.ATTRIBUTION
}
self._attributes.update(status_counts)
self._state = sum(status_counts.values())
async def async_added_to_hass(self):
"""Run when entity about to be added."""
restore_val = None
# Priority 1: Initial State
if self._initial is not None:
restore_val = self._initial
# Priority 2: Old state
if restore_val is None:
old_state = await async_get_last_state(self.hass, self.entity_id)
if old_state is not None:
restore_val = old_state.state
if restore_val is not None:
if not self.has_date:
self._current_datetime = dt_util.parse_time(restore_val)
elif not self.has_time:
self._current_datetime = dt_util.parse_date(restore_val)
else:
self._current_datetime = dt_util.parse_datetime(restore_val)
async def async_added_to_hass(self):
"""Run when entity about to be added."""
restore_val = None
# Priority 1: Initial State
if self._initial is not None:
restore_val = self._initial
# Priority 2: Old state
if restore_val is None:
old_state = await async_get_last_state(self.hass, self.entity_id)
if old_state is not None:
restore_val = old_state.state
if restore_val is not None:
if not self.has_date:
self._current_datetime = dt_util.parse_time(restore_val)
elif not self.has_time:
self._current_datetime = dt_util.parse_date(restore_val)
else:
self._current_datetime = dt_util.parse_datetime(restore_val)
def _handle_get_logbook(handler, path_match, data):
"""Return logbook entries."""
date_str = path_match.group('date')
if date_str:
start_date = dt_util.parse_date(date_str)
if start_date is None:
handler.write_json_message("Error parsing JSON", HTTP_BAD_REQUEST)
return
start_day = dt_util.start_of_local_day(start_date)
else:
start_day = dt_util.start_of_local_day()
end_day = start_day + timedelta(days=1)
events = recorder.query_events(
QUERY_EVENTS_BETWEEN,
(dt_util.as_utc(start_day), dt_util.as_utc(end_day)))
handler.write_json(humanify(events))
def _handle_get_logbook(handler, path_match, data):
"""Return logbook entries."""
date_str = path_match.group('date')
if date_str:
start_date = dt_util.parse_date(date_str)
if start_date is None:
handler.write_json_message("Error parsing JSON", HTTP_BAD_REQUEST)
return
start_day = dt_util.start_of_local_day(start_date)
else:
start_day = dt_util.start_of_local_day()
end_day = start_day + timedelta(days=1)
events = recorder.query_events(
QUERY_EVENTS_BETWEEN,
(dt_util.as_utc(start_day), dt_util.as_utc(end_day)))
handler.write_json(humanify(events))
def valid_initial(conf):
"""Check the initial value is valid."""
initial = conf.get(CONF_INITIAL)
if not initial:
return conf
if conf[CONF_HAS_DATE] and conf[CONF_HAS_TIME]:
parsed_value = dt_util.parse_datetime(initial)
if parsed_value is not None:
return conf
raise vol.Invalid(f"Initial value '{initial}' can't be parsed as a datetime")
if conf[CONF_HAS_DATE]:
parsed_value = dt_util.parse_date(initial)
if parsed_value is not None:
return conf
raise vol.Invalid(f"Initial value '{initial}' can't be parsed as a date")
parsed_value = dt_util.parse_time(initial)
if parsed_value is not None:
return conf
raise vol.Invalid(f"Initial value '{initial}' can't be parsed as a time")
def _api_history_period(handler, path_match, data):
"""Return history over a period of time."""
date_str = path_match.group('date')
one_day = timedelta(seconds=86400)
if date_str:
start_date = dt_util.parse_date(date_str)
if start_date is None:
handler.write_json_message("Error parsing JSON", HTTP_BAD_REQUEST)
return
start_time = dt_util.as_utc(dt_util.start_of_local_day(start_date))
else:
start_time = dt_util.utcnow() - one_day
end_time = start_time + one_day
entity_id = data.get('filter_entity_id')
handler.write_json(
get_significant_states(start_time, end_time, entity_id).values())
def from_dict(cls, restored: dict[str,
Any]) -> SensorExtraStoredData | None:
"""Initialize a stored sensor state from a dict."""
try:
native_value = restored["native_value"]
native_unit_of_measurement = restored["native_unit_of_measurement"]
except KeyError:
return None
try:
type_ = native_value["__type"]
if type_ == "<class 'datetime.datetime'>":
native_value = dt_util.parse_datetime(
native_value["isoformat"])
elif type_ == "<class 'datetime.date'>":
native_value = dt_util.parse_date(native_value["isoformat"])
except TypeError:
# native_value is not a dict
pass
except KeyError:
# native_value is a dict, but does not have all values
return None
return cls(native_value, native_unit_of_measurement)
def days_until_date(date_string: str, ts: datetime.datetime):
date = dt_util.parse_date(date_string)
diff = date - ts.date()
return diff.days
def expiration_date(self):
"""Return the subscription expiration as a UTC datetime object."""
return datetime.combine(
dt_util.parse_date(self.claims['custom:sub-exp']),
datetime.min.time()).replace(tzinfo=dt_util.UTC)
def expiration_date(self):
"""Return the subscription expiration as a UTC datetime object."""
return datetime.combine(
dt_util.parse_date(self.claims['custom:sub-exp']),
datetime.min.time()).replace(tzinfo=dt_util.UTC)
def _update_internal_state(self, time_date):
shopping_list = load_json(self.hass.config.path(PERSISTENCE),
default=[])
todo_list = {}
tts_add_list = {}
keys = {}
def rename(todo_name):
if todo_name in keys:
keys[todo_name] += 1
return ''.join([todo_name, '(', str(keys[todo_name]), ')'])
else:
keys[todo_name] = 1
return todo_name
for item in shopping_list:
if not item['complete']:
if item['name'].startswith('양') or item['name'].startswith(
'음'):
isLunar = item['name'].startswith('음')
try:
todo_date = item['name'][1:5]
todo_name = item['name'][6:]
solar_date = ''
ldate = ''
intercal = False
adddate = dt_util.parse_date(
str(datetime.now().year) + '-' + todo_date[0:2] +
'-' + todo_date[2:])
if isLunar:
intercal = '(윤)' in todo_name
solar_date = self.lunar_to_solar(adddate, intercal)
ldate = str(adddate.month) + "." + str(adddate.day)
if intercal:
ldate = ldate + INTERCALATION
todo_name = todo_name.replace('(윤)', '')
else:
solar_date = adddate
if solar_date < datetime.now().date():
solar_date = dt_util.parse_date(
str(datetime.now().year + 1) + '-' +
todo_date[0:2] + '-' + todo_date[2:])
if isLunar:
solar_date = self.lunar_to_solar(
solar_date, intercal)
dday = (solar_date - datetime.now().date()).days
sdate = str(solar_date.month) + "." + str(
solar_date.day)
todo_rename = rename(todo_name)
if dday < self._tts_days + 1:
tts_add_list[todo_rename] = dday
if isLunar:
todo_list[todo_rename] = [
dday, sdate, ldate, todo_name
]
else:
todo_list[todo_rename] = [
dday, sdate, "solar", todo_name
]
except:
_LOGGER.warn("Not date : %s", item['name'])
pass
self._attribute = todo_list
tts_add_list.update(TTS)
anniv_list = sorted(tts_add_list.items(), key=(lambda x: x[1]))
msg = ''
for anniv in anniv_list:
name = anniv[0]
value = anniv[1]
if value < self._tts_days + 1:
if todo_list.get(name) is not None:
name = todo_list.get(name)[3]
if msg != '':
msg = msg + ", "
if value == 0:
msg = msg + " ".join(["오늘은", name])
elif value == 1:
msg = msg + " ".join(["내일은", name])
else:
msg = msg + " ".join([str(value) + "일 후는", name])
self._state = msg
