caspia.gateway.services package

Submodules

caspia.gateway.services.base module

class caspia.gateway.services.base.GatewayService(config, network, storage)[source]

Bases: caspia.meadow.client.gateway.ServiceGatewayMixin

attach(connection)
property attached
characteristic_cached_read(characteristic)
characteristic_cached_write(characteristic, value_and_meta)
async characteristic_read(characteristic, **kwargs)
async characteristic_write(characteristic, value, **kwargs)
characteristics = {}
abstract configure()[source]
abstract property dependant_components
detach()
get_node()[source]
async notify(characteristic, value, if_changed=False, extra=None)
async on_component_event(component, event)[source]
optional = {}
async published()
type = None
class caspia.gateway.services.base.GatewayServiceMeta[source]

Bases: caspia.meadow.services.base.ServiceMeta, abc.ABCMeta

mro()

Return a type’s method resolution order.

register(subclass)

Register a virtual subclass of an ABC.

Returns the subclass, to allow usage as a class decorator.

caspia.gateway.services.blinds module

class caspia.gateway.services.blinds.Blinds(*args, **kwargs)[source]

Bases: caspia.gateway.services.base.GatewayService, caspia.meadow.services.blinds.BlindsBase

Initialize new service.

Parameters

  • name – Name of the service (or just its path)

  • include – What optional characteristics to include. Tuple of their names.

property all_observables
attach(connection)
property attached
auto_discovery = True
blind
async blind_read(**kwargs)[source]
calibrate
async calibrate_write(value, **kwargs)[source]
characteristic_cached_read(characteristic)
characteristic_cached_write(characteristic, value_and_meta)
async characteristic_read(characteristic, **kwargs)
characteristic_subscribe(characteristic, on_value, on_error=None)
async characteristic_write(characteristic, value, **kwargs)
characteristics = {'$metadata': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:$metadata>, 'blind': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:blind>, 'calibrate': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:calibrate>, 'move_down': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:move_down>, 'move_up': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:move_up>, 'movement': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:movement>, 'stop_movement': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:stop_movement>, 'target_blind': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:target_blind>, 'target_position': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:target_position>, 'target_tilt': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:target_tilt>, 'tilt': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:tilt>}
configure()[source]
property dependant_components
detach()
get_node()
static get_subclass(stype, mixin=None)
load_definition(spec)

Update characteristics of this instance based on serialized specs.

Parameters

spec – Dict most likely going to be coming from meadow - from some gateway informing us about its services and their characteristics.

metadata
move_down
async move_down_write(value, **kwargs)[source]
move_up
async move_up_write(value, **kwargs)[source]
movement
async movement_read(**kwargs)[source]
movement_to_str(movement)[source]
async notify(characteristic, value, if_changed=False, extra=None)
on(name, *args, **kwargs)
async on_component_event(component, event)[source]
optional = {}
async published()
serialize()

Return serialized version (most likely dict) if possible or None.

stop_movement
async stop_movement_write(value, **kwargs)[source]
target_blind
async target_blind_read(**kwargs)[source]
async target_blind_write(value, **kwargs)[source]
target_position
async target_position_read(**kwargs)[source]
async target_position_write(value, **kwargs)[source]
target_tilt
async target_tilt_read(**kwargs)[source]
async target_tilt_write(value, **kwargs)[source]
tilt
async tilt_read(**kwargs)[source]
type = 'blinds'

caspia.gateway.services.button module

class caspia.gateway.services.button.Button(*args, **kwargs)[source]

Bases: caspia.gateway.services.base.GatewayService, caspia.meadow.services.button.ButtonBase

Initialize new service.

Parameters

  • name – Name of the service (or just its path)

  • include – What optional characteristics to include. Tuple of their names.

property all_observables
attach(connection)
property attached
auto_discovery = True
characteristic_cached_read(characteristic)
characteristic_cached_write(characteristic, value_and_meta)
async characteristic_read(characteristic, **kwargs)
characteristic_subscribe(characteristic, on_value, on_error=None)
async characteristic_write(characteristic, value, **kwargs)
characteristics = {'$metadata': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:$metadata>, 'event': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:event>, 'is_pushed': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:is_pushed>, 'push': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:push>, 'release': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:release>}
configure()[source]
property dependant_components
detach()
event
get_node()
static get_subclass(stype, mixin=None)
is_pushed
async is_pushed_read(**kwargs)[source]
load_definition(spec)

Update characteristics of this instance based on serialized specs.

Parameters

spec – Dict most likely going to be coming from meadow - from some gateway informing us about its services and their characteristics.

metadata
async notify(characteristic, value, if_changed=False, extra=None)
on(name, *args, **kwargs)
async on_component_event(component, event)[source]
optional = {}
async published()
push
release
serialize()

Return serialized version (most likely dict) if possible or None.

subscribe_events()
type = 'button'

caspia.gateway.services.door module

class caspia.gateway.services.door.Door(*args, **kwargs)[source]

Bases: caspia.gateway.services.base.GatewayService, caspia.meadow.services.door.DoorBase

Initialize new service.

Parameters

  • name – Name of the service (or just its path)

  • include – What optional characteristics to include. Tuple of their names.

property all_observables
attach(connection)
property attached
auto_discovery = True
characteristic_cached_read(characteristic)
characteristic_cached_write(characteristic, value_and_meta)
async characteristic_read(characteristic, **kwargs)
characteristic_subscribe(characteristic, on_value, on_error=None)
async characteristic_write(characteristic, value, **kwargs)
characteristics = {'$metadata': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:$metadata>, 'is_handle_down': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:is_handle_down>, 'is_open': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:is_open>}
configure()[source]
property dependant_components
detach()
get_node()
static get_subclass(stype, mixin=None)
is_handle_down
async is_handle_down_read(**kwargs)[source]
is_open
async is_open_read(**kwargs)[source]
load_definition(spec)

Update characteristics of this instance based on serialized specs.

Parameters

spec – Dict most likely going to be coming from meadow - from some gateway informing us about its services and their characteristics.

metadata
async notify(characteristic, value, if_changed=False, extra=None)
on(name, *args, **kwargs)
async on_component_event(component, event)[source]
optional = {}
async published()
serialize()

Return serialized version (most likely dict) if possible or None.

type = 'door'

caspia.gateway.services.fan module

class caspia.gateway.services.fan.Fan(*args, **kwargs)[source]

Bases: caspia.gateway.services.relaybased.RelayBasedServiceMixin, caspia.gateway.services.base.GatewayService, caspia.meadow.services.fan.FanBase

property all_observables
attach(connection)
property attached
auto_discovery = True
characteristic_cached_read(characteristic)
characteristic_cached_write(characteristic, value_and_meta)
async characteristic_read(characteristic, **kwargs)
characteristic_subscribe(characteristic, on_value, on_error=None)
async characteristic_write(characteristic, value, **kwargs)
characteristics = {'$metadata': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:$metadata>, 'is_on': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:is_on>, 'speed': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:speed>, 'toggle': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:toggle>}
configure()
property dependant_components
detach()
get_node()
static get_subclass(stype, mixin=None)
is_on
async is_on_read(**kwargs)
async is_on_write(value, **kwargs)
load_definition(spec)

Update characteristics of this instance based on serialized specs.

Parameters

spec – Dict most likely going to be coming from meadow - from some gateway informing us about its services and their characteristics.

metadata
async notify(characteristic, value, if_changed=False, extra=None)
on(name, *args, **kwargs)
async on_component_event(component, event)
optional = {'speed'}
async published()
serialize()

Return serialized version (most likely dict) if possible or None.

speed
toggle
async toggle_write(value, **kwargs)
type = 'fan'

caspia.gateway.services.irrigation module

class caspia.gateway.services.irrigation.Irrigation(*args, **kwargs)[source]

Bases: caspia.gateway.services.relaybased.RelayBasedServiceMixin, caspia.gateway.services.base.GatewayService, caspia.meadow.services.irrigation.IrrigationBase

property all_observables
attach(connection)
property attached
auto_discovery = True
characteristic_cached_read(characteristic)
characteristic_cached_write(characteristic, value_and_meta)
async characteristic_read(characteristic, **kwargs)
characteristic_subscribe(characteristic, on_value, on_error=None)
async characteristic_write(characteristic, value, **kwargs)
characteristics = {'$metadata': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:$metadata>, 'is_on': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:is_on>, 'toggle': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:toggle>}
configure()
property dependant_components
detach()
get_node()
static get_subclass(stype, mixin=None)
is_on
async is_on_read(**kwargs)
async is_on_write(value, **kwargs)
load_definition(spec)

Update characteristics of this instance based on serialized specs.

Parameters

spec – Dict most likely going to be coming from meadow - from some gateway informing us about its services and their characteristics.

metadata
async notify(characteristic, value, if_changed=False, extra=None)
on(name, *args, **kwargs)
async on_component_event(component, event)
optional = {}
async published()
serialize()

Return serialized version (most likely dict) if possible or None.

toggle
async toggle_write(value, **kwargs)
type = 'irrigation'

caspia.gateway.services.light module

class caspia.gateway.services.light.Light(*args, **kwargs)[source]

Bases: caspia.gateway.services.relaybased.RelayBasedServiceMixin, caspia.gateway.services.base.GatewayService, caspia.meadow.services.light.LightBase

property all_observables
attach(connection)
property attached
auto_discovery = True
brightness
characteristic_cached_read(characteristic)
characteristic_cached_write(characteristic, value_and_meta)
async characteristic_read(characteristic, **kwargs)
characteristic_subscribe(characteristic, on_value, on_error=None)
async characteristic_write(characteristic, value, **kwargs)
characteristics = {'$metadata': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:$metadata>, 'brightness': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:brightness>, 'hue': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:hue>, 'is_on': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:is_on>, 'saturation': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:saturation>, 'toggle': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:toggle>}
configure()
property dependant_components
detach()
get_node()
static get_subclass(stype, mixin=None)
hue
is_on
async is_on_read(**kwargs)
async is_on_write(value, **kwargs)
load_definition(spec)

Update characteristics of this instance based on serialized specs.

Parameters

spec – Dict most likely going to be coming from meadow - from some gateway informing us about its services and their characteristics.

metadata
async notify(characteristic, value, if_changed=False, extra=None)
on(name, *args, **kwargs)
async on_component_event(component, event)
optional = {'brightness', 'hue', 'saturation'}
async published()
saturation
serialize()

Return serialized version (most likely dict) if possible or None.

toggle
async toggle_write(value, **kwargs)
type = 'light'

caspia.gateway.services.lockmechanism module

class caspia.gateway.services.lockmechanism.LockMechanism(*args, **kwargs)[source]

Bases: caspia.gateway.services.base.GatewayService, caspia.meadow.services.lockmechanism.LockMechanismBase

Initialize new service.

Parameters

  • name – Name of the service (or just its path)

  • include – What optional characteristics to include. Tuple of their names.

property all_observables
attach(connection)
property attached
auto_discovery = True
characteristic_cached_read(characteristic)
characteristic_cached_write(characteristic, value_and_meta)
async characteristic_read(characteristic, **kwargs)
characteristic_subscribe(characteristic, on_value, on_error=None)
async characteristic_write(characteristic, value, **kwargs)
characteristics = {'$metadata': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:$metadata>, 'state': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:state>, 'target_state': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:target_state>}
configure()[source]
property dependant_components
detach()
get_node()
static get_subclass(stype, mixin=None)
load_definition(spec)

Update characteristics of this instance based on serialized specs.

Parameters

spec – Dict most likely going to be coming from meadow - from some gateway informing us about its services and their characteristics.

metadata
async notify(characteristic, value, if_changed=False, extra=None)
on(name, *args, **kwargs)
async on_component_event(component, event)[source]
optional = {}
async published()
serialize()

Return serialized version (most likely dict) if possible or None.

state
target_state
async target_state_write(value, **kwargs)[source]
type = 'lock-mechanism'

caspia.gateway.services.outlet module

class caspia.gateway.services.outlet.Outlet(*args, **kwargs)[source]

Bases: caspia.gateway.services.relaybased.RelayBasedServiceMixin, caspia.gateway.services.base.GatewayService, caspia.meadow.services.outlet.OutletBase

property all_observables
attach(connection)
property attached
auto_discovery = True
characteristic_cached_read(characteristic)
characteristic_cached_write(characteristic, value_and_meta)
async characteristic_read(characteristic, **kwargs)
characteristic_subscribe(characteristic, on_value, on_error=None)
async characteristic_write(characteristic, value, **kwargs)
characteristics = {'$metadata': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:$metadata>, 'is_on': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:is_on>, 'toggle': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:toggle>}
configure()
property dependant_components
detach()
get_node()
static get_subclass(stype, mixin=None)
is_on
async is_on_read(**kwargs)
async is_on_write(value, **kwargs)
load_definition(spec)

Update characteristics of this instance based on serialized specs.

Parameters

spec – Dict most likely going to be coming from meadow - from some gateway informing us about its services and their characteristics.

metadata
async notify(characteristic, value, if_changed=False, extra=None)
on(name, *args, **kwargs)
async on_component_event(component, event)
optional = {}
async published()
serialize()

Return serialized version (most likely dict) if possible or None.

toggle
async toggle_write(value, **kwargs)
type = 'outlet'

caspia.gateway.services.pump module

class caspia.gateway.services.pump.Pump(*args, **kwargs)[source]

Bases: caspia.gateway.services.relaybased.RelayBasedServiceMixin, caspia.gateway.services.base.GatewayService, caspia.meadow.services.pump.PumpBase

property all_observables
attach(connection)
property attached
auto_discovery = True
characteristic_cached_read(characteristic)
characteristic_cached_write(characteristic, value_and_meta)
async characteristic_read(characteristic, **kwargs)
characteristic_subscribe(characteristic, on_value, on_error=None)
async characteristic_write(characteristic, value, **kwargs)
characteristics = {'$metadata': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:$metadata>, 'is_on': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:is_on>, 'toggle': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:toggle>}
configure()
property dependant_components
detach()
get_node()
static get_subclass(stype, mixin=None)
is_on
async is_on_read(**kwargs)
async is_on_write(value, **kwargs)
load_definition(spec)

Update characteristics of this instance based on serialized specs.

Parameters

spec – Dict most likely going to be coming from meadow - from some gateway informing us about its services and their characteristics.

metadata
async notify(characteristic, value, if_changed=False, extra=None)
on(name, *args, **kwargs)
async on_component_event(component, event)
optional = {}
async published()
serialize()

Return serialized version (most likely dict) if possible or None.

toggle
async toggle_write(value, **kwargs)
type = 'pump'

caspia.gateway.services.relaybased module

class caspia.gateway.services.relaybased.RelayBasedServiceMixin(*args, **kwargs)[source]

Bases: object

Mixin to be used in services that encapsulate relay components.

configure()[source]
property dependant_components
async is_on_read(**kwargs)[source]
async is_on_write(value, **kwargs)[source]
async on_component_event(component, event)[source]
async toggle_write(value, **kwargs)[source]

caspia.gateway.services.serial module

class caspia.gateway.services.serial.Serial(*args, **kwargs)[source]

Bases: caspia.gateway.services.base.GatewayService, caspia.meadow.services.serial.SerialBase

Initialize new service.

Parameters

  • name – Name of the service (or just its path)

  • include – What optional characteristics to include. Tuple of their names.

property all_observables
attach(connection)
property attached
auto_discovery = True
baudrate
characteristic_cached_read(characteristic)
characteristic_cached_write(characteristic, value_and_meta)
async characteristic_read(characteristic, **kwargs)[source]

Read value of the characteristic.

Parameters

  • characteristic – The characteristic to which the value should be written.

  • value – The value to be written.

  • kwargs – Dictionary with extra key (dictionary with metadata) and optionally a timeout (float specifing explicit timeout for the operation).

Returns

Tuple (value, extra).

characteristic_subscribe(characteristic, on_value, on_error=None)
async characteristic_write(characteristic, value, **kwargs)[source]

Write a value to the characteristic.

Parameters

  • characteristic – The characteristic to which the value should be written.

  • value – The value to be written.

  • kwargs – Dictionary with extra key (dictionary with metadata) and optionally a timeout (float specifing explicit timeout for the operation).

characteristics = {'$metadata': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:$metadata>, 'baudrate': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:baudrate>, 'data_available': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:data_available>, 'receive': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:receive>, 'send': <Characteristic <class 'caspia.meadow.services.base.ServiceMeta'>:send>}
configure()[source]
data_available
property dependant_components
detach()
get_node()
static get_subclass(stype, mixin=None)
load_definition(spec)

Update characteristics of this instance based on serialized specs.

Parameters

spec – Dict most likely going to be coming from meadow - from some gateway informing us about its services and their characteristics.

metadata
async notify(characteristic, value, if_changed=False, extra=None)
on(name, *args, **kwargs)
async on_component_event(component, event)[source]
optional = {}
async published()
receive
send
serialize()

Return serialized version (most likely dict) if possible or None.

type = 'serial'

Module contents