github
/
ha-supervisor
mirror of https://github.com/home-assistant/supervisor
1
Fork 0
Code Releases Activity

Fix typos (#704)

This commit is contained in:
Fabian Affolter 2018-09-18 18:17:20 +02:00 committed by GitHub
parent f5845564db
commit c2299ef8da
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
23 changed files with 186 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hassio/__init__.py
View File

@ -1 +1 @@
"""Init file for HassIO."""
"""Init file for Hass.io."""

10
hassio/__main__.py
View File

@ -1,4 +1,4 @@
"""Main file for HassIO."""
"""Main file for Hass.io."""
import asyncio
from concurrent.futures import ThreadPoolExecutor
import logging
@ -31,7 +31,7 @@ if __name__ == "__main__":
executor = ThreadPoolExecutor(thread_name_prefix="SyncWorker")
loop.set_default_executor(executor)
_LOGGER.info("Initialize Hassio setup")
_LOGGER.info("Initialize Hass.io setup")
coresys = bootstrap.initialize_coresys(loop)
bootstrap.migrate_system_env(coresys)
@ -43,13 +43,13 @@ if __name__ == "__main__":
loop.call_soon_threadsafe(bootstrap.reg_signal, loop)
try:
_LOGGER.info("Run HassIO")
_LOGGER.info("Run Hass.io")
loop.run_forever()
finally:
_LOGGER.info("Stopping HassIO")
_LOGGER.info("Stopping Hass.io")
loop.run_until_complete(coresys.core.stop())
executor.shutdown(wait=False)
loop.close()
_LOGGER.info("Close Hassio")
_LOGGER.info("Close Hass.io")
sys.exit(0)

34
hassio/bootstrap.py
View File

@ -1,4 +1,4 @@
"""Bootstrap HassIO."""
"""Bootstrap Hass.io."""
import logging
import os
import signal
@ -62,55 +62,55 @@ def initialize_coresys(loop):
def initialize_system_data(coresys):
"""Setup default config and create folders."""
"""Set up the default configuration and create folders."""
config = coresys.config
# homeassistant config folder
# Home Assistant configuration folder
if not config.path_homeassistant.is_dir():
_LOGGER.info(
"Create Home-Assistant config folder %s",
"Create Home Assistant configuration folder %s",
config.path_homeassistant)
config.path_homeassistant.mkdir()
# hassio ssl folder
if not config.path_ssl.is_dir():
_LOGGER.info("Create hassio ssl folder %s", config.path_ssl)
_LOGGER.info("Create Hass.io SSL/TLS folder %s", config.path_ssl)
config.path_ssl.mkdir()
# hassio addon data folder
if not config.path_addons_data.is_dir():
_LOGGER.info(
"Create hassio addon data folder %s", config.path_addons_data)
"Create Hass.io Add-on data folder %s", config.path_addons_data)
config.path_addons_data.mkdir(parents=True)
if not config.path_addons_local.is_dir():
_LOGGER.info("Create hassio addon local repository folder %s",
_LOGGER.info("Create Hass.io Add-on local repository folder %s",
config.path_addons_local)
config.path_addons_local.mkdir(parents=True)
if not config.path_addons_git.is_dir():
_LOGGER.info("Create hassio addon git repositories folder %s",
_LOGGER.info("Create Hass.io Add-on git repositories folder %s",
config.path_addons_git)
config.path_addons_git.mkdir(parents=True)
# hassio tmp folder
if not config.path_tmp.is_dir():
_LOGGER.info("Create hassio temp folder %s", config.path_tmp)
_LOGGER.info("Create Hass.io temp folder %s", config.path_tmp)
config.path_tmp.mkdir(parents=True)
# hassio backup folder
if not config.path_backup.is_dir():
_LOGGER.info("Create hassio backup folder %s", config.path_backup)
_LOGGER.info("Create Hass.io backup folder %s", config.path_backup)
config.path_backup.mkdir()
# share folder
if not config.path_share.is_dir():
_LOGGER.info("Create hassio share folder %s", config.path_share)
_LOGGER.info("Create Hass.io share folder %s", config.path_share)
config.path_share.mkdir()
# apparmor folder
if not config.path_apparmor.is_dir():
_LOGGER.info("Create hassio apparmor folder %s", config.path_apparmor)
_LOGGER.info("Create Hass.io Apparmor folder %s", config.path_apparmor)
config.path_apparmor.mkdir()
return config
@ -126,7 +126,7 @@ def migrate_system_env(coresys):
try:
old_build.rmdir()
except OSError:
_LOGGER.warning("Can't cleanup old addons build dir.")
_LOGGER.warning("Can't cleanup old Add-on build directory")
def initialize_logging():
@ -166,24 +166,24 @@ def check_environment():
# check docker socket
if not SOCKET_DOCKER.is_socket():
_LOGGER.fatal("Can't find docker socket!")
_LOGGER.fatal("Can't find Docker socket!")
return False
# check socat exec
if not shutil.which('socat'):
_LOGGER.fatal("Can't find socat program!")
_LOGGER.fatal("Can't find socat!")
return False
# check socat exec
if not shutil.which('gdbus'):
_LOGGER.fatal("Can't find gdbus program!")
_LOGGER.fatal("Can't find gdbus!")
return False
return True
def reg_signal(loop):
"""Register SIGTERM, SIGKILL to stop system."""
"""Register SIGTERM and SIGKILL to stop system."""
try:
loop.add_signal_handler(
signal.SIGTERM, lambda: loop.call_soon(loop.stop))

38
hassio/config.py
View File

@ -1,4 +1,4 @@
"""Bootstrap HassIO."""
"""Bootstrap Hass.io."""
from datetime import datetime
import logging
import os
@ -16,7 +16,7 @@ from .validate import SCHEMA_HASSIO_CONFIG
_LOGGER = logging.getLogger(__name__)
HOMEASSISTANT_CONFIG = PurePath("homeassistant")
HOMEASSISTANT_CONFIG = PurePath('homeassistant')
HASSIO_SSL = PurePath("ssl")
@ -56,7 +56,7 @@ class CoreConfig(JsonConfig):
timezone = data.group('timezone')
pytz.timezone(timezone)
except (pytz.exceptions.UnknownTimeZoneError, OSError, AssertionError):
_LOGGER.debug("Can't parse HomeAssistant timezone")
_LOGGER.debug("Can't parse Home Assistant timezone")
return self._data[ATTR_TIMEZONE]
return timezone
@ -93,17 +93,17 @@ class CoreConfig(JsonConfig):
@property
def path_hassio(self):
"""Return hassio data path."""
"""Return Hass.io data path."""
return HASSIO_DATA
@property
def path_extern_hassio(self):
"""Return hassio data path extern for docker."""
"""Return Hass.io data path external for Docker."""
return PurePath(os.environ['SUPERVISOR_SHARE'])
@property
def path_extern_homeassistant(self):
"""Return config path extern for docker."""
"""Return config path external for Docker."""
return str(PurePath(self.path_extern_hassio, HOMEASSISTANT_CONFIG))
@property
@ -113,7 +113,7 @@ class CoreConfig(JsonConfig):
@property
def path_extern_ssl(self):
"""Return SSL path extern for docker."""
"""Return SSL path external for Docker."""
return str(PurePath(self.path_extern_hassio, HASSIO_SSL))
@property
@ -123,42 +123,42 @@ class CoreConfig(JsonConfig):
@property
def path_addons_core(self):
"""Return git path for core addons."""
"""Return git path for core Add-ons."""
return Path(HASSIO_DATA, ADDONS_CORE)
@property
def path_addons_git(self):
"""Return path for git addons."""
"""Return path for Git Add-on."""
return Path(HASSIO_DATA, ADDONS_GIT)
@property
def path_addons_local(self):
"""Return path for customs addons."""
"""Return path for custom Add-ons."""
return Path(HASSIO_DATA, ADDONS_LOCAL)
@property
def path_extern_addons_local(self):
"""Return path for customs addons."""
"""Return path for custom Add-ons."""
return PurePath(self.path_extern_hassio, ADDONS_LOCAL)
@property
def path_addons_data(self):
"""Return root addon data folder."""
"""Return root Add-on data folder."""
return Path(HASSIO_DATA, ADDONS_DATA)
@property
def path_extern_addons_data(self):
"""Return root addon data folder extern for docker."""
"""Return root add-on data folder external for Docker."""
return PurePath(self.path_extern_hassio, ADDONS_DATA)
@property
def path_tmp(self):
"""Return hass.io temp folder."""
"""Return Hass.io temp folder."""
return Path(HASSIO_DATA, TMP_DATA)
@property
def path_extern_tmp(self):
"""Return hass.io temp folder for docker."""
"""Return Hass.io temp folder for Docker."""
return PurePath(self.path_extern_hassio, TMP_DATA)
@property
@ -168,7 +168,7 @@ class CoreConfig(JsonConfig):
@property
def path_extern_backup(self):
"""Return root backup data folder extern for docker."""
"""Return root backup data folder external for Docker."""
return PurePath(self.path_extern_hassio, BACKUP_DATA)
@property
@ -178,17 +178,17 @@ class CoreConfig(JsonConfig):
@property
def path_apparmor(self):
"""Return root apparmor profile folder."""
"""Return root Apparmor profile folder."""
return Path(HASSIO_DATA, APPARMOR_DATA)
@property
def path_extern_share(self):
"""Return root share data folder extern for docker."""
"""Return root share data folder external for Docker."""
return PurePath(self.path_extern_hassio, SHARE_DATA)
@property
def addons_repositories(self):
"""Return list of addons custom repositories."""
"""Return list of custom Add-on repositories."""
return self._data[ATTR_ADDONS_CUSTOM_LIST]
def add_addon_repository(self, repo):

2
hassio/const.py
View File

@ -1,4 +1,4 @@
"""Const file for HassIO."""
"""Constants file for Hass.io."""
from pathlib import Path
from ipaddress import ip_network

8
hassio/core.py
View File

@ -1,4 +1,4 @@
"""Main file for HassIO."""
"""Main file for Hass.io."""
from contextlib import suppress
import asyncio
import logging
@ -14,10 +14,10 @@ _LOGGER = logging.getLogger(__name__)
class HassIO(CoreSysAttributes):
"""Main object of hassio."""
"""Main object of Hass.io."""
def __init__(self, coresys):
"""Initialize hassio object."""
"""Initialize Hass.io object."""
self.coresys = coresys
async def setup(self):
@ -56,7 +56,7 @@ class HassIO(CoreSysAttributes):
self.sys_create_task(self.sys_dns.start())
async def start(self):
"""Start HassIO orchestration."""
"""Start Hass.io orchestration."""
# on release channel, try update itself
# on dev mode, only read new versions
if not self.sys_dev and self.sys_supervisor.need_update:

15
hassio/coresys.py
View File

@ -1,5 +1,4 @@
"""Handle core shared data."""
import aiohttp
from .const import CHANNEL_DEV
@ -49,21 +48,21 @@ class CoreSys:
@property
def arch(self):
"""Return running arch of hass.io system."""
"""Return running arch of the Hass.io system."""
if self._supervisor:
return self._supervisor.arch
return None
@property
def machine(self):
"""Return running machine type of hass.io system."""
"""Return running machine type of the Hass.io system."""
if self._homeassistant:
return self._homeassistant.machine
return None
@property
def dev(self):
"""Return True if we run dev modus."""
"""Return True if we run dev mode."""
return self._updater.channel == CHANNEL_DEV
@property
@ -118,21 +117,21 @@ class CoreSys:
@core.setter
def core(self, value):
"""Set a HassIO object."""
"""Set a Hass.io object."""
if self._core:
raise RuntimeError("HassIO already set!")
raise RuntimeError("Hass.io already set!")
self._core = value
@property
def homeassistant(self):
"""Return HomeAssistant object."""
"""Return Home Assistant object."""
return self._homeassistant
@homeassistant.setter
def homeassistant(self, value):
"""Set a HomeAssistant object."""
if self._homeassistant:
raise RuntimeError("HomeAssistant already set!")
raise RuntimeError("Home Assistant already set!")
self._homeassistant = value
@property

14
hassio/dbus/__init__.py
View File

@ -1,4 +1,4 @@
"""DBus interface objects."""
"""D-Bus interface objects."""
from .systemd import Systemd
from .hostname import Hostname
@ -7,10 +7,10 @@ from ..coresys import CoreSysAttributes
class DBusManager(CoreSysAttributes):
"""DBus Interface handler."""
"""A DBus Interface handler."""
def __init__(self, coresys):
"""Initialize DBus Interface."""
"""Initialize D-Bus interface."""
self.coresys = coresys
self._systemd = Systemd()
@ -19,21 +19,21 @@ class DBusManager(CoreSysAttributes):
@property
def systemd(self):
"""Return Systemd Interface."""
"""Return the systemd interface."""
return self._systemd
@property
def hostname(self):
"""Return hostname Interface."""
"""Return the hostname interface."""
return self._hostname
@property
def rauc(self):
"""Return rauc Interface."""
"""Return the rauc interface."""
return self._rauc
async def load(self):
"""Connect interfaces to dbus."""
"""Connect interfaces to D-Bus."""
await self.systemd.connect()
await self.hostname.connect()
await self.rauc.connect()

6
hassio/dbus/hostname.py
View File

@ -1,4 +1,4 @@
"""DBus interface for hostname."""
"""D-Bus interface for hostname."""
import logging
from .interface import DBusInterface
@ -13,10 +13,10 @@ DBUS_OBJECT = '/org/freedesktop/hostname1'
class Hostname(DBusInterface):
"""Handle DBus interface for hostname/system."""
"""Handle D-Bus interface for hostname/system."""
async def connect(self):
"""Connect do bus."""
"""Connect to system's D-Bus."""
try:
self.dbus = await DBus.connect(DBUS_NAME, DBUS_OBJECT)
except DBusError:

8
hassio/dbus/interface.py
View File

@ -1,8 +1,8 @@
"""Interface class for dbus wrappers."""
"""Interface class for D-Bus wrappers."""
class DBusInterface:
"""Handle DBus interface for hostname/system."""
"""Handle D-Bus interface for hostname/system."""
def __init__(self):
"""Initialize systemd."""
@ -10,9 +10,9 @@ class DBusInterface:
@property
def is_connected(self):
"""Return True, if they is connected to dbus."""
"""Return True, if they is connected to D-Bus."""
return self.dbus is not None
async def connect(self):
"""Connect do bus."""
"""Connect to D-Bus."""
raise NotImplementedError()

6
hassio/dbus/rauc.py
View File

@ -1,4 +1,4 @@
"""DBus interface for rauc."""
"""D-Bus interface for rauc."""
import logging
from .interface import DBusInterface
@ -13,10 +13,10 @@ DBUS_OBJECT = '/'
class Rauc(DBusInterface):
"""Handle DBus interface for rauc."""
"""Handle D-Bus interface for rauc."""
async def connect(self):
"""Connect do bus."""
"""Connect to D-Bus."""
try:
self.dbus = await DBus.connect(DBUS_NAME, DBUS_OBJECT)
except DBusError:

2
hassio/dbus/systemd.py
View File

@ -1,4 +1,4 @@
"""Interface to Systemd over dbus."""
"""Interface to Systemd over D-Bus."""
import logging
from .interface import DBusInterface

6
hassio/dbus/utils.py
View File

@ -1,12 +1,12 @@
"""Utils for dbus."""
"""Utils for D-Bus."""
from ..exceptions import DBusNotConnectedError
def dbus_connected(method):
"""Wrapper for check if dbus is connected."""
"""Wrapper for check if D-Bus is connected."""
def wrap_dbus(api, *args, **kwargs):
"""Check if dbus is connected before call a method."""
"""Check if D-Bus is connected before call a method."""
if api.dbus is None:
raise DBusNotConnectedError()
return method(api, *args, **kwargs)

8
hassio/hassos.py
View File

@ -68,7 +68,7 @@ class HassOS(CoreSysAttributes):
def _check_host(self):
"""Check if HassOS is availabe."""
if not self.available:
_LOGGER.error("No HassOS availabe")
_LOGGER.error("No HassOS available")
raise HassOSNotSupportedError()
async def _download_raucb(self, version):
@ -97,7 +97,7 @@ class HassOS(CoreSysAttributes):
_LOGGER.warning("Can't fetch versions from %s: %s", url, err)
except OSError as err:
_LOGGER.error("Can't write ota file: %s", err)
_LOGGER.error("Can't write OTA file: %s", err)
raise HassOSUpdateError()
@ -131,7 +131,7 @@ class HassOS(CoreSysAttributes):
"""
self._check_host()
_LOGGER.info("Sync config from USB on HassOS.")
_LOGGER.info("Syncing configuration from USB with HassOS.")
return self.sys_host.services.restart('hassos-config.service')
async def update(self, version=None):
@ -182,5 +182,5 @@ class HassOS(CoreSysAttributes):
if await self.instance.update(version):
return
_LOGGER.error("HassOS CLI update fails.")
_LOGGER.error("HassOS CLI update fails")
raise HassOSUpdateError()

117
hassio/homeassistant.py
View File

@ -1,4 +1,4 @@
"""HomeAssistant control object."""
"""Home Assistant control object."""
import asyncio
from contextlib import asynccontextmanager, suppress
from datetime import datetime, timedelta
@ -36,10 +36,10 @@ ConfigResult = attr.make_class('ConfigResult', ['valid', 'log'], frozen=True)
class HomeAssistant(JsonConfig, CoreSysAttributes):
"""Hass core object for handle it."""
"""Home Assistant core object for handle it."""
def __init__(self, coresys):
"""Initialize hass object."""
"""Initialize Home Assistant object."""
super().__init__(FILE_HASSIO_HOMEASSISTANT, SCHEMA_HASS_CONFIG)
self.coresys = coresys
self.instance = DockerHomeAssistant(coresys)
@ -50,16 +50,16 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
self._access_token_expires = None
async def load(self):
"""Prepare HomeAssistant object."""
"""Prepare Home Assistant object."""
if await self.instance.attach():
return
_LOGGER.info("No HomeAssistant docker %s found.", self.image)
_LOGGER.info("No Home Assistant Docker image %s found.", self.image)
await self.install_landingpage()
@property
def machine(self):
"""Return System Machines."""
"""Return the system machines."""
return self.instance.machine
@property
@ -69,81 +69,81 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
@property
def api_ip(self):
"""Return IP of HomeAssistant instance."""
"""Return IP of Home Assistant instance."""
return self.sys_docker.network.gateway
@property
def api_port(self):
"""Return network port to home-assistant instance."""
"""Return network port to Home Assistant instance."""
return self._data[ATTR_PORT]
@api_port.setter
def api_port(self, value):
"""Set network port for home-assistant instance."""
"""Set network port for Home Assistant instance."""
self._data[ATTR_PORT] = value
@property
def api_password(self):
"""Return password for home-assistant instance."""
"""Return password for Home Assistant instance."""
return self._data.get(ATTR_PASSWORD)
@api_password.setter
def api_password(self, value):
"""Set password for home-assistant instance."""
"""Set password for Home Assistant instance."""
self._data[ATTR_PASSWORD] = value
@property
def api_ssl(self):
"""Return if we need ssl to home-assistant instance."""
"""Return if we need ssl to Home Assistant instance."""
return self._data[ATTR_SSL]
@api_ssl.setter
def api_ssl(self, value):
"""Set SSL for home-assistant instance."""
"""Set SSL for Home Assistant instance."""
self._data[ATTR_SSL] = value
@property
def api_url(self):
"""Return API url to Home-Assistant."""
"""Return API url to Home Assistant."""
return "{}://{}:{}".format(
'https' if self.api_ssl else 'http', self.api_ip, self.api_port
)
@property
def watchdog(self):
"""Return True if the watchdog should protect Home-Assistant."""
"""Return True if the watchdog should protect Home Assistant."""
return self._data[ATTR_WATCHDOG]
@watchdog.setter
def watchdog(self, value):
"""Return True if the watchdog should protect Home-Assistant."""
"""Return True if the watchdog should protect Home Assistant."""
self._data[ATTR_WATCHDOG] = value
@property
def wait_boot(self):
"""Return time to wait for Home-Assistant startup."""
"""Return time to wait for Home Assistant startup."""
return self._data[ATTR_WAIT_BOOT]
@wait_boot.setter
def wait_boot(self, value):
"""Set time to wait for Home-Assistant startup."""
"""Set time to wait for Home Assistant startup."""
self._data[ATTR_WAIT_BOOT] = value
@property
def version(self):
"""Return version of running homeassistant."""
"""Return version of running Home Assistant."""
return self.instance.version
@property
def last_version(self):
"""Return last available version of homeassistant."""
"""Return last available version of Home Assistant."""
if self.is_custom_image:
return self._data.get(ATTR_LAST_VERSION)
return self.sys_updater.version_homeassistant
@last_version.setter
def last_version(self, value):
"""Set last available version of homeassistant."""
"""Set last available version of Home Assistant."""
if value:
self._data[ATTR_LAST_VERSION] = value
else:
@ -151,14 +151,14 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
@property
def image(self):
"""Return image name of hass containter."""
"""Return image name of the Home Assistant container."""
if self._data.get(ATTR_IMAGE):
return self._data[ATTR_IMAGE]
return os.environ['HOMEASSISTANT_REPOSITORY']
@image.setter
def image(self, value):
"""Set image name of hass containter."""
"""Set image name of Home Assistant container."""
if value:
self._data[ATTR_IMAGE] = value
else:
@ -172,27 +172,27 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
@property
def boot(self):
"""Return True if home-assistant boot is enabled."""
"""Return True if Home Assistant boot is enabled."""
return self._data[ATTR_BOOT]
@boot.setter
def boot(self, value):
"""Set home-assistant boot options."""
"""Set Home Assistant boot options."""
self._data[ATTR_BOOT] = value
@property
def uuid(self):
"""Return a UUID of this HomeAssistant."""
"""Return a UUID of this Home Assistant instance."""
return self._data[ATTR_UUID]
@property
def hassio_token(self):
"""Return a access token for Hass.io API."""
"""Return a access token for the Hass.io API."""
return self._data.get(ATTR_ACCESS_TOKEN)
@property
def refresh_token(self):
"""Return the refresh token to authenticate with HomeAssistant."""
"""Return the refresh token to authenticate with Home Assistant."""
return self._data.get(ATTR_REFRESH_TOKEN)
@refresh_token.setter
@ -202,7 +202,7 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
@process_lock
async def install_landingpage(self):
"""Install a landingpage."""
"""Install a landing page."""
_LOGGER.info("Setup HomeAssistant landingpage")
while True:
if await self.instance.install('landingpage'):
@ -211,16 +211,16 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
await asyncio.sleep(60)
# Run landingpage after installation
_LOGGER.info("Start landingpage")
_LOGGER.info("Start landing page")
try:
await self._start()
except HomeAssistantError:
_LOGGER.warning("Can't start landingpage")
_LOGGER.warning("Can't start landing page")
@process_lock
async def install(self):
"""Install a landingpage."""
_LOGGER.info("Setup HomeAssistant")
"""Install a landing page."""
_LOGGER.info("Setup Home Assistant")
while True:
# read homeassistant tag and install it
if not self.last_version:
@ -229,18 +229,18 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
tag = self.last_version
if tag and await self.instance.install(tag):
break
_LOGGER.warning("Error on install HomeAssistant. Retry in 60sec")
_LOGGER.warning("Error on install Home Assistant. Retry in 60sec")
await asyncio.sleep(60)
# finishing
_LOGGER.info("HomeAssistant docker now installed")
_LOGGER.info("Home Assistant docker now installed")
try:
if not self.boot:
return
_LOGGER.info("Start HomeAssistant")
_LOGGER.info("Start Home Assistant")
await self._start()
except HomeAssistantError:
_LOGGER.error("Can't start HomeAssistant!")
_LOGGER.error("Can't start Home Assistant!")
finally:
await self.instance.cleanup()
@ -260,13 +260,13 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
async def _update(to_version):
"""Run Home Assistant update."""
try:
_LOGGER.info("Update HomeAssistant to version %s", to_version)
_LOGGER.info("Update Home Assistant to version %s", to_version)
if not await self.instance.update(to_version):
raise HomeAssistantUpdateError()
finally:
if running:
await self._start()
_LOGGER.info("Successfull run HomeAssistant %s", to_version)
_LOGGER.info("Successful run Home Assistant %s", to_version)
# Update Home Assistant
with suppress(HomeAssistantError):
@ -281,9 +281,9 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
raise HomeAssistantUpdateError()
async def _start(self):
"""Start HomeAssistant docker & wait."""
"""Start Home Assistant Docker & wait."""
if await self.instance.is_running():
_LOGGER.warning("HomeAssistant allready running!")
_LOGGER.warning("Home Assistant is already running!")
return
# Create new API token
@ -296,7 +296,7 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
@process_lock
def start(self):
"""Run HomeAssistant docker.
"""Run Home Assistant docker.
Return a coroutine.
"""
@ -304,7 +304,7 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
@process_lock
def stop(self):
"""Stop HomeAssistant docker.
"""Stop Home Assistant Docker.
Return a coroutine.
"""
@ -312,7 +312,7 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
@process_lock
async def restart(self):
"""Restart HomeAssistant docker."""
"""Restart Home Assistant Docker."""
await self.instance.stop()
await self._start()
@ -324,21 +324,21 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
return self.instance.logs()
def stats(self):
"""Return stats of HomeAssistant.
"""Return stats of Home Assistant.
Return a coroutine.
"""
return self.instance.stats()
def is_running(self):
"""Return True if docker container is running.
"""Return True if Docker container is running.
Return a coroutine.
"""
return self.instance.is_running()
def is_initialize(self):
"""Return True if a docker container is exists.
"""Return True if a Docker container is exists.
Return a coroutine.
"""
@ -350,7 +350,7 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
return self.instance.in_progress or self.lock.locked()
async def check_config(self):
"""Run homeassistant config check."""
"""Run Home Assistant config check."""
result = await self.instance.execute_command(
"python3 -m homeassistant -c /config --script check_config"
)
@ -381,10 +381,10 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
}
) as resp:
if resp.status != 200:
_LOGGER.error("Can't update HomeAssistant access token!")
_LOGGER.error("Can't update Home Assistant access token!")
raise HomeAssistantAuthError()
_LOGGER.info("Updated HomeAssistant API token")
_LOGGER.info("Updated Home Assistant API token")
tokens = await resp.json()
self.access_token = tokens['access_token']
self._access_token_expires = \
@ -429,14 +429,14 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
raise HomeAssistantAPIError()
async def check_api_state(self):
"""Return True if Home-Assistant up and running."""
"""Return True if Home Assistant up and running."""
with suppress(HomeAssistantAPIError):
async with self.make_request('get', 'api/') as resp:
if resp.status in (200, 201):
return True
err = resp.status
_LOGGER.warning("Home-Assistant API config missmatch: %d", err)
_LOGGER.warning("Home Assistant API config mismatch: %d", err)
return False
async def send_event(self, event_type, event_data=None):
@ -449,7 +449,7 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
return
err = resp.status
_LOGGER.warning("HomeAssistant event %s fails: %s", event_type, err)
_LOGGER.warning("Home Assistant event %s fails: %s", event_type, err)
return HomeAssistantError()
async def _block_till_run(self):
@ -479,13 +479,13 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
# 1
# Check if Container is is_running
if not await self.instance.is_running():
_LOGGER.error("HomeAssistant is crashed!")
_LOGGER.error("Home Assistant has crashed!")
break
# 2
# Check if API response
if await self.sys_run_in_executor(check_port):
_LOGGER.info("Detect a running HomeAssistant instance")
_LOGGER.info("Detect a running Home Assistant instance")
self._error_state = False
return
@ -494,17 +494,18 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
if migration_file.exists():
if not migration_progress:
migration_progress = True
_LOGGER.info("HomeAssistant record migration in progress")
_LOGGER.info("Home Assistant record migration in progress")
continue
elif migration_progress:
migration_progress = False # Reset start time
start_time = time.monotonic()
_LOGGER.info("HomeAssistant record migration done")
_LOGGER.info("Home Assistant record migration done")
# 4
# Timeout
if time.monotonic() - start_time > self.wait_boot:
_LOGGER.warning("Don't wait anymore of HomeAssistant startup!")
_LOGGER.warning(
"Don't wait anymore of Home Assistant startup!")
break
self._error_state = True

22
hassio/supervisor.py
View File

@ -1,4 +1,4 @@
"""HomeAssistant control object."""
"""Home Assistant control object."""
import asyncio
import logging
from pathlib import Path
@ -15,7 +15,7 @@ _LOGGER = logging.getLogger(__name__)
class Supervisor(CoreSysAttributes):
"""Hass core object for handle it."""
"""Home Assistant core object for handle it."""
def __init__(self, coresys):
"""Initialize hass object."""
@ -23,9 +23,9 @@ class Supervisor(CoreSysAttributes):
self.instance = DockerSupervisor(coresys)
async def load(self):
"""Prepare HomeAssistant object."""
"""Prepare Home Assistant object."""
if not await self.instance.attach():
_LOGGER.fatal("Can't setup supervisor docker container!")
_LOGGER.fatal("Can't setup Supervisor Docker container!")
await self.instance.cleanup()
@property
@ -35,22 +35,22 @@ class Supervisor(CoreSysAttributes):
@property
def version(self):
"""Return version of running homeassistant."""
"""Return version of running Home Assistant."""
return self.instance.version
@property
def last_version(self):
"""Return last available version of homeassistant."""
"""Return last available version of Home Assistant."""
return self.sys_updater.version_hassio
@property
def image(self):
"""Return image name of hass containter."""
"""Return image name of Home Assistant container."""
return self.instance.image
@property
def arch(self):
"""Return arch of hass.io containter."""
"""Return arch of the Hass.io container."""
return self.instance.arch
async def update_apparmor(self):
@ -79,20 +79,20 @@ class Supervisor(CoreSysAttributes):
_LOGGER.error("Can't update AppArmor profile!")
async def update(self, version=None):
"""Update HomeAssistant version."""
"""Update Home Assistant version."""
version = version or self.last_version
if version == self.sys_supervisor.version:
_LOGGER.warning("Version %s is already installed", version)
return
_LOGGER.info("Update supervisor to version %s", version)
_LOGGER.info("Update Supervisor to version %s", version)
if await self.instance.install(version):
await self.update_apparmor()
self.sys_loop.call_later(1, self.sys_loop.stop)
return True
_LOGGER.error("Update of hass.io fails!")
_LOGGER.error("Update of Hass.io fails!")
return False
@property

26
hassio/tasks.py
View File

@ -1,4 +1,4 @@
"""Multible tasks."""
"""A collection of tasks."""
import asyncio
import logging
@ -22,7 +22,7 @@ RUN_WATCHDOG_HOMEASSISTANT_API = 300
class Tasks(CoreSysAttributes):
"""Handle Tasks inside HassIO."""
"""Handle Tasks inside Hass.io."""
def __init__(self, coresys):
"""Initialize Tasks."""
@ -58,7 +58,7 @@ class Tasks(CoreSysAttributes):
_LOGGER.info("All core tasks are scheduled")
async def _update_addons(self):
"""Check if an update is available for an addon and update it."""
"""Check if an update is available for an Add-on and update it."""
tasks = []
for addon in self.sys_addons.list_addons:
if not addon.is_installed or not addon.auto_update:
@ -71,14 +71,14 @@ class Tasks(CoreSysAttributes):
tasks.append(addon.update())
else:
_LOGGER.warning(
"Addon %s will be ignore, schema tests fails", addon.slug)
"Add-on %s will be ignore, schema tests fails", addon.slug)
if tasks:
_LOGGER.info("Addon auto update process %d tasks", len(tasks))
_LOGGER.info("Add-on auto update process %d tasks", len(tasks))
await asyncio.wait(tasks)
async def _update_supervisor(self):
"""Check and run update of supervisor hassio."""
"""Check and run update of Supervisor Hass.io."""
if not self.sys_supervisor.need_update:
return
@ -91,23 +91,23 @@ class Tasks(CoreSysAttributes):
await self.sys_supervisor.update()
async def _watchdog_homeassistant_docker(self):
"""Check running state of docker and start if they is close."""
# if Home-Assistant is active
"""Check running state of Docker and start if they is close."""
# if Home Assistant is active
if not await self.sys_homeassistant.is_initialize() or \
not self.sys_homeassistant.watchdog or \
self.sys_homeassistant.error_state:
return
# if Home-Assistant is running
# if Home Assistant is running
if self.sys_homeassistant.in_progress or \
await self.sys_homeassistant.is_running():
return
_LOGGER.warning("Watchdog found a problem with Home-Assistant docker!")
_LOGGER.warning("Watchdog found a problem with Home Assistant Docker!")
await self.sys_homeassistant.start()
async def _watchdog_homeassistant_api(self):
"""Create scheduler task for montoring running state of API.
"""Create scheduler task for monitoring running state of API.
Try 2 times to call API before we restart Home-Assistant. Maybe we had
a delay in our system.
@ -130,10 +130,10 @@ class Tasks(CoreSysAttributes):
retry_scan += 1
if retry_scan == 1:
self._cache[HASS_WATCHDOG_API] = retry_scan
_LOGGER.warning("Watchdog miss API response from Home-Assistant")
_LOGGER.warning("Watchdog miss API response from Home Assistant")
return
_LOGGER.error("Watchdog found a problem with Home-Assistant API!")
_LOGGER.error("Watchdog found a problem with Home Assistant API!")
try:
await self.sys_homeassistant.restart()
finally:

12
hassio/updater.py
View File

@ -39,27 +39,27 @@ class Updater(JsonConfig, CoreSysAttributes):
@property
def version_homeassistant(self):
"""Return last version of homeassistant."""
"""Return last version of Home Assistant."""
return self._data.get(ATTR_HOMEASSISTANT)
@property
def version_hassio(self):
"""Return last version of hassio."""
"""Return last version of Hass.io."""
return self._data.get(ATTR_HASSIO)
@property
def version_hassos(self):
"""Return last version of hassos."""
"""Return last version of HassOS."""
return self._data.get(ATTR_HASSOS)
@property
def version_hassos_cli(self):
"""Return last version of hassos cli."""
"""Return last version of HassOS cli."""
return self._data.get(ATTR_HASSOS_CLI)
@property
def channel(self):
"""Return upstream channel of hassio instance."""
"""Return upstream channel of Hass.io instance."""
return self._data[ATTR_CHANNEL]
@channel.setter
@ -69,7 +69,7 @@ class Updater(JsonConfig, CoreSysAttributes):
@AsyncThrottle(timedelta(seconds=60))
async def fetch_data(self):
"""Fetch current versions from github.
"""Fetch current versions from Github.
Is a coroutine.
"""

5
hassio/utils/__init__.py
View File

@ -1,4 +1,4 @@
"""Tools file for HassIO."""
"""Tools file for Hass.io."""
from datetime import datetime
import hashlib
import logging
@ -25,7 +25,8 @@ def process_lock(method):
"""Return api wrapper."""
if api.lock.locked():
_LOGGER.error(
"Can't excute %s while a task is in progress", method.__name__)
"Can't execute %s while a task is in progress",
method.__name__)
return False
async with api.lock:

4
hassio/utils/apparmor.py
View File

@ -1,4 +1,4 @@
"""Some functions around apparmor profiles."""
"""Some functions around AppArmor profiles."""
import logging
import re
@ -21,7 +21,7 @@ def get_profile_name(profile_file):
continue
profiles.add(match.group(1))
except OSError as err:
_LOGGER.error("Can't read apparmor profile: %s", err)
_LOGGER.error("Can't read AppArmor profile: %s", err)
raise AppArmorFileError()
if len(profiles) != 1:

4
hassio/utils/dt.py
View File

@ -1,4 +1,4 @@
"""Tools file for HassIO."""
"""Tools file for Hass.io."""
from datetime import datetime, timedelta, timezone
import logging
import re
@ -58,5 +58,5 @@ def parse_datetime(dt_str):
def utcnow():
"""Returns current timestamp including timezone."""
"""Return the current timestamp including timezone."""
return datetime.now(UTC)

15
hassio/utils/json.py
View File

@ -1,4 +1,4 @@
"""Tools file for HassIO."""
"""Tools file for Hass.io."""
import json
import logging
@ -9,14 +9,14 @@ _LOGGER = logging.getLogger(__name__)
def write_json_file(jsonfile, data):
"""Write a json file."""
"""Write a JSON file."""
json_str = json.dumps(data, indent=2)
with jsonfile.open('w') as conf_file:
conf_file.write(json_str)
def read_json_file(jsonfile):
"""Read a json file and return a dict."""
"""Read a JSON file and return a dict."""
with jsonfile.open('r') as cfile:
return json.loads(cfile.read())
@ -33,7 +33,7 @@ class JsonConfig:
self.read_data()
def reset_data(self):
"""Reset json file to default."""
"""Reset JSON file to default."""
try:
self._data = self._schema({})
except vol.Invalid as ex:
@ -41,7 +41,7 @@ class JsonConfig:
self._file, humanize_error(self._data, ex))
def read_data(self):
"""Read json file & validate."""
"""Read JSON file & validate."""
if self._file.is_file():
try:
self._data = read_json_file(self._file)
@ -61,7 +61,7 @@ class JsonConfig:
self._data = self._schema({})
def save_data(self):
"""Store data to config file."""
"""Store data to configuration file."""
# Validate
try:
self._data = self._schema(self._data)
@ -78,4 +78,5 @@ class JsonConfig:
try:
write_json_file(self._file, self._data)
except (OSError, json.JSONDecodeError) as err:
_LOGGER.error("Can't store config in %s: %s", self._file, err)
_LOGGER.error(
"Can't store configuration in %s: %s", self._file, err)

6
hassio/validate.py
View File

@ -24,7 +24,7 @@ CHANNELS = vol.In([CHANNEL_STABLE, CHANNEL_BETA, CHANNEL_DEV])
def validate_repository(repository):
"""Validate a valide repository."""
"""Validate a valid repository."""
data = RE_REPOSITORY.match(repository)
if not data:
raise vol.Invalid("No valid repository format!")
@ -55,7 +55,7 @@ def validate_timezone(timezone):
# pylint: disable=inconsistent-return-statements
def convert_to_docker_ports(data):
"""Convert data into docker port list."""
"""Convert data into Docker port list."""
# dynamic ports
if data is None:
return None
@ -72,7 +72,7 @@ def convert_to_docker_ports(data):
if isinstance(data, list) and len(data) == 2:
return (vol.Coerce(str)(data[0]), NETWORK_PORT(data[1]))
raise vol.Invalid("Can't validate docker host settings")
raise vol.Invalid("Can't validate Docker host settings")
DOCKER_PORTS = vol.Schema({